Erste Schritte mit AI Imaging

2025-05-20

Bildbearbeitungsmerkmale in Windows AI Foundry unterstützen die folgenden Funktionen:

Bild-Superauflösung: Skalieren und Schärfen eines Bilds.
Bildbeschreibung: Generieren von Text, der ein Bild beschreibt.
Bildsegmentierung: Identifizieren von Objekten innerhalb eines Bilds.
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.

Wichtig

Nachfolgend finden Sie eine Liste der Windows AI-Features und der Windows App SDK-Version, in der sie derzeit unterstützt werden.

Version 1.8 Experimental (1.8.0-experimental1) - Object Erase, Phi Silica, LoRA Feinoptimierung für Phi Silica,Unterhaltungszusammenfassung (Textintelligenz)

Private Vorschau – Semantiksuche

Version 1.7.1 (1.7.250401001) – Alle anderen APIs

Diese APIs sind nur auf Windows Insider Preview (WIP)-Geräten funktionsfähig, die das 7. Mai-Update erhalten haben. Am 28.-29. Mai wird ein optionales Update auf Nicht-WIP-Geräten veröffentlicht, gefolgt vom Update vom 10. Juni. Mit diesem Update werden die KI-Modelle bereitgestellt, die für die Funktion der Windows AI-APIs erforderlich sind. Diese Updates erfordern außerdem, dass jede App, die Windows AI-APIs verwendet, dies erst tun kann, wenn der App zur Laufzeit die Paketidentität bereitgestellt wurde.

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.

Weitere Details zu Image Scaler

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

Stellen Sie sicher, dass das Image Super Resolution-Modell verfügbar ist, indem Sie die ImageScaler.GetReadyState-Methode aufrufen und dann warten, bis die ImageScaler.EnsureReadyAsync-Methode erfolgreich zurückgegeben wird.
Sobald das Image Super Resolution-Modell verfügbar ist, erstellen Sie ein ImageScaler-Objekt , um darauf zu verweisen.
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.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);

Was kann ich mit der Bildbeschreibung tun?

Wichtig

Bildbeschreibung ist derzeit in China nicht verfügbar.

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:

Barrierefreiheit – Bietet eine lange Beschreibung mit Details, die für Benutzer mit Barrierefreiheitsanforderungen vorgesehen sind.
Beschriftung – Stellt eine kurze Beschreibung bereit, die für eine Bildbeschriftung geeignet ist. Der Standardwert, wenn kein Wert angegeben wird.
DetailedNarration – Enthält eine lange Beschreibung.
OfficeCharts – Stellt eine Beschreibung bereit, die für Diagramme und Tabellen geeignet ist.

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.

Abrufen einer Textbeschreibung aus einem Bild

Die Bildbeschreibungs-API verwendet ein Bild, den gewünschten Textbeschreibungstyp (optional) und die Ebene der Inhaltsmoderation, die Sie verwenden möchten (optional), um vor schädlicher Verwendung zu schützen.

Das folgende Beispiel zeigt, wie Sie eine Textbeschreibung für ein Bild abrufen.

Hinweis

Das Bild muss ein ImageBuffer-Objekt sein, da SoftwareBitmap derzeit nicht unterstützt wird. In diesem Beispiel wird veranschaulicht, wie SoftwareBitmap in ImageBuffer konvertiert wird.

Stellen Sie sicher, dass das Image Super Resolution-Modell verfügbar ist, indem Sie die ImageDescriptionGenerator.GetReadyState-Methode aufrufen und dann warten, bis die ImageDescriptionGenerator.EnsureReadyAsync-Methode erfolgreich zurückgegeben wird.
Nachdem das Bild-Superauflösungsmodell verfügbar ist, erstellen Sie ein ImageDescriptionGenerator -Objekt, um darauf zu verweisen.
(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.
Rufen Sie die Bildbeschreibung (LanguageModelResponse.Response) ab, indem Sie die ImageDescriptionGenerator.DescribeAsync-Methode mit dem Originalbild, eine Enumeration für den bevorzugten Beschreibungstyp (optional) und das ContentFilterOptions-Objekt (optional) aufrufen.

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

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.

Identifizieren eines Objekts in einem Bild

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.

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.
Nachdem das Image Segmentation-Modell verfügbar ist, erstellen Sie ein ImageObjectExtractor-Objekt , um darauf zu verweisen.
Übergeben Sie das Bild an ImageObjectExtractor.CreateWithSoftwareBitmapAsync.
Erstellen Sie ein ImageObjectExtractorHint-Objekt . Weitere Möglichkeiten zum Erstellen eines Hinweisobjekts mit unterschiedlichen Eingaben werden später veranschaulicht.
Ü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.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);

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 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.

Entfernen unerwünschter Objekte aus einem Bild

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.

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.
Nachdem das Objektradieriermodell verfügbar ist, erstellen Sie ein ImageObjectRemover-Objekt , um darauf zu verweisen.
Ü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.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);

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.