Kurz: Naučte se lineární detekci anomálií za jednu hodinu

Detektor anomálií s detekcí anomálií lineární (MVAD) je pokročilý nástroj AI pro detekci anomálií ze skupiny metrik bez dohledu .

Obecně platí, že pomocí MVAD můžete provést tyto kroky:

1. Vytvořte prostředek detektoru anomálií, který podporuje MVAD v Azure.
2. Připravte data.
3. Školení modelu MVAD.
4. Dotaz na stav modelu
5. Detekci anomálií pomocí proučeného modelu MVAD.
6. Načtení a interpretace výsledků odvození.

V tomto kurzu:

1. vytvoření prostředku detektoru anomálií, který podporuje MVAD

• Vytvořte si předplatné Azure, pokud ho nechcete vytvořit zdarma .
• Jakmile budete mít předplatné Azure, vytvořte v Azure Portal prostředek detektoru anomálií , abyste získali klíč rozhraní API a koncový bod rozhraní API.

2. Příprava dat

Pak potřebujete připravit školicí data (a odvozovat data).

Schéma vstupních dat

MVAD detekuje anomálie ze skupiny metrik a každou metriku nazýváme proměnnou nebo časovou řadu.

• Ukázkový datový soubor si můžete stáhnout od Microsoftu a zkontrolovat přijaté schéma z: https://aka.ms/AnomalyDetector/MVADSampleData

• Každá proměnná musí mít dvě a jenom dvě pole a a by měla být uložena v souboru hodnot oddělených timestamp value čárkami (CSV).

• Názvy sloupců souboru CSV by měly být přesně a timestamp value . Rozlišují se malá a velká písmena.

• Hodnoty timestamp by měly odpovídat standardu ISO 8601; hodnota může být celá čísla nebo desetinná čísla s value libovolným počtem desetinných míst. Dobrý příklad obsahu souboru CSV:

  časové razítko	hodnota
  2019-04-01T00:00:00Z	5
  2019-04-01T00:01:00Z	3,6
  2019-04-01T00:02:00Z	4
  ...	...

  Poznámka

  Pokud máte časová razítka v hodinách, minutách nebo sekundách, před voláním rozhraní API se ujistěte, že jsou správně zaokrouhlená nahoru.

  Pokud má mít například frekvence dat jeden datový bod každých 30 sekund, ale vidíte časová razítka jako 12:00:01 a 12:00:28, je to silný signál, že byste měli časová razítka předem zpracovat na nové hodnoty, jako jsou 12:00:00 a 12:00:30.

  Podrobnosti najdete v části "Zaokrouhlení časového razítka nahoru" v dokumentu s osvědčenými postupy.

• Název souboru CSV se použije jako název proměnné a měl by být jedinečný. Například "temperature.csv" a "humidity.csv".

• Proměnné pro trénování a proměnné pro odvozování by měly být konzistentní. Pokud například pro trénování používáte , , , a , měli byste pro odvození zadat přesně stejné series_1 series_2 series_3 series_4 series_5 proměnné.

• Soubory CSV by se měly zkomprimovat do souboru ZIP a nahrát do kontejneru objektů blob Azure. Soubor zip může mít název, který chcete.

Struktura složek

Běžnou chybou při přípravě dat jsou další složky v souboru zip. Předpokládejme například, že název souboru zip je series.zip . Po dekomprimování souborů do nové složky je správná cesta k souborům CSV a nesprávná cesta ./series může být ./series/series_1.csv ./series/foo/bar/series_1.csv .

Správný příklad adresářového stromu po dekomprimování souboru zip v Windows

.
└── series
    ├── series_1.csv
    ├── series_2.csv
    ├── series_3.csv
    ├── series_4.csv
    └── series_5.csv

Nesprávný příklad adresářového stromu po dekomprimování souboru zip v Windows

.
└── series
    └── series
        ├── series_1.csv
        ├── series_2.csv
        ├── series_3.csv
        ├── series_4.csv
        └── series_5.csv

Nástroje pro zipování a nahrávání dat

V této části sdílíme ukázkový kód a nástroje, které můžete zkopírovat a upravit pro přidání do vlastní logiky aplikace, která se zabývá MVAD vstupními daty.

Komprimace souborů CSV v * NIX

zip -j series.zip series/*.csv

Komprimace souborů CSV v Windows

• Přejděte do složky se všemi soubory CSV.
• Vyberte všechny soubory CSV, které potřebujete.
• Klikněte pravým tlačítkem na jeden ze souborů CSV a vyberte Send to .
• Vyberte Compressed (zipped) folder z rozevíracího seznamu.
• Přejmenujte soubor zip podle potřeby.

Python Code zipování & nahrávání dat do Azure Blob Storage

V tomto dokumentu najdete informace o tom, jak nahrát soubor do objektu blob Azure.

Nebo můžete odkazovat na vzorový kód uvedený níže, který může zipování a nahrávat za vás. Kód Pythonu v této části můžete zkopírovat a uložit jako soubor. py (například zipAndUpload.py ) a spustit ho pomocí příkazových řádků, jako jsou tyto:

• python zipAndUpload.py -s "foo\bar" -z test123.zip -c {azure blob connection string} -n container_xxx

  Tento příkaz zkomprimuje všechny soubory CSV do foo\bar jednoho souboru zip s názvem test123.zip . Nahraje se test123.zip do kontejneru container_xxx v objektu BLOB.

• python zipAndUpload.py -s "foo\bar" -z test123.zip -c {azure blob connection string} -n container_xxx -r

  Tento příkaz provede totéž jako u výše uvedeného, ale test123.zip po úspěšném nahrání soubor zip odstraní.

Náhodné

• --source-folder, -s , cesta ke zdrojové složce obsahující soubory CSV
• --zipfile-name, -z , název souboru ZIP
• --connection-string, -c , připojovací řetězec k objektu BLOB
• --container-name, -n , název kontejneru
• --remove-zipfile, -r Pokud je zapnuto, odebrat soubor zip

import os
import argparse
import shutil
import sys

from azure.storage.blob import BlobClient
import zipfile


class ZipError(Exception):
    pass


class UploadError(Exception):
    pass


def zip_file(root, name):
    try:
        z = zipfile.ZipFile(name, "w", zipfile.ZIP_DEFLATED)
        for f in os.listdir(root):
            if f.endswith("csv"):
                z.write(os.path.join(root, f), f)
        z.close()
        print("Compress files success!")
    except Exception as ex:
        raise ZipError(repr(ex))


def upload_to_blob(file, conn_str, cont_name, blob_name):
    try:
        blob_client = BlobClient.from_connection_string(conn_str, container_name=cont_name, blob_name=blob_name)
        with open(file, "rb") as f:
            blob_client.upload_blob(f, overwrite=True)
        print("Upload Success!")
    except Exception as ex:
        raise UploadError(repr(ex))


if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("--source-folder", "-s", type=str, required=True, help="path to source folder")
    parser.add_argument("--zipfile-name", "-z", type=str, required=True, help="name of the zip file")
    parser.add_argument("--connection-string", "-c", type=str, help="connection string")
    parser.add_argument("--container-name", "-n", type=str, help="container name")
    parser.add_argument("--remove-zipfile", "-r", action="store_true", help="whether delete the zip file after uploading")
    args = parser.parse_args()

    try:
        zip_file(args.source_folder, args.zipfile_name)
        upload_to_blob(args.zipfile_name, args.connection_string, args.container_name, args.zipfile_name)
    except ZipError as ex:
        print(f"Failed to compress files. {repr(ex)}")
        sys.exit(-1)
    except UploadError as ex:
        print(f"Failed to upload files. {repr(ex)}")
        sys.exit(-1)
    except Exception as ex:
        print(f"Exception encountered. {repr(ex)}")

    try:
        if args.remove_zipfile:
            os.remove(args.zipfile_name)
    except Exception as ex:
        print(f"Failed to delete the zip file. {repr(ex)}")

3. výuka modelu MVAD

Tady je ukázkový text požadavku a vzorový kód v Pythonu pro výuku modelu MVAD.

// Sample Request Body
{
    "slidingWindow": 200,
    "alignPolicy": {
        "alignMode": "Outer",
        "fillNAMethod": "Linear", 
        "paddingValue": 0
    },
    // This could be your own ZIP file of training data stored on Azure Blob and a SAS url could be used here
    "source": "https://aka.ms/AnomalyDetector/MVADSampleData", 
    "startTime": "2021-01-01T00:00:00Z", 
    "endTime": "2021-01-02T12:00:00Z", 
    "displayName": "Contoso model"
}

# Sample Code in Python
########### Python 3.x #############
import http.client, urllib.request, urllib.parse, urllib.error, base64

headers = {
    # Request headers
    'Content-Type': 'application/json',
    'Ocp-Apim-Subscription-Key': '{API key}',
}

params = urllib.parse.urlencode({})

try:
    conn = http.client.HTTPSConnection('{endpoint}')
    conn.request("POST", "/anomalydetector/v1.1-preview/multivariate/models?%s" % params, "{request body}", headers)
    response = conn.getresponse()
    data = response.read()
    print(data)
    conn.close()
except Exception as e:
    print("[Errno {0}] {1}".format(e.errno, e.strerror))

####################################

Kód odpovědi 201 indikuje úspěšný požadavek.

Vstupní parametry

Požadované parametry

Při žádostech rozhraní API pro trénování a odvozování se vyžaduje tyto tři parametry:

• source– Odkaz na soubor zip umístěný ve složce Azure Blob Storage se sdílenými přístupové podpisy (SAS).
• startTime – Čas zahájení dat používaných pro trénování nebo odvozování. Pokud je dřívější než skutečné nejstarší časové razítko v datech, použije se jako výchozí bod skutečné nejstarší časové razítko.
• endTime – Koncový čas dat používaných pro trénování nebo odvozování, která musí být pozdější než nebo rovna startTime . Pokud je hodnota pozdější než skutečné nejnovější časové razítko v datech, použije se jako koncový bod skutečné nejnovější endTime časové razítko. Pokud se rovná , znamená to odvozování jednoho datového bodu, který se často endTime startTime používá ve scénářích streamování.

Volitelné parametry pro rozhraní API pro trénování

Další parametry pro rozhraní API pro trénování jsou volitelné:

• slidingWindow – Kolik datových bodů se používá k určení anomálií. Celé číslo v rozmezí 28 až 2 880. Výchozí hodnota je 300. Pokud je pro trénování modelu, měly by být během odvozování alespoň body přístupné ze slidingWindow k zdrojového souboru, aby se k docíl k platným výsledkům.

  MVAD přebírá segment datových bodů, aby se rozhodl, jestli je dalším datovým bodem anomálie. Délka segmentu je slidingWindow . Při výběru hodnoty mějte na paměti dvě slidingWindow věci:

  1. Vlastnosti vašich dat: jestli jsou pravidelná a vzorkovací frekvence. Pokud jsou vaše data pravidelná, můžete nastavit délku 1 až 3 cykly jako slidingWindow . Pokud jsou vaše data vysokofrekvenční (malá členitost), například na úrovni minut nebo na druhé úrovni, můžete nastavit relativně vyšší hodnotu slidingWindow .
  2. Rozdíl mezi dobami trénování a odvozování a potenciálním dopadem na výkon Větší může slidingWindow způsobit delší dobu trénování nebo odvozování. Neexistuje žádná záruka, že větší slidingWindow hodnoty povede ke zvýšení přesnosti. Malá může způsobit, že se model obtížně slidingWindow konverguje na optimální řešení. Například je obtížné detekovat anomálie, pokud slidingWindow mají pouze dva body.

• alignMode – Jak zarovnat více proměnných (časovou řadu) podle časových razítek. Pro tento parametr existují dvě možnosti a Inner a výchozí hodnota je Outer Outer .

  Tento parametr je kritický, pokud dochází k nesouladu mezi sekvencemi časového razítka proměnných. Model musí před dalším zpracováním zarovnat proměnné ke stejné sekvenci časového razítka.

  Innerznamená, že model bude hlásit výsledky detekce pouze u časových razítek, na kterých má každá proměnná hodnotu, tj. průnik všech proměnných. Outerznamená, že model bude hlásit výsledky detekce podle časových razítek, na kterých má libovolná proměnná hodnotu, tj. sjednocené všechny proměnné.

  Tady je příklad vysvětlení různých alignModel hodnot.

  Proměnná-1

  časové razítko	hodnota
  2020-11-01	1
  2020-11-02	2
  2020-11-04	4
  2020-11-05	5

  Proměnná-2

  časové razítko	hodnota
  2020-11-01	1
  2020-11-02	2
  2020-11-03	3
  2020-11-04	4

  Inner spojení dvou proměnných

  časové razítko	Proměnná-1	Proměnná-2
  2020-11-01	1	1
  2020-11-02	2	2
  2020-11-04	4	4

  Outer spojení dvou proměnných

  časové razítko	Proměnná-1	Proměnná-2
  2020-11-01	1	1
  2020-11-02	2	2
  2020-11-03	nan	3
  2020-11-04	4	4
  2020-11-05	5	nan

• fillNAMethod – Jak vyplnit nan sloučenou tabulku Ve sloučené tabulce můžou chybět hodnoty, které by se měly správně zpracovat. Nabízíme několik metod, jak je vyplnit. Možnosti jsou Linear , , , a výchozí hodnota je Previous Subsequent Zero Fixed Linear .

  Možnost	Metoda
  Linear	Vyplňování nan hodnot lineární interpolací
  Previous	Šířete poslední platnou hodnotu, abyste vyplnili mezery. Příklad: [1, 2, nan, 3, nan, 4] -> [1, 2, 2, 3, 3, 4]
  Subsequent	K vyplnění mezer použijte další platnou hodnotu. Příklad: [1, 2, nan, 3, nan, 4] -> [1, 2, 3, 3, 4, 4]
  Zero	Vyplňte nan hodnoty hodnotou 0.
  Fixed	Vyplňte nan hodnoty zadanou platnou hodnotou, která by měla být zadaná v paddingValue .

• paddingValue – Hodnota odsazení se používá k vyplnění, když je a nan musí být v tomto případě fillNAMethod Fixed zadaná. V jiných případech je volitelný.

• displayName – Toto je volitelný parametr, který slouží k identifikaci modelů. Můžete ji například použít k označení parametrů, zdrojů dat a všech dalších metadat o modelu a jeho vstupních datech. Výchozí hodnota je prázdný řetězec.

4. získání stavu modelu

Protože rozhraní API pro školení je asynchronní, nezískáte model hned po volání rozhraní API pro školení. Můžete ale zadat dotaz na stav modelů buď pomocí klíče rozhraní API, který zobrazí seznam všech modelů, nebo podle ID modelu, které zobrazí informace o konkrétním modelu.

Vypsat všechny modely

Na této stránce se můžete podívat na informace o adrese URL požadavku a hlavičkách žádostí. Všimněte si, že vracíme jenom 10 modelů seřazených podle času aktualizace, ale můžete navštívit jiné modely nastavením $skip parametrů a $top v adrese URL požadavku. Pokud je vaše adresa URL žádosti například https://{endpoint}/anomalydetector/v1.1-preview/multivariate/models?$skip=10&$top=20 , přeskočíme nejnovější 10 modelů a vrátíme další 20 modelů.

Ukázková odpověď je

{
    "models": [
         {
             "createdTime":"2020-12-01T09:43:45Z",
             "displayName":"DevOps-Test",
             "lastUpdatedTime":"2020-12-01T09:46:13Z",
             "modelId":"b4c1616c-33b9-11eb-824e-0242ac110002",
             "status":"READY",
             "variablesCount":18
         },
         {
             "createdTime":"2020-12-01T09:43:30Z",
             "displayName":"DevOps-Test",
             "lastUpdatedTime":"2020-12-01T09:45:10Z",
             "modelId":"ab9d3e30-33b9-11eb-a3f4-0242ac110002",
             "status":"READY",
             "variablesCount":18
         }
    ],
    "currentCount": 1,
    "maxCount": 50, 
    "nextLink": "<link to more models>"
}

Odpověď obsahuje 4 pole, models , currentCount , maxCount a nextLink .

• models obsahuje čas vytvoření, čas poslední aktualizace, ID modelu, zobrazovaný název, počty proměnných a stav každého modelu.
• currentCount obsahuje počet proučených lineární modelů.
• maxCount je maximální počet modelů, které tento prostředek detektoru anomálie podporuje.
• nextLink dá se použít k načtení dalších modelů.

Získat modely podle ID modelu

Tato stránka popisuje adresu URL žádosti o dotaz na informace o modelu podle ID modelu. Ukázková odpověď vypadá takto.

{
        "modelId": "45aad126-aafd-11ea-b8fb-d89ef3400c5f",
        "createdTime": "2020-06-30T00:00:00Z",
        "lastUpdatedTime": "2020-06-30T00:00:00Z",
        "modelInfo": {
          "slidingWindow": 300,
          "alignPolicy": {
            "alignMode": "Outer",
            "fillNAMethod": "Linear",
            "paddingValue": 0
          },
          "source": "<TRAINING_ZIP_FILE_LOCATED_IN_AZURE_BLOB_STORAGE_WITH_SAS>",
          "startTime": "2019-04-01T00:00:00Z",
          "endTime": "2019-04-02T00:00:00Z",
          "displayName": "Devops-MultiAD",
          "status": "READY",
          "errors": [],
          "diagnosticsInfo": {
            "modelState": {
              "epochIds": [10, 20, 30, 40, 50, 60, 70, 80, 90, 100],
              "trainLosses": [0.6291328072547913, 0.1671326905488968, 0.12354248017072678, 0.1025966405868533, 
                              0.0958492755889896, 0.09069952368736267,0.08686016499996185, 0.0860302299260931,
                              0.0828735455870684, 0.08235538005828857],
              "validationLosses": [1.9232804775238037, 1.0645641088485718, 0.6031560301780701, 0.5302737951278687, 
                                   0.4698025286197664, 0.4395163357257843, 0.4182931482799006, 0.4057914316654053, 
                                   0.4056498706340729, 0.3849248886108984],
              "latenciesInSeconds": [0.3398594856262207, 0.3659665584564209, 0.37360644340515137, 
                                     0.3513407707214355, 0.3370304107666056, 0.31876277923583984, 
                                     0.3283309936523475, 0.3503587245941162, 0.30800247192382812,
                                     0.3327946662902832]
            },
            "variableStates": [
              {
                "variable": "ad_input",
                "filledNARatio": 0,
                "effectiveCount": 1441,
                "startTime": "2019-04-01T00:00:00Z",
                "endTime": "2019-04-02T00:00:00Z",
                "errors": []
              },
              {
                "variable": "ad_ontimer_output",
                "filledNARatio": 0,
                "effectiveCount": 1441,
                "startTime": "2019-04-01T00:00:00Z",
                "endTime": "2019-04-02T00:00:00Z",
                "errors": []
              },
              // More variables
            ]
          }
        }
      }

Zobrazí se podrobnější informace o dotazovaném modelu. Odpověď obsahuje meta informace o modelu, jeho parametrech školení a diagnostických informacích. Diagnostické informace jsou užitečné pro ladění a trasování postupu školení.

• epochIds Určuje, kolik epochs byl model vyškolený z celkového 100 epochs. Například pokud je model stále ve stavu školení, může to znamenat epochId [10, 20, 30, 40, 50] , že dokončil svůj 50 epocha školení a existuje poloviční způsob, jak jít.
• trainLosses a validationLosses slouží ke kontrole, zda průběh optimalizace konverguje, v jakém případě by se měly obě ztráty postupně snižovat.
• latenciesInSeconds obsahuje časové náklady každé epocha a zaznamenává se každých 10 epochs. V tomto příkladu 10. epocha trvá přibližně 0,34 sekund. To by bylo užitečné k odhadu doby dokončení školení.
• variableStates shrnuje informace o jednotlivých proměnných. Seznam je seřazen filledNARatio v sestupném pořadí. Informuje o tom, kolik datových bodů se pro jednotlivé proměnné používá, a filledNARatio informuje o tom, kolik bodů chybí. Obvykle je potřeba filledNARatio co nejvíc snížit. Příliš mnoho chybějících datových bodů bude zhoršit přesnost modelu.
• V poli budou zahrnuty chyby při zpracování dat errors .

5. odvození pomocí MVAD

Chcete-li provést odvození, jednoduše poskytněte zdroj objektu blob do souboru ZIP obsahujícího odvozená data, čas spuštění a čas ukončení.

Odvození je také asynchronní, takže výsledky se nevrátí hned. Všimněte si, že je třeba uložit v proměnné odkaz na výsledky v hlavičce odpovědi , která obsahuje resultId , aby bylo možné zjistit, kde jsou výsledky získány později.

Chyby jsou obvykle způsobeny problémy modelu nebo problémy s daty. Odvození není možné provést, pokud model není připravený nebo datový odkaz není platný. Ujistěte se, že školicí data a odvozená data jsou konzistentní, což znamená, že by měly být přesně stejné proměnné, ale s různými časovými razítky. Více proměnných, méně proměnných nebo odvození s jinou sadou proměnných neprojde fáze ověření dat a dojde k chybám. Ověření dat je odloženo, takže se zobrazí chybová zpráva pouze při dotazování na výsledky.

6. získání výsledků odvození

resultIdK získání výsledků potřebujete. resultId se získá z hlavičky Response při odeslání žádosti o odvození. Tato stránka obsahuje pokyny pro dotazování na odvozené výsledky.

Ukázková odpověď vypadá takto.

 {
        "resultId": "663884e6-b117-11ea-b3de-0242ac130004",
        "summary": {
          "status": "READY",
          "errors": [],
          "variableStates": [
            {
              "variable": "ad_input",
              "filledNARatio": 0,
              "effectiveCount": 26,
              "startTime": "2019-04-01T00:00:00Z",
              "endTime": "2019-04-01T00:25:00Z",
              "errors": []
            },
            {
              "variable": "ad_ontimer_output",
              "filledNARatio": 0,
              "effectiveCount": 26,
              "startTime": "2019-04-01T00:00:00Z",
              "endTime": "2019-04-01T00:25:00Z",
              "errors": []
            },
            // more variables
          ],
          "setupInfo": {
            "source": "https://aka.ms/AnomalyDetector/MVADSampleData",
            "startTime": "2019-04-01T00:15:00Z",
            "endTime": "2019-04-01T00:40:00Z"
          }
        },
        "results": [
          {
            "timestamp": "2019-04-01T00:15:00Z",
            "errors": [
              {
                "code": "InsufficientHistoricalData",
                "message": "historical data is not enough."
              }
            ]
          },
          // more results
          {
            "timestamp": "2019-04-01T00:20:00Z",
            "value": {
              "contributors": [],
              "isAnomaly": false,
              "severity": 0,
              "score": 0.17805261260751692
            }
          },
          // more results
          {
            "timestamp": "2019-04-01T00:27:00Z",
            "value": {
              "contributors": [
                {
                  "contributionScore": 0.0007775013367514271,
                  "variable": "ad_ontimer_output"
                },
                {
                  "contributionScore": 0.0007989604079048129,
                  "variable": "ad_series_init"
                },
                {
                  "contributionScore": 0.0008900927229851369,
                  "variable": "ingestion"
                },
                {
                  "contributionScore": 0.008068144477478554,
                  "variable": "cpu"
                },
                {
                  "contributionScore": 0.008222036467507165,
                  "variable": "data_in_speed"
                },
                {
                  "contributionScore": 0.008674941549594993,
                  "variable": "ad_input"
                },
                {
                  "contributionScore": 0.02232242629793674,
                  "variable": "ad_output"
                },
                {
                  "contributionScore": 0.1583773213660846,
                  "variable": "flink_last_ckpt_duration"
                },
                {
                  "contributionScore": 0.9816531517495176,
                  "variable": "data_out_speed"
                }
              ],
              "isAnomaly": true,
              "severity": 0.42135109874230336,
              "score": 1.213510987423033
            }
          },
          // more results
        ]
      }

Odpověď obsahuje stav výsledku, informace o proměnné, parametry odvození a výsledky odvození.

• variableStates Zobrazí informace o každé proměnné v žádosti o odvození.
• setupInfo je text žádosti odeslaný pro toto odvození.
• results obsahuje výsledky detekce. Existují tři typické typy výsledků detekce.
  1. Kód chyby InsufficientHistoricalData . K tomu obvykle dochází pouze s několika prvními časovými razítky, protože model vychází z dat způsobem založeným na okně a potřebuje k rozhodnutí provést historická data. U prvních několika časových razítek není k dispozici dostatek historických dat, takže u nich nelze provést odvozování. V takovém případě můžete chybovou zprávu ignorovat.
  2. "isAnomaly": false označuje, že aktuální časové razítko není anomálie.
     • severity označuje relativní závažnost anomálií a u normálních dat je vždy 0.
     • score je nezpracovaný výstup modelu, na kterém model provádí rozhodnutí, které by mohlo být nenulové i pro normální datové body.
  3. "isAnomaly": true označuje anomálii v aktuálním časovém razítku.
     • severity označuje relativní závažnost anomálií a v případě neobvyklých dat je vždy větší než 0.
     • score je nezpracovaný výstup modelu, na kterém se model rozhodne. severity je odvozená hodnota z score . Každý datový bod má score .
     • contributors je seznam obsahující skóre příspěvků každé proměnné. Vyšší skóre příspěvků značí vyšší možnost hlavní příčiny. Tento seznam se často používá pro interpretaci anomálií a také pro diagnostiku hlavních příčin.

Další kroky

• Osvědčené postupy: Doporučené postupy při používání rozhraní API pro více variant Detektor anomálií rozhraní API
• Rychlé starty: Použití Detektor anomálií multivariate client library