Introduzione all'imaging di intelligenza artificiale

2025-05-20

Le funzionalità di creazione di immagini in Windows AI Foundry supportano le funzionalità seguenti:

Super risoluzione dell'immagine: ridimensionamento e nitidezza un'immagine.
Descrizione immagine: generazione di testo che descrive un'immagine.
Segmentazione immagine: identificazione di oggetti all'interno di un'immagine.
Cancellazione oggetto: rimozione di oggetti da un'immagine.

Per informazioni dettagliate sull'API, vedere Riferimento API per le funzionalità di creazione dell'immagine di intelligenza artificiale.

Per informazioni dettagliate sulla moderazione dei contenuti, vedere Sicurezza dei contenuti con API di intelligenza artificiale generative.

Importante

Di seguito è riportato un elenco delle funzionalità di Intelligenza artificiale di Windows e della versione di Windows App SDK in cui sono attualmente supportate.

Versione 1.8 Sperimentale (1.8.0-experimental1) - Cancellazione degli oggetti, Phi Silica, Ottimizzazione di LoRA per Phi Silica, Riepilogo conversazioni (Intelligence per il testo)

Anteprima privata - Ricerca semantica

Versione 1.7.1 (1.7.250401001) - Tutte le altre API

Queste API saranno funzionali solo nei dispositivi Windows Insider Preview (WIP) che hanno ricevuto l'aggiornamento del 7 maggio. Il 28-29 maggio verrà rilasciato un aggiornamento facoltativo ai dispositivi non WIP, seguito dall'aggiornamento del 10 giugno. Questo aggiornamento porterà con sé i modelli di intelligenza artificiale necessari per il funzionamento delle API di intelligenza artificiale Windows. Questi aggiornamenti richiederanno anche che qualsiasi app che usa le API Windows per l'intelligenza artificiale, non sarà in grado di farlo fino a quando l'app non abbia concesso l'identità del pacchetto in fase di esecuzione.

Cosa posso fare con la Super Risoluzione dell'Immagine?

Le API di super risoluzione delle immagini abilitano la nitidezza e il ridimensionamento delle immagini.

Il ridimensionamento è limitato a un fattore massimo di 8 volte perché i fattori di scala superiore possono introdurre artefatti e compromettere l'accuratezza dell'immagine. Se la larghezza finale o l'altezza è maggiore di 8 volte i valori originali, verrà generata un'eccezione.

Altre informazioni su Image Scaler

L'esempio seguente illustra come modificare la scala (targetWidth, targetHeight) di un'immagine bitmap software esistente (softwareBitmap) e migliorare la nitidezza dell'immagine (per migliorare la nitidezza senza ridimensionare l'immagine, specificare semplicemente la larghezza e l'altezza dell'immagine esistenti) usando un oggetto ImageScaler.

Verificare che il modello image super resolution sia disponibile chiamando il metodo ImageScaler.GetReadyState e quindi attendendo che il metodo ImageScaler.EnsureReadyAsync restituisca correttamente.
Quando il modello image super resolution è disponibile, creare un oggetto ImageScaler per farvi riferimento.
Ottenere una versione nitida e ridimensionata dell'immagine esistente passando l'immagine esistente e la larghezza e l'altezza desiderate al modello usando il metodo 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);

Cosa posso fare con la descrizione dell'immagine?

Importante

La descrizione dell'immagine non è attualmente disponibile in Cina.

Le API Descrizione immagine consentono di generare vari tipi di descrizioni di testo per un'immagine.

Sono supportati i tipi di descrizioni di testo seguenti:

Accessibilità : fornisce una descrizione lunga con i dettagli destinati agli utenti con esigenze di accessibilità.
Didascalia : fornisce una breve descrizione adatta per una didascalia dell'immagine. Valore predefinito se non viene specificato alcun valore.
DetailedNarration: fornisce una descrizione lunga.
OfficeCharts: fornisce una descrizione adatta per grafici e diagrammi.

Poiché queste API usano modelli di Machine Learning (ML), possono verificarsi errori occasionali in cui il testo non descrive correttamente l'immagine. Pertanto, non è consigliabile usare queste API per le immagini negli scenari seguenti:

Dove le immagini contengono contenuti potenzialmente sensibili e descrizioni imprecise potrebbero essere controverse, ad esempio bandiere, mappe, globo, simboli culturali o simboli religiosi.
Quando le descrizioni accurate sono critiche, ad esempio per consulenza medica o diagnosi, contenuto legale o documenti finanziari.

Ottenere una descrizione di testo da un'immagine

L'API Descrizione immagine accetta un'immagine, il tipo di descrizione del testo desiderato (facoltativo) e il livello di moderazione del contenuto che si vuole usare (facoltativo) per proteggersi dall'uso dannoso.

Nell'esempio seguente viene illustrato come ottenere una descrizione di testo per un'immagine.

Nota

L'immagine deve essere un oggetto ImageBuffer perché SoftwareBitmap non è attualmente supportato. Questo esempio illustra come convertire SoftwareBitmap in ImageBuffer.

Verificare che il modello di Super Risoluzione Immagine sia disponibile chiamando il metodo ImageDescriptionGenerator.GetReadyState e quindi attendere che il metodo ImageDescriptionGenerator.EnsureReadyAsync restituisca correttamente.
Dopo aver reso disponibile il modello Image Super Resolution, creare un oggetto ImageDescriptionGenerator per farvi riferimento.
(Facoltativo) Creare un oggetto ContentFilterOptions e specificare i valori preferiti. Se si sceglie di usare i valori predefiniti, è possibile passare un oggetto Null.
Ottenere la descrizione dell'immagine (LanguageModelResponse.Response) chiamando il metodo ImageDescriptionGenerator.DescribeAsync con l'immagine originale, un'enumerazione per il tipo di descrizione preferito (facoltativo) e l'oggetto ContentFilterOptions (facoltativo).

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

Cosa posso fare con la segmentazione delle immagini?

La segmentazione dell'immagine può essere usata per identificare oggetti specifici in un'immagine. Il modello accetta sia un'immagine che un oggetto chiamato "indicazioni" e restituisce una maschera dell'oggetto identificato.

Gli hint possono essere forniti tramite qualsiasi combinazione dei seguenti elementi:

Coordinate per i punti che appartengono all'elemento che stai identificando.
Coordinate per i punti che non appartengono a quello che stai identificando.
Il rettangolo di coordinate che racchiude ciò che stai identificando.

Maggiore è il numero di suggerimenti forniti, maggiore è la precisione del modello. Seguire queste linee guida sui suggerimenti per ridurre al minimo i risultati o gli errori inaccurati.

Evitare di usare più rettangoli in un suggerimento perché possono produrre una maschera imprecisa.
Evitare di usare esclusivamente punti di esclusione senza includere punti o un rettangolo.
Non specificare più del massimo supportato di 32 coordinate (1 per un punto, 2 per un rettangolo) perché verrà restituito un errore.

La maschera restituita è in formato grigio-8 con i pixel della maschera per l'oggetto identificato con un valore pari a 255 (tutti gli altri hanno un valore pari a 0).

Identificare un oggetto all'interno di un'immagine

Negli esempi seguenti vengono illustrati i modi per identificare un oggetto all'interno di un'immagine. Gli esempi presuppongono che sia già presente un oggetto bitmap software (softwareBitmap) per l'input.

Verificare che il modello di segmentazione dell'immagine sia disponibile chiamando il metodo GetReadyState e attendendo che il metodo EnsureReadyAsync restituisca correttamente.
Una volta che il modello di "image segmentation" è disponibile, creare un oggetto ImageObjectExtractor per farvi riferimento.
Passare l'immagine a ImageObjectExtractor.CreateWithSoftwareBitmapAsync.
Creare un oggetto ImageObjectExtractorHint . Altri modi per creare un oggetto hint con input diversi vengono illustrati in un secondo momento.
Inviare l'hint al modello usando il metodo GetSoftwareBitmapObjectMask , che restituisce il risultato finale.

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

Specificare suggerimenti con punti inclusi ed esclusi

Questo frammento di codice illustra come usare punti inclusi ed esclusi come hint.

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

Specificare i suggerimenti con rettangolo

Questo frammento di codice illustra come usare un rettangolo (RectInt32 è X, Y, Width, Height) come hint.

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

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

Cosa posso fare con la cancellazione di oggetti?

La cancellazione degli oggetti può essere usata per rimuovere oggetti dalle immagini. Il modello accetta sia un'immagine che una maschera in scala di grigi che indica l'oggetto da rimuovere, cancella l'area mascherata dall'immagine e sostituisce l'area cancellata con lo sfondo dell'immagine.

Rimuovere oggetti indesiderati da un'immagine

Nell'esempio seguente viene illustrato come rimuovere un oggetto da un'immagine. Nell'esempio si presuppone che siano già presenti oggetti bitmap software (softwareBitmap) sia per l'immagine che per la maschera. La maschera deve essere in formato Gray8 con ogni pixel dell'area da rimuovere su 255 e tutti gli altri pixel impostati su 0.

Verificare che il modello di segmentazione dell'immagine sia disponibile chiamando il metodo GetReadyState e attendendo che il metodo EnsureReadyAsync restituisca correttamente.
Quando il modello Di cancellazione oggetti è disponibile, creare un oggetto ImageObjectRemover per farvi riferimento.
Inviare infine l'immagine e la maschera al modello usando il metodo RemoveFromSoftwareBitmap , che restituisce il risultato finale.

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

Intelligenza artificiale responsabile

È stata usata una combinazione dei passaggi seguenti per garantire che queste API di imaging siano affidabili, sicure e create in modo responsabile. È consigliabile esaminare le procedure consigliate descritte in Sviluppo di intelligenza artificiale responsabile in Windows quando si implementano le funzionalità di intelligenza artificiale nell'app.