Procedura per accorgersi che i dati che arrivano a un modello pubblicato non somigliano più a quelli con cui è stato addestrato. L'endpoint salva ogni richiesta, un monitor la confronta con i dati di addestramento colonna per colonna e segnala le colonne che si sono spostate. Una console .NET manda prima fiori simili a quelli di addestramento, poi fiori con i petali più lunghi del 50%.

Occorre: l'area di lavoro mlw-guide-extranet-01 con il modello iris-model registrato nella versione 2, cioè i passi da 1 a 8 della guida Addestrare una rete neurale su Azure Machine Learning e chiamarla da .NET, Python con scikit-learn e .NET 10 sul computer. Durata: circa tre ore, quasi tutte di attesa: nella prova la pubblicazione ha richiesto 25 minuti e il controllo del monitor un'ora e mezza. Costo: pochi dollari, se elimini le risorse alla fine. Lo studio indica 0,12 dollari l'ora per la macchina dell'endpoint e 0,55 dollari l'ora per ciascuna delle macchine del controllo.

Lo studio delle schermate è in inglese: i nomi dei comandi sono riportati come appaiono a schermo.

I dati di riferimento

1. Prepara la cartella

Il monitor confronta le richieste con una tabella di riferimento: le 105 righe usate per l'addestramento, divise come nello script della guida di partenza. Crea riferimento.py:

from pathlib import Path
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

iris = load_iris(as_frame=True)
features = iris.data
features.columns = ["sepal_length", "sepal_width", "petal_length", "petal_width"]
x_train, _, _, _ = train_test_split(
    features, iris.target, test_size=0.3, random_state=42, stratify=iris.target)

folder = Path("iris-reference")
folder.mkdir(exist_ok=True)
x_train.to_csv(folder / "iris.csv", index=False)
(folder / "MLTable").write_text("""paths:
  - file: ./iris.csv
transformations:
  - read_delimited:
      delimiter: ","
      header: all_files_same_headers
""")

Avvia python riferimento.py. Nasce la cartella iris-reference con iris.csv e MLTable, il file che dice ad Azure come leggere la tabella.

2. Registra la tabella

Nello studio apri Data > Create e compila:

  • Name: iris-reference
  • Type: Table (mltable)

Premi Next, scegli From local files, poi l'archivio proposto, workspaceblobstore. Premi Upload folder e scegli la cartella iris-reference.

La cartella con MLTable caricata

Premi Next e Create.

Le richieste da controllare

3. Pubblica il modello con la raccolta dei dati

Apri Models > iris-model, versione 2, premi Use this model > Real-time endpoint e compila:

  • Instance count: 1
  • Virtual machine: Standard_D2as_v4, quella proposta
  • Endpoint: New
  • Endpoint name: un nome tuo, unico nella regione, qui iris-drift-extranet-01
  • Deployment name: main
  • Inferencing data collection: Enabled

La pubblicazione con la raccolta dei dati attiva

Premi Deploy. Con la raccolta attiva l'endpoint salva ogni richiesta e ogni risposta: in Data compaiono iris-drift-extranet-01-main-model_inputs e iris-drift-extranet-01-main-model_outputs.

4. Copia indirizzo e chiave

In Endpoints > iris-drift-extranet-01, scheda Consume, copia REST endpoint e Primary key. La chiave dà accesso al modello: non scriverla nel codice e non pubblicarla.

5. Crea la console

dotnet new console -n iris-drift
cd iris-drift

Sostituisce Program.cs. Manda 30 richieste da 10 fiori, inventati a partire da media e deviazione delle misure delle tre specie. Con un argomento moltiplica per quel numero lunghezza e larghezza dei petali.

using System.Net.Http.Headers;
using System.Net.Http.Json;

string scoringUri = Environment.GetEnvironmentVariable("SCORING_URI")!;
string key = Environment.GetEnvironmentVariable("ENDPOINT_KEY")!;
double petalFactor = args.Length > 0 ? double.Parse(args[0], System.Globalization.CultureInfo.InvariantCulture) : 1.0;

// average measures and standard deviation of the three species, in cm
double[][] means = [[5.0, 3.4, 1.5, 0.2], [5.9, 2.8, 4.3, 1.3], [6.6, 3.0, 5.6, 2.0]];
double[][] deviations = [[0.35, 0.38, 0.17, 0.11], [0.52, 0.31, 0.47, 0.20], [0.64, 0.32, 0.55, 0.27]];

Random random = new(42);
double Normal(double mean, double deviation) =>
    mean + deviation * Math.Sqrt(-2 * Math.Log(1 - random.NextDouble())) * Math.Cos(2 * Math.PI * random.NextDouble());

using HttpClient http = new();
http.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", key);

int sent = 0;
for (int request = 0; request < 30; request++)
{
    double[][] flowers = new double[10][];
    for (int i = 0; i < flowers.Length; i++)
    {
        int species = random.Next(3);
        double[] f = new double[4];
        for (int c = 0; c < 4; c++)
        {
            f[c] = Math.Round(Math.Max(0.1, Normal(means[species][c], deviations[species][c])), 1);
        }
        f[2] = Math.Round(f[2] * petalFactor, 1);
        f[3] = Math.Round(f[3] * petalFactor, 1);
        flowers[i] = f;
    }

    var body = new
    {
        input_data = new
        {
            columns = new[] { "sepal_length", "sepal_width", "petal_length", "petal_width" },
            index = Enumerable.Range(0, flowers.Length).ToArray(),
            data = flowers,
        },
    };

    using HttpResponseMessage response = await http.PostAsJsonAsync(scoringUri, body);
    response.EnsureSuccessStatusCode();
    sent += flowers.Length;
}

Console.WriteLine($"{sent} flowers sent, petal factor {petalFactor}");

6. Manda fiori normali e fiori spostati

Imposta le due variabili con i valori copiati e avvia:

export SCORING_URI=https://iris-drift-extranet-01.westeurope.inference.ml.azure.com/score
export ENDPOINT_KEY=<chiave>
dotnet run
dotnet run -- 1.5

In PowerShell le prime due righe sono $env:SCORING_URI = "..." e $env:ENDPOINT_KEY = "...". Nella prova:

300 flowers sent, petal factor 1
300 flowers sent, petal factor 1.5

Il primo giro imita i dati di addestramento; il secondo ha i petali più lunghi e più larghi del 50%, come se arrivassero misure di una varietà che il modello non ha mai visto.

Il monitor

7. Crea il monitor

Apri Monitoring > Add e compila:

  • Select model: iris-model, versione 2
  • Select deployment with data collection enabled: iris-drift-extranet-01/main
  • Select training data: iris-reference:1, da Search for data
  • Model task type: Classification
  • Monitor name: iris-drift-monitor
  • Virtual machine size: Standard_E4s_v3, quella proposta

In fondo scegli quando gira il controllo. Nella prova Cron expression con 0 * * * *, cioè ogni ora; l'ora è in UTC.

Le impostazioni di base del monitor

Premi Next. In Configure data asset lo studio ha già aggiunto le tre tabelle: premi Next.

8. Tieni solo il segnale del drift

In Select monitoring signals lo studio propone quattro segnali. Nella prova, con tutti e quattro, Next restava disattivato: elimina con Delete tutti tranne data-drift-signal.

Il solo segnale del drift dei dati

Il segnale confronta le colonne delle richieste con quelle di riferimento: per i numeri usa la distanza di Wasserstein normalizzata, con soglia 0,1. Premi Next, in Notifications scrivi l'indirizzo che riceve gli avvisi, premi Next e Create.

9. Libera la quota

Il controllo gira su Spark e chiede fino a cinque macchine Standard_E4s_v3 da 4 core, 20 core in tutto. Nella prova la sottoscrizione aveva 20 core per Azure Machine Learning in West Europe, e 4 li occupava l'endpoint: il controllo è rimasto in coda per ore, con il messaggio This job is waiting for available quota in scheduling queue. Dalla pagina Quota dello studio l'aumento per la famiglia ESv3 è stato rifiutato.

Le richieste sono già salvate al passo 3, quindi l'endpoint non serve più. In Endpoints > iris-drift-extranet-01, scheda Details, premi Update traffic, scrivi 0 per main e premi Update; poi, nel riquadro Deployment main, premi l'icona del cestino, spunta Delete deployment: main e premi Delete.

La conferma dell'eliminazione di main

La conferma avvisa che l'eliminazione spegne anche il monitor.

10. Avvia il controllo

In Monitoring spunta iris-drift-monitor e premi Enable, poi Trigger manually e Submit. Il controllo parte subito, senza aspettare l'ora. Nella prova è durato un'ora e mezza.

Il risultato

11. Leggi il drift

Apri iris-drift-monitor. Il riquadro Signals mostra quante colonne superano la soglia; Notifications elenca gli avvisi.

Il monitor con quattro colonne sopra la soglia

Premi data-drift-signal per le distanze di ogni colonna. Nella prova:

Le distanze per colonna

Colonna Distanza
petal_length 0,621
petal_width 0,447
sepal_length 0,108
sepal_width 0,106

I petali, spostati del 50% in metà delle richieste, superano la soglia di molte volte. I sepali, non toccati, la superano di poco: sono i fiori inventati dalla console, che non somigliano del tutto a quelli veri. La soglia va tarata sui propri dati e si cambia con Edit signal: con 0,15, le distanze dei sepali della prova resterebbero sotto.

12. Spegni il monitor

In Monitoring spunta iris-drift-monitor, premi Disable e conferma. Spento, non avvia più controlli a pagamento.

Eliminare le risorse

13. Elimina il gruppo

Elimina il gruppo rg-guide-ml-01 come al passo 13 della guida di partenza.

14. Elimina in modo definitivo l'area di lavoro

Sul portale cerca Azure Machine Learning, premi Recently deleted, scegli la sottoscrizione e, in Location, West Europe. Spunta mlw-guide-extranet-01 e premi Permanently delete, come al passo 14 della guida di partenza. Senza questo passo, per 14 giorni non puoi creare un'area di lavoro con lo stesso nome.

Nomi dei comandi, schermate e risultati rilevati il 17 novembre 2026, regione West Europe, con .NET 10.