Erste Schritte mit AI Imaging

Die von den Windows AI-APIs unterstützten KI-Bildgebungsfunktionen eröffnen folgende Möglichkeiten:

• Bild-Superauflösung: Skalieren und Schärfen eines Bilds.
• Bildbeschreibung: Generieren von Text, der ein Bild beschreibt.
• Bildsegmentierung: Identifizieren von Objekten innerhalb eines Bilds.
• Bild-Vordergrundextraktion: Extrahieren des Vordergrunds eines Eingabebilds
• Objektlöschung: Entfernen von Objekten aus einem Bild.

Api-Details finden Sie in der API-Referenz für KI-Imageerstellungsfeatures.

Details zur Inhaltsmoderation finden Sie unter Inhaltssicherheit mit generativen AI-APIs.

<Dependencies>
  <TargetDeviceFamily Name="Windows.Universal" MinVersion="10.0.17763.0" MaxVersionTested="10.0.26226.0" />
  <TargetDeviceFamily Name="Windows.Desktop" MinVersion="10.0.17763.0" MaxVersionTested="10.0.26226.0" />
</Dependencies>

Was kann ich mit der Bild-Superauflösung tun?

Die BILD-APIs mit superauflösung ermöglichen das Schärfen und Skalieren von Bildern.

Die Skalierung ist auf einen maximalen Faktor von 8x beschränkt, da höhere Skalierungsfaktoren Artefakte und Kompromittierung der Bildgenauigkeit auslösen können. Wenn entweder die endgültige Breite oder Höhe größer als das 8-fache ihres ursprünglichen Werts ist, wird eine Ausnahme ausgelöst.

Beispiel für Bild-Superauflösung

Das folgende Beispiel zeigt, wie Sie die Skalierung (targetWidth, targetHeight) eines vorhandenen Softwarebitmapbilds (softwareBitmap) ändern und die Bildschärfe mithilfe eines ImageScaler Objekts verbessern (um die Schärfe zu verbessern, ohne das Bild zu skalieren, einfach die vorhandene Bildbreite und -höhe angeben).

1. Stellen Sie sicher, dass das Image Super Resolution-Modell verfügbar ist, indem Sie die GetReadyState-Methode aufrufen und dann darauf warten, dass die EnsureReadyAsync-Methode erfolgreich zurückgegeben wird.

2. Sobald das Image Super Resolution-Modell verfügbar ist, erstellen Sie ein ImageScaler-Objekt , um darauf zu verweisen.

3. Rufen Sie eine geschärfete und skalierte Version des vorhandenen Bilds ab, indem Sie das vorhandene Bild und die gewünschte Breite und Höhe mithilfe der ScaleSoftwareBitmap-Methode an das Modell übergeben.

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

if (ImageScaler.GetReadyState() == AIFeatureReadyState.NotReady) 
{
    var result = await ImageScaler.EnsureReadyAsync();
    if (result.Status != AIFeatureReadyResultState.Success)
    {
        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);

Was kann ich mit der Bildbeschreibung tun?

Die Bildbeschreibungs-APIs bieten die Möglichkeit, verschiedene Arten von Textbeschreibungen für ein Bild zu generieren.

Die folgenden Arten von Textbeschreibungen werden unterstützt:

• Kurz – Liefert eine Beschreibung, die für Tabellen und Diagramme geeignet ist.
• Detailliert – Enthält eine lange Beschreibung.
• Diagramm – Stellt eine kurze Beschreibung bereit, die für eine Bildbeschriftung geeignet ist. Der Standardwert, wenn kein Wert angegeben wird.
• Barrierefrei – Bietet eine lange Beschreibung mit Details, die für Benutzer mit Barrierefreiheitsanforderungen vorgesehen sind.

Da diese APIs Machine Learning (ML)-Modelle verwenden, können gelegentlich Fehler auftreten, bei denen der Text das Bild nicht richtig beschreibt. Daher wird die Verwendung dieser APIs für Bilder in den folgenden Szenarien nicht empfohlen:

• Wenn Bilder potenziell sensible Inhalte zeigen und durch ungenaue Beschreibungen umstritten sein könnten, wie z. B. Flaggen, Karten, Globen, kulturelle Symbole oder religiöse Symbole.
• Wenn genaue Beschreibungen wichtig sind, z. B. für medizinische Beratung oder Diagnose, rechtliche Inhalte oder Finanzdokumente.

Beispiel für eine Bildbeschreibung

Das folgende Beispiel zeigt, wie Eine Textbeschreibung für ein Bild basierend auf dem angegebenen Beschreibungstyp (optional) und der Ebene der Inhaltsmoderation (optional) abgerufen wird.

1. Stellen Sie sicher, dass das Image Super Resolution-Modell verfügbar ist, indem Sie die GetReadyState-Methode aufrufen und dann darauf warten, dass die EnsureReadyAsync-Methode erfolgreich zurückgegeben wird.

2. Nachdem das Bild-Superauflösungsmodell verfügbar ist, erstellen Sie ein ImageDescriptionGenerator -Objekt, um darauf zu verweisen.

3. (Optional) Erstellen Sie ein ContentFilterOptions-Objekt , und geben Sie Ihre bevorzugten Werte an. Wenn Sie sich für die Verwendung von Standardwerten entscheiden, können Sie ein NULL-Objekt übergeben.

4. Rufen Sie die Bildbeschreibung (LanguageModelResponse.Response) ab, indem Sie die DescribeAsync-Methode aufrufen, die das ursprüngliche Bild angibt, das ImageDescriptionKind (ein optionaler Wert für den bevorzugten Beschreibungstyp) und das ContentFilterOptions-Objekt (optional).

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.NotReady) 
{
    var result = await ImageDescriptionGenerator.EnsureReadyAsync();
    if (result.Status != AIFeatureReadyResultState.Success)
    {
        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();

Was kann ich mit der Bildsegmentierung tun?

Die Bildsegmentierung kann dazu verwendet werden, bestimmte Objekte in einem Bild zu identifizieren. Das Modell nimmt sowohl ein Bild als auch ein „Hinweis“-Objekt entgegen und gibt eine Maske des identifizierten Objekts zurück.

Hinweise können durch eine beliebige Kombination der folgenden Punkte gegeben werden:

• Koordinaten für Punkte, die zu dem Objekt gehören, das Sie identifizieren möchten.
• Koordinaten für Punkte, die nicht zu dem Objekt gehören, das Sie identifizieren möchten.
• Ein Koordinatenrechteck, das den zu identifizierenden Punkt umschließt.

Je mehr Hinweise Sie geben, desto präziser kann das Modell arbeiten. Befolgen Sie diese Hinweise, um ungenaue Ergebnisse oder Fehler zu minimieren.

• Vermeiden Sie die Verwendung mehrerer Rechtecke in einem Hinweis, da dies zu einer ungenauen Maske führen kann.
• Vermeiden Sie es, ausschließlich Ausschlusspunkte ohne Einschlusspunkte oder ein Rechteck zu verwenden.
• Geben Sie nicht mehr als die unterstützte Höchstzahl von 32 Koordinaten an (1 für einen Punkt, 2 für ein Rechteck), da dies zu einem Fehler führt.

Die zurückgegebene Maske ist im Graustufen-8-Format mit den Pixeln der Maske für das identifizierte Objekt mit einem Wert von 255 (alle anderen mit dem Wert 0) dargestellt.

Beispiel für bildsegmentierung

Die folgenden Beispiele zeigen Möglichkeiten zum Identifizieren eines Objekts innerhalb eines Bilds. In den Beispielen wird davon ausgegangen, dass Sie bereits über ein Software-Bitmapobjekt (softwareBitmap) für die Eingabe verfügen.

1. Stellen Sie sicher, dass das ImageSegmentation-Modell verfügbar ist, indem Sie die GetReadyState-Methode aufrufen und darauf warten, dass die EnsureReadyAsync-Methode erfolgreich zurückgegeben wird.

2. Nachdem das Image Segmentation-Modell verfügbar ist, erstellen Sie ein ImageObjectExtractor-Objekt , um darauf zu verweisen.

3. Übergeben Sie das Bild an CreateWithSoftwareBitmapAsync.

4. Erstellen Sie ein ImageObjectExtractorHint-Objekt . Weitere Möglichkeiten zum Erstellen eines Hinweisobjekts mit unterschiedlichen Eingaben werden später veranschaulicht.

5. Übermitteln Sie den Hinweis mithilfe der GetSoftwareBitmapObjectMask-Methode an das Modell, das das endgültige Ergebnis zurückgibt.

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

if (ImageObjectExtractor::GetReadyState() == AIFeatureReadyState.NotReady) 
{
    var result = await ImageObjectExtractor.EnsureReadyAsync();
    if (result.Status != AIFeatureReadyResultState.Success)
    {
        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);

Hinweise mit eingeschlossenen und ausgeschlossenen Punkten angeben

Dieser Codeausschnitt veranschaulicht die Verwendung von eingeschlossenen und ausgeschlossenen Punkten als Hinweise.

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

Hinweise mit Rechteck angeben

Dieser Codeausschnitt veranschaulicht die Verwendung eines Rechtecks (RectInt32 ist X, Y, Width, Height) als Hinweis.

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

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

Was kann ich mit dem Bild-Vordergrundextraktionsmodul tun?

Verwenden Sie ImageForegroundExtractor , um den Vordergrund eines Eingabebilds zu segmentieren und Features wie das Entfernen von Hintergrund und die Generierung von Aufklebern zu aktivieren.

Die zurückgegebene Maske ist im Graustufen-8-Format. Pixelwerte reichen von 0 bis 255, wobei 0 Hintergrundpixel darstellt, 255 Vordergrundpixel darstellt und Zwischenwerte eine Mischung aus Vordergrund- und Hintergrundpixeln angeben.

Generieren einer Maske aus einem Bitmapbild

1. Rufen Sie GetReadyState auf, und warten Sie, bis EnsureReadyAsync erfolgreich abgeschlossen wurde, um zu bestätigen, dass das ImageForegroundExtractor-Objekt bereit ist.
2. Rufen Sie nach abschluss des Modells CreateAsync auf, um ein ImageForegroundExtractor-Objekt zu instanziieren.
3. Rufen Sie GetMaskFromSoftwareBitmap mit dem Eingabebild auf, um die Vordergrundmaske zu generieren.

using Microsoft.Windows.AI.Imaging;
using Microsoft.Windows.AI;

if (ImageForegroundExtractor.GetReadyState() == AIFeatureReadyState.NotReady)
{
    var result  = await ImageForegroundExtractor.EnsureReadyAsync();
    if (result.Status != AIFeatureReadyResultState.Success)
    {
        throw result.ExtendedError;
    }
}

var model = await ImageForegroundExtractor.CreateAsync();

// Insert your own softwareBitmap here.
var foregroundMask = model.GetMaskFromSoftwareBitmap(softwareBitmap);

#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 (ImageForegroundExtractor::GetReadyState() == AIFeatureReadyState::NotReady)
{
    auto loadResult = ImageForegroundExtractor::EnsureReadyAsync().get();

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

auto model = co_await ImageForegroundExtractor::CreateAsync();

// Insert your own softwareBitmap here.
auto foregroundMask = model.GetMaskFromSoftwareBitmap(softwareBitmap);

Was kann ich mit Objektlöschung tun?

Objektlöschung kann verwendet werden, um Objekte aus Bildern zu entfernen. Das Modell verwendet sowohl ein Bild als auch eine Graustufenmaske, die angibt, dass das zu entfernende Objekt entfernt wird, den maskierten Bereich aus dem Bild löscht und den gelöschten Bereich durch den Bildhintergrund ersetzt.

Objektlöschen (Beispiel)

Das folgende Beispiel zeigt, wie ein Objekt aus einem Bild entfernt wird. Im Beispiel wird davon ausgegangen, dass Sie bereits Über Software-Bitmapobjekte (softwareBitmap) für das Bild und die Maske verfügen. Die Maske muss im Grau8-Format sein, wobei jedes Pixel des zu entfernenden Bereichs auf 255 festgelegt ist und alle anderen Pixel auf 0 festgelegt sind.

1. Stellen Sie sicher, dass das ImageSegmentation-Modell verfügbar ist, indem Sie die GetReadyState-Methode aufrufen und darauf warten, dass die EnsureReadyAsync-Methode erfolgreich zurückgegeben wird.
2. Nachdem das Objektradieriermodell verfügbar ist, erstellen Sie ein ImageObjectRemover-Objekt , um darauf zu verweisen.
3. Übermitteln Sie schließlich das Bild und die Maske mithilfe der RemoveFromSoftwareBitmap-Methode an das Modell, das das endgültige Ergebnis zurückgibt.

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

if (ImageObjectRemover::GetReadyState() == AIFeatureReadyState.NotReady) 
{
    var result = await ImageObjectRemover.EnsureReadyAsync();
    if (result.Status != AIFeatureReadyResultState.Success)
    {
        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);

Verantwortungsvolle KI

Wir haben eine Kombination der folgenden Schritte verwendet, um sicherzustellen, dass diese Imageerstellungs-APIs vertrauenswürdig, sicher und verantwortungsbewusst erstellt sind. Es wird empfohlen, die bewährten Methoden zu überprüfen, die bei der Implementierung von KI-Features in Ihrer App in der verantwortungsvollen generativen KI-Entwicklung unter Windows beschrieben sind.

Siehe auch

• KI-Entwicklungskatalog
• Beispiele für windows AI-API