Amazon Redshift unterstützt UDFs ab Patch 198 nicht mehr die Erstellung von neuem Python. Das bestehende Python UDFs wird bis zum 30. Juni 2026 weiterhin funktionieren. Weitere Informationen finden Sie im [Blog-Posting](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/). 

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.

# Tutorial: k-Means-Clustering-Modelle erstellen
<a name="tutorial_k-means_clustering"></a>

In diesem Tutorial verwenden Sie Amazon Redshift ML, um ein Machine-Learning-Modell auf der Grundlage des [k-Means-Algorithmus](url-sm-dev;k-means.html) zu erstellen, zu trainieren und bereitzustellen. Dieser Algorithmus löst Clusterprobleme, bei denen Sie Gruppierungen in den Daten erkennen möchten. k-Means hilft beim Gruppieren von Daten, die noch nicht beschriftet wurden. Weitere Informationen über K-Means-Clustering finden Sie unter [So funktioniert K-Means-Clustering](https://docs.aws.amazon.com/sagemaker/latest/dg/algo-kmeans-tech-notes.html) im Amazon SageMaker AI Developer Guide.

Sie verwenden eine CREATE-MODEL-Operation, um ein k-Means-Modell aus einem Amazon-Redshift-Cluster zu erstellen. Sie können einen CREATE-MODEL-Befehl verwenden, um Trainingsdaten zu exportieren, ein Modell zu trainieren, das Modell zu importieren und eine Amazon-Redshift-Prognosefunktion vorzubereiten. Verwenden Sie die Operation CREATE MODEL, um Trainingsdaten entweder als Tabelle oder SELECT-Anweisung anzugeben.

In diesem Tutorial verwenden Sie k-Means für den Datensatz [Global Database of Events, Language, and Tone (GDELT)](https://aws.amazon.com/public-datasets/gdelt/), der Weltnachrichten auf der ganzen Welt überwacht, und die Daten werden jede Sekunde jeden Tag gespeichert. k-Means gruppiert Ereignisse mit ähnlichem Ton, Akteuren oder Orten. Die Daten werden in zwei verschiedenen Ordnern in mehreren Dateien im Amazon Simple Storage Service gespeichert. Die Ordner sind historisch, d. h., sie decken die Jahre 1979–2013 ab, und enthalten tägliche Updates, die sich auf die Jahre 2013 und später beziehen. In diesem Beispiel verwenden wir das historische Format und greifen auf Daten von 1979 zurück.

## Beispielanwendungsfälle
<a name="tutorial_k-means_clustering_tasks"></a>

Sie können andere Clustering-Probleme mit Amazon Redshift ML lösen, z. B. das Gruppieren von Kunden mit ähnlichen Sehgewohnheiten bei einem Streaming-Dienst. Sie können Redshift ML auch verwenden, um die optimale Anzahl von Versandzentren für einen Lieferservice zu prognostizieren.

**Aufgaben**
+ Voraussetzungen
+ Schritt 1: Laden von Daten aus Amazon S3 in Amazon Redshift
+ Schritt 2: Erstellen des Machine-Learning-Modells
+ Schritt 3: Erstellen von Prognosen mit dem Modell

## Voraussetzungen
<a name="tutorial_k-means_clustering_prereqs"></a>

Zum Durchführen dieses Tutorials müssen Sie die [administrative Einrichtung](https://docs.aws.amazon.com/redshift/latest/dg/admin-setup.html) für Amazon Redshift ML abschließen.

## Schritt 1: Laden von Daten aus Amazon S3 in Amazon Redshift
<a name="tutorial_k-means_clustering_step_load"></a>

1. Verwenden Sie den [Abfrage-Editor v2 von Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2-using.html), um die folgende Abfrage auszuführen. Die Abfrage entfernt die Tabelle `gdelt_data` aus dem öffentlichen Schema, falls sie vorhanden ist, und erstellt eine Tabelle mit demselben Namen im öffentlichen Schema.

   ```
   DROP TABLE IF EXISTS gdelt_data CASCADE;
   
   CREATE TABLE gdelt_data (
       GlobalEventId bigint,
       SqlDate bigint,
       MonthYear bigint,
       Year bigint,
       FractionDate double precision,
       Actor1Code varchar(256),
       Actor1Name varchar(256),
       Actor1CountryCode varchar(256),
       Actor1KnownGroupCode varchar(256),
       Actor1EthnicCode varchar(256),
       Actor1Religion1Code varchar(256),
       Actor1Religion2Code varchar(256),
       Actor1Type1Code varchar(256),
       Actor1Type2Code varchar(256),
       Actor1Type3Code varchar(256),
       Actor2Code varchar(256),
       Actor2Name varchar(256),
       Actor2CountryCode varchar(256),
       Actor2KnownGroupCode varchar(256),
       Actor2EthnicCode varchar(256),
       Actor2Religion1Code varchar(256),
       Actor2Religion2Code varchar(256),
       Actor2Type1Code varchar(256),
       Actor2Type2Code varchar(256),
       Actor2Type3Code varchar(256),
       IsRootEvent bigint,
       EventCode bigint,
       EventBaseCode bigint,
       EventRootCode bigint,
       QuadClass bigint,
       GoldsteinScale double precision,
       NumMentions bigint,
       NumSources bigint,
       NumArticles bigint,
       AvgTone double precision,
       Actor1Geo_Type bigint,
       Actor1Geo_FullName varchar(256),
       Actor1Geo_CountryCode varchar(256),
       Actor1Geo_ADM1Code varchar(256),
       Actor1Geo_Lat double precision,
       Actor1Geo_Long double precision,
       Actor1Geo_FeatureID bigint,
       Actor2Geo_Type bigint,
       Actor2Geo_FullName varchar(256),
       Actor2Geo_CountryCode varchar(256),
       Actor2Geo_ADM1Code varchar(256),
       Actor2Geo_Lat double precision,
       Actor2Geo_Long double precision,
       Actor2Geo_FeatureID bigint,
       ActionGeo_Type bigint,
       ActionGeo_FullName varchar(256),
       ActionGeo_CountryCode varchar(256),
       ActionGeo_ADM1Code varchar(256),
       ActionGeo_Lat double precision,
       ActionGeo_Long double precision,
       ActionGeo_FeatureID bigint,
       DATEADDED bigint
   );
   ```

1. Die folgende Abfrage lädt die Beispieldaten in die Tabelle `gdelt_data`.

   ```
   COPY gdelt_data
   FROM 's3://gdelt-open-data/events/1979.csv' 
   REGION 'us-east-1'
   IAM_ROLE default 
   CSV
   DELIMITER '\t';
   ```

### Untersuchen der Trainingsdaten (optional)
<a name="tutorial_k-means_clustering_examine"></a>

Verwenden Sie die folgende Abfrage, um zu sehen, mit welchen Daten Ihr Modell trainiert wird.

```
SELECT
    AvgTone,
    EventCode,
    NumArticles,
    Actor1Geo_Lat,
    Actor1Geo_Long,
    Actor2Geo_Lat,
    Actor2Geo_Long
FROM
    gdelt_data LIMIT 100;
```

## Schritt 2: Erstellen des Machine-Learning-Modells
<a name="tutorial_k-means_clustering_create_model"></a>

Im folgenden Beispiel wird der Befehl CREATE MODEL verwendet, um ein Modell zu erstellen, das die Daten in sieben Cluster gruppiert. Der K-Wert entspricht der Anzahl der Cluster, in die Ihre Datenpunkte unterteilt sind. Das Modell klassifiziert Ihre Datenpunkte in Cluster, in denen Datenpunkte eine größere Ähnlichkeit haben. Durch Clustering der Datenpunkte in Gruppen ermittelt der k-Means-Algorithmus iterativ das beste Clusterzentrum. Der Algorithmus weist dann jeden Datenpunkt dem nächstgelegenen Clusterzentrum zu. Mitglieder mit dem gleichen nächstgelegenen Clusterzentrum gehören zur selben Gruppe. Mitglieder einer Gruppe sind anderen Mitgliedern derselben Gruppe so ähnlich wie möglich und unterscheiden sich so stark wie möglich von Mitgliedern anderer Gruppen. Der K-Wert ist subjektiv und hängt von Methoden ab, die die Ähnlichkeiten zwischen Datenpunkten messen. Sie können den K-Wert ändern, um Clustergrößen auszugleichen, wenn die Cluster ungleichmäßig verteilt sind.

Ersetzen Sie im folgenden Beispiel amzn-s3-demo-bucket durch Ihren eigenen Amazon-S3-Bucket.

```
CREATE MODEL news_data_clusters
FROM
    (
        SELECT
            AvgTone,
            EventCode,
            NumArticles,
            Actor1Geo_Lat,
            Actor1Geo_Long,
            Actor2Geo_Lat,
            Actor2Geo_Long
        FROM
            gdelt_data
    ) FUNCTION news_monitoring_cluster 
    IAM_ROLE default 
    AUTO OFF 
    MODEL_TYPE KMEANS 
    PREPROCESSORS 'none' 
    HYPERPARAMETERS DEFAULT
    EXCEPT
    (K '7') 
    SETTINGS (S3_BUCKET 'amzn-s3-demo-bucket');
```

### Überprüfen des Status des Modelltrainings (optional)
<a name="tutorial_k-means_clustering_check_status"></a>

Sie können den Befehl SHOW MODEL verwenden, um festzustellen, wann Ihr Modell bereit ist.

Verwenden Sie die folgende Operation SHOW MODEL, um den Status des Modells zu überprüfen und herauszufinden, ob der `Model State` `Ready` lautet.

```
SHOW MODEL NEWS_DATA_CLUSTERS;
```

Wenn das Modell bereit ist, sollte die Ausgabe der vorherigen Operation zeigen, dass der `Model State` `Ready` lautet. Es folgt ein Beispiel für die Ausgabe der Operation SHOW MODEL.

```
+--------------------------+------------------------------------------------------------------------------------------------------+
|        Model Name        |                                          news_data_clusters                                          |
+--------------------------+------------------------------------------------------------------------------------------------------+
|       Schema Name        |                                                public                                                |
|          Owner           |                                               awsuser                                                |
|      Creation Time       |                                       Fri, 17.06.2022 16:32:19                                       |
|       Model State        |                                                READY                                                 |
|        train:msd         |                                             2973.822754                                              |
|      train:progress      |                                              100.000000                                              |
|     train:throughput     |                                            237114.875000                                             |
|      Estimated Cost      |                                               0.004983                                               |
|                          |                                                                                                      |
|      TRAINING DATA:      |                                                                                                      |
|          Query           | SELECT AVGTONE, EVENTCODE, NUMARTICLES, ACTOR1GEO_LAT, ACTOR1GEO_LONG, ACTOR2GEO_LAT, ACTOR2GEO_LONG |
|                          |                                           FROM GDELT_DATA                                            |
|                          |                                                                                                      |
|       PARAMETERS:        |                                                                                                      |
|        Model Type        |                                                kmeans                                                |
|    Training Job Name     |                                redshiftml-20220617163219978978-kmeans                                |
|      Function Name       |                                       news_monitoring_cluster                                        |
|   Function Parameters    |       avgtone eventcode numarticles actor1geo_lat actor1geo_long actor2geo_lat actor2geo_long        |
| Function Parameter Types |                             float8 int8 int8 float8 float8 float8 float8                             |
|         IAM Role         |                                         default-aws-iam-role                                         |
|        S3 Bucket         |                                            amzn-s3-demo-bucket                                       |
|       Max Runtime        |                                                 5400                                                 |
|                          |                                                                                                      |
|     HYPERPARAMETERS:     |                                                                                                      |
|       feature_dim        |                                                  7                                                   |
|            k             |                                                  7                                                   |
+--------------------------+------------------------------------------------------------------------------------------------------+
```

## Schritt 3: Erstellen von Prognosen mit dem Modell
<a name="tutorial_k-means_clustering_step_perform_predictions"></a>

### Identifizieren der Cluster
<a name="tutorial_k-means_clustering_identify_clusters"></a>

Sie können diskrete Gruppierungen, auch Cluster genannt, finden, die von Ihrem Modell in den Daten identifiziert wurden. Ein Cluster ist ein Satz von Datenpunkten, der näher an seinem Clusterzentrum als an allen anderen Clusterzentren liegt. Da der K-Wert die Anzahl der Cluster im Modell darstellt, stellt er auch die Anzahl der Clusterzentren dar. Die folgende Abfrage identifiziert die Cluster, indem sie den Cluster anzeigt, der der jeweiligen `globaleventid` zugeordnet ist.

```
SELECT
    globaleventid,
    news_monitoring_cluster (
        AvgTone,
        EventCode,
        NumArticles,
        Actor1Geo_Lat,
        Actor1Geo_Long,
        Actor2Geo_Lat,
        Actor2Geo_Long
    ) AS cluster
FROM
    gdelt_data;
```

### Überprüfen der Verteilung der Daten
<a name="tutorial_k-means_clustering_check_distribution"></a>

Sie können die Verteilung der Daten auf die Cluster überprüfen, um festzustellen, ob der von Ihnen ausgewählte K-Wert dazu geführt hat, dass die Daten etwas gleichmäßiger verteilt wurden. Verwenden Sie die folgende Abfrage, um zu ermitteln, ob die Daten gleichmäßig auf Ihre Cluster verteilt sind.

```
SELECT
    events_cluster,
    COUNT(*) AS nbr_events
FROM
    (
        SELECT
            globaleventid,
            news_monitoring_cluster(
                AvgTone,
                EventCode,
                NumArticles,
                Actor1Geo_Lat,
                Actor1Geo_Long,
                Actor2Geo_Lat,
                Actor2Geo_Long
            ) AS events_cluster
        FROM
            gdelt_data
    )
GROUP BY
    1;
```

Hinweis: Sie können den K-Wert ändern, um Clustergrößen auszugleichen, wenn die Cluster ungleichmäßig verteilt sind.

### Ermitteln der Clusterzentren
<a name="tutorial_k-means_clustering_determine_centers"></a>

Ein Datenpunkt liegt näher an seinem Clusterzentrum als an allen anderen Clusterzentren. Das Auffinden der Clusterzentren hilft Ihnen daher, die Cluster zu definieren.

Führen Sie die folgende Abfrage aus, um die Zentren der Cluster basierend auf der Anzahl der Artikel nach Ereigniscode zu ermitteln.

```
SELECT
    news_monitoring_cluster (
        AvgTone,
        EventCode,
        NumArticles,
        Actor1Geo_Lat,
        Actor1Geo_Long,
        Actor2Geo_Lat,
        Actor2Geo_Long
    ) AS events_cluster,
    eventcode,
    SUM(numArticles) AS numArticles
FROM
    gdelt_data
GROUP BY
    1,
    2;
```

### Anzeigen der Informationen über Datenpunkte in einem Cluster
<a name="tutorial_k-means_clustering_data_points_info"></a>

Verwenden Sie die folgende Abfrage, um die Daten für die Punkte zurückzugeben, die dem fünften Cluster zugewiesen sind. Die ausgewählten Artikel müssen zwei Akteure haben.

```
SELECT
    news_monitoring_cluster (
        AvgTone,
        EventCode,
        NumArticles,
        Actor1Geo_Lat,
        Actor1Geo_Long,
        Actor2Geo_Lat,
        Actor2Geo_Long
    ) AS events_cluster,
    eventcode,
    actor1name,
    actor2name,
    SUM(numarticles) AS totalarticles
FROM
    gdelt_data
WHERE
    events_cluster = 5
    AND actor1name <> ' '
    AND actor2name <> ' '
GROUP BY
    1,
    2,
    3,
    4
ORDER BY
    5 desc;
```

### Anzeigen von Daten über Ereignisse mit Akteuren desselben ethnischen Codes
<a name="tutorial_k-means_clustering_show_events_data"></a>

Die folgende Abfrage zählt die Anzahl der Artikel, die positiv über Ereignisse berichten. Die Abfrage erfordert auch, dass die beiden Akteure denselben ethnischen Code haben, und sie gibt zurück, welchem Cluster jedes Ereignis zugewiesen ist.

```
SELECT
    news_monitoring_cluster (
        AvgTone,
        EventCode,
        NumArticles,
        Actor1Geo_Lat,
        Actor1Geo_Long,
        Actor2Geo_Lat,
        Actor2Geo_Long
    ) AS events_cluster,
    SUM(numarticles) AS total_articles,
    eventcode AS event_code,
    Actor1EthnicCode AS ethnic_code
FROM
    gdelt_data
WHERE
    Actor1EthnicCode = Actor2EthnicCode
    AND Actor1EthnicCode <> ' '
    AND Actor2EthnicCode <> ' '
    AND AvgTone > 0
GROUP BY
    1,
    3,
    4
HAVING
    (total_articles) > 4
ORDER BY
    1,
    2 ASC;
```

## Verwandte Themen
<a name="tutorial_k-means_clustering_related_topics"></a>

Weitere Informationen zu Amazon Redshift ML finden Sie in der folgenden Dokumentation:
+ [Kosten für die Verwendung von Amazon Redshift ML](https://docs.aws.amazon.com/redshift/latest/dg/cost.html)
+ [Operation CREATE MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_MODEL.html)
+ [Funktion EXPLAIN\$1MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_explain_model_function.html)

Weitere Informationen über Machine Learning finden Sie in der folgenden Dokumentation:
+ [Übersicht zum Machine Learning](https://docs.aws.amazon.com/redshift/latest/dg/machine_learning_overview.html)
+ [Machine Learning für Anfänger und Experten](https://docs.aws.amazon.com/redshift/latest/dg/novice_expert.html)
+ [Was ist Fairness und Modellerklärbarkeit für Prognosen mit Machine Learning?](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-fairness-and-explainability.html)