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.
# Tutorials für Amazon Redshift ML
Mithilfe von Amazon Redshift ML können Sie Machine-Learning-Modelle mit SQL-Anweisungen trainieren und sie in SQL-Abfragen für Prognosen aufrufen. Machine Learning in Amazon Redshift trainiert ein Modell mit einem SQL-Befehl. Amazon Redshift startet automatisch einen Schulungsjob in Amazon SageMaker AI und generiert ein Modell. Nachdem ein Modell erstellt wurde, können Sie mithilfe der Voraussagefunktion des Modells Prognosen in Amazon Redshift erstellen.
Befolgen Sie die Schritte in diesen Tutorials, um mehr über die Funktionen von Amazon Redshift ML zu erfahren:
+ [Tutorial: Erstellen von Kundenabwanderungsmodellen](tutorial_customer_churn.md) – In diesem Tutorial verwenden Sie Amazon Redshift ML, um mit dem Befehl CREATE MODEL ein Kundenabwanderungsmodell zu erstellen und Voraussageabfragen für Benutzerszenarien auszuführen. Anschließend implementieren Sie Abfragen mit der SQL-Funktion, die der Befehl CREATE MODEL generiert.
+ [Tutorial: k-Means-Clustering-Modelle erstellen](tutorial_k-means_clustering.md) – 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.
+ [Tutorial: Erstellen von Mehrklassen-Klassifizierungsmodellen](tutorial_multi-class_classification.md) – In diesem Tutorial verwenden Sie Amazon Redshift ML, um ein Machine-Learning-Modell zu erstellen, das Mehrklassen-Klassifizierungsprobleme löst. Der Mehrklassen-Klassifizierungsalgorithmus klassifiziert Datenpunkte in eine von drei oder mehr Klassen. Anschließend implementieren Sie Abfragen mit der SQL-Funktion, die der Befehl CREATE MODEL generiert.
+ [Tutorial: Modelle erstellen XGBoost](tutorial_xgboost.md) – In diesem Tutorial erstellen Sie ein Modell mit Daten aus Amazon S3 und führen Voraussageabfragen mit dem Modell mithilfe von Amazon Redshift ML aus. Der XGBoost Algorithmus ist eine optimierte Implementierung des Gradient Boosted Trees-Algorithmus.
+ [Tutorial: Erstellen von Regressionsmodellen](tutorial_regression.md) – In diesem Tutorial verwenden Sie Amazon Redshift ML, um ein Regressionsmodell für Machine Learning zu erstellen und Voraussageabfragen für das Modell auszuführen. Mit Regressionsmodellen können Sie numerische Ergebnisse vorhersagen, z. B. den Preis eines Hauses oder wie viele Personen den Fahrradverleih einer Stadt nutzen werden.
+ [Tutorial: Erstellen von Regressionsmodellen mit linearem Lernen](tutorial_linear_learner_regression.md) – In diesem Tutorial erstellen Sie ein lineares Lernmodell mit Daten aus Amazon S3 und führen Voraussageabfragen mit dem Modell mithilfe von Amazon Redshift ML aus. Der SageMaker KI-Algorithmus für lineare Lernende löst entweder Regressions- oder Klassifikationsprobleme mit mehreren Klassen.
+ [Tutorial: Erstellen von Mehrklassen-Klassifizierungsmodellen mit linearem Lernen](tutorial_linear_learner_multi-class_classification.md) – In diesem Tutorial erstellen Sie ein lineares Lernmodell mit Daten aus Amazon S3 und führen dann mithilfe von Amazon Redshift ML Voraussageabfragen mit dem Modell aus. Der SageMaker KI-Algorithmus für lineare Lernende löst entweder Regressions- oder Klassifikationsprobleme.
# Tutorial: Erstellen von Kundenabwanderungsmodellen
In diesem Tutorial verwenden Sie Amazon Redshift ML, um mit dem Befehl CREATE MODEL ein Kundenabwanderungsmodell zu erstellen und Voraussageabfragen für Benutzerszenarien auszuführen. Anschließend implementieren Sie Abfragen mit der SQL-Funktion, die der Befehl CREATE MODEL generiert.
Sie können einen einfachen 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 Anweisung CREATE MODEL, um Trainingsdaten entweder als Tabelle oder SELECT-Anweisung anzugeben.
Dieses Beispiel verwendet historische Informationen, um ein Machine-Learning-Modell für die Abwanderung von Kunden eines Mobilfunkbetreibers zu erstellen. Zunächst trainiert SageMaker KI Ihr Modell für maschinelles Lernen und testet dann Ihr Modell anhand der Profilinformationen eines beliebigen Kunden. Nachdem das Modell validiert wurde, stellt Amazon SageMaker AI das Modell und die Prognosefunktion in Amazon Redshift bereit. Mit der Voraussagefunktion können Sie prognostizieren, ob ein Kunde abwandern wird oder nicht.
## Beispielanwendungsfälle
Mit Amazon Redshift ML können Sie andere binäre Klassifikationsprobleme lösen, z. B. voraussagen, ob ein Vertriebs-Lead abgeschlossen wird oder nicht. Sie können auch voraussagen, ob eine Finanztransaktion einen Betrug darstellt oder nicht.
**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
Für dieses Tutorial benötigen Sie Folgendes:
+ Sie müssen einen Amazon-Redshift-Cluster für Amazon Redshift ML einrichten. Verwenden Sie dazu die Dokumentation zum Thema [Einrichtung für die Amazon-Redshift-ML-Administration in Cluster aufteilen und konfigurieren](https://docs.aws.amazon.com/redshift/latest/dg/admin-setup.html).
+ Der Amazon-Redshift-Cluster, den Sie zum Erstellen des Modells verwenden, und der Amazon-S3-Bucket, der zur Bereitstellung der Trainingsdaten und zum Speichern der Modellartefakte verwendet wird, müssen sich in derselben AWS -Region befinden.
+ Führen Sie einen der folgenden Schritte aus, um die in dieser Dokumentation verwendeten SQL-Befehle und den Beispieldatensatz anzuzeigen oder herunterzuladen:
+ Laden Sie die [SQL-Befehle](https://s3.amazonaws.com/redshift-downloads/redshift-ml/tutorial-scripts/redshift-ml-tutorial.sql), die [Datei customer\$1activity](https://s3.amazonaws.com/redshift-downloads/redshift-ml/customer_activity/customer_activity.csv) und die [Datei abalone](https://s3.amazonaws.com/redshift-downloads/redshift-ml/abalone_xg/abalone.csv) herunter.
+ Führen Sie mit dem AWS CLI für Amazon S3 den folgenden Befehl aus. Sie können Ihren eigenen Zielpfad verwenden.
```
aws s3 cp s3://redshift-downloads/redshift-ml/tutorial-scripts/redshift-ml-tutorial.sql
aws s3 cp s3://redshift-downloads/redshift-ml/customer_activity/customer_activity.csv
aws s3 cp s3://redshift-downloads/redshift-ml/abalone_xgb/abalone_xgb.csv
```
## Schritt 1: Laden von Daten aus Amazon S3 in Amazon Redshift
Verwenden Sie den [Abfrage-Editor v2 von Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2-using.html), um Abfragen zu bearbeiten und auszuführen und Ergebnisse visuell darzustellen.
Durch Ausführen der folgenden Abfragen werden eine Tabelle mit dem Namen `customer_activity` erstellt und der Beispieldatensatz von Amazon S3 erfasst.
```
DROP TABLE IF EXISTS customer_activity;
CREATE TABLE customer_activity (
state varchar(2),
account_length int,
area_code int,
phone varchar(8),
intl_plan varchar(3),
vMail_plan varchar(3),
vMail_message int,
day_mins float,
day_calls int,
day_charge float,
total_charge float,
eve_mins float,
eve_calls int,
eve_charge float,
night_mins float,
night_calls int,
night_charge float,
intl_mins float,
intl_calls int,
intl_charge float,
cust_serv_calls int,
churn varchar(6),
record_date date
);
COPY customer_activity
FROM 's3://redshift-downloads/redshift-ml/customer_activity/'
REGION 'us-east-1' IAM_ROLE default
FORMAT AS CSV IGNOREHEADER 1;
```
## Schritt 2: Erstellen des Machine-Learning-Modells
Die Abwanderung ist unsere Zieleingabe in diesem Modell. Alle anderen Eingaben für das Modell sind Attribute, die helfen, eine Funktion zur Voraussage der Abwanderung zu erstellen.
Im folgenden Beispiel wird die Operation CREATE MODEL verwendet, um ein Modell bereitzustellen, das voraussagen kann, ob ein Kunde aktiv sein wird. Hierfür werden Eingaben wie das Alter des Kunden, die Postleitzahl, die Ausgaben und die Fälle herangezogen. Ersetzen Sie im folgenden Beispiel amzn-s3-demo-bucket durch Ihren eigenen Amazon-S3-Bucket.
```
CREATE MODEL customer_churn_auto_model
FROM
(
SELECT state,
account_length,
area_code,
total_charge/account_length AS average_daily_spend,
cust_serv_calls/account_length AS average_daily_cases,
churn
FROM customer_activity
WHERE record_date < '2020-01-01'
)
TARGET churn FUNCTION ml_fn_customer_churn_auto
IAM_ROLE default SETTINGS (
S3_BUCKET 'amzn-s3-demo-bucket'
);
```
Mit der SELECT-Abfrage im vorherigen Beispiel werden die Trainingsdaten erstellt. Die TARGET-Klausel gibt an, welche Spalte das Machine-Learning-Label ist, das die Operation CREATE MODEL zum Erlernen des Voraussagens verwendet. Die Zielspalte „churn“ (Abwanderung) gibt an, ob der Kunde noch eine aktive Mitgliedschaft hat oder die Mitgliedschaft beendet hat. Das Feld S3\$1BUCKET ist der Name des Amazon-S3-Buckets, den Sie zuvor erstellt haben. Der Amazon S3 S3-Bucket wird verwendet, um Trainingsdaten und Artefakte zwischen Amazon Redshift und Amazon SageMaker AI auszutauschen. Die restlichen Spalten sind die Merkmale, die für die Prognose verwendet werden.
Eine Zusammenfassung der Syntax und Merkmale eines einfachen Anwendungsfalls des Befehls CREATE MODEL finden Sie unter [Einfaches CREATE MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_create_model_use_cases.html#r_simple_create_model).
### Hinzufügen von Berechtigungen für die serverseitige Verschlüsselung (optional)
Amazon Redshift verwendet standardmäßig Amazon SageMaker AI Autopilot für Schulungen. Insbesondere exportiert Amazon Redshift Trainingsdaten sicher in den vom Kunden angegebenen Amazon-S3-Bucket. Wenn Sie keine `KMS_KEY_ID` angeben, werden die Daten standardmäßig unter Verwendung der serverseitigen Verschlüsselung SSE-S3 verschlüsselt.
Wenn Sie Ihre Eingabe mithilfe einer serverseitigen Verschlüsselung mit einem AWS KMS verwalteten Schlüssel (SSE-MMS) verschlüsseln, fügen Sie die folgenden Berechtigungen hinzu:
```
{
"Effect": "Allow",
"Action": [
"kms:Encrypt"
"kms:Decrypt"
]
}
```
Weitere Informationen zu Amazon SageMaker AI-Rollen finden Sie unter [Amazon SageMaker AI-Rollen](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html) im *Amazon SageMaker AI Developer Guide*.
### Überprüfen des Status des Modelltrainings (optional)
Sie können den Befehl SHOW MODEL verwenden, um festzustellen, wann Ihr Modell bereit ist.
Verwenden Sie die Operation, um den Status des Modells zu überprüfen.
```
SHOW MODEL customer_churn_auto_model;
```
Es folgt ein Beispiel für die Ausgabe der vorherigen Operation.
```
+--------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------+
| Key | Value |
+--------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------+
| Model Name | customer_churn_auto_model |
| Schema Name | public |
| Owner | awsuser |
| Creation Time | Tue, 14.06.2022 17:15:52 |
| Model State | TRAINING |
| | |
| TRAINING DATA: | |
| Query | SELECT STATE, ACCOUNT_LENGTH, AREA_CODE, TOTAL_CHARGE / ACCOUNT_LENGTH AS AVERAGE_DAILY_SPEND, CUST_SERV_CALLS / ACCOUNT_LENGTH AS AVERAGE_DAILY_CASES, CHURN |
| | FROM CUSTOMER_ACTIVITY |
| | WHERE RECORD_DATE < '2020-01-01' |
| Target Column | CHURN |
| | |
| PARAMETERS: | |
| Model Type | auto |
| Problem Type | |
| Objective | |
| AutoML Job Name | redshiftml-20220614171552640901 |
| Function Name | ml_fn_customer_churn_auto |
| Function Parameters | state account_length area_code average_daily_spend average_daily_cases |
| Function Parameter Types | varchar int4 int4 float8 int4 |
| IAM Role | default-aws-iam-role |
| S3 Bucket | amzn-s3-demo-bucket |
| Max Runtime | 5400 |
+--------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------+
```
Wenn das Modelltraining abgeschlossen ist, wird die Variable `model_state` zu `Model is Ready` und die Voraussagefunktion wird verfügbar.
## Schritt 3: Erstellen von Prognosen mit dem Modell
Sie können SQL-Anweisungen verwenden, um die vom Prognosemodell getroffenen Voraussagen anzuzeigen. In diesem Beispiel erhält die von der Operation CREATE MODEL erstellte Voraussagefunktion den Namen `ml_fn_customer_churn_auto`. Die Eingabeargumente für die Voraussagefunktion entsprechen den Merkmaltypen, z. B. varchar für `state` und Ganzzahl für `account_length`. Die Ausgabe der Prognosefunktion ist derselbe Typ wie die TARGET-Spalte der CREATE-MODEL-Anweisung.
1. Sie haben das Modell anhand von Daten aus der Zeit vor dem 01.01.2020 trainiert, sodass Sie jetzt die Voraussagefunktion für den Testsatz verwenden. Die folgende Abfrage zeigt die Prognosen an, ob Kunden, die sich nach dem 01.01.2020 registriert haben, von Abwanderung betroffen sein werden oder nicht.
```
SELECT
phone,
ml_fn_customer_churn_auto(
state,
account_length,
area_code,
total_charge / account_length,
cust_serv_calls / account_length
) AS active
FROM
customer_activity
WHERE
record_date > '2020-01-01';
```
1. Im folgenden Beispiel wird dieselbe Voraussagefunktion für einen anderen Anwendungsfall verwendet. In diesem Fall prognostiziert Amazon Redshift das Verhältnis der abwandernden und nicht abwandernden Kunden aus unterschiedlichen Staaten mit einem Erfassungsdatum nach 01.01.2020.
```
WITH predicted AS (
SELECT
state,
ml_fn_customer_churn_auto(
state,
account_length,
area_code,
total_charge / account_length,
cust_serv_calls / account_length
) :: varchar(6) AS active
FROM
customer_activity
WHERE
record_date > '2020-01-01'
)
SELECT
state,
SUM(
CASE
WHEN active = 'True.' THEN 1
ELSE 0
END
) AS churners,
SUM(
CASE
WHEN active = 'False.' THEN 1
ELSE 0
END
) AS nonchurners,
COUNT(*) AS total_per_state
FROM
predicted
GROUP BY
state
ORDER BY
state;
```
1. Im folgenden Beispiel wird die Voraussagefunktion für den Anwendungsfall zur Prognose des Prozentsatzes der Kunden verwendet, die in einem Bundesstaat abwandern. In diesem Fall prognostiziert Amazon Redshift den Prozentsatz der abwandernden Kunden, bei denen das Erfassungsdatum nach dem 01.01.2020 liegt.
```
WITH predicted AS (
SELECT
state,
ml_fn_customer_churn_auto(
state,
account_length,
area_code,
total_charge / account_length,
cust_serv_calls / account_length
) :: varchar(6) AS active
FROM
customer_activity
WHERE
record_date > '2020-01-01'
)
SELECT
state,
CAST((CAST((SUM(
CASE
WHEN active = 'True.' THEN 1
ELSE 0
END
)) AS FLOAT) / CAST(COUNT(*) AS FLOAT)) AS DECIMAL (3, 2)) AS pct_churn,
COUNT(*) AS total_customers_per_state
FROM
predicted
GROUP BY
state
ORDER BY
3 DESC;
```
## Verwandte Themen
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)
+ [Befehl 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)
# Tutorial: k-Means-Clustering-Modelle erstellen
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
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
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
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)
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
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)
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
### Identifizieren der Cluster
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
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
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
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
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
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)
# Tutorial: Erstellen von Mehrklassen-Klassifizierungsmodellen
In diesem Tutorial verwenden Sie Amazon Redshift ML, um ein Machine-Learning-Modell zu erstellen, das Mehrklassen-Klassifizierungsprobleme löst. Der Mehrklassen-Klassifizierungsalgorithmus klassifiziert Datenpunkte in eine von drei oder mehr Klassen. Anschließend implementieren Sie Abfragen mit der SQL-Funktion, die der Befehl CREATE MODEL generiert.
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.
Um dem Tutorial zu folgen, verwenden Sie den öffentlichen Datensatz [E-Commerce Sales Forecast](https://www.kaggle.com/allunia/e-commerce-sales-forecast), der Verkaufsdaten eines britischen Online-Einzelhändlers enthält. Das von Ihnen generierte Modell richtet sich an die aktivsten Kunden für ein spezielles Kundenbindungsprogramm. Mit der Mehrklassen-Klassifizierung können Sie anhand des Modells voraussagen, wie viele Monate ein Kunde über einen Zeitraum von 13 Monaten aktiv sein wird. Die Prognosefunktion bestimmt Kunden, die voraussichtlich 7 oder mehr Monate aktiv sind, um zum Programm zugelassen zu werden.
## Beispielanwendungsfälle
Sie können andere Mehrklassen-Klassifizierungsprobleme mit Amazon Redshift ML lösen, z. B. das meistverkaufte Produkt einer Produktlinie voraussagen. Sie können auch prognostizieren, welche Früchte ein Bild enthält, z. B. Äpfel, Birnen oder Orangen auswählen.
**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
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
Verwenden Sie den [Abfrage-Editor v2 von Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2-using.html), um die folgenden Abfragen auszuführen. Diese Abfragen laden die Beispieldaten in Amazon Redshift.
1. Mit der folgenden Abfrage wird eine Tabelle mit dem Namen `ecommerce_sales` erstellt.
```
CREATE TABLE IF NOT EXISTS ecommerce_sales (
invoiceno VARCHAR(30),
stockcode VARCHAR(30),
description VARCHAR(60),
quantity DOUBLE PRECISION,
invoicedate VARCHAR(30),
unitprice DOUBLE PRECISION,
customerid BIGINT,
country VARCHAR(25)
);
```
1. Die folgende Abfrage kopiert die Beispieldaten aus dem [Datensatz „E-Commerce Sales Forecast“](https://www.kaggle.com/allunia/e-commerce-sales-forecast) in die `ecommerce_sales`-Tabelle.
```
COPY ecommerce_sales
FROM
's3://redshift-ml-multiclass/ecommerce_data.txt'
IAM_ROLE default
DELIMITER '\t'
IGNOREHEADER 1
REGION 'us-east-1'
MAXERROR 100;
```
### Aufteilen der Daten
Wenn Sie ein Modell in Amazon Redshift ML erstellen, teilt SageMaker KI Ihre Daten automatisch in Trainings- und Testsätze auf, sodass SageMaker KI die Modellgenauigkeit bestimmen kann. Durch manuelles Aufteilen der Daten in diesem Schritt können Sie die Genauigkeit des Modells überprüfen, indem Sie einen zusätzlichen Prognosesatz zuweisen.
Verwenden Sie die folgende SQL-Anweisung, um die Daten für Training, Validierung und Voraussage auf drei Sätze aufzuteilen.
```
--creates table with all data
CREATE TABLE ecommerce_sales_data AS (
SELECT
t1.stockcode,
t1.description,
t1.invoicedate,
t1.customerid,
t1.country,
t1.sales_amt,
CAST(RANDOM() * 100 AS INT) AS data_group_id
FROM
(
SELECT
stockcode,
description,
invoicedate,
customerid,
country,
SUM(quantity * unitprice) AS sales_amt
FROM
ecommerce_sales
GROUP BY
1,
2,
3,
4,
5
) t1
);
--creates training set
CREATE TABLE ecommerce_sales_training AS (
SELECT
a.customerid,
a.country,
a.stockcode,
a.description,
a.invoicedate,
a.sales_amt,
(b.nbr_months_active) AS nbr_months_active
FROM
ecommerce_sales_data a
INNER JOIN (
SELECT
customerid,
COUNT(
DISTINCT(
DATE_PART(y, CAST(invoicedate AS DATE)) || '-' || LPAD(
DATE_PART(mon, CAST(invoicedate AS DATE)),
2,
'00'
)
)
) AS nbr_months_active
FROM
ecommerce_sales_data
GROUP BY
1
) b ON a.customerid = b.customerid
WHERE
a.data_group_id < 80
);
--creates validation set
CREATE TABLE ecommerce_sales_validation AS (
SELECT
a.customerid,
a.country,
a.stockcode,
a.description,
a.invoicedate,
a.sales_amt,
(b.nbr_months_active) AS nbr_months_active
FROM
ecommerce_sales_data a
INNER JOIN (
SELECT
customerid,
COUNT(
DISTINCT(
DATE_PART(y, CAST(invoicedate AS DATE)) || '-' || LPAD(
DATE_PART(mon, CAST(invoicedate AS DATE)),
2,
'00'
)
)
) AS nbr_months_active
FROM
ecommerce_sales_data
GROUP BY
1
) b ON a.customerid = b.customerid
WHERE
a.data_group_id BETWEEN 80
AND 90
);
--creates prediction set
CREATE TABLE ecommerce_sales_prediction AS (
SELECT
customerid,
country,
stockcode,
description,
invoicedate,
sales_amt
FROM
ecommerce_sales_data
WHERE
data_group_id > 90);
```
## Schritt 2: Erstellen des Machine-Learning-Modells
In diesem Schritt verwenden Sie die Anweisung CREATE MODEL, um Ihr Machine-Learning-Modell mithilfe der Mehrklassen-Klassifizierung zu erstellen.
Die folgende Abfrage erstellt das Mehrklassen-Klassifizierungsmodell mit dem Trainingssatz unter Verwendung der Operation CREATE MODEL. Ersetzen Sie amzn-s3-demo-bucket durch Ihren eigenen Amazon-S3-Bucket.
```
CREATE MODEL ecommerce_customer_activity
FROM
(
SELECT
customerid,
country,
stockcode,
description,
invoicedate,
sales_amt,
nbr_months_active
FROM
ecommerce_sales_training
) TARGET nbr_months_active FUNCTION predict_customer_activity IAM_ROLE default PROBLEM_TYPE MULTICLASS_CLASSIFICATION SETTINGS (
S3_BUCKET 'amzn-s3-demo-bucket',
S3_GARBAGE_COLLECT OFF
);
```
In dieser Abfrage geben Sie den Problemtyp als `Multiclass_Classification` an. Das Ziel, das Sie für das Modell voraussagen, ist `nbr_months_active`. Wenn SageMaker KI das Training des Modells abgeschlossen hat, erstellt sie die Funktion`predict_customer_activity`, mit der Sie Vorhersagen in Amazon Redshift treffen können.
### Anzeigen des Status des Modelltrainings (optional)
Sie können den Befehl SHOW MODEL verwenden, um festzustellen, wann Ihr Modell bereit ist.
Verwenden Sie die folgende Abfrage, um verschiedene Metriken des Modells zurückzugeben, einschließlich Modellstatus und Genauigkeit.
```
SHOW MODEL ecommerce_customer_activity;
```
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 | ecommerce_customer_activity |
+--------------------------+-----------------------------------------------------------------------------------------------+
| Schema Name | public |
| Owner | awsuser |
| Creation Time | Fri, 17.06.2022 19:02:15 |
| Model State | READY |
| Training Job Status | MaxAutoMLJobRuntimeReached |
| validation:accuracy | 0.991280 |
| Estimated Cost | 7.897689 |
| | |
| TRAINING DATA: | |
| Query | SELECT CUSTOMERID, COUNTRY, STOCKCODE, DESCRIPTION, INVOICEDATE, SALES_AMT, NBR_MONTHS_ACTIVE |
| | FROM ECOMMERCE_SALES_TRAINING |
| Target Column | NBR_MONTHS_ACTIVE |
| | |
| PARAMETERS: | |
| Model Type | xgboost |
| Problem Type | MulticlassClassification |
| Objective | Accuracy |
| AutoML Job Name | redshiftml-20220617190215268770 |
| Function Name | predict_customer_activity |
| Function Parameters | customerid country stockcode description invoicedate sales_amt |
| Function Parameter Types | int8 varchar varchar varchar varchar float8 |
| IAM Role | default-aws-iam-role |
| S3 Bucket | amzn-s3-demo-bucket |
| Max Runtime | 5400 |
+--------------------------+-----------------------------------------------------------------------------------------------+
```
## Schritt 3: Erstellen von Prognosen mit dem Modell
Die folgende Abfrage zeigt, welche Kunden sich für Ihr Kundenbindungsprogramm qualifizieren. Wenn das Modell voraussagt, dass der Kunde mindestens sieben Monate lang aktiv sein wird, wählt das Modell den Kunden für das Treueprogramm aus.
```
SELECT
customerid,
predict_customer_activity(
customerid,
country,
stockcode,
description,
invoicedate,
sales_amt
) AS predicted_months_active
FROM
ecommerce_sales_prediction
WHERE
predicted_months_active >= 7
GROUP BY
1,
2
LIMIT
10;
```
### Ausführen von Voraussageabfragen für die Validierungsdaten (optional)
Führen Sie die folgenden Voraussageabfragen für die Validierungsdaten aus, um den Genauigkeitsgrad des Modells zu ermitteln.
```
SELECT
CAST(SUM(t1.match) AS decimal(7, 2)) AS predicted_matches,
CAST(SUM(t1.nonmatch) AS decimal(7, 2)) AS predicted_non_matches,
CAST(SUM(t1.match + t1.nonmatch) AS decimal(7, 2)) AS total_predictions,
predicted_matches / total_predictions AS pct_accuracy
FROM
(
SELECT
customerid,
country,
stockcode,
description,
invoicedate,
sales_amt,
nbr_months_active,
predict_customer_activity(
customerid,
country,
stockcode,
description,
invoicedate,
sales_amt
) AS predicted_months_active,
CASE
WHEN nbr_months_active = predicted_months_active THEN 1
ELSE 0
END AS match,
CASE
WHEN nbr_months_active <> predicted_months_active THEN 1
ELSE 0
END AS nonmatch
FROM
ecommerce_sales_validation
)t1;
```
### Prognostizieren, wie viele Kunden nicht aufgenommen werden (optional)
Die folgende Abfrage vergleicht die Anzahl der Kunden, die voraussichtlich nur 5 oder 6 Monate aktiv sind. Das Modell prognostiziert, dass sich diese Kunden nicht für das Treueprogramm qualifizieren werden. Die Abfrage vergleicht dann die Anzahl der nicht in das Programm aufgenommenen Kunden mit der Anzahl, die sich laut Prognose für das Treueprogramm qualifizieren. Diese Abfrage könnte verwendet werden, um eine Entscheidung darüber zu treffen, ob der Schwellenwert für das Treueprogramm gesenkt werden soll. Sie können auch feststellen, ob es eine erhebliche Anzahl von Kunden gibt, die sich laut Prognose nicht für das Programm qualifizieren werden. Sie können diese Kunden dann ermutigen, ihre Aktivität zu steigern, um in das Treueprogramm aufgenommen zu werden.
```
SELECT
predict_customer_activity(
customerid,
country,
stockcode,
description,
invoicedate,
sales_amt
) AS predicted_months_active,
COUNT(customerid)
FROM
ecommerce_sales_prediction
WHERE
predicted_months_active BETWEEN 5 AND 6
GROUP BY
1
ORDER BY
1 ASC
LIMIT
10)
UNION
(SELECT
NULL AS predicted_months_active,
COUNT (customerid)
FROM
ecommerce_sales_prediction
WHERE
predict_customer_activity(
customerid,
country,
stockcode,
description,
invoicedate,
sales_amt
) >=7);
```
## Verwandte Themen
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)
# Tutorial: Modelle erstellen XGBoost
In diesem Tutorial erstellen Sie ein Modell mit Daten aus Amazon S3 und führen Voraussageabfragen mit dem Modell mithilfe von Amazon Redshift ML aus. Der XGBoost Algorithmus ist eine optimierte Implementierung des Gradient Boosted Trees-Algorithmus. XGBoost verarbeitet mehr Datentypen, Beziehungen und Verteilungen als andere Algorithmen für gradientengestützte Bäume. Sie können ihn XGBoost für Regressions-, binäre Klassifizierungs-, Mehrklassenklassifizierungs- und Rankingprobleme verwenden. Weitere Informationen zum XGBoost Algorithmus finden Sie unter [XGBoostAlgorithmus](https://docs.aws.amazon.com/sagemaker/latest/dg/xgboost.html) im Amazon SageMaker AI Developer Guide.
Der Amazon Redshift `CREATE MODEL` ML-Vorgang mit der `AUTO OFF` Option unterstützt derzeit XGBoost als. `MODEL_TYPE` Sie können relevante Informationen wie das Ziel und die Hyperparameter als Teil des Befehls `CREATE MODEL` basierend auf Ihrem Anwendungsfall angeben.
In diesem Tutorial verwenden Sie den [Banknotenauthentifizierungs-Datensatz](https://archive.ics.uci.edu/ml/datasets/banknote+authentication), ein binäres Klassifizierungsproblem, um vorauszusagen, ob eine bestimmte Banknote echt oder gefälscht ist.
## Beispielanwendungsfälle
Mit Amazon Redshift ML können Sie andere binäre Klassifikationsprobleme lösen, z. B. voraussagen, ob ein Patient gesund ist oder an einer Krankheit leidet. Sie können auch prognostizieren, ob es sich bei einer E-Mail um Spam handelt oder nicht.
**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
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
Verwenden Sie den [Abfrage-Editor v2 von Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2-using.html), um die folgenden Abfragen auszuführen.
Mit der folgenden Abfrage werden zwei Tabellen erstellt, die Daten aus Amazon S3 geladen und auf einen Trainingsatz und einen Testsatz aufgeteilt. Sie verwenden das Trainingsset, um Ihr Modell zu trainieren und die Voraussagefunktion zu erstellen. Anschließend testen Sie die Voraussagefunktion mit dem Testsatz.
```
--create training set table
CREATE TABLE banknoteauthentication_train(
variance FLOAT,
skewness FLOAT,
curtosis FLOAT,
entropy FLOAT,
class INT
);
--Load into training table
COPY banknoteauthentication_train
FROM
's3://redshiftbucket-ml-sagemaker/banknote_authentication/train_data/' IAM_ROLE default REGION 'us-west-2' IGNOREHEADER 1 CSV;
--create testing set table
CREATE TABLE banknoteauthentication_test(
variance FLOAT,
skewness FLOAT,
curtosis FLOAT,
entropy FLOAT,
class INT
);
--Load data into testing table
COPY banknoteauthentication_test
FROM
's3://redshiftbucket-ml-sagemaker/banknote_authentication/test_data/'
IAM_ROLE default
REGION 'us-west-2'
IGNOREHEADER 1
CSV;
```
## Schritt 2: Erstellen des Machine-Learning-Modells
Die folgende Abfrage erstellt das XGBoost Modell in Amazon Redshift ML aus dem Trainingssatz, den Sie im vorherigen Schritt erstellt haben. Ersetzen Sie `amzn-s3-demo-bucket` mit Ihrem eigenen `S3_BUCKET`, in dem Ihre Eingabedatensätze und andere Redshift-ML-Artefakte gespeichert werden.
```
CREATE MODEL model_banknoteauthentication_xgboost_binary
FROM
banknoteauthentication_train
TARGET class
FUNCTION func_model_banknoteauthentication_xgboost_binary
IAM_ROLE default
AUTO OFF
MODEL_TYPE xgboost
OBJECTIVE 'binary:logistic'
PREPROCESSORS 'none'
HYPERPARAMETERS DEFAULT
EXCEPT(NUM_ROUND '100')
SETTINGS(S3_BUCKET 'amzn-s3-demo-bucket');
```
### Anzeigen des Status des Modelltrainings (optional)
Sie können den Befehl SHOW MODEL verwenden, um festzustellen, wann Ihr Modell bereit ist.
Verwenden Sie die folgende Abfrage, um den Trainingsfortschritt des Modells zu überwachen.
```
SHOW MODEL model_banknoteauthentication_xgboost_binary;
```
Wenn das Modell `READY` ist, bietet die Operation SHOW MODEL auch die `train:error`-Metrik, wie im folgenden Beispiel für die Ausgabe gezeigt. Die `train:error`-Metrik ist ein Maß für die Genauigkeit Ihres Modells, das bis zu sechs Dezimalstellen misst. Ein Wert von 0 ist am genauesten und ein Wert von 1 ist am wenigsten genau.
```
+--------------------------+--------------------------------------------------+
| Model Name | model_banknoteauthentication_xgboost_binary |
+--------------------------+--------------------------------------------------+
| Schema Name | public |
| Owner | awsuser |
| Creation Time | Tue, 21.06.2022 19:07:35 |
| Model State | READY |
| train:error | 0.000000 |
| Estimated Cost | 0.006197 |
| | |
| TRAINING DATA: | |
| Query | SELECT * |
| | FROM "BANKNOTEAUTHENTICATION_TRAIN" |
| Target Column | CLASS |
| | |
| PARAMETERS: | |
| Model Type | xgboost |
| Training Job Name | redshiftml-20220621190735686935-xgboost |
| Function Name | func_model_banknoteauthentication_xgboost_binary |
| Function Parameters | variance skewness curtosis entropy |
| Function Parameter Types | float8 float8 float8 float8 |
| IAM Role | default-aws-iam-role |
| S3 Bucket | amzn-s3-demo-bucket |
| Max Runtime | 5400 |
| | |
| HYPERPARAMETERS: | |
| num_round | 100 |
| objective | binary:logistic |
+--------------------------+--------------------------------------------------+
```
## Schritt 3: Erstellen von Prognosen mit dem Modell
### Überprüfen der Genauigkeit des Modells
Die folgende Voraussageabfrage verwendet die im vorherigen Schritt erstellte Prognosefunktion, um die Genauigkeit Ihres Modells zu überprüfen. Führen Sie diese Abfrage für den Testsatz aus, um sicherzustellen, dass das Modell dem Trainingssatz nicht zu genau entspricht. Diese enge Übereinstimmung wird auch als Überanpassung bezeichnet. Eine Überanpassung kann dazu führen, dass das Modell unzuverlässige Voraussagen trifft.
```
WITH predict_data AS (
SELECT
class AS label,
func_model_banknoteauthentication_xgboost_binary (variance, skewness, curtosis, entropy) AS predicted,
CASE
WHEN label IS NULL THEN 0
ELSE label
END AS actual,
CASE
WHEN actual = predicted THEN 1 :: INT
ELSE 0 :: INT
END AS correct
FROM
banknoteauthentication_test
),
aggr_data AS (
SELECT
SUM(correct) AS num_correct,
COUNT(*) AS total
FROM
predict_data
)
SELECT
(num_correct :: FLOAT / total :: FLOAT) AS accuracy
FROM
aggr_data;
```
### Prognostizieren der Menge der echten und der gefälschten Banknoten
Die folgende Prognoseabfrage gibt die prognostizierte Anzahl der echten und gefälschten Banknoten im Testsatz zurück.
```
WITH predict_data AS (
SELECT
func_model_banknoteauthentication_xgboost_binary(variance, skewness, curtosis, entropy) AS predicted
FROM
banknoteauthentication_test
)
SELECT
CASE
WHEN predicted = '0' THEN 'Original banknote'
WHEN predicted = '1' THEN 'Counterfeit banknote'
ELSE 'NA'
END AS banknote_authentication,
COUNT(1) AS count
FROM
predict_data
GROUP BY
1;
```
### Ermitteln des Durchschnitts der Beobachtungen echter und gefälschter Banknoten
Die folgende Prognoseabfrage gibt den Durchschnittswert jedes Merkmals für Banknoten zurück, bei denen im Testsatz vorausgesagt wird, dass sie echt und gefälscht sind.
```
WITH predict_data AS (
SELECT
func_model_banknoteauthentication_xgboost_binary(variance, skewness, curtosis, entropy) AS predicted,
variance,
skewness,
curtosis,
entropy
FROM
banknoteauthentication_test
)
SELECT
CASE
WHEN predicted = '0' THEN 'Original banknote'
WHEN predicted = '1' THEN 'Counterfeit banknote'
ELSE 'NA'
END AS banknote_authentication,
TRUNC(AVG(variance), 2) AS avg_variance,
TRUNC(AVG(skewness), 2) AS avg_skewness,
TRUNC(AVG(curtosis), 2) AS avg_curtosis,
TRUNC(AVG(entropy), 2) AS avg_entropy
FROM
predict_data
GROUP BY
1
ORDER BY
2;
```
## Verwandte Themen
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)
# Tutorial: Erstellen von Regressionsmodellen
In diesem Tutorial verwenden Sie Amazon Redshift ML, um ein Regressionsmodell für Machine Learning zu erstellen und Voraussageabfragen für das Modell auszuführen. Mit Regressionsmodellen können Sie numerische Ergebnisse vorhersagen, z. B. den Preis eines Hauses oder wie viele Personen den Fahrradverleih einer Stadt nutzen werden. Sie verwenden den Befehl CREATE MODEL in Amazon Redshift mit Ihren Trainingsdaten. Anschließend kompiliert Amazon Redshift ML das Modell, importiert das trainierte Modell in Redshift und bereitet eine SQL-Voraussagefunktion vor. Sie können die Voraussagefunktion in SQL-Abfragen in Amazon Redshift verwenden.
In diesem Tutorial erstellen Sie mithilfe von Amazon Redshift ML ein Regressionsmodell, das die Anzahl der Personen vorhersagt, die den Bike-Sharing-Service der Stadt Toronto zu einer bestimmten Tageszeit nutzen. Die Eingaben für das Modell umfassen Feiertage und Wetterbedingungen. Sie verwenden ein Regressionsmodell, da für dieses Problem ein numerisches Ergebnis erwünscht ist.
Sie können den Befehl CREATE MODEL verwenden, um Trainingsdaten zu exportieren, ein Modell zu trainieren und es in Amazon Redshift als SQL-Funktion verfügbar zu machen. Verwenden Sie die Operation CREATE MODEL, um Trainingsdaten entweder als Tabelle oder SELECT-Anweisung anzugeben.
## Beispielanwendungsfälle
Sie können andere Regressionsprobleme mit Amazon Redshift ML lösen, z. B. den Wert für die Lebensdauer eines Kunden prognostizieren. Sie können Redshift ML auch verwenden, um den profitabelsten Preis und den daraus resultierenden Umsatz eines Produkts vorauszusagen.
**Aufgaben**
+ Voraussetzungen
+ Schritt 1: Laden von Daten aus Amazon S3 in Amazon Redshift
+ Schritt 2: Erstellen des Machine-Learning-Modells
+ Schritt 3: Validieren des Modells
## Voraussetzungen
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
Verwenden Sie den [Abfrage-Editor v2 von Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2-using.html), um die folgenden Abfragen auszuführen.
1. Sie müssen drei Tabellen erstellen, um die drei öffentlichen Datensätze in Amazon Redshift zu laden. Die Datensätze sind [Toronto Bike Ridership Data](https://open.toronto.ca/dataset/bike-share-toronto-ridership-data/), [Historical Weather Data](https://climate.weather.gc.ca/historical_data/search_historic_data_e.html) und [Historical Holidays Data](https://github.com/uWaterloo/Datasets/blob/master/Holidays/holidays.csv). Führen Sie die folgende Abfrage im Abfrage-Editor von Amazon Redshift aus, um Tabellen mit dem Namen `ridership`, `weather` und `holiday` zu erstellen.
```
CREATE TABLE IF NOT EXISTS ridership (
trip_id INT,
trip_duration_seconds INT,
trip_start_time timestamp,
trip_stop_time timestamp,
from_station_name VARCHAR(50),
to_station_name VARCHAR(50),
from_station_id SMALLINT,
to_station_id SMALLINT,
user_type VARCHAR(20)
);
CREATE TABLE IF NOT EXISTS weather (
longitude_x DECIMAL(5, 2),
latitude_y DECIMAL(5, 2),
station_name VARCHAR(20),
climate_id BIGINT,
datetime_utc TIMESTAMP,
weather_year SMALLINT,
weather_month SMALLINT,
weather_day SMALLINT,
time_utc VARCHAR(5),
temp_c DECIMAL(5, 2),
temp_flag VARCHAR(1),
dew_point_temp_c DECIMAL(5, 2),
dew_point_temp_flag VARCHAR(1),
rel_hum SMALLINT,
rel_hum_flag VARCHAR(1),
precip_amount_mm DECIMAL(5, 2),
precip_amount_flag VARCHAR(1),
wind_dir_10s_deg VARCHAR(10),
wind_dir_flag VARCHAR(1),
wind_spd_kmh VARCHAR(10),
wind_spd_flag VARCHAR(1),
visibility_km VARCHAR(10),
visibility_flag VARCHAR(1),
stn_press_kpa DECIMAL(5, 2),
stn_press_flag VARCHAR(1),
hmdx SMALLINT,
hmdx_flag VARCHAR(1),
wind_chill VARCHAR(10),
wind_chill_flag VARCHAR(1),
weather VARCHAR(10)
);
CREATE TABLE IF NOT EXISTS holiday (holiday_date DATE, description VARCHAR(100));
```
1. Die folgende Abfrage lädt die Beispieldaten in die Tabellen, die Sie im vorherigen Schritt erstellt haben.
```
COPY ridership
FROM
's3://redshift-ml-bikesharing-data/bike-sharing-data/ridership/'
IAM_ROLE default
FORMAT CSV
IGNOREHEADER 1
DATEFORMAT 'auto'
TIMEFORMAT 'auto'
REGION 'us-west-2'
gzip;
COPY weather
FROM
's3://redshift-ml-bikesharing-data/bike-sharing-data/weather/'
IAM_ROLE default
FORMAT csv
IGNOREHEADER 1
DATEFORMAT 'auto'
TIMEFORMAT 'auto'
REGION 'us-west-2'
gzip;
COPY holiday
FROM
's3://redshift-ml-bikesharing-data/bike-sharing-data/holiday/'
IAM_ROLE default
FORMAT csv
IGNOREHEADER 1
DATEFORMAT 'auto'
TIMEFORMAT 'auto'
REGION 'us-west-2'
gzip;
```
1. Die folgende Abfrage führt Transformationen für die Datensätze `ridership` und `weather` zur Beseitigung von Verzerrungen oder Anomalien aus. Das Entfernen von Verzerrungen und Anomalien führt zu einer verbesserten Modellgenauigkeit. Die Abfrage vereinfacht die Tabellen, indem sie zwei neue Ansichten mit dem Namen `ridership_view` und `weather_view` erstellt.
```
CREATE
OR REPLACE VIEW ridership_view AS
SELECT
trip_time,
trip_count,
TO_CHAR(trip_time, 'hh24') :: INT trip_hour,
TO_CHAR(trip_time, 'dd') :: INT trip_day,
TO_CHAR(trip_time, 'mm') :: INT trip_month,
TO_CHAR(trip_time, 'yy') :: INT trip_year,
TO_CHAR(trip_time, 'q') :: INT trip_quarter,
TO_CHAR(trip_time, 'w') :: INT trip_month_week,
TO_CHAR(trip_time, 'd') :: INT trip_week_day
FROM
(
SELECT
CASE
WHEN TRUNC(r.trip_start_time) < '2017-07-01' :: DATE THEN CONVERT_TIMEZONE(
'US/Eastern',
DATE_TRUNC('hour', r.trip_start_time)
)
ELSE DATE_TRUNC('hour', r.trip_start_time)
END trip_time,
COUNT(1) trip_count
FROM
ridership r
WHERE
r.trip_duration_seconds BETWEEN 60
AND 60 * 60 * 24
GROUP BY
1
);
CREATE
OR REPLACE VIEW weather_view AS
SELECT
CONVERT_TIMEZONE(
'US/Eastern',
DATE_TRUNC('hour', datetime_utc)
) daytime,
ROUND(AVG(temp_c)) temp_c,
ROUND(AVG(precip_amount_mm)) precip_amount_mm
FROM
weather
GROUP BY
1;
```
1. Die folgende Abfrage erstellt eine Tabelle, die alle relevanten Eingabeattribute aus `ridership_view` und `weather_view` in Tabelle `trip_data` kombiniert.
```
CREATE TABLE trip_data AS
SELECT
r.trip_time,
r.trip_count,
r.trip_hour,
r.trip_day,
r.trip_month,
r.trip_year,
r.trip_quarter,
r.trip_month_week,
r.trip_week_day,
w.temp_c,
w.precip_amount_mm,CASE
WHEN h.holiday_date IS NOT NULL THEN 1
WHEN TO_CHAR(r.trip_time, 'D') :: INT IN (1, 7) THEN 1
ELSE 0
END is_holiday,
ROW_NUMBER() OVER (
ORDER BY
RANDOM()
) serial_number
FROM
ridership_view r
JOIN weather_view w ON (r.trip_time = w.daytime)
LEFT OUTER JOIN holiday h ON (TRUNC(r.trip_time) = h.holiday_date);
```
### Anzeigen der Beispieldaten (optional)
Die folgende Abfrage zeigt Einträge aus der Tabelle. Sie können diesen Vorgang ausführen, um sicherzustellen, dass die Tabelle korrekt erstellt wurde.
```
SELECT *
FROM trip_data
LIMIT 5;
```
Es folgt ein Beispiel für die Ausgabe der vorherigen Operation.
```
+---------------------+------------+-----------+----------+------------+-----------+--------------+-----------------+---------------+--------+------------------+------------+---------------+
| trip_time | trip_count | trip_hour | trip_day | trip_month | trip_year | trip_quarter | trip_month_week | trip_week_day | temp_c | precip_amount_mm | is_holiday | serial_number |
+---------------------+------------+-----------+----------+------------+-----------+--------------+-----------------+---------------+--------+------------------+------------+---------------+
| 2017-03-21 22:00:00 | 47 | 22 | 21 | 3 | 17 | 1 | 3 | 3 | 1 | 0 | 0 | 1 |
| 2018-05-04 01:00:00 | 19 | 1 | 4 | 5 | 18 | 2 | 1 | 6 | 12 | 0 | 0 | 3 |
| 2018-01-11 10:00:00 | 93 | 10 | 11 | 1 | 18 | 1 | 2 | 5 | 9 | 0 | 0 | 5 |
| 2017-10-28 04:00:00 | 20 | 4 | 28 | 10 | 17 | 4 | 4 | 7 | 11 | 0 | 1 | 7 |
| 2017-12-31 21:00:00 | 11 | 21 | 31 | 12 | 17 | 4 | 5 | 1 | -15 | 0 | 1 | 9 |
+---------------------+------------+-----------+----------+------------+-----------+--------------+-----------------+---------------+--------+------------------+------------+---------------+
```
### Anzeigen der Korrelation zwischen Attributen (optional)
Die Bestimmung der Korrelation hilft Ihnen, die Stärke der Assoziation zwischen Attributen zu messen. Mithilfe der Zuordnungsebene können Sie feststellen, was Ihre Zielausgabe beeinflusst. In diesem Tutorial lautet die Zielausgabe `trip_count`.
Die folgende Abfrage erstellt oder ersetzt das Verfahren `sp_correlation`. Sie verwenden die gespeicherte Prozedur namens `sp_correlation`, um die Korrelation zwischen einem Attribut und anderen Attributen in einer Tabelle in Amazon Redshift anzuzeigen.
```
CREATE OR REPLACE PROCEDURE sp_correlation(source_schema_name in varchar(255), source_table_name in varchar(255), target_column_name in varchar(255), output_temp_table_name inout varchar(255)) AS $$
DECLARE
v_sql varchar(max);
v_generated_sql varchar(max);
v_source_schema_name varchar(255)=lower(source_schema_name);
v_source_table_name varchar(255)=lower(source_table_name);
v_target_column_name varchar(255)=lower(target_column_name);
BEGIN
EXECUTE 'DROP TABLE IF EXISTS ' || output_temp_table_name;
v_sql = '
SELECT
''CREATE temp table '|| output_temp_table_name||' AS SELECT ''|| outer_calculation||
'' FROM (SELECT COUNT(1) number_of_items, SUM('||v_target_column_name||') sum_target, SUM(POW('||v_target_column_name||',2)) sum_square_target, POW(SUM('||v_target_column_name||'),2) square_sum_target,''||
inner_calculation||
'' FROM (SELECT ''||
column_name||
'' FROM '||v_source_table_name||'))''
FROM
(
SELECT
DISTINCT
LISTAGG(outer_calculation,'','') OVER () outer_calculation
,LISTAGG(inner_calculation,'','') OVER () inner_calculation
,LISTAGG(column_name,'','') OVER () column_name
FROM
(
SELECT
CASE WHEN atttypid=16 THEN ''DECODE(''||column_name||'',true,1,0)'' ELSE column_name END column_name
,atttypid
,''CAST(DECODE(number_of_items * sum_square_''||rn||'' - square_sum_''||rn||'',0,null,(number_of_items*sum_target_''||rn||'' - sum_target * sum_''||rn||
'')/SQRT((number_of_items * sum_square_target - square_sum_target) * (number_of_items * sum_square_''||rn||
'' - square_sum_''||rn||''))) AS numeric(5,2)) ''||column_name outer_calculation
,''sum(''||column_name||'') sum_''||rn||'',''||
''SUM(trip_count*''||column_name||'') sum_target_''||rn||'',''||
''SUM(POW(''||column_name||'',2)) sum_square_''||rn||'',''||
''POW(SUM(''||column_name||''),2) square_sum_''||rn inner_calculation
FROM
(
SELECT
row_number() OVER (order by a.attnum) rn
,a.attname::VARCHAR column_name
,a.atttypid
FROM pg_namespace AS n
INNER JOIN pg_class AS c ON n.oid = c.relnamespace
INNER JOIN pg_attribute AS a ON c.oid = a.attrelid
WHERE a.attnum > 0
AND n.nspname = '''||v_source_schema_name||'''
AND c.relname = '''||v_source_table_name||'''
AND a.atttypid IN (16,20,21,23,700,701,1700)
)
)
)';
EXECUTE v_sql INTO v_generated_sql;
EXECUTE v_generated_sql;
END;
$$ LANGUAGE plpgsql;
```
Die folgende Abfrage zeigt die Korrelation zwischen der Zielspalte `trip_count` und anderen numerischen Attributen in unserem Datensatz.
```
call sp_correlation(
'public',
'trip_data',
'trip_count',
'tmp_corr_table'
);
SELECT
*
FROM
tmp_corr_table;
```
Das folgende Beispiel zeigt die Ausgabe der vorherigen Operation `sp_correlation`.
```
+------------+-----------+----------+------------+-----------+--------------+-----------------+---------------+--------+------------------+------------+---------------+
| trip_count | trip_hour | trip_day | trip_month | trip_year | trip_quarter | trip_month_week | trip_week_day | temp_c | precip_amount_mm | is_holiday | serial_number |
+------------+-----------+----------+------------+-----------+--------------+-----------------+---------------+--------+------------------+------------+---------------+
| 1 | 0.32 | 0.01 | 0.18 | 0.12 | 0.18 | 0 | 0.02 | 0.53 | -0.07 | -0.13 | 0 |
+------------+-----------+----------+------------+-----------+--------------+-----------------+---------------+--------+------------------+------------+---------------+
```
## Schritt 2: Erstellen des Machine-Learning-Modells
1. Die folgende Abfrage teilt Ihre Daten in einen Trainingssatz und einen Validierungssatz auf, indem 80 % des Datensatzes für das Training und 20 % für die Validierung bestimmt werden. Der Trainingssatz ist die Eingabe für das ML-Modell, um den bestmöglichen Algorithmus für das Modell zu ermitteln. Nachdem das Modell erstellt wurde, verwenden Sie den Validierungssatz, um die Modellgenauigkeit zu überprüfen.
```
CREATE TABLE training_data AS
SELECT
trip_count,
trip_hour,
trip_day,
trip_month,
trip_year,
trip_quarter,
trip_month_week,
trip_week_day,
temp_c,
precip_amount_mm,
is_holiday
FROM
trip_data
WHERE
serial_number > (
SELECT
COUNT(1) * 0.2
FROM
trip_data
);
CREATE TABLE validation_data AS
SELECT
trip_count,
trip_hour,
trip_day,
trip_month,
trip_year,
trip_quarter,
trip_month_week,
trip_week_day,
temp_c,
precip_amount_mm,
is_holiday,
trip_time
FROM
trip_data
WHERE
serial_number <= (
SELECT
COUNT(1) * 0.2
FROM
trip_data
);
```
1. Die folgende Abfrage erstellt ein Regressionsmodell zur Voraussage des Werts `trip_count` für ein beliebiges Eingabedatum und eine Uhrzeit. Ersetzen Sie im folgenden Beispiel amzn-s3-demo-bucket durch Ihren eigenen S3-Bucket.
```
CREATE MODEL predict_rental_count
FROM
training_data TARGET trip_count FUNCTION predict_rental_count
IAM_ROLE default
PROBLEM_TYPE regression
OBJECTIVE 'mse'
SETTINGS (
s3_bucket 'amzn-s3-demo-bucket',
s3_garbage_collect off,
max_runtime 5000
);
```
## Schritt 3: Validieren des Modells
1. Verwenden Sie die folgende Abfrage, um Aspekte des Modells auszugeben und die Mean-Square-Error-Metrik in der Ausgabe zu ermitteln. Der Mean Square Error ist eine typische Genauigkeitsmetrik für Regressionsprobleme.
```
show model predict_rental_count;
```
1. Führen Sie die folgenden Voraussageabfragen für die Validierungsdaten aus, um die prognostizierte Anzahl der Fahrten mit der tatsächlichen Anzahl der Fahrten zu vergleichen.
```
SELECT
trip_time,
actual_count,
predicted_count,
(actual_count - predicted_count) difference
FROM
(
SELECT
trip_time,
trip_count AS actual_count,
PREDICT_RENTAL_COUNT (
trip_hour,
trip_day,
trip_month,
trip_year,
trip_quarter,
trip_month_week,
trip_week_day,
temp_c,
precip_amount_mm,
is_holiday
) predicted_count
FROM
validation_data
)
LIMIT
5;
```
1. Die folgende Abfrage berechnet den Mean Square Error und den Root Mean Square Error basierend auf Ihren Validierungsdaten. Sie verwenden den Mean Square Error und den Root Mean Square Error, um die Abweichung zwischen dem vorausgesagten numerischen Ziel und der tatsächlichen numerischen Antwort zu messen. Ein gutes Modell erzielt bei beiden Metriken ein niedriges Ergebnis. Die folgende Abfrage gibt den Wert beider Metriken zurück.
```
SELECT
ROUND(
AVG(POWER((actual_count - predicted_count), 2)),
2
) mse,
ROUND(
SQRT(AVG(POWER((actual_count - predicted_count), 2))),
2
) rmse
FROM
(
SELECT
trip_time,
trip_count AS actual_count,
PREDICT_RENTAL_COUNT (
trip_hour,
trip_day,
trip_month,
trip_year,
trip_quarter,
trip_month_week,
trip_week_day,
temp_c,
precip_amount_mm,
is_holiday
) predicted_count
FROM
validation_data
);
```
1. Die folgende Abfrage berechnet den prozentualen Fehler bei der Anzahl der Fahrten für jede Fahrtzeit am 01.01.2017. Die Abfrage ordnet die Fahrtzeiten von der Zeit mit dem niedrigsten prozentualen Fehler bis zur Zeit mit dem höchsten prozentualen Fehler an.
```
SELECT
trip_time,
CAST(ABS(((actual_count - predicted_count) / actual_count)) * 100 AS DECIMAL (7,2)) AS pct_error
FROM
(
SELECT
trip_time,
trip_count AS actual_count,
PREDICT_RENTAL_COUNT (
trip_hour,
trip_day,
trip_month,
trip_year,
trip_quarter,
trip_month_week,
trip_week_day,
temp_c,
precip_amount_mm,
is_holiday
) predicted_count
FROM
validation_data
)
WHERE
trip_time LIKE '2017-01-01 %%:%%:%%'
ORDER BY
2 ASC;
```
## Verwandte Themen
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)
# Tutorial: Erstellen von Regressionsmodellen mit linearem Lernen
In diesem Tutorial erstellen Sie ein lineares Lernmodell mit Daten aus Amazon S3 und führen Voraussageabfragen mit dem Modell mithilfe von Amazon Redshift ML aus. Der SageMaker KI-Algorithmus für lineare Lernende löst entweder Regressions- oder Klassifizierungsprobleme mit mehreren Klassen. Weitere Informationen zu Regressions- und Klassifizierungsproblemen mit mehreren Klassen finden Sie unter [Problemtypen für die Machine-Learning-Paradigmen](https://docs.aws.amazon.com/sagemaker/latest/dg/algorithms-choose.html#basic-machine-learning-paradigms) im Amazon SageMaker AI Developer Guide. In diesem Tutorial lösen Sie ein Regressionsproblem. Der Algorithmus für lineares Lernen trainiert viele Modelle parallel und ermittelt automatisch das am besten optimierte Modell. Sie verwenden den Vorgang CREATE MODEL in Amazon Redshift, der Ihr lineares Lernmodell mithilfe von SageMaker KI erstellt und eine Vorhersagefunktion an Amazon Redshift sendet. Weitere Informationen zum linearen Lernalgorithmus finden Sie unter [Linear Learner Algorithm](https://docs.aws.amazon.com/sagemaker/latest/dg/linear-learner.html) im Amazon SageMaker AI Developer Guide.
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.
Lineare Lernmodelle optimieren entweder kontinuierliche oder diskrete Ziele. Kontinuierliche Ziele werden für die Regression verwendet, während diskrete Variablen für die Klassifizierung genutzt werden. Einige Methoden, wie die Regressionsmethode, bieten eine Lösung nur für kontinuierliche Ziele. Der Algorithmus für lineares Lernen bietet eine Steigerung der Geschwindigkeit gegenüber naiven Hyperparameter-Optimierungstechniken wie der Naive-Bayes-Technik. Eine naive Optimierungstechnik geht davon aus, dass jede Eingabevariable unabhängig ist. Um den Algorithmus für lineares Lernen verwenden zu können, müssen Sie Spalten, die die Dimensionen der Eingaben darstellen, und Zeilen, die Beobachtungen repräsentieren, bereitstellen. Weitere Informationen zum linearen Lernalgorithmus finden Sie unter [Linear Learner Algorithm](https://docs.aws.amazon.com/sagemaker/latest/dg/linear-learner.html) im Amazon SageMaker AI Developer Guide.
In diesem Tutorial erstellen Sie ein lineares Lernmodell, das das Alter von Abalonen voraussagen kann. Sie verwenden den Befehl CREATE MODEL für den [Abalone-Datensatz](http://archive.ics.uci.edu/ml/datasets/Abalone), um die Beziehung zwischen den verschiedenen physikalischen Messungen der Abalone zu bestimmen. Anschließend verwenden Sie das Modell, um das Alter der Abalone zu bestimmen.
## Beispielanwendungsfälle
Sie können andere Regressionsprobleme mit dem linearen Lernmodell und Amazon Redshift ML lösen, z. B. den Preis eines Hauses prognostizieren. Sie können Redshift ML auch verwenden, um die Anzahl der Personen vorauszusagen, die den Fahrradverleih einer Stadt nutzen werden.
**Aufgaben**
+ Voraussetzungen
+ Schritt 1: Laden von Daten aus Amazon S3 in Amazon Redshift
+ Schritt 2: Erstellen des Machine-Learning-Modells
+ Schritt 3: Validieren des Modells
## Voraussetzungen
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
Verwenden Sie den [Abfrage-Editor v2 von Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2-using.html), um die folgenden Abfragen auszuführen. Diese Abfragen laden die Beispieldaten in Redshift und teilen die Daten in einen Trainingssatz und einen Validierungssatz auf.
1. Mit der folgenden Abfrage wird die Tabelle `abalone_dataset` erstellt.
```
CREATE TABLE abalone_dataset (
id INT IDENTITY(1, 1),
Sex CHAR(1),
Length float,
Diameter float,
Height float,
Whole float,
Shucked float,
Viscera float,
Shell float,
Rings integer
);
```
1. Die folgende Abfrage kopiert die Beispieldaten aus dem [Abalone-Datensatz](http://archive.ics.uci.edu/ml/datasets/Abalone) in Amazon S3 in die Tabelle `abalone_dataset`, die Sie zuvor in Amazon Redshift erstellt haben.
```
COPY abalone_dataset
FROM
's3://redshift-ml-multiclass/abalone.csv' REGION 'us-east-1' IAM_ROLE default CSV IGNOREHEADER 1 NULL AS 'NULL';
```
1. Durch manuelles Aufteilen der Daten können Sie die Genauigkeit des Modells überprüfen, indem Sie einen zusätzlichen Prognosesatz zuweisen. Die folgende Abfrage teilt die Daten in zwei Sätze auf. Die Tabelle `abalone_training` ist für das Training und die Tabelle `abalone_validation` für die Validierung bestimmt.
```
CREATE TABLE abalone_training as
SELECT
*
FROM
abalone_dataset
WHERE
mod(id, 10) < 8;
CREATE TABLE abalone_validation as
SELECT
*
FROM
abalone_dataset
WHERE
mod(id, 10) >= 8;
```
## Schritt 2: Erstellen des Machine-Learning-Modells
In diesem Schritt verwenden Sie die Anweisung CREATE MODEL, um Ihr Machine-Learning-Modell mit dem linearen Lernalgorithmus zu erstellen.
Die folgende Abfrage erstellt das lineare Lernmodell mit der Operation CREATE MODEL unter Verwendung Ihres S3-Buckets. Ersetzen Sie amzn-s3-demo-bucket durch Ihren eigenen S3-Bucket.
```
CREATE MODEL model_abalone_ring_prediction
FROM
(
SELECT
Sex,
Length,
Diameter,
Height,
Whole,
Shucked,
Viscera,
Shell,
Rings AS target_label
FROM
abalone_training
) TARGET target_label FUNCTION f_abalone_ring_prediction IAM_ROLE default MODEL_TYPE LINEAR_LEARNER PROBLEM_TYPE REGRESSION OBJECTIVE 'MSE' SETTINGS (
S3_BUCKET 'amzn-s3-demo-bucket',
MAX_RUNTIME 15000
);
```
### Anzeigen des Status des Modelltrainings (optional)
Sie können den Befehl SHOW MODEL verwenden, um festzustellen, wann Ihr Modell bereit ist.
Verwenden Sie die folgende Abfrage, um den Trainingsfortschritt des Modells zu überwachen.
```
SHOW MODEL model_abalone_ring_prediction;
```
Wenn das Modell bereit ist, sollte die Ausgabe der vorherigen Operation dem folgenden Beispiel ähneln. Beachten Sie, dass die Ausgabe die Metrik `validation:mse` angibt, die dem Mean Square Error entspricht. Sie verwenden den Mean Square Error im nächsten Schritt, um die Genauigkeit des Modells zu überprüfen.
```
+--------------------------+----------------------------------------------------------------------------------------------------+
| Model Name | model_abalone_ring_prediction |
+--------------------------+----------------------------------------------------------------------------------------------------+
| Schema Name | public |
| Owner | awsuser |
| Creation Time | Thu, 30.06.2022 18:00:10 |
| Model State | READY |
| validation:mse | 4.168633 |
| Estimated Cost | 4.291608 |
| | |
| TRAINING DATA: | |
| Query | SELECT SEX , LENGTH , DIAMETER , HEIGHT , WHOLE , SHUCKED , VISCERA , SHELL, RINGS AS TARGET_LABEL |
| | FROM ABALONE_TRAINING |
| Target Column | TARGET_LABEL |
| | |
| PARAMETERS: | |
| Model Type | linear_learner |
| Problem Type | Regression |
| Objective | MSE |
| AutoML Job Name | redshiftml-20220630180010947843 |
| Function Name | f_abalone_ring_prediction |
| Function Parameters | sex length diameter height whole shucked viscera shell |
| Function Parameter Types | bpchar float8 float8 float8 float8 float8 float8 float8 |
| IAM Role | default-aws-iam-role |
| S3 Bucket | amzn-s3-demo-bucket |
| Max Runtime | 15000 |
+--------------------------+----------------------------------------------------------------------------------------------------+
```
## Schritt 3: Validieren des Modells
1. Die folgende Voraussageabfrage validiert die Genauigkeit des Modells für den Datensatz `abalone_validation` durch Berechnung des Mean Square Errors und des Root Mean Square Errors.
```
SELECT
ROUND(AVG(POWER((tgt_label - predicted), 2)), 2) mse,
ROUND(SQRT(AVG(POWER((tgt_label - predicted), 2))), 2) rmse
FROM
(
SELECT
Sex,
Length,
Diameter,
Height,
Whole,
Shucked,
Viscera,
Shell,
Rings AS tgt_label,
f_abalone_ring_prediction(
Sex,
Length,
Diameter,
Height,
Whole,
Shucked,
Viscera,
Shell
) AS predicted,
CASE
WHEN tgt_label = predicted then 1
ELSE 0
END AS match,
CASE
WHEN tgt_label <> predicted then 1
ELSE 0
END AS nonmatch
FROM
abalone_validation
) t1;
```
Die Ausgabe der vorherigen Abfrage sollte dem folgenden Beispiel ähneln. Der Wert der Mean-Square-Error-Metrik sollte ähnlich wie die Metrik `validation:mse` sein, die in der Ausgabe der Operation SHOW MODEL angezeigt wird.
```
+-----+--------------------+
| mse | rmse |
+-----+--------------------+
| 5.1 | 2.2600000000000002 |
+-----+--------------------+
```
1. Verwenden Sie die folgende Abfrage, um die Operation EXPLAIN\$1MODEL für Ihre Prognosefunktion auszuführen. Die Operation gibt einen Modellerklärbarkeitsbericht zurück. Weitere Informationen über die Operation EXPLAIN\$1MODEL finden Sie unter [Funktion EXPLAIN\$1MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_explain_model_function.html) im Datenbankentwicklerhandbuch zu Amazon Redshift.
```
SELECT
EXPLAIN_MODEL ('model_abalone_ring_prediction');
```
Die folgenden Informationen sind ein Beispiel für den Modellerklärbarkeitsbericht, der mit der vorherigen Operation EXPLAIN\$1MODEL erstellt wurde. Die Werte für die einzelnen Eingaben sind Shapley-Werte. Die Shapley-Werte stellen den Effekt dar, den jede Eingabe auf die Voraussage Ihres Modells hat, wobei höherwertige Eingaben einen größeren Einfluss auf die Voraussage haben. In diesem Beispiel haben die höherwertigen Eingaben einen größeren Einfluss auf die Voraussage des Alters der Abalone.
```
{
"explanations": {
"kernel_shap": {
"label0": {
"expected_value" :10.290688514709473,
"global_shap_values": {
"diameter" :0.6856910187882492,
"height" :0.4415323937124035,
"length" :0.21507476107609084,
"sex" :0.448611774505744,
"shell" :1.70426496893776,
"shucked" :2.1181392924386994,
"viscera" :0.342220754059912,
"whole" :0.6711906974084011
}
}
}
},
"version" :"1.0"
};
```
1. Verwenden Sie die folgende Abfrage, um den Prozentsatz korrekter Voraussagen für Abalonen zu berechnen, die das Modell für noch nicht ausgereifte Abalonen trifft. Unreife Abalonen haben 10 Ringe oder weniger und eine korrekte Voraussage ist auf einen Ring Abweichung von der tatsächlichen Anzahl der Ringe genau.
```
SELECT
TRUNC(
SUM(
CASE
WHEN ROUND(
f_abalone_ring_prediction(
Sex,
Length,
Diameter,
Height,
Whole,
Shucked,
Viscera,
Shell
),
0
) BETWEEN Rings - 1
AND Rings + 1 THEN 1
ELSE 0
END
) / CAST(COUNT(SHELL) AS FLOAT),
4
) AS prediction_pct
FROM
abalone_validation
WHERE
Rings <= 10;
```
## Verwandte Themen
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)
# Tutorial: Erstellen von Mehrklassen-Klassifizierungsmodellen mit linearem Lernen
In diesem Tutorial erstellen Sie ein lineares Lernmodell mit Daten aus Amazon S3 und führen dann mithilfe von Amazon Redshift ML Voraussageabfragen mit dem Modell aus. Der SageMaker KI-Algorithmus für lineare Lernende löst entweder Regressions- oder Klassifikationsprobleme. Weitere Informationen zu Regressions- und Klassifizierungsproblemen mit mehreren Klassen finden Sie unter [Problemtypen für die Machine-Learning-Paradigmen](https://docs.aws.amazon.com/sagemaker/latest/dg/algorithms-choose.html#basic-machine-learning-paradigms) im Amazon SageMaker AI Developer Guide. In diesem Tutorial lösen Sie ein Mehrklassen-Klassifizierungsproblem. Der Algorithmus für lineares Lernen trainiert viele Modelle parallel und ermittelt automatisch das am besten optimierte Modell. Sie verwenden den Vorgang CREATE MODEL in Amazon Redshift, der Ihr lineares Lernmodell mithilfe von SageMaker KI erstellt und die Vorhersagefunktion an Amazon Redshift sendet. Weitere Informationen zum linearen Lernalgorithmus finden Sie unter [Linear Learner Algorithm](https://docs.aws.amazon.com/sagemaker/latest/dg/linear-learner.html) im Amazon SageMaker AI Developer Guide.
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.
Lineare Lernmodelle optimieren entweder kontinuierliche oder diskrete Ziele. Kontinuierliche Ziele werden für die Regression verwendet, während diskrete Variablen für die Klassifizierung genutzt werden. Einige Methoden, wie eine Regressionsmethode, bieten eine Lösung nur für kontinuierliche Ziele. Der Algorithmus für lineares Lernen bietet eine Steigerung der Geschwindigkeit gegenüber naiven Hyperparameter-Optimierungstechniken wie der Naive-Bayes-Technik. Eine naive Optimierungstechnik geht davon aus, dass jede Eingabevariable unabhängig ist. Der Algorithmus für lineares Lernen trainiert viele Modelle parallel und wählt das am besten optimierte Modell aus. Ein ähnlicher Algorithmus ist XGBoost, der Schätzungen aus einer Reihe einfacherer und schwächerer Modelle kombiniert, um Vorhersagen zu treffen. Weitere Informationen finden Sie XGBoost unter [XGBoost Algorithmus](https://docs.aws.amazon.com/sagemaker/latest/dg/xgboost.html) im Amazon SageMaker AI Developer Guide.
Um den Algorithmus für lineares Lernen verwenden zu können, müssen Sie Spalten, die die Dimensionen der Eingaben darstellen, und Zeilen, die Beobachtungen repräsentieren, bereitstellen. Weitere Informationen zum linearen Lernalgorithmus finden Sie unter [Linear Learner Algorithm](https://docs.aws.amazon.com/sagemaker/latest/dg/linear-learner.html) im Amazon SageMaker AI Developer Guide.
In diesem Tutorial erstellen Sie ein lineares Lernmodell, das die Art der Bewaldung für ein bestimmtes Gebiet voraussagen kann. Sie verwenden den Befehl CREATE MODEL für den [Covertype-Datensatz](https://archive.ics.uci.edu/ml/datasets/covertype) aus dem UCI Machine Learning Repository. Anschließend verwenden Sie die durch den Befehl erstellte Voraussagefunktion, um die Bewaldungsarten in einem Wildnisgebiet zu bestimmen. Ein Bewaldungstyp ist normalerweise eine Baumart. Zu den Eingaben, die Redshift ML zum Erstellen des Modells verwendet, gehören der Bodentyp, die Entfernung zu Straßen und die Bezeichnung des Wildnisgebiets. Weitere Informationen zu dem Datensatz finden Sie im [Covertype-Datensatz](https://archive.ics.uci.edu/ml/datasets/covertype) im UCI Machine Learning Repository.
## Beispielanwendungsfälle
Mit dem linearen Lernmodell können Sie weitere Mehrklassen-Klassifizierungsprobleme lösen, z. B. die Pflanzenart anhand eines Bildes voraussagen. Sie können auch die Menge eines Produkts prognostizieren, die ein Kunde kaufen wird.
**Aufgaben**
+ Voraussetzungen
+ Schritt 1: Laden von Daten aus Amazon S3 in Amazon Redshift
+ Schritt 2: Erstellen des Machine-Learning-Modells
+ Schritt 3: Validieren des Modells
## Voraussetzungen
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
Verwenden Sie den [Abfrage-Editor v2 von Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2-using.html), um die folgenden Abfragen auszuführen. Diese Abfragen laden die Beispieldaten in Redshift und teilen die Daten in einen Trainingssatz und einen Validierungssatz auf.
1. Mit der folgenden Abfrage wird die Tabelle `covertype_data` erstellt.
```
CREATE TABLE public.covertype_data (
elevation bigint ENCODE az64,
aspect bigint ENCODE az64,
slope bigint ENCODE az64,
horizontal_distance_to_hydrology bigint ENCODE az64,
vertical_distance_to_hydrology bigint ENCODE az64,
horizontal_distance_to_roadways bigint ENCODE az64,
hillshade_9am bigint ENCODE az64,
hillshade_noon bigint ENCODE az64,
hillshade_3pm bigint ENCODE az64,
horizontal_distance_to_fire_points bigint ENCODE az64,
wilderness_area1 bigint ENCODE az64,
wilderness_area2 bigint ENCODE az64,
wilderness_area3 bigint ENCODE az64,
wilderness_area4 bigint ENCODE az64,
soil_type1 bigint ENCODE az64,
soil_type2 bigint ENCODE az64,
soil_type3 bigint ENCODE az64,
soil_type4 bigint ENCODE az64,
soil_type5 bigint ENCODE az64,
soil_type6 bigint ENCODE az64,
soil_type7 bigint ENCODE az64,
soil_type8 bigint ENCODE az64,
soil_type9 bigint ENCODE az64,
soil_type10 bigint ENCODE az64,
soil_type11 bigint ENCODE az64,
soil_type12 bigint ENCODE az64,
soil_type13 bigint ENCODE az64,
soil_type14 bigint ENCODE az64,
soil_type15 bigint ENCODE az64,
soil_type16 bigint ENCODE az64,
soil_type17 bigint ENCODE az64,
soil_type18 bigint ENCODE az64,
soil_type19 bigint ENCODE az64,
soil_type20 bigint ENCODE az64,
soil_type21 bigint ENCODE az64,
soil_type22 bigint ENCODE az64,
soil_type23 bigint ENCODE az64,
soil_type24 bigint ENCODE az64,
soil_type25 bigint ENCODE az64,
soil_type26 bigint ENCODE az64,
soil_type27 bigint ENCODE az64,
soil_type28 bigint ENCODE az64,
soil_type29 bigint ENCODE az64,
soil_type30 bigint ENCODE az64,
soil_type31 bigint ENCODE az64,
soil_type32 bigint ENCODE az64,
soil_type33 bigint ENCODE az64,
soil_type34 bigint ENCODE az64,
soil_type35 bigint ENCODE az64,
soil_type36 bigint ENCODE az64,
soil_type37 bigint ENCODE az64,
soil_type38 bigint ENCODE az64,
soil_type39 bigint ENCODE az64,
soil_type40 bigint ENCODE az64,
cover_type bigint ENCODE az64
) DISTSTYLE AUTO;
```
1. Die folgende Abfrage kopiert die Beispieldaten aus dem [Covertype-Datensatz](https://archive.ics.uci.edu/ml/datasets/covertype) in Amazon S3 in die Tabelle `covertype_data`, die Sie zuvor in Amazon Redshift erstellt haben.
```
COPY public.covertype_data
FROM
's3://redshift-ml-multiclass/covtype.data.gz' IAM_ROLE DEFAULT gzip DELIMITER ',' REGION 'us-east-1';
```
1. Durch manuelles Aufteilen der Daten können Sie die Genauigkeit des Modells überprüfen, indem Sie einen zusätzlichen Testsatz zuweisen. Die folgende Abfrage teilt die Daten in drei Sätze auf. Die Tabelle `covertype_training` ist für das Training, die Tabelle `covertype_validation` zur Validierung und die Tabelle `covertype_test` zum Testen Ihres Modells bestimmt. Sie verwenden den Trainingsatz, um Ihr Modell zu trainieren, und den Validierungssatz, um die Entwicklung des Modells zu validieren. Anschließend verwenden Sie den Testsatz, um die Leistung des Modells zu testen und festzustellen, ob das Modell den Datensatz über- oder unterpasst.
```
CREATE TABLE public.covertype_data_prep AS
SELECT
a.*,
CAST (random() * 100 AS int) AS data_group_id
FROM
public.covertype_data a;
--training dataset
CREATE TABLE public.covertype_training as
SELECT
*
FROM
public.covertype_data_prep
WHERE
data_group_id < 80;
--validation dataset
CREATE TABLE public.covertype_validation AS
SELECT
*
FROM
public.covertype_data_prep
WHERE
data_group_id BETWEEN 80
AND 89;
--test dataset
CREATE TABLE public.covertype_test AS
SELECT
*
FROM
public.covertype_data_prep
WHERE
data_group_id > 89;
```
## Schritt 2: Erstellen des Machine-Learning-Modells
In diesem Schritt verwenden Sie die Anweisung CREATE MODEL, um Ihr Machine-Learning-Modell mit dem linearen Lernalgorithmus zu erstellen.
Die folgende Abfrage erstellt das lineare Lernmodell mit der Operation CREATE MODEL unter Verwendung Ihres S3-Buckets. Ersetzen Sie amzn-s3-demo-bucket durch Ihren eigenen S3-Bucket.
```
CREATE MODEL forest_cover_type_model
FROM
(
SELECT
Elevation,
Aspect,
Slope,
Horizontal_distance_to_hydrology,
Vertical_distance_to_hydrology,
Horizontal_distance_to_roadways,
HIllshade_9am,
Hillshade_noon,
Hillshade_3pm,
Horizontal_Distance_To_Fire_Points,
Wilderness_Area1,
Wilderness_Area2,
Wilderness_Area3,
Wilderness_Area4,
soil_type1,
Soil_Type2,
Soil_Type3,
Soil_Type4,
Soil_Type5,
Soil_Type6,
Soil_Type7,
Soil_Type8,
Soil_Type9,
Soil_Type10,
Soil_Type11,
Soil_Type12,
Soil_Type13,
Soil_Type14,
Soil_Type15,
Soil_Type16,
Soil_Type17,
Soil_Type18,
Soil_Type19,
Soil_Type20,
Soil_Type21,
Soil_Type22,
Soil_Type23,
Soil_Type24,
Soil_Type25,
Soil_Type26,
Soil_Type27,
Soil_Type28,
Soil_Type29,
Soil_Type30,
Soil_Type31,
Soil_Type32,
Soil_Type33,
Soil_Type34,
Soil_Type36,
Soil_Type37,
Soil_Type38,
Soil_Type39,
Soil_Type40,
Cover_type
from
public.covertype_training
) TARGET cover_type FUNCTION predict_cover_type IAM_ROLE default MODEL_TYPE LINEAR_LEARNER PROBLEM_TYPE MULTICLASS_CLASSIFICATION OBJECTIVE 'Accuracy' SETTINGS (
S3_BUCKET 'amzn-s3-demo-bucket',
S3_GARBAGE_COLLECT OFF,
MAX_RUNTIME 15000
);
```
### Anzeigen des Status des Modelltrainings (optional)
Sie können den Befehl SHOW MODEL verwenden, um festzustellen, wann Ihr Modell bereit ist.
Verwenden Sie die folgende Abfrage, um den Trainingsfortschritt des Modells zu überwachen.
```
SHOW MODEL forest_cover_type_model;
```
Wenn das Modell bereit ist, sollte die Ausgabe der vorherigen Operation dem folgenden Beispiel ähneln. Beachten Sie, dass die Ausgabe die Metrik `validation:multiclass_accuracy` bereitstellt, die Sie auf der rechten Seite des folgenden Beispiels sehen können. Die Mehrklassen-Genauigkeit misst den Prozentsatz der Datenpunkte, die vom Modell korrekt klassifiziert werden. Sie verwenden die Mehrklassen-Genauigkeit, um die Genauigkeit des Modells im nächsten Schritt zu überprüfen.
```
+--------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| Key | Value |
+--------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| Model Name | forest_cover_type_model |
| Schema Name | public |
| Owner | awsuser |
| Creation Time | Tue, 12.07.2022 20:24:32 |
| Model State | READY |
| validation:multiclass_accuracy | 0.724952 |
| Estimated Cost | 5.341750 |
| | |
| TRAINING DATA: | |
| Query | SELECT ELEVATION, ASPECT, SLOPE, HORIZONTAL_DISTANCE_TO_HYDROLOGY, VERTICAL_DISTANCE_TO_HYDROLOGY, HORIZONTAL_DISTANCE_TO_ROADWAYS, HILLSHADE_9AM, HILLSHADE_NOON, HILLSHADE_3PM , HORIZONTAL_DISTANCE_TO_FIRE_POINTS, WILDERNESS_AREA1, WILDERNESS_AREA2, WILDERNESS_AREA3, WILDERNESS_AREA4, SOIL_TYPE1, SOIL_TYPE2, SOIL_TYPE3, SOIL_TYPE4, SOIL_TYPE5, SOIL_TYPE6, SOIL_TYPE7, SOIL_TYPE8, SOIL_TYPE9, SOIL_TYPE10 , SOIL_TYPE11, SOIL_TYPE12 , SOIL_TYPE13 , SOIL_TYPE14, SOIL_TYPE15, SOIL_TYPE16, SOIL_TYPE17, SOIL_TYPE18, SOIL_TYPE19, SOIL_TYPE20, SOIL_TYPE21, SOIL_TYPE22, SOIL_TYPE23, SOIL_TYPE24, SOIL_TYPE25, SOIL_TYPE26, SOIL_TYPE27, SOIL_TYPE28, SOIL_TYPE29, SOIL_TYPE30, SOIL_TYPE31, SOIL_TYPE32, SOIL_TYPE33, SOIL_TYPE34, SOIL_TYPE36, SOIL_TYPE37, SOIL_TYPE38, SOIL_TYPE39, SOIL_TYPE40, COVER_TYPE |
| | FROM PUBLIC.COVERTYPE_TRAINING |
| Target Column | COVER_TYPE |
| | |
| PARAMETERS: | |
| Model Type | linear_learner |
| Problem Type | MulticlassClassification |
| Objective | Accuracy |
| AutoML Job Name | redshiftml-20220712202432187659 |
| Function Name | predict_cover_type |
| Function Parameters | elevation aspect slope horizontal_distance_to_hydrology vertical_distance_to_hydrology horizontal_distance_to_roadways hillshade_9am hillshade_noon hillshade_3pm horizontal_distance_to_fire_points wilderness_area1 wilderness_area2 wilderness_area3 wilderness_area4 soil_type1 soil_type2 soil_type3 soil_type4 soil_type5 soil_type6 soil_type7 soil_type8 soil_type9 soil_type10 soil_type11 soil_type12 soil_type13 soil_type14 soil_type15 soil_type16 soil_type17 soil_type18 soil_type19 soil_type20 soil_type21 soil_type22 soil_type23 soil_type24 soil_type25 soil_type26 soil_type27 soil_type28 soil_type29 soil_type30 soil_type31 soil_type32 soil_type33 soil_type34 soil_type36 soil_type37 soil_type38 soil_type39 soil_type40 |
| Function Parameter Types | int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 |
| IAM Role | default-aws-iam-role |
| S3 Bucket | amzn-s3-demo-bucket |
| Max Runtime | 15000 |
+--------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
```
## Schritt 3: Validieren des Modells
1. Die folgende Voraussageabfrage validiert die Genauigkeit des Modells für den Datensatz `covertype_validation` durch Berechnung der Mehrklassen-Genauigkeit. Die Mehrklassen-Genauigkeit ist der Prozentsatz der korrekten Voraussagen des Modells.
```
SELECT
CAST(sum(t1.match) AS decimal(7, 2)) AS predicted_matches,
CAST(sum(t1.nonmatch) AS decimal(7, 2)) AS predicted_non_matches,
CAST(sum(t1.match + t1.nonmatch) AS decimal(7, 2)) AS total_predictions,
predicted_matches / total_predictions AS pct_accuracy
FROM
(
SELECT
Elevation,
Aspect,
Slope,
Horizontal_distance_to_hydrology,
Vertical_distance_to_hydrology,
Horizontal_distance_to_roadways,
HIllshade_9am,
Hillshade_noon,
Hillshade_3pm,
Horizontal_Distance_To_Fire_Points,
Wilderness_Area1,
Wilderness_Area2,
Wilderness_Area3,
Wilderness_Area4,
soil_type1,
Soil_Type2,
Soil_Type3,
Soil_Type4,
Soil_Type5,
Soil_Type6,
Soil_Type7,
Soil_Type8,
Soil_Type9,
Soil_Type10,
Soil_Type11,
Soil_Type12,
Soil_Type13,
Soil_Type14,
Soil_Type15,
Soil_Type16,
Soil_Type17,
Soil_Type18,
Soil_Type19,
Soil_Type20,
Soil_Type21,
Soil_Type22,
Soil_Type23,
Soil_Type24,
Soil_Type25,
Soil_Type26,
Soil_Type27,
Soil_Type28,
Soil_Type29,
Soil_Type30,
Soil_Type31,
Soil_Type32,
Soil_Type33,
Soil_Type34,
Soil_Type36,
Soil_Type37,
Soil_Type38,
Soil_Type39,
Soil_Type40,
Cover_type AS actual_cover_type,
predict_cover_type(
Elevation,
Aspect,
Slope,
Horizontal_distance_to_hydrology,
Vertical_distance_to_hydrology,
Horizontal_distance_to_roadways,
HIllshade_9am,
Hillshade_noon,
Hillshade_3pm,
Horizontal_Distance_To_Fire_Points,
Wilderness_Area1,
Wilderness_Area2,
Wilderness_Area3,
Wilderness_Area4,
soil_type1,
Soil_Type2,
Soil_Type3,
Soil_Type4,
Soil_Type5,
Soil_Type6,
Soil_Type7,
Soil_Type8,
Soil_Type9,
Soil_Type10,
Soil_Type11,
Soil_Type12,
Soil_Type13,
Soil_Type14,
Soil_Type15,
Soil_Type16,
Soil_Type17,
Soil_Type18,
Soil_Type19,
Soil_Type20,
Soil_Type21,
Soil_Type22,
Soil_Type23,
Soil_Type24,
Soil_Type25,
Soil_Type26,
Soil_Type27,
Soil_Type28,
Soil_Type29,
Soil_Type30,
Soil_Type31,
Soil_Type32,
Soil_Type33,
Soil_Type34,
Soil_Type36,
Soil_Type37,
Soil_Type38,
Soil_Type39,
Soil_Type40
) AS predicted_cover_type,
CASE
WHEN actual_cover_type = predicted_cover_type THEN 1
ELSE 0
END AS match,
CASE
WHEN actual_cover_type <> predicted_cover_type THEN 1
ELSE 0
END AS nonmatch
FROM
public.covertype_validation
) t1;
```
Die Ausgabe der vorherigen Abfrage sollte dem folgenden Beispiel ähneln. Der Wert der Mehrklassen-Genauigkeitsmetrik sollte ähnlich wie der Wert der Metrik `validation:multiclass_accuracy` sein, die in der Ausgabe der Operation SHOW MODEL angezeigt wird.
```
+-------------------+-----------------------+-------------------+--------------+
| predicted_matches | predicted_non_matches | total_predictions | pct_accuracy |
+-------------------+-----------------------+-------------------+--------------+
| 41211 | 16324 | 57535 | 0.71627704 |
+-------------------+-----------------------+-------------------+--------------+
```
1. Die folgende Abfrage prognostiziert die gängigste Bewaldungsart für `wilderness_area2`. Dieser Datensatz umfasst vier Wildnisgebiete und sieben Bewaldungsarten. Ein Wildnisgebiet kann mehrere Bewaldungsarten aufweisen.
```
SELECT t1. predicted_cover_type, COUNT(*)
FROM
(
SELECT
Elevation,
Aspect,
Slope,
Horizontal_distance_to_hydrology,
Vertical_distance_to_hydrology,
Horizontal_distance_to_roadways,
HIllshade_9am,
Hillshade_noon,
Hillshade_3pm ,
Horizontal_Distance_To_Fire_Points,
Wilderness_Area1,
Wilderness_Area2,
Wilderness_Area3,
Wilderness_Area4,
soil_type1,
Soil_Type2,
Soil_Type3,
Soil_Type4,
Soil_Type5,
Soil_Type6,
Soil_Type7,
Soil_Type8,
Soil_Type9,
Soil_Type10 ,
Soil_Type11,
Soil_Type12 ,
Soil_Type13 ,
Soil_Type14,
Soil_Type15,
Soil_Type16,
Soil_Type17,
Soil_Type18,
Soil_Type19,
Soil_Type20,
Soil_Type21,
Soil_Type22,
Soil_Type23,
Soil_Type24,
Soil_Type25,
Soil_Type26,
Soil_Type27,
Soil_Type28,
Soil_Type29,
Soil_Type30,
Soil_Type31,
Soil_Type32,
Soil_Type33,
Soil_Type34,
Soil_Type36,
Soil_Type37,
Soil_Type38,
Soil_Type39,
Soil_Type40,
predict_cover_type( Elevation,
Aspect,
Slope,
Horizontal_distance_to_hydrology,
Vertical_distance_to_hydrology,
Horizontal_distance_to_roadways,
HIllshade_9am,
Hillshade_noon,
Hillshade_3pm ,
Horizontal_Distance_To_Fire_Points,
Wilderness_Area1,
Wilderness_Area2,
Wilderness_Area3,
Wilderness_Area4,
soil_type1,
Soil_Type2,
Soil_Type3,
Soil_Type4,
Soil_Type5,
Soil_Type6,
Soil_Type7,
Soil_Type8,
Soil_Type9,
Soil_Type10,
Soil_Type11,
Soil_Type12,
Soil_Type13,
Soil_Type14,
Soil_Type15,
Soil_Type16,
Soil_Type17,
Soil_Type18,
Soil_Type19,
Soil_Type20,
Soil_Type21,
Soil_Type22,
Soil_Type23,
Soil_Type24,
Soil_Type25,
Soil_Type26,
Soil_Type27,
Soil_Type28,
Soil_Type29,
Soil_Type30,
Soil_Type31,
Soil_Type32,
Soil_Type33,
Soil_Type34,
Soil_Type36,
Soil_Type37,
Soil_Type38,
Soil_Type39,
Soil_Type40) AS predicted_cover_type
FROM public.covertype_test
WHERE wilderness_area2 = 1)
t1
GROUP BY 1;
```
Die Ausgabe der vorherigen Operation sollte dem folgenden Beispiel ähneln. Diese Ausgabe bedeutet, dass das Modell vorausgesagt hat, dass der Großteil der Bewaldung Bewaldungsart 1 ist und die Bewaldung in einigen Gebieten den Bewaldungsarten 2 und 7 entspricht.
```
+----------------------+-------+
| predicted_cover_type | count |
+----------------------+-------+
| 2 | 564 |
| 7 | 97 |
| 1 | 2309 |
+----------------------+-------+
```
1. Die folgende Abfrage zeigt die häufigste Bewaldungsart in einem einzelnen Wildnisgebiet. Die Abfrage zeigt das Aufkommen dieser Bewaldungsart und das Wildnisgebiet der Bewaldungsart an.
```
SELECT t1. predicted_cover_type, COUNT(*), wilderness_area
FROM
(
SELECT
Elevation,
Aspect,
Slope,
Horizontal_distance_to_hydrology,
Vertical_distance_to_hydrology,
Horizontal_distance_to_roadways,
HIllshade_9am,
Hillshade_noon,
Hillshade_3pm ,
Horizontal_Distance_To_Fire_Points,
Wilderness_Area1,
Wilderness_Area2,
Wilderness_Area3,
Wilderness_Area4,
soil_type1,
Soil_Type2,
Soil_Type3,
Soil_Type4,
Soil_Type5,
Soil_Type6,
Soil_Type7,
Soil_Type8,
Soil_Type9,
Soil_Type10 ,
Soil_Type11,
Soil_Type12 ,
Soil_Type13 ,
Soil_Type14,
Soil_Type15,
Soil_Type16,
Soil_Type17,
Soil_Type18,
Soil_Type19,
Soil_Type20,
Soil_Type21,
Soil_Type22,
Soil_Type23,
Soil_Type24,
Soil_Type25,
Soil_Type26,
Soil_Type27,
Soil_Type28,
Soil_Type29,
Soil_Type30,
Soil_Type31,
Soil_Type32,
Soil_Type33,
Soil_Type34,
Soil_Type36,
Soil_Type37,
Soil_Type38,
Soil_Type39,
Soil_Type40,
predict_cover_type( Elevation,
Aspect,
Slope,
Horizontal_distance_to_hydrology,
Vertical_distance_to_hydrology,
Horizontal_distance_to_roadways,
HIllshade_9am,
Hillshade_noon,
Hillshade_3pm ,
Horizontal_Distance_To_Fire_Points,
Wilderness_Area1,
Wilderness_Area2,
Wilderness_Area3,
Wilderness_Area4,
soil_type1,
Soil_Type2,
Soil_Type3,
Soil_Type4,
Soil_Type5,
Soil_Type6,
Soil_Type7,
Soil_Type8,
Soil_Type9,
Soil_Type10,
Soil_Type11,
Soil_Type12,
Soil_Type13,
Soil_Type14,
Soil_Type15,
Soil_Type16,
Soil_Type17,
Soil_Type18,
Soil_Type19,
Soil_Type20,
Soil_Type21,
Soil_Type22,
Soil_Type23,
Soil_Type24,
Soil_Type25,
Soil_Type26,
Soil_Type27,
Soil_Type28,
Soil_Type29,
Soil_Type30,
Soil_Type31,
Soil_Type32,
Soil_Type33,
Soil_Type34,
Soil_Type36,
Soil_Type37,
Soil_Type38,
Soil_Type39,
Soil_Type40) AS predicted_cover_type,
CASE WHEN Wilderness_Area1 = 1 THEN 1
WHEN Wilderness_Area2 = 1 THEN 2
WHEN Wilderness_Area3 = 1 THEN 3
WHEN Wilderness_Area4 = 1 THEN 4
ELSE 0
END AS wilderness_area
FROM public.covertype_test)
t1
GROUP BY 1, 3
ORDER BY 2 DESC
LIMIT 1;
```
Die Ausgabe der vorherigen Operation sollte dem folgenden Beispiel ähneln.
```
+----------------------+-------+-----------------+
| predicted_cover_type | count | wilderness_area |
+----------------------+-------+-----------------+
| 2 | 15738 | 1 |
+----------------------+-------+-----------------+
```
## Verwandte Themen
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)