Partager via

Prise en main d’AI Imaging

Les fonctionnalités d’imagerie dans Windows AI Foundry prennent en charge les fonctionnalités suivantes :

Pour plus d’informations sur l’API, consultez la référence d’API pour les fonctionnalités d’imagerie IA.

Pour plus de détails sur la modération du contenu, voir Sécurité du contenu avec les API d’IA générative.

Importante

Voici une liste des fonctionnalités Windows AI et de la version du Kit de développement logiciel (SDK) d’application Windows dans laquelle elles sont actuellement prises en charge.

Version 1.8 Expérimentale (1.8.0-experimental1) - Effacement d'objets, Phi Silice, Optimisation LoRA pour Phi Silice, Synthèse des conversations (Intelligence Textuelle)

Accès anticipé privé - Recherche sémantique

Version 1.7.1 (1.7.250401001) - Toutes les autres API

Ces API ne seront fonctionnelles que sur les appareils Windows Insider Preview (WIP) qui ont reçu la mise à jour du 7 mai. Le 28 au 29 mai, une mise à jour facultative sera publiée sur les appareils non WIP, suivie de la mise à jour du 10 juin. Cette mise à jour apporte avec elle les modèles IA requis pour que les API d’IA Windows fonctionnent. Ces mises à jour nécessitent également que toute application utilisant des API Windows AI ne puisse pas le faire tant que l’application n’a pas reçu l’identité du package au moment de l’exécution.

Que puis-je faire avec la super résolution d’images ?

Les API Super-résolution d’images permettent d’affiner et de mettre à l’échelle des images.

La mise à l’échelle est limitée à un facteur maximal de 8x, car des facteurs d’échelle plus élevés peuvent introduire des artefacts et compromettre la précision de l’image. Si la largeur ou la hauteur finale est supérieure à 8 fois la valeur d’origine, une exception est levée.

Obtenir plus d’informations sur l’échelle d’image

L’exemple suivant montre comment modifier l’échelle (targetWidth, targetHeight) d’une image bitmap logicielle existante (softwareBitmap) et améliorer la netteté de l’image (pour améliorer la netteté sans mettre à l’échelle l’image, spécifiez simplement la largeur et la hauteur de l’image existante) à l’aide d’un objet ImageScaler.

  1. Vérifiez que le modèle Image Super Resolution est disponible en appelant la méthode ImageScaler.GetReadyState , puis en attendant que la méthode ImageScaler.EnsureReadyAsync retourne correctement.

  2. Une fois le modèle Image Super Resolution disponible, créez un objet ImageScaler pour le référencer.

  3. Obtenez une version aiguisée et mise à l’échelle de l’image existante en passant l’image existante et la largeur et la hauteur souhaitées au modèle à l’aide de la méthode ScaleSoftwareBitmap .

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

if (ImageScaler.GetReadyState() == AIFeatureReadyState.EnsureNeeded) 
{
    var result = await ImageScaler.EnsureReadyAsync();
    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/Microsoft.Windows.AI.h>
#include <winrt/Windows.Foundation.h>
#include <winrt/Windows.Graphics.Imaging.h>

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

if (ImageScaler::GetReadyState() == AIFeatureReadyState::NotReady)
{
    auto loadResult = ImageScaler::EnsureReadyAsync().get();

    if (loadResult.Status() != AIFeatureReadyResultState::Success)
    {
        throw winrt::hresult_error(loadResult.ExtendedError());
    }
}
int targetWidth = 100;
int targetHeight = 100;
ImageScaler imageScaler = ImageScaler::CreateAsync().get();
Windows::Graphics::Imaging::SoftwareBitmap finalImage = 
    imageScaler.ScaleSoftwareBitmap(softwareBitmap, targetWidth, targetHeight);

Que puis-je faire avec la description de l’image ?

Importante

La description de l’image n’est pas disponible en Chine.

Les API Description d’image permettent de générer différents types de descriptions de texte pour une image.

Les types de descriptions de texte suivants sont pris en charge :

  • - Accessibilité : fournit une description détaillée destinée aux utilisateurs ayant des besoins spécifiques en matière d'accessibilité.
  • Légende - Fournit une courte description adaptée à une légende d'image. Valeur par défaut si aucune valeur n’est spécifiée.
  • DetailedNarration - Fournit une description longue.
  • OfficeCharts : fournit une description adaptée aux graphiques et diagrammes.

Étant donné que ces API utilisent des modèles Machine Learning (ML), des erreurs occasionnelles peuvent se produire lorsque le texte ne décrit pas correctement l’image. Par conséquent, nous vous déconseillons d’utiliser ces API pour les images dans les scénarios suivants :

  • Lorsque les images contiennent du contenu potentiellement sensible et des descriptions inexactes peuvent être controversées, telles que des drapeaux, des cartes, des globes, des symboles culturels ou des symboles religieux.
  • Lorsque des descriptions précises sont essentielles, comme pour les conseils médicaux ou le diagnostic, le contenu juridique ou les documents financiers.

Obtenir une description de texte à partir d’une image

L’API Description d’image prend une image, le type de description de texte souhaité (facultatif) et le niveau de modération de contenu que vous souhaitez utiliser (facultatif) pour vous protéger contre l’utilisation dangereuse.

L’exemple suivant montre comment obtenir une description de texte pour une image.

Remarque

L’image doit être un objet ImageBuffer , car SoftwareBitmap n’est actuellement pas pris en charge. Cet exemple montre comment convertir SoftwareBitmap en ImageBuffer.

  1. Vérifiez que le modèle Image Super Resolution est disponible en appelant la méthode ImageDescriptionGenerator.GetReadyState , puis en attendant que la méthode ImageDescriptionGenerator.EnsureReadyAsync retourne correctement.

  2. Une fois le modèle Image Super Resolution disponible, créez un objet ImageDescriptionGenerator pour le référencer.

  3. (Facultatif) Créez un objet ContentFilterOptions et spécifiez vos valeurs préférées. Si vous choisissez d’utiliser des valeurs par défaut, vous pouvez passer un objet Null.

  4. Obtenez la description de l’image (LanguageModelResponse.Response) en appelant la méthode ImageDescriptionGenerator.DescribeAsync avec l’image d’origine, une énumération pour le type de description préféré (facultatif) et l’objet ContentFilterOptions (facultatif).

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

if (ImageDescriptionGenerator.GetReadyState() == AIFeatureReadyState.EnsureNeeded) 
{
    var result = await ImageDescriptionGenerator.EnsureReadyAsync();
    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.Imaging.h>
#include <winrt/Microsoft.Windows.AI.ContentSafety.h>
#include <winrt/Microsoft.Windows.AI.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;
using namespace winrt::Microsoft::Windows::AI::ContentSafety; 
using namespace winrt::Microsoft::Windows::AI::Imaging; 
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::GetReadyState() == AIFeatureReadyState::NotReady)
{
    auto loadResult = ImageDescriptionGenerator::EnsureReadyAsync().get();
    auto loadResult = ImageScaler::EnsureReadyAsync().get();

    if (loadResult.Status() != AIFeatureReadyResultState::Success)
    {
        throw winrt::hresult_error(loadResult.ExtendedError());
    }
}

ImageDescriptionGenerator imageDescriptionGenerator = 
    ImageDescriptionGenerator::CreateAsync().get();

// Convert already available softwareBitmap to ImageBuffer.
auto inputBuffer = Microsoft::Graphics::Imaging::ImageBuffer::CreateForSoftwareBitmap(bitmap); (softwareBitmap);

// Create content moderation thresholds object.

ContentFilterOptions contentFilter{};
contentFilter.PromptMaxAllowedSeverityLevel().Violent(SeverityLevel::Medium);
contentFilter.ResponseMaxAllowedSeverityLevel().Violent(SeverityLevel::Medium);

// Get text description.
auto response = imageDescriptionGenerator.DescribeAsync(inputImage, ImageDescriptionKind::BriefDescription, contentFilter).get();
string text = response.Description();

Que puis-je faire avec la segmentation d’images ?

La segmentation d’image peut être utilisée pour identifier des objets spécifiques dans une image. Le modèle prend une image et un objet « indice » et renvoie un masque de l'objet identifié.

Les indices peuvent être fournis à partir de n’importe quelle combinaison des éléments suivants :

  • Des coordonnées de points qui font partie de ce que vous voulez identifier.
  • Des coordonnées de points qui ne font pas partie de ce que vous voulez identifier.
  • Un rectangle de coordonnées qui entoure ce que vous voulez identifier.

Plus vous fournissez d’indices, plus le modèle sera précis. Suivez ces consignes d'indications pour minimiser les résultats inexacts ou les erreurs.

  • Évitez d’utiliser plusieurs rectangles dans un même indice, au risque que le masque créé ne perde en précision.
  • Évitez d’utiliser uniquement des points d'exclusion, sans aucun point d'inclusion ni rectangle.
  • Le nombre maximum de coordonnées prises en charge est de 32, à raison de 1 coordonnée pour un point et 2 pour un rectangle. Au-delà, un message d'erreur apparaît.

Le masque retourné est au format grisscale-8 avec les pixels du masque pour l’objet identifié ayant une valeur de 255 (toutes les autres ayant une valeur de 0).

Identifier un objet dans une image

Les exemples suivants montrent comment identifier un objet dans une image. Les exemples supposent que vous disposez déjà d’un objet bitmap logiciel (softwareBitmap) pour l’entrée.

  1. Vérifiez que le modèle de segmentation d’image est disponible en appelant la méthode GetReadyState et en attendant que la méthode EnsureReadyAsync retourne correctement.

  2. Une fois le modèle de segmentation d’image disponible, créez un objet ImageObjectExtractor pour le référencer.

  3. Passez l’image à ImageObjectExtractor.CreateWithSoftwareBitmapAsync.

  4. Créez un objet ImageObjectExtractorHint . D’autres façons de créer un objet hint avec différentes entrées sont illustrées ultérieurement.

  5. Envoyez l’indicateur au modèle à l’aide de la méthode GetSoftwareBitmapObjectMask , qui retourne le résultat final.

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

if (ImageObjectExtractor::GetReadyState() == AIFeatureReadyState.EnsureNeeded) 
{
    var result = await ImageObjectExtractor.EnsureReadyAsync();
    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/Microsoft.Windows.AI.Imaging.h>
#include <winrt/Windows.Graphics.Imaging.h>
#include <winrt/Windows.Foundation.h>
using namespace winrt::Microsoft::Graphics::Imaging; 
using namespace winrt::Microsoft::Windows::AI.Imaging;
using namespace winrt::Windows::Graphics::Imaging; 
using namespace winrt::Windows::Foundation;

if (ImageObjectExtractor::GetReadyState() == AIFeatureReadyState::NotReady)
{
    auto loadResult = ImageObjectExtractor::EnsureReadyAsync().get();

    if (loadResult.Status() != AIFeatureReadyResultState::Success)
    {
        throw winrt::hresult_error(loadResult.ExtendedError());
    }
}

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

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

Windows::Graphics::Imaging::SoftwareBitmap finalImage = imageObjectExtractor.GetSoftwareBitmapObjectMask(hint);

Spécifiez des indices, sous forme de points inclus et de points exclus

Cet extrait de code montre comment utiliser des points inclus et exclus en tant qu’indicateurs.

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}
    }
);

Spécifiez des indices sous forme de rectangle

Cet extrait de code montre comment utiliser un rectangle (RectInt32 est X, Y, Width, Height) comme indicateur.

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

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

Que puis-je faire avec l’effacement d’objet ?

L’effacement d’objet peut être utilisé pour supprimer des objets d’images. Le modèle prend à la fois une image et un masque en niveaux de gris indiquant l'objet à supprimer, efface la zone masquée de l'image, et remplace la zone effacée par l'arrière-plan de l'image.

Supprimer les objets indésirables d’une image

L’exemple suivant montre comment supprimer un objet d’une image. L’exemple suppose que vous disposez déjà d’objets bitmap logiciels (softwareBitmap) pour l’image et le masque. Le masque doit être au format Gray8 avec chaque pixel de la zone à supprimer défini sur 255 et tous les autres pixels définis sur 0.

  1. Vérifiez que le modèle de segmentation d’image est disponible en appelant la méthode GetReadyState et en attendant que la méthode EnsureReadyAsync retourne correctement.
  2. Une fois le modèle Object Erase disponible, créez un objet ImageObjectRemover pour le référencer.
  3. Enfin, envoyez l’image et le masque au modèle à l’aide de la méthode RemoveFromSoftwareBitmap , qui retourne le résultat final.
using Microsoft.Graphics.Imaging;
using Microsoft.Windows.AI;
using Microsoft.Windows.Management.Deployment;
using Windows.Graphics.Imaging;

if (ImageObjectRemover::GetReadyState() == AIFeatureReadyState.EnsureNeeded) 
{
    var result = await ImageObjectRemover.EnsureReadyAsync();
    if (result.Status != PackageDeploymentStatus.CompletedSuccess)
    {
        throw result.ExtendedError;
    }
}
ImageObjectRemover imageObjectRemover = await ImageObjectRemover.CreateAsync();
SoftwareBitmap finalImage = imageObjectRemover.RemoveFromSoftwareBitmap(imageBitmap, maskBitmap); // Insert your own imagebitmap and maskbitmap

#include <winrt/Microsoft.Graphics.Imaging.h>
#include <winrt/Microsoft.Windows.AI.Imaging.h>
#include <winrt/Windows.Graphics.Imaging.h>
#include <winrt/Windows.Foundation.h>
using namespace winrt::Microsoft::Graphics::Imaging;
using namespace winrt::Microsoft::Windows::AI.Imaging;
using namespace winrt::Windows::Graphics::Imaging; 
using namespace winrt::Windows::Foundation;
if (ImageObjectRemover::GetReadyState() == AIFeatureReadyState::NotReady)
{
    auto loadResult = ImageObjectRemover::EnsureReadyAsync().get();

    if (loadResult.Status() != AIFeatureReadyResultState::Success)
    {
        throw winrt::hresult_error(loadResult.ExtendedError());
    }
}

ImageObjectRemover imageObjectRemover = ImageObjectRemover::CreateAsync().get();
// Insert your own imagebitmap and maskbitmap
Windows::Graphics::Imaging::SoftwareBitmap buffer = 
    imageObjectRemover.RemoveFromSoftwareBitmap(imageBitmap, maskBitmap);

IA responsable

Nous avons utilisé une combinaison des étapes suivantes pour garantir que ces API d’imagerie sont fiables, sécurisées et générées de manière responsable. Nous vous recommandons de consulter les meilleures pratiques décrites dans développement d’IA responsable sur Windows lors de l’implémentation de fonctionnalités IA dans votre application.

Voir aussi