---

Novembre 2017

Volume 33 Numero 11

Il presente articolo è stato tradotto automaticamente.

Machine Learning - Analisi delle serie temporali di Azure Machine Learning per il rilevamento anomalie

Da Dawid Borycki

Rilevamento di anomalie è una delle funzionalità più importanti di soluzioni di Internet delle cose (IoT) di raccogliere e analizzare lemento-poral modifiche dei dati da varie sensori. In molti scenari di dati del sensore non viene modificato in modo significativo nel tempo. Tuttavia, quando esegue, in genere significa che il sistema ha rilevato un'anomalia, e questo anomalie possono causare un malfunzionamento specifico. In questo articolo verrà illustrato come utilizzare il rilevamento di anomalie serie Azure Machine Learning ora per identificare letture dei sensori anomali. A tal fine verrà estendere l'app RemoteCamera Universal Windows Platform (UWP) è sviluppato nell'articolo precedente (msdn.com/magazine/mt809116) mediante l'aggiunta di un elenco che consente di visualizzare valori anomali (vedere figura 1). L'app RemoteCamera acquisisce le immagini da webcam e calcola la luminosità varia intorno a un valore specifico, a meno che l'immagine di fotocamera subisce una modifica significativa. Perché è facilmente può provocare gravi di luminosità (tramite la copertura della fotocamera, ad esempio), iniziali irregolarità, a questa applicazione fornisce un input valido per il rilevamento di anomalie di serie temporali.

Figura 1 rilevamento di anomalie luminosità valori con Azure Machine Learning

Rilevamento di anomalie

Come spiegato in un articolo di recente da James McCaffrey (msdn.com/magazine/mt826350), è un modo comune per il rilevamento di anomalie tramite regressione serie temporali. Mediante l'adattamento di un modello ai dati, è possibile stimare le tendenze e quindi verificare se tutti i valori di sequenza rispettarli calcolando la differenza tra i valori effettivi e stimati. Una divergenza grandi rispetto ai valori previsti indica outlier o valori anomali. In questo caso, prima viene illustrato come rilevare tali outlier analizzando i cosiddetti punteggi z. Maggiore il punteggio z, maggiore sarà la probabilità che il valore effettivo è un valore anomalo. In tal caso, per individuare eventuali anomalie, specificare l'intervallo di punteggi z, che vengono considerati come "normale". Tutti i punteggi z di fuori dell'intervallo di indicano eventuali anomalie. Tuttavia, questo approccio Usa una soglia fissa, pertanto potrebbe causare un numero elevato di falsi positivi. Per risolvere un problema di questo tipo, più complessi algoritmi. In particolare, il modulo di rilevamento di anomalie di Azure ora serie è basato su martingales sostituibilità (bit.ly/2wjBYUU), che analizza se una sequenza di valori può essere riordinata in modo arbitrario senza modificare la probabilità di ricerca di un determinato valore in tale sequenza (o in altre parole, che ogni valore è ugualmente probabile che possano essere trovati in un set di dati). Questa proprietà sostituibilità del set di dati comporta i punteggi di anomalie di piccole dimensioni. Quando sostituibilità viene interrotto, i punteggi di anomalie di grandi dimensioni verranno generati, che indica i valori anomali.

In questo articolo viene illustrato come creare questi algoritmi di machine learning (ML). Utilizzo di Microsoft Azure Machine Learning Studio (studio.azureml.net), che è stata descritta anche con McCaffrey nel numero di settembre 2014 (msdn.com/magazine/dn781358). In questo caso, passerà tale articolo e, come anche come creazione esperimenti di Machine Learning, verrà illustrato come distribuire la soluzione risultante come servizio Web, e quindi utilizzare tale servizio nell'app RemoteCamera.

Il Set di dati di training

È il primo passaggio per estendere l'app RemoteCamera mediante l'aggiunta di un'altra scheda, che consente di acquisire il set di dati di training e di abilitare o disabilitare il rilevamento di anomalie usando una casella di controllo (figura 2).

Figura 2 scheda di rilevamento di anomalie dell'App RemoteCamera

Il pulsante, acquisizione training set, viene attivato dopo avere avviato l'anteprima della fotocamera (usando i controlli dalla prima scheda). Quando si tocca il pulsante, un'app viene avviata l'acquisizione del set di dati di training. Questo funziona in background e viene indicato con un livello di stato. Il set di dati di training risultante è costituito da 100 punti dati, ognuno dei quali è rappresentato da un'istanza della struttura di BrightnessDataPoint:

public struct BrightnessDataPoint
{
  public DateTime Time { get; private set; }
  public byte Brightness { get; private set; }

  public BrightnessDataPoint(byte brightness)
  {
    Time = DateTime.Now;
    Brightness = brightness;
  }
}

Lo struct BrightnessDataPoint archivia un valore di luminosità oltre al tempo che la luminosità è stata determinata. Una raccolta di tali valori verrà quindi esportata nel file BrightnessData.csv, che è simile al seguente:

Time,Brightness
9/8/2017 11:30:00,103
9/8/2017 11:30:01,103
9/8/2017 11:30:02,102
9/8/2017 11:30:03,42
9/8/2017 11:30:04,46
9/8/2017 11:30:05,149
9/8/2017 11:30:06,99
9/8/2017 11:30:07,101
9/8/2017 11:30:08,104

L'ubicazione specifica del set di dati di training viene quindi visualizzato nella casella di testo. Usare un file di delimitato da virgole (CSV) in modo che può essere facilmente caricata in Machine Learning Studio.

Per implementare questa funzionalità, ho scritto due classi: BrightnessFileStorage e AnomalyDetector. La prima classe, la luminosità-FileStorage, è definita nel file BrightnessFileStorage.cs nella sottocartella AnomalyDetection al codice complementare. Luminosità FileStorage Salva una raccolta di oggetti BrightnessDataPoint nel file CSV utilizzando la classe DataWriter (bit.ly/2wS31dq).

La seconda classe AnomalyDetector, gestisce la logica correlata al rilevamento di anomalie. In particolare, include un metodo pubblico, Add-TrainingValue, illustrato nella figura 3, che viene richiamato destra dopo che viene calcolata la luminosità (vedere il gestore dell'evento ImageProcessor_ProcessingDone nel file MainPage.xaml.cs di codice associato). AddTrainingValue procede nel modo seguente: Innanzitutto, creare un'istanza di BrightnessDataPoint, che viene quindi aggiunto alla raccolta. Quando questa raccolta contiene 100 elementi, Salva nel file CSV. Quindi possibile generare l'evento di TrainingDataReady, che viene gestito in MainPage per interrompere l'acquisizione di training set e visualizzare il percorso del file nell'interfaccia utente:

private async void AnomalyDetector_TrainingDataReady(
  object sender, TrainingDataReadyEventArgs e)
{
  await ThreadHelper.InvokeOnMainThread(() =>
  {
    remoteCameraViewModel.IsTrainingActive = false;
    remoteCameraViewModel.TrainingDataSetFilePath = e.FilePath;
  });
}

Figura 3 durante l'acquisizione dei set di dati di Training

private const int trainingDataSetLength = 100;
private List<BrightnessDataPoint> trainingDataSet = 
  new List<BrightnessDataPoint>();

public event EventHandler<TrainingDataReadyEventArgs> TrainingDataReady;

public async Task AddTrainingValue(byte brightness)
{
  trainingDataSet.Add(new BrightnessDataPoint(brightness));

  // Check if all data points were acquired
  if (trainingDataSet.Count == trainingDataSetLength)
  {
    // If so, save them to csv file
    var brightnessFileStorage = 
      await BrightnessFileStorage.CreateAsync();
    await brightnessFileStorage.WriteData(trainingDataSet);

    // ... and inform listeners that the training data set is ready
    TrainingDataReady?.Invoke(this,
      new TrainingDataReadyEventArgs(
      brightnessFileStorage.FilePath));
  }
}

Il percorso del set di dati di training viene visualizzato nella casella di testo, che è facilmente copiarlo e incollarlo in Esplora risorse per visualizzare i dati risultanti.

Z-Score Analysis

Con il training set di dati pronti, preparare l'esperimento in Machine Learning Studio, seguendo le istruzioni nell'articolo 2014 del McCaffrey primo. Innanzitutto caricare il file BrightnessData.csv e quindi progettare l'esperimento usando la finestra di progettazione visiva, come illustrato nel figura 4. In breve, tutti i componenti sono i menu che si trova sul lato sinistro di Machine Learning Studio. Per inserire un elemento nell'esperimento, sufficiente trascinarla nel riquadro esperimento (parte centrale di Machine Learning Studio). Ogni componente specifico input e output. Si connettono i nodi compatibili per controllare il flusso di dati tra i moduli. I componenti possono avere un'ulteriore configurazione, che viene impostato utilizzando la finestra Proprietà (visualizzato nella parte destra di Machine Learning Studio).

Figura 4 il rilevamento di anomalie usando punteggio z Analysis

L'algoritmo di Machine Learning rappresentati figura 4 funziona in due modalità: sperimentazione e servizio Web. Si differenziano solo nell'input. In modalità di registrazione di experi, un input è costituito il set di dati di training caricato (BrightnessData), che viene sostituita dal servizio Web di input nella modalità di servizio Web. Indipendentemente dalla modalità di, l'input viene convertito in un set di dati, quindi i valori dalla colonna luminosità vengono normalizzati mediante la trasformazione del punteggio z (bit.ly/2eWwHAa). La trasformazione converte i valori di luminosità punteggi z, che indicano il valore corrente di quanto si dal valore medio. La distanza è misurata in deviazioni standard. Il più elevato una distanza, maggiore sarà la probabilità che il valore corrente è un valore anomalo. Applicare la normalizzazione del punteggio z perché, in generale, il livello di base o normale luminosità varia a seconda di quale la fotocamera vede. Di conseguenza, la trasformazione del punteggio z garantisce il livello di luminosità corretto dopo normaliza ne è vicino a 0. I valori non elaborati luminosità variano da circa 40-150. Dopo la normalizzazione, tutti i valori di luminosità saranno compresi tra circa-4.0 e +4.0, come illustrato nella figura 5. Di conseguenza, per trovare i valori anomali sufficiente per eseguire è applicare il filtro di soglia. In questo caso, usare il filtro di soglia Azure Machine Learning di tipo OutOfRange con i limiti superiore e inferiore impostati su -2 e 1.5. Si sceglie di questi valori in base ai punteggi z tracciato in figura 5 e impostarli utilizzando il riquadro proprietà del filtro di soglia in Machine Learning Studio.

Figura 5, il set di dati di Training dopo la normalizzazione

Dopo la soglia, il set di dati contiene una colonna booleana che specifica se un punto specificato è compreso nell'intervallo specificato. Per integrare queste informazioni con i valori effettivi luminosità identificate come outlier, combinare questa colonna con il set di dati originale e quindi dividere il set di dati risultante in due subset: uno che contiene solo valori anomali e l'altro con la normale valori (vedere la parte inferiore figura 4). Modificare il tipo di dati di colonna prima della suddivisione, perché il modulo di suddivisione dei dati non accetta valori booleani. Quindi, il primo subset viene restituito dall'esperimento. Nella visualizzazione del servizio Web, questo risultato viene trasferito al client. Si noti che per visualizzare i valori da un set di dati è utilizzare il set di dati di risultati | Visualizzare l'opzione dal menu di scelta rapida set di dati in Machine Learning Studio. Questa opzione funziona fornito in precedenza è stato eseguito l'esperimento. Figura 6 illustra un esempio di tale visualizzazione dell'ultimo set di dati da nell'esperimento figura 4.

Figura 6 rilevato valori anomali con punteggio z Analysis

Machine Learning analisi delle serie temporali

Vediamo ora come usare il modulo di rilevamento di anomalie serie (ATSAD) di Azure ora per identificare gli outlier. Come illustrato nella figura 7, il flusso dell'esperimento è piuttosto simile a quella precedente. Il set di dati iniziale viene normalizzato e trasformazione di punteggio z trans-ferred al modulo ATSAD (è possibile trovare il nodo Time Series di Machine Learning Studio). Questa operazione è necessario fornire più input, che vengono configurati con la finestra Proprietà (bit.ly/2xUGTg2). Prima specificare le colonne di dati e l'ora, quindi si configura il tipo di martingale. Qui viene utilizzato il martingale di alimentazione. Questa operazione attiva un'altra casella di testo, Epsilon, in cui è possibile digitare qualsiasi valore da 0 a 1 per specificare la sensibilità del rilevamento. Quindi, scegliere una funzione e sul, utilizzando una delle tre opzioni:

• RangePercentile: Utilizzare questa opzione per identificare i valori sono chiaramente non compreso nell'intervallo, ad esempio picchi o DIP. Usare questa opzione in my esperimento in modo che funzioni Analogamente a esperimento precedente, ma con un'analisi più completa.
• SlowPos e SlowNegTrend: Utilizzare queste opzioni per identificare le modifiche positive e negative tendenza nel set di dati. Ciò è utile quando la soluzione cerca aumenta o diminuisce in valori osservati.

Figura 7 un esperimento che utilizzano il modulo di rilevamento delle anomalie serie Azure ora

Successivamente, specificare la lunghezza della cronologia dei valori martingale ed e sul. È possibile scegliere qualsiasi numero intero compreso tra 10 e 1000. Dopo un po' di sperimentazione trial-and-error, stabilito i parametri seguenti per il rilevamento:

• Epsilon = 0,4
• Lunghezza di martingale ed e sul valori cronologia = 50

L'ultimo parametro il rilevamento è una soglia di avviso, che specifica il valore minimo del punteggio di anomalie che contrassegna il valore specificato come outlier. Per impostazione predefinita, la soglia di avviso è impostata su 3.5. Per la sperimentazione, dopo aver modificato questa a 2.

Se si visualizza l'output del modulo ATSAD, si noterà che integra il set di dati di input con due colonne: il punteggio di anomalie, che misura le anomalie, e l'indicatore di avviso, che contiene un valore binario (0 o 1) che indica se un valore è anomalo. Utilizzare quest'ultimo per suddividere il set di dati in due subset: normali e anomali. Solo il subset anomalo viene restituito dall'esperimento. Gli altri elementi dell'esperimento sono identici a quelli precedenti in modo non verrà trattata di nuovo. Solo possibile notare che un aspetto molto importante dell'esperimento necessaria per un servizio Web è il nome di input e output. Questi valori si imposta su dati (input del servizio Web) e AnomalyDetectionResult (output del servizio Web).

Client del servizio Web

Con gli esperimenti di impostare è possibile ora pubblicarli come servizi Web in modo da renderli accessibili dall'app RemoteCamera per identificare eventuali anomalie di luminosità di immagine. Per configurare un servizio Web è necessario eseguire l'esperimento e quindi premere l'icona di distribuzione di servizio Web nel riquadro inferiore di Machine Learning Studio (vedere l'elemento evidenziato in figura 8). Se non aggiungere l'input del servizio Web e i moduli per l'esperimento di output, questo riquadro viene visualizzato di servizio Web. Se è selezionata, servizio Web di input e output moduli verranno aggiunto l'esperimento, e l'etichetta del pulsante Cambia al servizio Web di distribuire.

Figura 8 di Azure Machine Learning Studio azione riquadro

Al termine della distribuzione del servizio Web, si verrà reindirizzati a dashboard del servizio Web, illustrato nella figura 9. Il dashboard Visualizza un riepilogo del servizio Web pubblicato, insieme alla chiave dell'API e istruzioni su come inviare le richieste e gestire le risposte (pagina della Guida API). In particolare, dopo aver fatto clic sul collegamento ipertestuale di richiesta/risposta, un URL del servizio Web e un richiesta dettagliata e una struttura di risposta in formato JSON verrà visualizzate.

Figura 9, il Dashboard del servizio Web

Per continuare, archiviare la chiave API e creano JSON-a-C# mapping tramite il servizio JSONUtils (jsonutils.com). Quindi salvare le classi risultante nel file corrispondenti, AnomalyDetectionRequest.cs e AnomalyDetectionResponse.cs, nella sottocartella AnomalyDetection. La struttura è simile, entrambi i file contengono le classi, che normalmente sono composte da principalmente le proprietà implementate automaticamente. AnomalyDetectionRequest e AnomalyDetectionResponse rappresentano oggetti JSON corrispondenti trasmessi tra un client e un servizio Web. Ad esempio, la definizione della classe AnomalyDetectionRequest e gli oggetti dipendenti è specificata in figura 10. Si noti che per convertire una raccolta di punti dati luminosità a un input accettato dal servizio Web di Machine Learning Studio (matrice bidimensionale di stringhe), usare una classe helper, ConversionHelper. Quest'ultimo, la definizione completa è il codice complementare, dispone di due metodi pubblici. È la raccolta di punti dati luminosità vengono convertite in stringa [,] (BrightnessDataToStringTable) o viceversa versa (AnomalyDetectionResponseToBrignthessData).

Figura 10 A definizione della classe AnomalyDetectionRequest e gli oggetti dipendenti

public class AnomalyDetectionRequest
{
  public Inputs Inputs { get; set; }
  public GlobalParameters GlobalParameters { get; set; }

  public AnomalyDetectionRequest(
    IList<BrightnessDataPoint> brightnessData)
  {
    Inputs = new Inputs()
    {
      Data = new Data()
      {
        ColumnNames = new string[]
        {
          "Time",
          "Brightness"
        },

          Values = ConversionHelper.
            BrightnessDataToStringTable(brightnessData)
      }
    };
  }
}

public class Inputs
{ 
  public Data Data { get; set; }
}

public class Data
{
  public string[] ColumnNames { get; set; }
  public string[,] Values { get; set; }
}

public class GlobalParameters { }

Una volta JSON-a-mapping degli oggetti in c# viene stabilito, è possibile scrivere il client del servizio Web effettivo. A tale scopo prima di tutto installare il pacchetto NuGet webapi e utilizzarlo per definire la classe AnomalyDetectionClient (vedere il file corrispondente nel codice complementare). Questa classe contiene tre campi privati: baseAddress, apiKey e httpClient. Il primo campo memorizza l'URL del servizio Web di Machine Learning Studio, mentre la seconda contiene la chiave API. Questi due valori vengono utilizzati per creare un'istanza della classe HttpClient (dal pacchetto NuGet installato):

public AnomalyDetectionClient()
{
  httpClient = new HttpClient()
  {
    BaseAddress = new Uri(baseAddress),
  };

  httpClient.DefaultRequestHeaders.Authorization = 
    new AuthenticationHeaderValue("Bearer", apiKey);
}

Dopo aver creato il client, è possibile avviare l'invio di richieste al servizio Web di Machine Learning Studio con il metodo AnomalyDetectionClient.DetectAnomalyAsync da figura 11. Questo metodo accetta una raccolta di punti dati luminosità, che rappresentano i dati di test. Questi dati di test sostituiscono il file CSV è utilizzata in precedenza per provare e viene utilizzato per creare un'istanza AnomalyDetectionRequest. Un'istanza di questa classe viene registrata in un secondo momento il servizio Web per l'analisi con il metodo di estensione PostAsJsonAsync. La risposta JSON risultante viene convertita all'istanza della classe AnomalyDetectionResponse, che viene infine restituito dalla funzione DetectAnomalyAsync. Anche di cercare eventuali errori e alla fine di generare un'eccezione se appropriato.

Figura 11 l'invio di richieste al servizio Web Azure Machine Learning Studio

public async Task<IList<BrightnessDataPoint>> 
  DetectAnomalyAsync(IList<BrightnessDataPoint> brightnessData)
{
  var request = new AnomalyDetectionRequest(brightnessData);

  var response = await httpClient.PostAsJsonAsync(string.Empty, request);

  IList<BrightnessDataPoint> result; 

  if (response.IsSuccessStatusCode)
  {
    var anomalyDetectionResponse = await 
      response.Content.ReadAsAsync<AnomalyDetectionResponse>();

    result = ConversionHelper.
      AnomalyDetectionResponseToBrightnessData(anomalyDetectionResponse);
  }
  else
  {
    throw new Exception(response.ReasonPhrase);
  }

  return result;
}

Il AnomalyDetectionClient viene utilizzato nel metodo della classe AnomalyDetector AddTestValue (figura 12). Ad esempio AddTrain-ingValue, AddTestValue viene anche richiamato nel gestore dell'evento ImageProcessor_ProcessingDone (vedere MainPage.xaml.cs nel codice compan ion). Tuttavia, AddTestValue procede in modo leggermente diverso rispetto al metodo AddTrainingValue. In AddTestValue aggiungere punti dati luminosità a un'istanza della classe BrightnessDataset, che utilizza internamente la classe generica List per implementare una finestra in sequenza. Questa finestra è simile a quello nell'articolo di ottobre di James McCaffrey, viene utilizzata per archiviare i valori di test. Per impostazione predefinita, le dimensioni della finestra in sequenza sono impostata su 30 elementi, ma è possibile controllare questo valore utilizzando un costruttore del BrightnessDataset. Come illustrato nella figura 12, non inviare dati per l'analisi fino a quando la finestra è completa, quindi verificare se la raccolta di valori anomali restituiti dal servizio Web contiene elementi. Se in tal caso, richiama l'evento AnomalyDetected, che viene usata anche per passare le anomalie di listener di traccia.

Figura 12 rilevamento di anomalie

public event EventHandler<AnomalyDetectedEventArgs> AnomalyDetected;
private BrightnessDataset dataSet = new BrightnessDataset();

public async Task AddTestValue(byte brightness)
{
  dataSet.Add(new BrightnessDataPoint(brightness));

  if (dataSet.IsFull)
  {
    try
    {
      var anomalousValues = await anomalyDetectionClient.
        DetectAnomalyAsync(dataSet.Data);

      if (anomalousValues.Count > 0)
      {
        AnomalyDetected?.Invoke(this,
          new AnomalyDetectedEventArgs(anomalousValues));
      }
    }
    catch (Exception ex)
    {
      Debug.WriteLine(ex);
    }
  }
}

Per visualizzare valori anomali nell'interfaccia utente, gestisce l'evento AnomalyDetected nella classe MainPage nel modo seguente:

private async void AnomalyDetector_AnomalyDetected(
  object sender, AnomalyDetectedEventArgs e)
{
  await ThreadHelper.InvokeOnMainThread(() =>
  {
    foreach (var anomalousValue in e.AnomalousValues)
    {
      if (!remoteCameraViewModel.AnomalousValues.Contains(anomalousValue))
      {
        remoteCameraViewModel.AnomalousValues.Add(anomalousValue);
      }
    }
  });
}

In particolare, scorre la raccolta di valori ottenuti per verificare se sono già stati aggiunti all'archivio dati locale (la proprietà AnomalousValues del modello di visualizzazione). In caso contrario, è aggiungerli alla raccolta osservabile. Di conseguenza, i nuovi valori anomali verranno visualizzato nell'elenco riportato precedentemente in figura 1. Eseguo questo controllo aggiuntivo a causa di finestra in sequenza, in cui viene modificato un solo elemento tra le chiamate successive al servizio Web.

Per testare la soluzione, è necessario eseguire l'app RemoteCamera, avviare l'anteprima della fotocamera e abilitare il rilevamento di anomalie usando la casella di controllo nella scheda il rilevamento di anomalie. Al termine è possibile generare valori anomali tramite la copertura della fotocamera. Questi valori devono essere riconosciuti rapidamente per il rilevamento di ML remoto come anomala e visualizzato nella casella di riepilogo (come in figura 1).

Conclusione

Illustrato di seguito come progettare due esperimenti di rilevamento di anomalie diversi in Azure Machine Learning Studio. Entrambi exper-iments inoltre sono stati distribuiti come servizi Web e combinato con l'applicazione client RemoteCamera, che invia i dati acquisiti in locale della serie temporale per l'analisi di machine learning identificare eventuali anomalie. In questo caso, si usa un servizio Web nell'app UWP. Tuttavia, è possibile utilizzare lo stesso codice per accedere a un servizio Web da un'app Web ASP.NET, in cui si gestisce la logica di ML alla fine anziché sull'endpoint, che, nel caso di IoT può essere solo un sensore semplice.

---

Dawid Borycki* è un tecnico del software e ingegno biomedica altoparlante conferenze e autore. Ama nuove tecnologie per la creazione di prototipi e di software esperimenti di apprendimento.*

Grazie per il seguente esperto tecnico di Microsoft per la revisione dell'articolo: Dr. James McCaffrey

---

Viene illustrato in questo articolo nel forum di MSDN Magazine