

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# K-nearest neighbors (k-NN)-Algorithmus
<a name="k-nearest-neighbors"></a>

Der Amazon SageMaker AI-Algorithmus für k-Nearest Neighbors (k-NN) ist ein indexbasierter Algorithmus. Er verwendet eine nicht parametrische Methode zur Klassifizierung oder Regression. Bei Klassifizierungsproblemen fragt der Algorithmus die *k*-Punkte ab, die dem Stichprobenpunkt am nächsten liegen, und gibt die am häufigsten verwendeten Bezeichnungen ihrer Klasse als prognostizierte Bezeichnung zurück. Bei Regressionsproblemen fragt der Algorithmus die *k*-Punkte ab, die dem Stichprobenpunkt am nächsten liegen, und gibt den Durchschnitt ihrer Funktionswerte als prognostizierten Wert zurück. 

Das Training mit dem k-NN-Algorithmus umfasst drei Schritte: Sampling, Dimensionsreduzierung und Indexerstellung. Durch Sampling wird die Größe des anfänglichen Datensatzes reduziert, sodass es in den Arbeitsspeicher passt. Für die Dimensionsreduzierung verringert der Algorithmus die Funktionsdimension der Daten, um den Ressourcenbedarf des k-NN-Modells im Speicher und die Inferenzlatenz zu senken. Wir stellen zwei-Methoden der Dimensionsreduzierung zur Verfügung: zufällige Projektion und die schnelle Johnson-Lindenstrauss-Transformation. In der Regel verwenden Sie die Dimensionsreduzierung für hochdimensionale Datensätze (d > 1000), um die Nachteile der Dimensionalität zu vermeiden, die die statistische Analyse von Daten beeinträchtigt, deren Dichte mit steigender Dimensionalität geringer wird. Das Hauptziel des k-NN-Trainings ist die Erstellung des Index. Der Index ermöglicht ein effizientes Suchen von Entfernungen zwischen Punkten, deren Werte oder Klassenbezeichnungen noch nicht festgelegt wurden, und den k nächstgelegenen Punkten zur Inferenz.

**Topics**
+ [E/A-Schnittstelle für den k-NN-Algorithmus](#kNN-input_output)
+ [k-NN-Beispiel-Notebooks](#kNN-sample-notebooks)
+ [So funktioniert der k-NN-Algorithmus](kNN_how-it-works.md)
+ [EC2-Instance-Empfehlung für den k-NN-Algorithmus](#kNN-instances)
+ [k-NN-Hyperparameter](kNN_hyperparameters.md)
+ [Optimieren eines k-NN-Modells](kNN-tuning.md)
+ [Datenformate für k-NN-Trainingseingaben](kNN-in-formats.md)
+ [k-NN-Anforderungs- und Antwortformate](kNN-inference-formats.md)

## E/A-Schnittstelle für den k-NN-Algorithmus
<a name="kNN-input_output"></a>

SageMaker AI k-NN unterstützt Train- und Testdatenkanäle.
+ Verwenden Sie einen *Trainingskanal* für Daten, die Sie als Stichproben erfassen und in den die k-NN-Index einbauen möchten.
+ Verwenden Sie ein *Testkanal,* um Punktzahlen in Protokolldateien auszugeben. Punktzahlen werden als eine Zeile pro Mini-Stapel aufgeführt: Genauigkeit für `classifier`, mittlerer quadratischer Fehler (MSE) für `regressor` für die Punktzahl.

Für Trainingseingaben unterstützt k-NN – `text/csv`und `application/x-recordio-protobuf`-Datenformate. Für den Eingabetyp `text/csv` werden die ersten `label_size` Spalten als Bezeichnungsvektor für diese Zeile interpretiert. Sie können entweder den Datei- oder den Pipe-Modus verwenden, um Modelle mit Daten, die als `recordIO-wrapped-protobuf` oder `CSV` formatiert sind, zu trainieren.

Für Inferenzeingaben unterstützt k-NN die `application/json`-, – `application/x-recordio-protobuf`und `text/csv`-Datenformate. Das `text/csv`-Format akzeptiert eine `label_size` und einen Codierungsparameter. Es setzt eine `label_size` von 0 und eine UTF-8-Codierung voraus.

Für Inferenzausgaben unterstützt k-NN die – `application/json`und `application/x-recordio-protobuf`-Datenformate. Diese beiden Datenformate unterstützen auch einen Verbose-Ausgabemodus. Im Verbose-Ausgabemodus stellt die API die Suchergebnisse mit dem Entfernungsvektor aufsteigend sortiert und die entsprechenden Elemente im Bezeichnungsvektor bereit.

Für die Stapeltransformation unterstützt k-NN das `application/jsonlines`-Datenformat für die Ein- und Ausgabe. Die Eingabe lautet z. B.:

```
content-type: application/jsonlines

{"features": [1.5, 16.0, 14.0, 23.0]}
{"data": {"features": {"values": [1.5, 16.0, 14.0, 23.0]}}
```

Die Ausgabe lautet z. B.:

```
accept: application/jsonlines

{"predicted_label": 0.0}
{"predicted_label": 2.0}
```

Weitere Informationen zu den Ein- und Ausgabedateiformaten finden Sie unter [Datenformate für k-NN-Trainingseingaben](kNN-in-formats.md) für das Training, [k-NN-Anforderungs- und Antwortformate](kNN-inference-formats.md) für Inferenz und [k-NN-Beispiel-Notebooks](#kNN-sample-notebooks).

## k-NN-Beispiel-Notebooks
<a name="kNN-sample-notebooks"></a>

Ein Beispiel für ein Notizbuch, das den SageMaker KI-Algorithmus k-Nearest Neighbor verwendet, um anhand von geologischen Daten und forstwirtschaftlichen Daten die Art der Wildnisbedeckung vorherzusagen, finden Sie unter [K-Nearest Neighbor](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/k_nearest_neighbors_covtype/k_nearest_neighbors_covtype.html) Covertype. 

Verwenden Sie eine Jupyter-Notebook-Instanz, um das Beispiel in KI auszuführen. SageMaker Informationen zum Erstellen und Öffnen einer Jupyter-Notebook-Instanz in KI finden Sie unter. SageMaker [SageMaker Amazon-Notebook-Instanzen](nbi.md) Nachdem Sie eine Notebook-Instanz erstellt und geöffnet haben, wählen Sie den Tab **SageMaker KI-Beispiele** aus, um eine Liste aller SageMaker KI-Beispiel-Notebooks anzuzeigen. Suchen Sie nach K-Nearest Neighbor Notebooks im Abschnitt **Einführung in Amazon-Algorithmen**. Zum Öffnen eines Notebooks klicken Sie auf die Registerkarte **Use (Verwenden)** und wählen Sie **Create copy (Kopie erstellen)** aus.

# So funktioniert der k-NN-Algorithmus
<a name="kNN_how-it-works"></a>

Der Amazon SageMaker AI-Algorithmus k-Nearest Neighbors (k-NN) folgt einem mehrstufigen Trainingsprozess, der die Stichprobenerhebung der Eingabedaten, die Dimensionsreduzierung und die Erstellung eines Index umfasst. Die indizierten Daten werden dann während der Inferenz verwendet, um effizient die k-nächsten Nachbarn für einen bestimmten Datenpunkt zu finden und Vorhersagen auf der Grundlage der benachbarten Bezeichnungen oder Werte zu treffen.

## Schritt 1: Stichprobe
<a name="step1-k-NN-sampling"></a>

Verwenden Sie den `sample_size`-Parameter, um die Gesamtanzahl der Datenpunkte anzugeben, die als Stichprobe vom Trainingsdatensatz genommen werden sollen. Beispiel: Wenn der erste Datensatz über 1 000 Datenpunkte verfügt und `sample_size` auf 100 festgelegt ist, wobei die Gesamtanzahl der Instances 2 beträgt, nimmt jeder Worker Stichproben von 50 Punkten. Es würde eine Reihe von insgesamt 100 Datenpunkten erfasst werden. Die Stichprobenerfassung erfolgt in linearer Zeit in Bezug auf die Anzahl der Datenpunkte. 

## Schritt 2: Ausführen der Dimensionsreduzierung
<a name="step2-kNN-dim-reduction"></a>

Die aktuelle Implementierung des k-NN-Algorithmus verfügt über zwei Methoden der Dimensionsreduzierung. Sie geben die Methode im `dimension_reduction_type`-Hyperparameter an. Die `sign`-Methode gibt eine zufällige Projektion an, die eine lineare Projektion mithilfe einer Matrix von zufälligen Zeichen verwendet. Die `fjlt`-Methode gibt eine schnelle Johnson-Lindenstrauss-Transformation an, eine Methode auf der Grundlage der Fourier-Transformation. Beide Methoden bewahren die L2- und inneren Produktentfernungen. Die `fjlt`-Methode sollte verwendet werden, wenn die Zieldimension groß ist, und bietet eine bessere Leistung mit CPU-Inferenzen. Die Methoden unterscheiden sich in ihren Rechenkomplexitä. Die `sign`-Methode erfordert O(ndk)-Zeit, um die Dimension eines Stapels von n Punkten der Dimension d auf eine Ziel-Dimension k zu reduzieren. Die `fjlt`-Methode erfordert O(nd log(d)) Zeit, doch die beteiligten Konstanten sind größer. Durch die Dimensionsreduzierung werden die Daten verzerrt, wodurch sich die Prognosegenauigkeit verringern kann.

## Schritt 3: Erstellen eines Index
<a name="step3-kNN-build-index"></a>

Während der Inferenz fragt der Algorithmus den Index für einen Stichprobenpunkt ab k-nearest-neighbors. Basierend auf den Verweisen auf die Punkte nimmt der Algorithmus die Klassifizierungs- oder Regressionsprognose vor. Seine Prognose basiert auf den bereitgestellten Klassenbezeichnungen oder Werten. k-NN bietet drei verschiedene Arten von Indizes: einen flachen Index, einen umgekehrten Index und einen umgekehrten Index mit Produktquantisierung. Sie geben den Typ mit dem `index_type`-Parameter an.

## Serialisieren des Modells
<a name="kNN-model-serialization"></a>

Wenn der k-NN-Algorithmus Trainings abgeschlossen hat, serialisiert er drei Dateien zur Vorbereitung der Inferenz. 
+ model\$1algo-1: Enthält den serialisierten Index zur Berechnung der nächsten Nachbarn.
+ model\$1alg-1.labels: Enthält serialisierte Bezeichnungen (np.float32-Binärformat) zum Berechnen der prognostizierten Bezeichnung basierend auf dem Abfrageergebnis aus dem Index.
+ model\$1algo-1.json: Enthält die Modellmetadaten im JSON-Format, in dem die – `k`und `predictor_type`-Hyperparameter aus den Trainings für Inferenz zusammen mit anderen relevanten Zuständen gespeichert werden.

Mit der aktuellen Implementierung von k-NN können Sie die Metadatendatei ändern, um die Art zu ändern, wie Prognosen berechnet werden. So können Sie z. B. `k` in 10 oder `predictor_type` in *regressor* ändern.

```
{
  "k": 5,
  "predictor_type": "classifier",
  "dimension_reduction": {"type": "sign", "seed": 3, "target_dim": 10, "input_dim": 20},
  "normalize": False,
  "version": "1.0"
}
```

## EC2-Instance-Empfehlung für den k-NN-Algorithmus
<a name="kNN-instances"></a>

Wir empfehlen, auf einer CPU-Instance (wie ml.m5.2xlarge) oder auf einer GPU-Instance zu trainieren. Der k-NN-Algorithmus unterstützt die GPU-Instancefamilien P2, P3, G4dn und G5 für Training und Inferenz.

Inferenzanfragen von haben CPUs im Allgemeinen eine geringere durchschnittliche Latenz als Anfragen von, GPUs da bei Verwendung von GPU-Hardware eine CPU-to-GPU Belastung der Kommunikation anfällt. GPUs Im Allgemeinen weisen sie jedoch bei größeren Batches einen höheren Durchsatz auf.

# k-NN-Hyperparameter
<a name="kNN_hyperparameters"></a>

In der folgenden Tabelle sind die Hyperparameter aufgeführt, die Sie für den Amazon SageMaker AI-Algorithmus k-Nearest Neighbors (k-NN) festlegen können.


| Name des Parameters | Description | 
| --- | --- | 
| feature\$1dim |  Die Anzahl der Merkmale der Eingabedaten. **Erforderlich** Gültige Werte: positive Ganzzahl.  | 
| k |  Die Anzahl der nächsten Nachbarn. **Erforderlich** Gültige Werte: positive Ganzzahl  | 
| predictor\$1type |  Der Inferenztyp, der für die Datenbezeichnungen verwendet werden soll. **Erforderlich** Gültige Werte: *Classifier* für die Klassifizierung oder *regressor* für die Regression.  | 
| sample\$1size |  Die Anzahl der Datenpunkte, die aus dem Trainingsdatensatz gesampelt werden soll.  **Erforderlich** Gültige Werte: positive Ganzzahl  | 
| dimension\$1reduction\$1target |  Die Zieldimension, auf die reduziert werden soll. **Erforderlich**, wenn Sie den `dimension_reduction_type`-Parameter angeben. Gültige Werte: positive Ganzzahl größer als 0 und kleiner als `feature_dim`.  | 
| dimension\$1reduction\$1type |  Der Typ der Dimensionsreduzierungsmethode.  **Optional** Gültige Werte: *sign* für zufällige Projektion oder *fjlt* für die schnelle Johnson-Lindenstrauss-Transformation. Standardwert: Keine Dimensionsreduzierung  | 
| faiss\$1index\$1ivf\$1nlists |  *Die Anzahl der Zentroide, die im Index erstellt werden sollen, wenn er nicht erreicht ist. `index_type` *IVFFlat*oder Faiss.IVFPQ.* **Optional** Gültige Werte: positive Ganzzahl Standardwert: *auto*, der in `sqrt(sample_size)` aufgelöst wird.  | 
| faiss\$1index\$1pq\$1m |  Die Anzahl der Vektorsubkomponenten zur Erstellung im Index, wenn `index_type` auf *faiss.IVFPQ* eingestellt ist.  Die FAISS-Bibliothek ( FaceBook AI Similarity Search) erfordert, dass der Wert von ein Divisor der `faiss_index_pq_m` Datendimension ist.  Wenn `faiss_index_pq_m` kein Divisor der Datendimension ist, erhöhen wir die Datendimension auf die kleinste Ganzzahl, die durch `faiss_index_pq_m` teilbar ist. Wenn keine Dimensionsreduzierung angewendet wird, fügt der Algorithmus eine Auffüllung mit Nullen hinzu. Wenn die Dimensionsreduzierung angewendet wird, erhöht der Algorithmus den Wert des `dimension_reduction_target`-Hyperparameters. **Optional** Gültige Werte: Eine der folgenden positiven Ganzzahlen: 1, 2, 3, 4, 8, 12, 16, 20, 24, 28, 32, 40, 48, 56, 64, 96  | 
| index\$1metric |  Die Metrik, um den Abstand zwischen den Punkten bei der Suche nach den nächsten Nachbarn zu messen. Wenn Trainings mit dem Wert `index_type` auf `faiss.IVFPQ` ausgeführt werden, werden `INNER_PRODUCT`-Entfernung und `COSINE`-Ähnlichkeit nicht unterstützt. **Optional** Gültige Werte: *L2* für die euklidische Entfernung, *INNER\$1PRODUCT* für die innere Produktentfernung, *COSINE* für Kosinusähnlichkeit. Standardwert: *L2*  | 
| index\$1type |  Der Typ des Index. **Optional** *Gültige Werte: *faiss.Flat, faiss*. *IVFFlat*,* faiss.IVFPQ. Standardwerte: *faiss.Flat*  | 
| mini\$1batch\$1size |  Die Anzahl der Beobachtungen pro Mini-Stapel für den Dateniterator.  **Optional** Gültige Werte: positive Ganzzahl Standardwert: 5000  | 

# Optimieren eines k-NN-Modells
<a name="kNN-tuning"></a>

Der Amazon SageMaker AI K-Nearest Neighbors-Algorithmus ist ein überwachter Algorithmus. Der Algorithmus verbraucht ein Testdatensatz und gibt eine Metrik über die Genauigkeit für eine Klassifizierungsaufgabe oder über den mittleren quadratischen Fehler für eine Regressionsaufgabe aus. Diese Genauigkeitsmetriken vergleichen die Modellprognosen für ihre jeweilige Aufgabe mit den Referenzdaten, die anhand der empirischen Testdaten bereitgestellt werden. Führen Sie einen Hyperparameter-Optimierungsauftrag für k-NN aus, um das beste Modell zu suchen, das die höchste Genauigkeit oder den geringsten Fehler im Testdatensatz meldet. 

Die *automatische Modelloptimierung*, auch bekannt als Hyperparameteroptimierung, sucht die beste Version eines Modells, indem viele Aufträge ausgeführt werden, die einen Bereich von Hyperparametern in Ihrem Datensatz testen. Sie wählen die optimierbaren Hyperparameter, eine Reihe von Werten für jeden Parameter und eine objektive Metrik aus. Sie wählen die objektive Metrik für die Prognoseaufgabe des Algorithmus aus. Die automatische Modelloptimierung durchsucht die ausgewählten Hyperparameter nach der Kombination von Werten, die das Modell ergeben, das die objektive Metrik optimiert. Die Hyperparameter werden nur verwendet, um Modellparameter zu schätzen. Sie werden nicht vom trainierten Modell verwendet, um Prognosen zu treffen.

Mehr Informationen über die Modelloptimierung finden Sie unter [Automatische Modelloptimierung mit KI SageMaker](automatic-model-tuning.md).

## Vom k-NN-Algorithmus berechnete Metriken
<a name="km-metrics"></a>

Der k-nearest neighbors-Algorithmus berechnet eine von zwei Metriken in der folgenden Tabelle während des Trainings abhängig von der Art der durch den `predictor_type`-Hyperparameter angegebenen Aufgabe. 
+ *Classifier* gibt eine Klassifizierungsaufgabe an und berechnet `test:accuracy`. 
+ *Regressor* gibt eine Regressionsaufgabe an und berechnet `test:mse`.

Wählen Sie den für die Art der Aufgabe geeigneten `predictor_type`-Wert aus, mit der die relevante objektive Metrik beim Optimieren eines Modells berechnet wird.


| Metrikname | Description | Optimierungsrichtung | 
| --- | --- | --- | 
| test:accuracy |  Wenn `predictor_type` auf *classifier* festgelegt ist, vergleicht k-NN die prognostizierte Bezeichnung, basierend auf dem Durchschnitt der k-nearest neighbors-Bezeichnungen, mit den in den Testkanaldaten angegebenen Referenzdaten. Die gemeldete Genauigkeit liegt im Bereich von 0,0 (0 %) bis 1,0 (100 %).  |  Maximieren  | 
| test:mse |  Wenn `predictor_type` auf *regressor* festgelegt ist, vergleicht k-NN die prognostizierte Bezeichnung, basierend auf dem Durchschnitt der k-nearest neighbors-Bezeichnungen, mit den in den Testkanaldaten angegebenen Referenzdaten. Der mittlere quadratische Fehler wird berechnet, indem die beiden Bezeichnungen verglichen werden.  |  Minimieren  | 



## Optimierbare k-NN-Hyperparameter
<a name="km-tunable-hyperparameters"></a>

Optimieren Sie das Amazon SageMaker AI K-Nearest Neighbor-Modell mit den folgenden Hyperparametern.


| Name des Parameters | Parametertyp | Empfohlene Bereiche | 
| --- | --- | --- | 
| k |  IntegerParameterRanges  |  MinValue: 1, MaxValue: 1024  | 
| sample\$1size |  IntegerParameterRanges  |  MinValue: 256, MaxValue: 2000000  | 

# Datenformate für k-NN-Trainingseingaben
<a name="kNN-in-formats"></a>

Alle integrierten Algorithmen von Amazon SageMaker AI halten sich an die gängigen Eingabe-Trainingsformate, die unter [Common Data Formats — Training](https://docs.aws.amazon.com/sagemaker/latest/dg/cdf-training.html) beschrieben sind. Dieses Thema enthält eine Liste der verfügbaren Eingabeformate für den SageMaker k-nearest-neighbor KI-Algorithmus.

## CSV-Datenformate
<a name="kNN-training-data-csv"></a>

Inhaltstyp: text/csv; label\$1size=1

```
4,1.2,1.3,9.6,20.3
```

Die ersten `label_size` Spalten werden als Bezeichnungsvektor für diese Zeile interpretiert.

## RECORDIO-Datenformat
<a name="kNN-training-data-recordio"></a>

Inhaltstyp: Anwendung/ x-recordio-protobuf

```
[
    Record = {
        features = {
            'values': {
                values: [1.2, 1.3, 9.6, 20.3]  # float32
            }
        },
        label = {
            'values': {
                values: [4]  # float32
            }
        }
    }
] 

                
}
```

# k-NN-Anforderungs- und Antwortformate
<a name="kNN-inference-formats"></a>

Alle integrierten Algorithmen von Amazon SageMaker AI halten sich an das gemeinsame Eingabe-Inferenzformat, das unter [Common Data Formats — Inference](https://docs.aws.amazon.com/sagemaker/latest/dg/cdf-inference.html) beschrieben ist. Dieses Thema enthält eine Liste der verfügbaren Ausgabeformate für den SageMaker k-nearest-neighbor KI-Algorithmus.

## EINGABE: CSV-Anforderungsformat
<a name="kNN-input-csv"></a>

Inhaltstyp: text/csv

```
1.2,1.3,9.6,20.3
```

Dieser Parameter akzeptiert eine `label_size` oder einen Codierungsparameter. Es setzt eine `label_size` von 0 und eine UTF-8-Codierung voraus.

## EINGABE: JSON-Anforderungsformat
<a name="kNN-input-json"></a>

Inhaltstyp: application/json

```
{
  "instances": [
    {"data": {"features": {"values": [-3, -1, -4, 2]}}},
    {"features": [3.0, 0.1, 0.04, 0.002]}]
}
```

## EINGABE: JSONLINES-Anforderungsformat
<a name="kNN-input-jsonlines"></a>

Inhaltstyp: application/jsonlines

```
{"features": [1.5, 16.0, 14.0, 23.0]}
{"data": {"features": {"values": [1.5, 16.0, 14.0, 23.0]}}
```

## EINGABE: RECORDIO-Anforderungsformat
<a name="kNN-input-recordio"></a>

Inhaltstyp: Anwendung/ x-recordio-protobuf

```
[
    Record = {
        features = {
            'values': {
                values: [-3, -1, -4, 2]  # float32
            }
        },
        label = {}
    },
    Record = {
        features = {
            'values': {
                values: [3.0, 0.1, 0.04, 0.002]  # float32
            }
        },
        label = {}
    },
]
```

## AUSGABE: JSON-Antwortformat
<a name="kNN-output-json"></a>

Akzeptiert: application/json

```
{
  "predictions": [
    {"predicted_label": 0.0},
    {"predicted_label": 2.0}
  ]
}
```

## AUSGABE: JSONLINES-Antwortformat
<a name="kNN-output-jsonlines"></a>

Akzeptiert: application/jsonlines

```
{"predicted_label": 0.0}
{"predicted_label": 2.0}
```

## AUSGABE: VERBOSE-JSON-Antwortformat
<a name="KNN-output-verbose-json"></a>

Im Verbose-Modus stellt die API die Suchergebnisse mit dem Entfernungsvektor aufsteigend sortiert und die entsprechenden Elemente im Bezeichnungsvektor bereit. In diesem Beispiel wird "k" auf 3 festgelegt.

Akzeptiert: application/json;verbose=true

```
{
  "predictions": [
    {
        "predicted_label": 0.0,
        "distances": [3.11792408, 3.89746071, 6.32548437],
        "labels": [0.0, 1.0, 0.0]
    },
    {
        "predicted_label": 2.0,
        "distances": [1.08470316, 3.04917915, 5.25393973],
        "labels": [2.0, 2.0, 0.0]
    }
  ]
}
```

## AUSGABE: RECORDIO PROTOBUF-Antwortformat
<a name="kNN-output-recordio-protobuf"></a>

Inhaltstyp: Anwendung/ x-recordio-protobuf

```
[
    Record = {
        features = {},
        label = {
            'predicted_label': {
                values: [0.0]  # float32
            }
        }
    },
    Record = {
        features = {},
        label = {
            'predicted_label': {
                values: [2.0]  # float32
            }
        }
    }
]
```

## AUSGABE: VERBOSE RECORDIO PROTOBUF-Antwortformat
<a name="kNN-output-verbose-recordio"></a>

Im Verbose-Modus stellt die API die Suchergebnisse mit dem Entfernungsvektor aufsteigend sortiert und die entsprechenden Elemente im Bezeichnungsvektor bereit. In diesem Beispiel wird "k" auf 3 festgelegt.

akzeptieren: Anwendung/; verbose=true x-recordio-protobuf

```
[
    Record = {
        features = {},
        label = {
            'predicted_label': {
                values: [0.0]  # float32
            },
            'distances': {
                values: [3.11792408, 3.89746071, 6.32548437]  # float32
            },
            'labels': {
                values: [0.0, 1.0, 0.0]  # float32
            }
        }
    },
    Record = {
        features = {},
        label = {
            'predicted_label': {
                values: [0.0]  # float32
            },
            'distances': {
                values: [1.08470316, 3.04917915, 5.25393973]  # float32
            },
            'labels': {
                values: [2.0, 2.0, 0.0]  # float32
            }
        }
    }
]
```

## BEISPIELAUSGABE für den k-NN-Algorithmus
<a name="kNN-sample-output"></a>

Für regressor-Aufgaben:

```
[06/08/2018 20:15:33 INFO 140026520049408] #test_score (algo-1) : ('mse', 0.013333333333333334)
```

Für classifier-Aufgaben:

```
[06/08/2018 20:15:46 INFO 140285487171328] #test_score (algo-1) : ('accuracy', 0.98666666666666669)
```