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.
# Machine Learning
Amazon Redshift Machine Learning (Amazon Redshift ML) ist ein robuster, cloudbasierter Service, der Analysten und Datenwissenschaftlern aller Kenntnisstufen die Arbeit mit Machine-Learning-Technologien erleichtert. Amazon Redshift ML verwendet ein Modell, um Ergebnisse zu generieren. Sie können Modelle auf folgende Weisen verwenden:
+ Sie können die Daten, die Sie zum Trainieren eines Modells verwenden möchten, sowie Metadaten, die mit Dateneingaben verknüpft sind, für Amazon Redshift bereitstellen. Anschließend erstellt Amazon Redshift ML Modelle in Amazon SageMaker AI, die Muster in den Eingabedaten erfassen. Durch die Verwendung eigener Daten für das Modell können Sie mithilfe von Amazon Redshift ML Trends in den Daten identifizieren, z. B. Abwanderungsprognosen, Customer Lifetime Value oder Umsatzprognosen. Sie können diese Modelle verwenden, um Prognosen für neue Eingabedaten zu generieren, ohne dass zusätzliche Kosten entstehen.
+ Sie können eines der von Amazon Bedrock bereitgestellten Basismodelle (FM) wie Claude oder Amazon Titan verwenden. Mit Amazon Bedrock können Sie die Leistungsfähigkeit großer Sprachmodelle (LLMs) in wenigen Schritten mit Ihren Analysedaten in Amazon Redshift kombinieren. Durch die Nutzung eines externen großen Sprachmodells (LLM) können Sie Amazon Redshift für die natürliche Sprachverarbeitung (NLP) Ihrer Daten verwenden. Sie können NLP für Anwendungen wie Textgenerierung, Stimmungsanalyse oder Übersetzung verwenden. Weitere Informationen zur Verwendung von Amazon Bedrock mit Amazon Redshift finden Sie unter [Integration von Amazon Redshift ML mit Amazon Bedrock](machine-learning-br.md).
**Anmerkung**
**Abmeldung von der Nutzung Ihrer Daten zur Serviceverbesserung**
Wenn Sie Amazon Bedrock-Modelle verwenden, empfehlen wir Ihnen, die AWS Richtlinien darüber zu lesen, wie der Amazon Bedrock-Service mit Ihren Daten umgeht. Sie sollten feststellen, ob Sie eine Abmelderichtlinie verwenden müssen, um zu verhindern, dass der Service Ihre Daten für Modell- oder Serviceverbesserungen verwendet, falls Amazon Bedrock eine solche Funktionalität in der Zukunft implementiert. Um sicherzustellen, dass der Service Ihre Daten nicht für solche Zwecke verwendet, verwenden Sie die allgemeinen AWS Opt-Out-Richtlinien.
Weitere Informationen finden Sie hier:
[Richtlinien zur Deaktivierung von KI-Diensten](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_ai-opt-out.html)
[Amazon Bedrock FAQs](https://aws.amazon.com/bedrock/faqs/)
**Anmerkung**
LLMs kann zu ungenauen oder unvollständigen Informationen führen. Wir empfehlen, die bereitgestellten Informationen zu überprüfen, LLMs um sicherzustellen, dass sie korrekt und vollständig sind.
**So funktioniert Amazon Redshift ML mit Amazon AI SageMaker **
Amazon Redshift arbeitet mit Amazon SageMaker AI Autopilot zusammen, um automatisch das beste Modell zu ermitteln und die Prognosefunktion in Amazon Redshift verfügbar zu machen.
Das folgende Diagramm veranschaulicht, wie Amazon Redshift ML funktioniert.
![\[Workflow für die Integration von Amazon Redshift ML mit Amazon SageMaker AI Autopilot.\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/images/machine_learning_overview.png)
Im Allgemeinen sieht der Workflow wie folgt aus:
1. Amazon Redshift exportiert die Trainingsdaten in Amazon S3.
1. Amazon SageMaker AI Autopilot verarbeitet die Trainingsdaten vor. Die *Vorverarbeitung* umfasst wichtige Funktionen, wie zum Beispiel die Imputation fehlender Werte. Im Rahmen der Vorverarbeitung werden außerdem kategorische Spalten (zum Beispiel die Postleitzahl) erfasst und für das Training formatiert sowie weitere Funktionen durchgeführt. Die Auswahl der besten Präprozessoren für den Trainingsdatensatz ist an sich schon ein Problem, und Amazon SageMaker AI Autopilot automatisiert seine Lösung.
1. Amazon SageMaker AI Autopilot findet den Algorithmus und die Algorithmus-Hyperparameter, die das Modell mit den genauesten Vorhersagen liefern.
1. Amazon Redshift registriert die Prognosefunktion als SQL-Funktion in Ihrem Amazon-Redshift-Cluster.
1. Wenn Sie CREATE MODEL-Anweisungen ausführen, verwendet Amazon Redshift Amazon SageMaker AI für das Training. Daher fallen Kosten für das Training Ihres Modells an. Dies ist ein separater Posten für Amazon SageMaker AI in Ihrer AWS Rechnung. Sie zahlen außerdem für den Speicher, der in Amazon S3 für die Speicherung Ihrer Trainingsdaten verwendet wird. Inferenzen mit Modellen, die mit CREATE MODEL erstellt wurden, die Sie kompilieren und auf Ihrem Redshift-Cluster ausführen können, werden nicht berechnet. Es fallen keine zusätzlichen Amazon-Redshift-Gebühren für die Verwendung von Amazon Redshift ML an.
**Topics**
+ [Übersicht zum Machine Learning](machine_learning_overview.md)
+ [Machine Learning für Anfänger und Experten](novice_expert.md)
+ [Kosten für die Verwendung von Amazon Redshift ML](cost.md)
+ [Erste Schritte mit Amazon Redshift ML](getting-started-machine-learning.md)
+ [Tutorials für Amazon Redshift ML](tutorials_for_amazon_redshift_ml.md)
+ [Integration von Amazon Redshift ML mit Amazon Bedrock](machine-learning-br.md)
# Übersicht zum Machine Learning
Mit Amazon Redshift können Sie Machine-Learning-Funktionen nutzen, um wertvolle Erkenntnisse aus Ihren Daten zu gewinnen. Diese Übersicht zu Machine Learning (ML) zeigt Ihnen, wie Sie Ihre Daten für das Training und die Bereitstellung von ML-Modellen untersuchen, visualisieren und vorbereiten können. Die folgenden Abschnitte führen Sie durch den Prozess der Nutzung von Amazon Redshift ML, um das Potenzial Ihrer Daten mithilfe von Machine Learning auszuschöpfen.
Mithilfe von Amazon Redshift ML können Sie Machine-Learning-Modelle mithilfe von SQL-Anweisungen trainieren und sie in SQL-Abfragen für Prognosen aufrufen.
Mehr über die Verwendung von Amazon Redshift ML erfahren Sie in folgendem Video.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/pJF2kYGtO4A)
Informationen zu den Voraussetzungen für die Einrichtung Ihres Redshift-Clusters oder Ihrer Serverless-Arbeitsgruppe, zu den Berechtigungen und zur Eigentümerschaft für die Verwendung von Amazon Redshift ML finden Sie in den folgenden Abschnitten. In diesen Abschnitten wird auch beschrieben, wie einfache Trainings und Prognosen in Amazon Redshift ML funktionieren.
## Wie Machine Learning dabei hilft, ein Problem zu lösen
Machine-Learning-Modelle generieren Prognosen, indem Muster in Ihren Trainingsdaten gefunden und diese Muster dann auf neue Daten angewendet werden. Beim Machine Learning trainieren Sie diese Modelle, indem Muster gelernt werden, die ihre Daten am besten beschreiben. Dann verwenden Sie diese Modelle, um Prognosen (auch als Inferenzen bezeichnet) für neue Daten zu stellen. Machine Learning ist normalerweise ein iterativer Prozess, bei dem Sie die Genauigkeit der Prognosen weiter verbessern können, indem Sie die Parameter ändern und Ihre Trainingsdaten verbessern. Wenn sich Daten ändern, erfolgt ein erneutes Training neuer Modelle mit dem neuen Datensatz.
Um verschiedene Geschäftsziele zu erreichen, gibt es verschiedene grundlegende Machine-Learning-Ansätze.
### Supervised Learning in Amazon Redshift ML
Amazon Redshift unterstützt Supervised Learning – den gängigsten Ansatz für fortschrittliche Unternehmensanalysen. Supervised Learning ist der bevorzugte Machine-Learning-Ansatz, wenn Sie einen festgelegten Datensatz haben und verstehen, wie bestimmte Eingabedaten Prognosen zu verschiedenen Geschäftsergebnissen erstellen. Diese Ergebnisse werden manchmal als Labels bezeichnet. Ihr Datensatz ist im Wesentlichen eine Tabelle mit Attributen, die aus Merkmalen (Eingaben) und Zielen (Ausgaben) bestehen. Stellen Sie sich zum Beispiel eine Tabelle vor, die das Alter und die Postleitzahl für vergangene und gegenwärtige Kunden enthält. Nehmen Sie außerdem an, dass es das Feld „aktiv“ gibt, das für gegenwärtige Kunden den Wert „true“ hat und für vergangene Kunden, die ihre Mitgliedschaft ausgesetzt haben, den Wert „false“. Das Ziel des Supervised Machine Learning ist es, Muster im Alter und den Postleitzahlen zu erkennen, die zur Kundenabwanderung führen, die von Kunden mit dem Wert „false“ dargestellt wird. Sie können dieses Modell verwenden, um vorherzusagen, welche Kunden wahrscheinlich abwandern werden, zum Beispiel indem sie ihre Mitgliedschaft aussetzen, und gegebenenfalls Initiativen zur Bindung anzubieten.
Amazon Redshift unterstützt Supervised Learning. Dies umfasst Regression, binäre Klassifizierung und Mehrklassen-Klassifizierung. Regression bezieht sich auf das Problem der Prognose kontinuierlicher Werte, wie zum Beispiel der Gesamtausgaben der Kunden. Binäre Klassifizierung bezieht sich auf das Problem der Prognose eines von zwei Ergebnissen, z. B. die Prognose, ob ein Kunde abwandert oder nicht. Mehrklassen-Klassifizierung bezieht sich auf das Problem der Prognose eines von vielen Ergebnissen, z. B. die Prognose des Artikels, der für einen Kunden interessant sein könnte. Datenanalysten und Datenwissenschaftler können sie verwenden, um Supervised Learning durchzuführen, um Probleme bei Prognosen, der Personalisierung und der Vorhersage der Kundenabwanderung zu lösen. Sie können Supervised Learning auch bei Problemen wie der Prognose, welche Verkäufe abgeschlossen werden, Umsatzprognose, Betrugserkennung und Prognose des Kundenlebenszeitwerts nutzen.
### Unsupervised Learning in Amazon Redshift ML
Unsupervised Learning verwendet Machine-Learning-Algorithmen, um nicht gekennzeichnete Trainingsdaten zu analysieren und zu gruppieren. Die Algorithmen erkennen versteckte Muster oder Gruppierungen. Ziel ist es, die zugrunde liegende Struktur oder Verteilung in den Daten zu modellieren, um weitere Informationen über die Daten zu erfahren.
Amazon Redshift unterstützt den K-Means-Clustering-Algorithmus für die Lösung von Unsupervised-Learning-Problemen. Dieser Algorithmus löst Clusterprobleme, bei denen Sie Gruppierungen in den Daten erkennen möchten. Der K-Means-Algorithmus versucht, separate Gruppierungen innerhalb der Daten zu finden. Nicht klassifizierte Daten werden aufgrund ihrer Ähnlichkeiten und Unterschiede gruppiert und partitioniert. Durch die Gruppierung ermittelt der K-Means-Algorithmus iterativ die besten Schwerpunkte und weist jedes Element dem nächstgelegenen Schwerpunkt zu. Mitglieder mit dem gleichen nächstgelegenen Schwerpunkt 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. Zum Beispiel lassen sich mithilfe des K-Means-Clustering-Algorithmus anhand der Beliebtheit von Konsumgütern Städte klassifizieren, die von einer Pandemie betroffen sind.
Bei Verwendung des K-Means-Algorithmus legen Sie eine Eingabe `k` fest. Diese gibt die Anzahl der Cluster an, die in den Daten gefunden werden sollen. Dieser Algorithmus gibt einen Satz von k-Schwerpunkten aus. Jeder Datenpunkt gehört zu einem der k-Cluster, der ihm am nächsten liegt. Beschrieben wird jeder Cluster durch seinen Schwerpunkt. Der Schwerpunkt kann als mehrdimensionaler Durchschnitt des Clusters bertrachtet werden. Der K-Means-Algorithmus vergleicht die Entfernungen, um zu sehen, wie sehr sich die Cluster voneinander unterscheiden. Ein größerer Abstand weist allgemein auf einen größeren Unterschied zwischen den Clustern hin.
Die Vorverarbeitung der Daten ist für K-Means wichtig, weil damit die Merkmale des Modells im gleichen Maßstab bleiben und zuverlässige Ergebnisse geliefert werden. Amazon Redshift unterstützt einige K-Means-Präprozessoren für die CREATE MODEL-Anweisung, wie StandardScaler, und MinMax. NumericPassthrough Wenn Sie keine Vorverarbeitung für K-Means anwenden möchten, wählen Sie NumericPassthrough explizit als Transformer. Informationen zum Festlegen von K-Means-Parametern finden Sie unter [CREATE MODEL mit K-MEANS – Parameter](r_create_model_use_cases.md#r_k-means-create-model-parameters).
Um zu lernen, wie man unbeaufsichtigtes Training mit K-Means Clustering durchführt, können Sie sich das folgende Video ansehen.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/TFKgl5d0U_0)
## Begriffe und Konzepte von Amazon Redshift ML
Die folgenden Beschreibungen werden verwendet, um einige Konzepte von Amazon Redshift ML zu beschreiben:
+ *Machine Learning* in Amazon Redshift trainiert ein Modell mit einem SQL-Befehl. Amazon Redshift ML und Amazon SageMaker AI verwalten alle Datenkonvertierungen, Berechtigungen, die Ressourcennutzung und die Suche nach dem richtigen Modell.
+ *Training* ist die Phase, in der Amazon Redshift ein Machine-Learning-Modell erstellt, indem eine bestimmte Teilmenge von Daten im Modell ausgeführt wird. Amazon Redshift startet automatisch einen Schulungsjob in Amazon SageMaker AI und generiert ein Modell.
+ *Prognose* (auch *Inferenz* genannt) ist die Verwendung des Modells in Amazon-Redshift-SQL-Abfragen, um Ergebnisse vorherzusagen. Zur Inferenzzeit verwendet Amazon Redshift eine modellbasierte Prognosefunktion als Teil einer größeren Abfrage, um Prognosen zu erstellen. Die Prognosen werden lokal im Redshift-Cluster berechnet und bieten somit einen hohen Durchsatz, eine niedrige Latenz und keine Zusatzkosten.
+ Mit *Bring Your Own Model (BYOM)* können Sie ein außerhalb von Amazon Redshift mit Amazon SageMaker AI trainiertes Modell für datenbankinterne Inferenzen lokal in Amazon Redshift verwenden. Amazon Redshift ML unterstützt die Verwendung von BYOM in der lokalen Inferenz.
+ *Lokale Inferenz* wird verwendet, wenn Modelle in Amazon SageMaker AI vortrainiert, von Amazon SageMaker AI Neo kompiliert und in Amazon Redshift ML lokalisiert werden. Um Modelle zu importieren, die für lokale Inferenz in Amazon Redshift unterstützt werden, verwenden Sie den Befehl CREATE MODEL. Amazon Redshift importiert die vortrainierten SageMaker KI-Modelle, indem es Amazon SageMaker AI Neo aufruft. Sie kompilieren das Modell dort und importieren das kompilierte Modell in Amazon Redshift. Nutzen Sie lokale Inferenz für höhere Geschwindigkeit und niedrigere Kosten.
+ *Ferninferenz* wird verwendet, wenn Amazon Redshift einen in KI bereitgestellten Modellendpunkt aufruft. SageMaker Remote-Inferenz bietet die Flexibilität, alle Arten von benutzerdefinierten Modellen und Deep-Learning-Modellen aufzurufen, z. B. TensorFlow Modelle, die Sie in Amazon SageMaker AI erstellt und bereitgestellt haben.
Wichtig sind außerdem:
+ *Amazon SageMaker AI* ist ein vollständig verwalteter Service für maschinelles Lernen. Mit Amazon SageMaker AI können Datenwissenschaftler und Entwickler auf einfache Weise Modelle erstellen, trainieren und direkt in einer produktionsbereiten gehosteten Umgebung bereitstellen. Informationen zu Amazon SageMaker AI finden Sie unter [Was ist Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/whatis.html) im *Amazon SageMaker AI Developer Guide*.
+ *Amazon SageMaker AI Autopilot* ist ein Funktionsumfang, der auf der Grundlage Ihrer Daten automatisch die besten Modelle für maschinelles Lernen für die Klassifizierung oder Regression trainiert und optimiert. Sie behalten die volle Kontrolle und Transparenz. Amazon SageMaker AI Autopilot unterstützt Eingabedaten im Tabellenformat. Amazon SageMaker AI Autopilot bietet automatische Datenbereinigung und Vorverarbeitung, automatische Algorithmusauswahl für lineare Regression, binäre Klassifizierung und Mehrklassenklassifizierung. Es unterstützt auch die automatische Hyperparameteroptimierung (HPO), verteiltes Training, automatische Instances und Clustergrößenauswahl. Informationen zu Amazon SageMaker AI Autopilot finden [Sie unter Automatisieren der Modellentwicklung mit Amazon SageMaker AI Autopilot](https://docs.aws.amazon.com/sagemaker/latest/dg/autopilot-automate-model-development.html) im *Amazon SageMaker * AI Developer Guide.
+ *Amazon Bedrock* ist ein vollständig verwalteter Service, der über eine einzige API eine Auswahl an leistungsstarken Basismodellen (FMs) von führenden KI-Unternehmen wie AI21 Labs, Anthropic, Cohere, Meta, Mistral AI, Stability AI und Amazon sowie eine breite Palette von Funktionen bietet, die für die Entwicklung generativer KI-Anwendungen erforderlich sind.
# Machine Learning für Anfänger und Experten
Mit Amazon Redshift können Sie Machine Learning (ML)-Funktionen nutzen, um Erkenntnisse aus Ihren Daten zu gewinnen, unabhängig davon, ob Sie Anfänger auf diesem Gebiet oder bereits ML-Experte sind. Machine Learning ist ein Feature von Amazon Redshift, das es Ihnen ermöglicht, ML-Modelle mithilfe von SQL-Befehlen zu erstellen, zu trainieren und bereitzustellen, ohne hierfür umfangreiche ML-Kenntnisse oder komplexes Data Engineering zu benötigen.
Die folgenden Abschnitte führen Sie durch den Prozess der Nutzung von Machine Learning, um das volle Potenzial Ihrer Daten mit Amazon Redshift auszuschöpfen.
Amazon Redshift ML ermöglicht es Ihnen, Modelle mit einem einzigen SQL-CREATE-MODEL-Befehl zu trainieren. Der Befehl CREATE MODEL erstellt ein Modell, das Amazon Redshift verwendet, um modellbasierte Prognosen mit vertrauten SQL-Konstrukten zu generieren.
Amazon Redshift ML ist besonders nützlich, wenn Sie kein Fachwissen in maschinellem Lernen, Tools, Sprachen, Algorithmen usw. haben. APIs Mit Amazon Redshift ML sparen Sie sich den Aufwand, der mit der Integration eines externen Machine-Learning-Services verbunden ist. Amazon Redshift spart Ihnen Zeit, um Daten zu formatieren und zu verschieben, Berechtigungskontrollen zu verwalten und benutzerdefinierte Integrationen, Workflows und Skripts zu entwickeln. Sie können ganz einfach gängige Machine-Learning-Algorithmen verwenden und Trainingsanforderungen vereinfachen, die häufige Iterationen vom Training bis zur Prognose erfordern. Amazon Redshift erkennt automatisch den besten Algorithmus und passt das beste Modell für Ihr Problem an. Sie können Prognosen innerhalb des Amazon-Redshift-Clusters erstellen, ohne dass Daten aus Amazon Redshift verschoben werden müssen. Da Sie sich nicht mit einem anderen Service verbinden müssen, sparen Sie außerdem die damit verbundenen Kosten.
Amazon Redshift ML unterstützt Datenanalysten und Datenwissenschaftler bei der Nutzung von Machine Learning. Damit können Experten für Machine Learning auch ihr Wissen dazu nutzen, mit der Anweisung CREATE MODEL nur die von ihnen angegebenen Aspekte zu verwenden. Dadurch können Sie die Zeit verkürzen, die CREATE MODEL benötigt, um den besten Kandidaten zu finden, die Genauigkeit des Modells zu verbessern oder beides zu erreichen.
Die Anweisung CREATE MODEL bietet Ihnen Flexibilität beim Festlegen der Parameter für den Trainingsauftrag. Dank dieser Flexibilität können sowohl Anfänger als auch Experten im Bereich Machine Learning ihre bevorzugten Präprozessoren, Algorithmen, Problemtypen und Hyperparameter auswählen. So kann zum Beispiel ein Benutzer, der mehr über die Kundenabwanderung erfahren möchte, für die CREATE-MODEL-ANWEISUNG festlegen, dass der Problemtyp eine binäre Klassifizierung sein soll, die für den Bereich Kundenabwanderung geeignet ist. Die CREATE-MODEL-Anweisung schränkt die Suche nach dem besten Modell dann auf Modelle mit binärer Klassifizierung ein. Selbst wenn der Benutzer den Problemtyp frei auswählen kann, bleiben immer noch viele Optionen übrig, mit denen die CREATE-MODEL-Anweisung arbeiten kann. Beispielsweise kann CREATE MODEL die besten Vorverarbeitungstransformationen finden und anwenden sowie die besten Hyperparametereinstellungen ermitteln.
Amazon Redshift ML erleichtert das Training, indem es mithilfe von Amazon SageMaker AI Autopilot automatisch das beste Modell findet. Hinter den Kulissen trainiert und optimiert Amazon SageMaker AI Autopilot automatisch das beste Modell für maschinelles Lernen auf der Grundlage Ihrer bereitgestellten Daten. Amazon SageMaker AI Neo kompiliert dann das Trainingsmodell und stellt es für Prognosen in Ihrem Redshift-Cluster zur Verfügung. Wenn Sie eine Machine-Learning-Inferenzabfrage mit einem trainierten Modell ausführen, kann die Abfrage die MPP-Funktionen (Massively Parallel Processing) von Amazon Redshift nutzen. Gleichzeitig kann die Abfrage auf Machine Learning basierende Vorhersage verwenden.
+ Als *Anfänger im Bereich Machine Learning* mit allgemeinen Kenntnissen zu unterschiedlichen ML-Aspekten wie Präprozessoren, Algorithmen und Hyperparametern können Sie die CREATE-MODEL-Anweisung für die von Ihnen angegebenen Aspekte verwenden. Sie können dann die Zeit verkürzen, die CREATE MODEL benötigt, um den besten Kandidaten zu finden oder die Genauigkeit des Modells zu verbessern. Außerdem können Sie den geschäftlichen Wert der Prognosen erhöhen, indem Sie zusätzliche Domäneninformationen wie den Problemtyp oder das Ziel hinzufügen. Wenn beispielsweise in einem Kundenabwanderungsszenario das Ergebnis „Kunde ist nicht aktiv“ selten ist, wird das F1-Ziel häufig dem Ziel „Genauigkeit“ vorgezogen. Modelle mit einer hohen Genauigkeit sagen wahrscheinlich immer „Kunde ist aktiv“ voraus. Dies ergibt zwar eine hohe Genauigkeit, jedoch ist der geschäftliche Wert gering. Informationen zu F1-Zielen finden Sie unter [Auto MLJob Objective](https://docs.aws.amazon.com//sagemaker/latest/APIReference/API_AutoMLJobObjective.html) in der *Amazon SageMaker AI API-Referenz*.
Weitere Informationen zu den grundlegenden Optionen für die CREATE-MODEL-Anweisung finden Sie unter [Einfaches CREATE MODEL](r_create_model_use_cases.md#r_simple_create_model).
+ Als *Fortgeschrittener im Bereich Machine Learning* können Sie den Problemtyp und die Präprozessoren für manche (nicht alle) Merkmale angeben. Dann folgt CREATE MODEL Ihren Vorschlägen zu den angegebenen Aspekten. Gleichzeitig ermittelt CREATE MODEL noch die besten Präprozessoren für die verbleibenden Funktionen und die besten Hyperparameter. Weitere Informationen zum Einschränken von einem oder mehreren Aspekten der Trainings-Pipeline finden Sie unter [CREATE MODEL mit Benutzerführung](r_create_model_use_cases.md#r_user_guidance_create_model).
+ Als *Experte im Bereich Machine Learning* haben Sie die volle Kontrolle über das Training und die Optimierung der Hyperparameter. CREATE MODEL versucht dann nicht, die besten Präprozessoren, Algorithmen und Hyperparameter zu ermitteln, da Sie alle Entscheidungen treffen. Weitere Informationen zur Verwendung von CREATE MODEL mit AUTO OFF finden Sie unter [ERSTELLEN Sie XGBoost Modelle mit AUTO OFF](r_create_model_use_cases.md#r_auto_off_create_model).
+ Als *Dateningenieur* können Sie ein vortrainiertes XGBoost Modell in Amazon SageMaker AI importieren und es zur lokalen Inferenz in Amazon Redshift importieren. Mit Bring Your Own Model (BYOM) können Sie ein außerhalb von Amazon Redshift mit Amazon SageMaker AI trainiertes Modell für datenbankinterne Inferenzen lokal in Amazon Redshift verwenden. Amazon Redshift ML unterstützt die Verwendung von BYOM in der lokalen oder Remote-Inferenz.
Weitere Informationen zur Verwendung der CREATE-MODEL-Anweisung für die lokale oder Remote-Inferenz finden Sie unter [Bring Your Own Model (BYOM) - lokale Inferenz](r_create_model_use_cases.md#r_byom_create_model).
Als Benutzer von Amazon Redshift ML können Sie eine der folgenden Optionen auswählen, um Ihr Modell zu trainieren und bereitzustellen:
+ Problemtypen, siehe [CREATE MODEL mit Benutzerführung](r_create_model_use_cases.md#r_user_guidance_create_model).
+ Ziele, siehe [CREATE MODEL mit Benutzerführung](r_create_model_use_cases.md#r_user_guidance_create_model) oder [ERSTELLEN Sie XGBoost Modelle mit AUTO OFF](r_create_model_use_cases.md#r_auto_off_create_model).
+ Modelltypen, siehe [ERSTELLEN Sie XGBoost Modelle mit AUTO OFF](r_create_model_use_cases.md#r_auto_off_create_model).
+ Präprozessoren, siehe [CREATE MODEL mit Benutzerführung](r_create_model_use_cases.md#r_user_guidance_create_model).
+ Hyperparameter, siehe [ERSTELLEN Sie XGBoost Modelle mit AUTO OFF](r_create_model_use_cases.md#r_auto_off_create_model).
+ Bring your own model (BYOM), siehe [Bring Your Own Model (BYOM) - lokale Inferenz](r_create_model_use_cases.md#r_byom_create_model).
# Kosten für die Verwendung von Amazon Redshift ML
Mit Amazon Redshift können Sie Machine-Learning-Funktionen nutzen, um Erkenntnisse aus Ihren Daten zu gewinnen, ohne hierfür umfangreiche Fachkenntnisse in Bezug auf Data Engineering oder Machine Learning zu benötigen. In den folgenden Abschnitten werden die mit der Verwendung von Amazon Redshift ML verbundenen Kosten erläutert. Diese Informationen helfen Ihnen, Ihre Ausgaben zu planen und zu optimieren und gleichzeitig diese leistungsstarke Machine-Learning-Integration zu nutzen.
## Kosten für die Verwendung von Amazon Redshift ML mit KI SageMaker
Amazon Redshift ML for SageMaker AI verwendet Ihre vorhandenen Cluster-Ressourcen für Prognosen, sodass Sie zusätzliche Amazon Redshift Redshift-Gebühren vermeiden können. Es fallen keine zusätzlichen Amazon-Redshift-Gebühren für das Erstellen oder Verwenden eines Modells an. Die Prognose erfolgt lokal in Ihrem Redshift-Cluster, sodass Sie nicht extra bezahlen müssen, es sei denn, Sie müssen die Größe Ihres Clusters ändern. Amazon Redshift ML verwendet Amazon SageMaker AI für das Training Ihres Modells, was mit zusätzlichen Kosten verbunden ist.
Für Prognosefunktionen, die in Ihrem Amazon-Redshift-Cluster ausgeführt werden, fallen keine zusätzlichen Gebühren an. Die CREATE MODEL-Anweisung verwendet Amazon SageMaker AI und verursacht zusätzliche Kosten. Die Kosten steigen mit der Anzahl der Zellen in Ihren Trainingsdaten. Die Anzahl der Zellen ist das Produkt aus der Anzahl der Datensätze (in der Trainingsabfrage oder Tabellenzeiten) mal der Anzahl der Spalten. Wenn beispielsweise eine SELECT-Abfrage der CREATE-MODEL-Anweisung 10 000 Datensätze und 5 Spalten erstellt, beträgt die Anzahl der erstellten Zellen 50 000.
In einigen Fällen überschreiten die von der SELECT-Abfrage von CREATE MODEL erzeugten Trainingsdaten das von Ihnen angegebene MAX\$1CELLS-Limit (oder die Standardeinstellung 1 Million, wenn Sie kein Limit angegeben haben). In diesen Fällen wählt CREATE MODEL MAX\$1CELLS (d. h. die „Anzahl der Spalten“-Datensätze aus dem Trainingsdatensatz) nach dem Zufallsprinzip aus. CREATE MODEL führt dann das Training mit diesen zufällig ausgewählten Tupeln durch. Diese zufällige Auswahl stellt sicher, dass der reduzierte Trainingsdatensatz keine Verzerrung aufweist. Sie können also durch die Festlegung von MAX\$1CELLS die Trainingskosten kontrollieren.
Wenn Sie die Anweisung CREATE MODEL verwenden, können Sie die Optionen MAX\$1CELLS und MAX\$1RUNTIME verwenden, um Kosten, Zeit und potenzielle Modellgenauigkeit zu steuern.
MAX\$1RUNTIME gibt die maximale Zeit an, die das Training in SageMaker KI dauern kann, wenn die Option AUTO ON oder OFF verwendet wird. Je nach Größe des Datensatzes werden Trainingsaufträge früher als MAX\$1RUNTIME abgeschlossen. Nachdem ein Modell trainiert wurde, führt Amazon Redshift zusätzliche Aufgaben im Hintergrund durch, um Ihre Modelle in Ihrem Cluster zu kompilieren und zu installieren. Daher kann CREATE MODEL länger dauern als MAX\$1RUNTIME. MAX\$1RUNTIME begrenzt jedoch den Rechenaufwand und die Zeit, die in SageMaker KI zum Trainieren Ihres Modells benötigt werden. Sie können den Status Ihres Modells jederzeit mit SHOW MODEL überprüfen.
Wenn Sie CREATE MODEL mit AUTO ON ausführen, verwendet Amazon Redshift ML SageMaker KI Autopilot, um automatisch und intelligent verschiedene Modelle (oder Kandidaten) zu untersuchen, um das beste Modell zu finden. MAX\$1RUNTIME begrenzt den Zeitaufwand und die Berechnung. Wenn MAX\$1RUNTIME zu niedrig eingestellt ist, reicht die Zeit möglicherweise nicht einmal aus, um einen einzigen Kandidaten zu untersuchen. Wenn der Fehler „Autopilot candidate has no models“ (Autopilot-Kandidat hat keine Modelle) angezeigt wird, führen Sie CREATE MODEL erneut mit einem höheren MAX\$1RUNTIME-Wert aus. Weitere Informationen zu diesem Parameter finden Sie [MaxAutoMLJobRuntimeInSeconds](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AutoMLJobCompletionCriteria.html)in der *Amazon SageMaker AI API-Referenz*.
Wenn Sie CREATE MODEL mit AUTO OFF ausführen, entspricht MAX\$1RUNTIME einem Limit dafür, wie lange der Trainingsjob in SageMaker AI ausgeführt wird. Trainingsaufträge werden oft früher abgeschlossen, abhängig von der Größe des Datensatzes und anderen verwendeten Parametern, wie z. B. num\$1rounds in MODEL\$1TYPE XGBOOST.
Sie können auch Kosten kontrollieren oder die Trainingszeit reduzieren, indem Sie einen kleineren MAX\$1CELLS-Wert angeben, wenn Sie CREATE MODEL ausführen. Eine *Zelle* ist ein Eintrag in der Datenbank. Jede Zeile entspricht so vielen Zellen wie vorhandenen Spalten, die eine feste oder unterschiedliche Breite haben können. MAX\$1CELLS begrenzt die Anzahl der Zellen und damit die Anzahl der Trainingsbeispiele, die zum Trainieren Ihres Modells verwendet werden. Standardmäßig ist MAX\$1CELLS auf 1 Million Zellen festgelegt. Durch die Reduzierung von MAX\$1CELLS wird die Anzahl der Zeilen aus dem Ergebnis der SELECT-Abfrage in CREATE MODEL reduziert, die Amazon Redshift exportiert und an SageMaker KI sendet, um ein Modell zu trainieren. Die Reduzierung von MAX\$1CELLS reduziert somit die Größe des Datensatzes, der zum Trainieren von Modellen mit AUTO ON und AUTO OFF verwendet wird. Dieser Ansatz trägt dazu bei, die Kosten und die Zeit für das Training von Modellen zu reduzieren. Um Informationen zu Schulungen und Abrechnungszeiten für einen bestimmten Schulungsjob zu sehen, wählen Sie **Schulungsjobs** in Amazon SageMaker AI.
Durch die Erhöhung von MAX\$1RUNTIME und MAX\$1CELLS wird häufig die Modellqualität verbessert, da die SageMaker KI mehr Kandidaten ausfindig machen kann. Auf diese Weise kann SageMaker KI mehr Zeit in Anspruch nehmen, um jeden Kandidaten zu trainieren, und mehr Daten verwenden, um bessere Modelle zu trainieren. Wenn eine schnellere Iteration oder Untersuchung Ihres Datensatzes erforderlich ist, reduzieren Sie die MAX\$1RUNTIME und MAX\$1CELLS. Wenn eine höhere Genauigkeit von Modellen erforderlich ist, erhöhen Sie die MAX\$1RUNTIME und MAX\$1CELLS.
Weitere Informationen zu den Kosten für unterschiedliche Zellanzahlen und kostenlosen Testversionen finden Sie unter [Amazon-Redshift-Preise](https://aws.amazon.com/redshift/pricing).
## Kosten für die Verwendung von Amazon Redshift ML mit Amazon Bedrock
Für die Verwendung von Amazon Redshift ML mit Amazon Bedrock fallen zusätzliche Kosten an. Weitere Informationen finden Sie unter [Amazon Bedrock – Preise](https://aws.amazon.com/bedrock/pricing/).
# Erste Schritte mit Amazon Redshift ML
Amazon Redshift ML erleichtert SQL-Benutzern das Erstellen, Trainieren und Bereitstellen von Machine-Learning-Modellen mit vertrauten SQL-Befehlen. Mit Amazon Redshift ML können Sie Ihre Daten in Ihrem Redshift-Cluster verwenden, um Modelle mit Amazon SageMaker AI zu trainieren. Danach können Sie die Modelle lokalisieren und Prognosen innerhalb einer Amazon-Redshift-Datenbank erstellen. Amazon Redshift ML unterstützt derzeit die Algorithmen für maschinelles Lernen: XGBoost (AUTO ON und OFF) und Multilayer Perceptron (AUTO ON), K-Means (AUTO OFF) und Linear Learner.
**Topics**
+ [Einrichtung für die Amazon-Redshift-ML-Administration in Cluster aufteilen und konfigurieren](#admin-setup)
+ [Verwenden der Modellerklärbarkeit mit Amazon Redshift ML](#clarify)
+ [Wahrscheinlichkeitsmetriken von Amazon Redshift ML](#probability_metrics)
## Einrichtung für die Amazon-Redshift-ML-Administration in Cluster aufteilen und konfigurieren
Bevor Sie mit Amazon Redshift ML arbeiten, schließen Sie die Cluster-Einrichtung ab und konfigurieren Sie die Berechtigungen für die Verwendung von Amazon Redshift ML.
### Cluster-Einrichtung für die Verwendung von Amazon Redshift ML
Bevor Sie mit Amazon Redshift ML arbeiten können, müssen die folgenden Voraussetzungen erfüllt sein.
Führen Sie als Amazon-Redshift-Administrator die folgende einmalige Einrichtung für die Verwendung von durch Amazon Redshift bereitgestellten Clustern durch. Informationen zur Verwendung von Amazon Redshift ML mit Amazon Redshift Serverless finden Sie unter [Erste Schritte mit Amazon Redshift Serverless](https://docs.aws.amazon.com/redshift/latest/gsg/new-user-serverless.html).
So führen Sie eine einmalige ClusterEinrichtung für Amazon Redshift ML durch
1. Erstellen Sie einen Redshift-Cluster mit dem AWS-Managementkonsole oder dem AWS Command Line Interface (AWS CLI). Stellen Sie sicher, dass Sie die AWS Identity and Access Management (IAM-) Richtlinie bei der Erstellung des Clusters anhängen. Weitere Informationen zu den erforderlichen Berechtigungen für die Verwendung von Amazon Redshift ML mit Amazon SageMaker AI finden Sie unter [Erforderliche Berechtigungen für die Verwendung von Amazon Redshift Machine Learning (](https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-iam-access-control-identity-based.html#iam-permission-ml?)ML)
1. Erstellen Sie die IAM-Rolle, die für die Nutzung von Amazon Redshift ML erforderlich ist, mit einer der folgenden Methoden:
+ Um SageMaker KI mit Amazon Redshift ML zu verwenden, erstellen Sie eine IAM-Rolle mit `AmazonS3FullAccess` und `AmazonSageMakerFullAccess` Richtlinien. Wenn Sie planen, auch Prognosemodelle zu erstellen, fügen Sie die Richtlinie `AmazonForecastFullAccess` ebenfalls Ihrer Rolle hinzu.
+ Erstellen Sie eine IAM-Rolle mit `AmazonS3FullAccess`- und `AmazonBedrockFullAccess`-Richtlinien, um Amazon Bedrock mit Amazon Redshift ML zu nutzen.
+ Wir empfehlen, dass Sie eine IAM-Rolle über die Amazon-Redshift-Konsole erstellen, die über die `AmazonRedshiftAllCommandsFullAccess`-Richtlinie mit Berechtigungen zum Ausführen von SQL-Befehlen wie z. B. CREATE MODEL verfügt. Amazon Redshift verwendet einen nahtlosen API-basierten Mechanismus, um in Ihrem Namen programmgesteuert IAM-Rollen in Ihrem Namen zu erstellen. AWS-Konto Amazon Redshift fügt der IAM-Rolle automatisch bestehende AWS verwaltete Richtlinien hinzu. Bei dieser Methode können Sie in der Amazon-Redshift-Konsole bleiben und müssen zur Rollenerstellung nicht zur IAM-Konsole wechseln. Weitere Informationen finden Sie unter [Erstellen einer IAM-Rolle als Standard für Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/default-iam-role.html).
Wenn eine IAM-Rolle als Standard für Ihren Cluster erstellt wird, schließen Sie `redshift` als Teil des Ressourcennamens ein oder verwenden Sie ein Redshift-spezifisches Tag, um diese Ressourcen zu kennzeichnen.
Um Amazon-Bedrock-Basismodelle zu verwenden, fügen Sie den folgenden Abschnitt hinzu:
```
// Required section if you use Bedrock models.
{
"Effect": "Allow",
"Action": "bedrock:InvokeModel",
"Resource": [
"arn:aws:bedrock:::foundation-model/*"
]
}
```
+ Wenn Sie eine IAM-Rolle mit einer restriktiveren Richtlinie erstellen möchten, können Sie die folgende Richtlinie verwenden. Sie können diese Richtlinie auch entsprechend Ihren Anforderungen anpassen.
Der Amazon-S3-Bucket `redshift-downloads/redshift-ml/` ist der Ort, an dem die Beispieldaten für andere Schritte und Beispiele gespeichert werden. Sie können ihn entfernen, wenn Sie keine Daten aus Amazon S3 laden müssen. Sie können ihn auch durch andere Amazon-S3-Buckets ersetzen, die Sie zum Laden von Daten in Amazon Redshift verwenden.
Bei den Werten *`your-account-id`*, *`your-role`* und `amzn-s3-demo-bucket` handelt es sich um die Werte, die Sie als Teil Ihres Befehls CREATE MODEL angeben.
(Optional) Verwenden Sie den Abschnitt AWS KMS Schlüssel der Beispielrichtlinie, wenn Sie bei der Verwendung von Amazon Redshift ML einen AWS KMS Schlüssel angeben. Der Wert *`your-kms-key`* ist der Schlüssel, den Sie als Teil Ihres CREATE-MODEL-Befehls verwenden.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"cloudwatch:PutMetricData",
"ecr:BatchCheckLayerAvailability",
"ecr:BatchGetImage",
"ecr:GetAuthorizationToken",
"ecr:GetDownloadUrlForLayer",
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:DescribeLogStreams",
"logs:PutLogEvents",
"sagemaker:*Job*",
"sagemaker:AddTags",
"sagemaker:CreateModel",
"sagemaker:CreateEndpoint",
"sagemaker:CreateEndpointConfig",
"sagemaker:DeleteEndpoint",
"sagemaker:DeleteEndpointConfig",
"sagemaker:DeleteModel"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"iam:PassRole",
"s3:AbortMultipartUpload",
"s3:GetObject",
"s3:DeleteObject",
"s3:PutObject"
],
"Resource": [
"arn:aws:iam::111122223333:role/",
"arn:aws:s3:::amzn-s3-demo-bucket/*",
"arn:aws:s3:::redshift-downloads/*"
]
},
{
"Effect": "Allow",
"Action": [
"s3:GetBucketLocation",
"s3:ListBucket"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket",
"arn:aws:s3:::redshift-downloads"
]
},
{
"Effect": "Allow",
"Action": [
"kms:CreateGrant",
"kms:Decrypt",
"kms:DescribeKey",
"kms:Encrypt",
"kms:GenerateDataKey*"
],
"Resource": [
"arn:aws:kms:us-east-1:111122223333:key/"
]
}
]
}
```
------
1. Damit Amazon Redshift und SageMaker KI die Rolle für die Interaktion mit anderen Diensten übernehmen können, fügen Sie der IAM-Rolle die folgende Vertrauensrichtlinie hinzu.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"redshift.amazonaws.com",
"sagemaker.amazonaws.com",
"forecast.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. (Optional) Erstellen Sie einen Amazon S3 S3-Bucket und einen AWS KMS Schlüssel. Diese werden von Amazon Redshift verwendet, um die an Amazon SageMaker AI gesendeten Trainingsdaten zu speichern und das trainierte Modell von Amazon SageMaker AI zu empfangen.
1. (Optional) Erstellen Sie verschiedene Kombinationen von IAM-Rollen und Amazon-S3-Buckets, um den Zugriff auf verschiedene Benutzergruppen zu steuern.
1. Wenn Sie das erweiterte VPC-Routing aktivieren, wird der Datenverkehr zwischen Redshift ML und Ihrem S3-Bucket über Ihre private VPC geleitet. Weitere Informationen zum VPC-Routing finden Sie unter [Enhanced VPC Routing in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/enhanced-vpc-routing.html).
Weitere Informationen zu den erforderlichen Berechtigungen, um eine private VPC für Ihren Hyperparameter-Tuning-Job anzugeben, finden Sie unter [Erforderliche Berechtigungen für die Verwendung von Amazon Redshift ML mit](https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-iam-access-control-identity-based.html) Amazon AI. SageMaker
**Anmerkung**
Inferenzrufe an entfernte SageMaker KI-Modelle werden nicht über Ihre VPC geleitet.
Informationen zur Verwendung der CREATE-MODEL-Anweisung zum Erstellen von Modellen für verschiedene Anwendungsfälle finden Sie unter [CREATE MODEL](r_CREATE_MODEL.md).
### Verwalten von Berechtigungen und Eigentümerschaft
Wie bei anderen Datenbankobjekten wie z. B. Tabellen oder Funktionen bindet Amazon Redshift das Erstellen und Verwenden von ML-Modellen an Mechanismen für die Zugriffssteuerung. Für die Erstellung eines Modells, das Prognosefunktionen ausführt, sind separate Berechtigungen erforderlich.
In den folgenden Beispielen werden zwei Benutzergruppen verwendet: `retention_analyst_grp` (Modellersteller) und `marketing_analyst_grp` (Modellbenutzer), um zu veranschaulichen, wie Amazon Redshift die Zugriffskontrolle verwaltet. Der Retention Analyst erstellt Machine-Learning-Modelle, die andere Benutzer verwenden können, wenn sie über entsprechende Berechtigungen verfügen.
Ein Superuser kann GRANT USER- oder GROUP-Berechtigungen für die Erstellung von Machine-Learning-Anweisungen erteilen. Dafür wird die folgende Anweisung verwendet.
```
GRANT CREATE MODEL TO GROUP retention_analyst_grp;
```
Benutzer oder Gruppen mit dieser Berechtigung können ein Modell in einem beliebigen Schema im Cluster erstellen, wenn ein Benutzer über die übliche CREATE-Berechtigung für das SCHEMA verfügt. Das Machine-Learning-Modell ist Teil der Schemahierarchie, ähnlich wie bei Tabellen, Ansichten, Prozeduren und benutzerdefinierte Funktionen.
Wenn beispielsweise das Schema `demo_ml` bereits vorhanden ist, können Sie zwei Benutzergruppen Berechtigungen für das Schema erteilten. Dies sieht so aus:
```
GRANT CREATE, USAGE ON SCHEMA demo_ml TO GROUP retention_analyst_grp;
```
```
GRANT USAGE ON SCHEMA demo_ml TO GROUP marketing_analyst_grp;
```
Um anderen Benutzern die Verwendung der Machine-Learning-Inferenzfunktion zu ermöglichen, erteilen Sie die EXECUTE-Berechtigung. Im folgenden Beispiel wird die EXECUTE-Berechtigung verwendet, um der marketing\$1analyst\$1grp GROUP die Berechtigung zur Verwendung des Modells zu erteilen.
```
GRANT EXECUTE ON MODEL demo_ml.customer_churn_auto_model TO GROUP marketing_analyst_grp;
```
Verwenden Sie die REVOKE-Anweisung mit CREATE MODEL und EXECUTE, um Benutzern oder Gruppen diese Berechtigungen wieder zu entziehen. Weitere Informationen zu Befehlen für die Berechtigung finden Sie unter [GRANT](r_GRANT.md) und [REVOKE](r_REVOKE.md).
## Verwenden der Modellerklärbarkeit mit Amazon Redshift ML
Mit der Modellerklärbarkeit in Amazon Redshift ML verstehen Sie anhand von Werten für die Funktionsbedeutung, wie jedes Attribut in Ihren Trainingsdaten zum prognostizierten Ergebnis beiträgt.
Die Erklärbarkeit von Modellen hilft dabei, Ihre Machine-Learning-Modelle (ML) zu verbessern, indem die von den Modellen getätigten Prognosen näher erläutert werden. Die Erklärbarkeit des Modells hilft mit der Zuordnung von Funktionen zu erläutern, wie diese Modelle Prognosen erstellen.
Amazon Redshift ML nutzt die Erklärbarkeit von Modellen, um Amazon-Redshift-ML-Benutzern Funktionen zur Modellerklärung bereitzustellen. Weitere Informationen zur Erklärbarkeit von Modellen finden Sie unter [Was ist Fairness und Modellerklärbarkeit](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-fairness-and-explainability.html) von Vorhersagen für Machine Learning? im *Amazon SageMaker AI Developer Guide*.
Die Modellerklärbarkeit überwacht auch die Inferenzen, zu denen es bei in der Produktion eingesetzten Modellen kommt, auf eine Drift der Funktionszuordnung. Sie bietet auch Tools, mit denen Sie Modell-Governance-Berichte zur Information von Risiko- und Compliance-Teams sowie externer Aufsichtsbehörden erstellen können.
Wenn Sie bei der Verwendung der CREATE MODEL-Anweisung die Option AUTO ON oder AUTO OFF angeben, erstellt SageMaker AI nach Abschluss des Modelltrainingsjobs die Erklärungsausgabe. Sie können mithilfe der Funktion EXPLAIN\$1MODEL den Erklärbarkeitsbericht in einem JSON-Format abfragen. Weitere Informationen finden Sie unter [Machine-Learning-Funktionen](ml-function.md).
## Wahrscheinlichkeitsmetriken von Amazon Redshift ML
Bei Supervised-Learning-Problemen sind Klassen-Labels die Ergebnisse von Vorhersagen, die Eingabedaten verwenden. Wenn Sie beispielsweise ein Modell verwenden, um vorherzusagen, ob ein Kunde einen Streaming-Dienst erneut abonnieren wird, sind mögliche Labels „likely“ (wahrscheinlich) und „unlikely“ (unwahrscheinlich). Redshift ML bietet die Möglichkeit zur Verwendung von Wahrscheinlichkeitsmetriken, die jedem Label eine Wahrscheinlichkeit zuweisen, um die Wahrscheinlichkeit seines Eintretens anzugeben. Dies hilft Ihnen, fundiertere Entscheidungen auf der Grundlage der prognostizierten Ergebnisse zu treffen. In Amazon Redshift ML sind Wahrscheinlichkeitsmetriken verfügbar, wenn AUTO-ON-Modelle mit dem Problemtyp binäre Klassifikation oder Mehrklassen-Klassifizierung erstellt werden. Wenn Sie den Parameter AUTO ON weglassen, geht Redshift ML davon aus, dass für das Modell AUTO ON gelten sollte.
### Erstellen des Modells
Beim Erstellen eines Modells erkennt Amazon Redshift automatisch den Modelltyp und den Problemtyp. Wenn es sich um ein Klassifizierungsproblem handelt, erstellt Redshift automatisch eine zweite Inferenzfunktion, mit deren Hilfe Sie Wahrscheinlichkeiten in Relation zu den einzelnen Labels ausgeben können. Der Name dieser zweiten Inferenzfunktion ist der Name Ihrer angegebenen Inferenzfunktion, gefolgt von der Zeichenfolge `_probabilities`. Wenn Sie beispielsweise Ihre Inferenzfunktion als `customer_churn_predict` bezeichnen, lautet der Name der zweiten Inferenzfunktion `customer_churn_predict_probabilities`. Sie können diese Funktion dann abfragen, um die Wahrscheinlichkeiten der einzelnen Labels zu erhalten.
```
CREATE MODEL customer_churn_model
FROM customer_activity
PROBLEM_TYPE BINARY_CLASSIFICATION
TARGET churn
FUNCTION customer_churn_predict
IAM_ROLE {default}
AUTO ON
SETTINGS ( S3_BUCKET 'amzn-s3-demo-bucket'
```
### Abrufen von Wahrscheinlichkeiten
Wenn die Wahrscheinlichkeitsfunktion einsatzbereit ist, wird bei Ausführung des Befehls ein [SUPER-Typ](https://docs.aws.amazon.com/redshift/latest/dg/r_SUPER_type.html) zurückgegeben, der Arrays der zurückgegebenen Wahrscheinlichkeiten und der zugehörigen Labels enthält. Das Ergebnis `"probabilities" : [0.7, 0.3], "labels" : ["False.", "True."]` bedeutet beispielsweise, dass das Label „False“ (Falsch) eine Wahrscheinlichkeit von 0,7 und das Label „True“ (Wahr) eine Wahrscheinlichkeit von 0,3 aufweist.
```
SELECT customer_churn_predict_probabilities(Account_length, Area_code,
VMail_message, Day_mins, Day_calls, Day_charge,Eve_mins, Eve_calls,
Eve_charge, Night_mins, Night_calls, Night_charge,Intl_mins, Intl_calls,
Intl_charge, Cust_serv_calls)
FROM customer_activity;
customer_churn_predict_probabilities
--------------------
{"probabilities" : [0.7, 0.3], "labels" : ["False.", "True."]}
{"probabilities" : [0.8, 0.2], "labels" : ["False.", "True."]}
{"probabilities" : [0.75, 0.25], "labels" : ["True.", "False"]}
```
Die Arrays der Wahrscheinlichkeiten und Labels sind immer in absteigender Reihenfolge nach ihren Wahrscheinlichkeiten sortiert. Sie können eine Abfrage schreiben, die nur das prognostizierte Label mit der höchsten Wahrscheinlichkeit zurückgibt, indem Sie die Verschachtelung der von SUPER zurückgegebenen Ergebnisse der Wahrscheinlichkeitsfunktion aufheben.
```
SELECT prediction.labels[0], prediction.probabilities[0]
FROM (SELECT customer_churn_predict_probabilities(Account_length, Area_code,
VMail_message, Day_mins, Day_calls, Day_charge,Eve_mins, Eve_calls,
Eve_charge, Night_mins, Night_calls, Night_charge,Intl_mins, Intl_calls,
Intl_charge, Cust_serv_calls) AS prediction
FROM customer_activity);
labels | probabilities
-----------+--------------
"False." | 0.7
"False." | 0.8
"True." | 0.75
```
Um die Abfragen zu vereinfachen, können Sie die Ergebnisse der Vorhersagefunktion in einer Tabelle speichern.
```
CREATE TABLE churn_auto_predict_probabilities AS
(SELECT customer_churn_predict_probabilities(Account_length, Area_code,
VMail_message, Day_mins, Day_calls, Day_charge,Eve_mins, Eve_calls,
Eve_charge, Night_mins, Night_calls, Night_charge,Intl_mins,
Intl_calls, Intl_charge, Cust_serv_calls) AS prediction
FROM customer_activity);
```
Sie können die Tabelle mit den Ergebnissen abfragen, um nur Vorhersagen mit einer Wahrscheinlichkeit von mehr als 0,7 zurückzugeben.
```
SELECT prediction.labels[0], prediction.probabilities[0]
FROM churn_auto_predict_probabilities
WHERE prediction.probabilities[0] > 0.7;
labels | probabilities
-----------+--------------
"False." | 0.8
"True." | 0.75
```
Mithilfe der Indexnotation können Sie die Wahrscheinlichkeit eines bestimmten Labels ermitteln. Im folgenden Beispiel werden die Wahrscheinlichkeiten aller `True.`-Labels zurückgegeben.
```
SELECT label, index, p.prediction.probabilities[index]
FROM churn_auto_predict_probabilities p, p.prediction.labels AS label AT index
WHERE label='True.';
label | index | probabilities
---------+-------+---------------
"True." | 0 | 0.3
"True." | 0 | 0.2
"True." | 0 | 0.75
```
Im folgenden Beispiel werden alle Zeilen mit einem `True`-Label mit einer Wahrscheinlichkeit von mehr als 0,7 zurückgegeben, einem Hinweis dafür, dass der Kunde wahrscheinlich abwandern wird.
```
SELECT prediction.labels[0], prediction.probabilities[0]
FROM churn_auto_predict_probabilities
WHERE prediction.probabilities[0] > 0.7 AND prediction.labels[0] = "True.";
labels | probabilities
-----------+--------------
"True." | 0.75
```
# 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)
# Integration von Amazon Redshift ML mit Amazon Bedrock
In diesem Abschnitt wird die Verwendung der Integration von Amazon Redshift ML mit Amazon Bedrock beschrieben. Mit diesem Feature können Sie ein Amazon-Bedrock-Modell unter Verwendung von SQL aufrufen und Ihre Daten aus einem Data Warehouse in Amazon Redshift verwenden, um Anwendungen auf Basis von generativer KI zu erstellen, wie Textgenerierung, Stimmungsanalyse oder Übersetzung.
**Topics**
+ [Erstellen oder Aktualisieren einer IAM-Rolle für die Integration von Amazon Redshift ML mit Amazon Bedrock](#machine-learning-br-iam)
+ [Erstellen eines externen Modells für die Integration von Amazon Redshift ML mit Amazon Bedrock](#machine-learning-br-create)
+ [Verwenden eines externen Modells für die Integration von Amazon Redshift ML mit Amazon Bedrock](#machine-learning-br-use)
+ [Prompt-Engineering für die Integration von Amazon Redshift ML mit Amazon Bedrock](#machine-learning-br-prompt)
## Erstellen oder Aktualisieren einer IAM-Rolle für die Integration von Amazon Redshift ML mit Amazon Bedrock
In diesem Abschnitt wird gezeigt, wie Sie eine IAM-Rolle erstellen, die Sie für die Integration von Amazon Redshift ML mit Amazon Bedrock verwenden können.
Fügen Sie der IAM-Rolle, die Sie für die Integration von Amazon Redshift ML mit Amazon Bedrock verwenden, die folgende Richtlinie hinzu:
+ `AmazonBedrockFullAccess`
Fügen Sie der IAM-Rolle die folgende Vertrauensrichtlinie hinzu, damit Amazon Redshift die Rolle zur Interaktion mit anderen Services übernehmen kann.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"redshift.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
}
```
------
Wenn sich der Cluster oder Namespace in einer VPC befindet, folgen Sie den Anweisungen unter [Einrichtung für die Amazon-Redshift-ML-Administration in Cluster aufteilen und konfigurieren](getting-started-machine-learning.md#admin-setup).
Wenn Sie eine restriktivere Richtlinie benötigen, können Sie eine erstellen, die nur die auf den folgenden Seiten angegebenen Amazon-Bedrock-Berechtigungen umfasst:
+ [Einrichtung für die Amazon-Redshift-ML-Administration in Cluster aufteilen und konfigurieren](getting-started-machine-learning.md#admin-setup)
+ [ Für die Verwendung von Amazon Redshift Machine Learning (ML) erforderliche Berechtigungen](https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-iam-access-control-identity-based.html#iam-permission-ml?)
Weitere Informationen zum Erstellen von IAM-Rollen finden Sie unter [Erstellung einer IAM-Rolle](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create.html) im *AWS Identity and Access Management -Benutzerhandbuch*.
## Erstellen eines externen Modells für die Integration von Amazon Redshift ML mit Amazon Bedrock
In diesem Abschnitt wird gezeigt, wie Sie ein externes Modell erstellen, das als Schnittstelle für Amazon Bedrock in Ihrem Data Warehouse in Amazon Redshift verwendet werden kann.
Um ein Amazon-Bedrock-Modell von Amazon Redshift aus aufzurufen, müssen Sie zuerst den Befehl `CREATE EXTERNAL MODEL` ausführen. Dieser Befehl erstellt ein externes Modellobjekt in der Datenbank und eine zugehörige Benutzerfunktion, die Sie verwenden, um Textinhalte mit Amazon Bedrock zu generieren.
Das folgende Codebeispiel zeigt einen Basisbefehl `CREATE EXTERNAL MODEL`:
```
CREATE EXTERNAL MODEL llm_claude
FUNCTION llm_claude_func
IAM_ROLE ''
MODEL_TYPE BEDROCK
SETTINGS (
MODEL_ID 'anthropic.claude-v2:1',
PROMPT 'Summarize the following text:');
```
Der Befehl `CREATE EXTERNAL MODEL` verfügt über eine einheitliche und konsistente Schnittstelle zu Amazon Bedrock für alle Basismodelle (FM), die Nachrichten unterstützen. Dies ist die Standardoption, wenn Sie den Befehl `CREATE EXTERNAL MODEL` verwenden oder explizit den Anforderungstyp `UNIFIED` angeben. Weitere Informationen finden Sie in der [Converse-API-Dokumentation](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html) in der *Dokumentation zur Amazon-Bedrock-API*.
Wenn ein FM keine Nachrichten unterstützt, müssen Sie die Einstellung für `request_type` auf `RAW` setzen, wie im folgenden Beispiel zu sehen. Wenn Sie `request_type` auf `RAW` setzen, müssen Sie die an Amazon Bedrock gesendete Anforderung erstellen, wenn Sie die Inferenzfunktion auf der Grundlage des ausgewählten FM verwenden. Stellen Sie sicher, dass Sie den Zugriff auf das Modell Titan Text G1 – Express in Amazon Bedrock aktivieren, bevor Sie das folgende Beispiel ausführen.
```
CREATE EXTERNAL MODEL titan_raw
FUNCTION func_titan_raw
IAM_ROLE ''
MODEL_TYPE BEDROCK
SETTINGS (
MODEL_ID 'amazon.titan-text-express-v1',
REQUEST_TYPE RAW,
RESPONSE_TYPE SUPER);
```
Wenn Sie weitere Informationen zu einer Eingabeanforderung benötigen, z. B. die Gesamtzahl der Token, können Sie beim Erstellen des Modells `RESPONSE_TYPE` auf `super` setzen.
```
CREATE EXTERNAL MODEL patient_recommendations_v2
FUNCTION patient_recommendations_func_v2
IAM_ROLE ''
MODEL_TYPE BEDROCK
SETTINGS (
MODEL_ID 'anthropic.claude-v2',
PROMPT 'Generate personalized diet plan for following patient:',
RESPONSE_TYPE SUPER);
```
Der `PROMPT`-Parameter für den Befehl `CREATE EXTERNAL MODEL` ist ein statischer Prompt. Wenn Sie einen dynamischen Prompt für Ihre Anwendung benötigen, müssen Sie diesen angeben, wenn Sie die Inferenzfunktion verwenden. Weitere Details finden Sie unter [Prompt-Engineering für die Integration von Amazon Redshift ML mit Amazon Bedrock](#machine-learning-br-prompt).
Weitere Informationen zur Anweisung `CREATE EXTERNAL MODEL`, ihren Parametern und Einstellungen finden Sie unter [ERSTELLEN EINES EXTERNEN MODELLS](r_create_external_model.md).
## Verwenden eines externen Modells für die Integration von Amazon Redshift ML mit Amazon Bedrock
In diesem Abschnitt wird gezeigt, wie Sie ein externes Modell aufrufen, um Text als Antwort auf bereitgestellte Prompts zu generieren. Verwenden Sie die Inferenzfunktion, die Sie mit `CREATE EXTERNAL MODEL` erstellen, um ein externes Modell aufzurufen.
**Topics**
+ [Inferenz mit Modellen des Anforderungstyps `UNIFIED`](#machine-learning-br-use-unified)
+ [Inferenz mit Modellen des Anforderungstyps `RAW`](#machine-learning-br-use-raw)
+ [Inferenzfunktionen als reine Leader-Funktionen](#machine-learning-br-use-leader)
+ [Nutzungshinweise für die Inferenzfunktion](#machine-learning-br-use-usage)
### Inferenz mit Modellen des Anforderungstyps `UNIFIED`
Die Inferenzfunktion für Modelle mit dem Anforderungstyp `UNIFIED` verfügt über die folgenden drei Parameter, die der Reihe nach an die Funktion übergeben werden:
+ **Eingabetext** (erforderlich): Dieser Parameter gibt den Eingabetext an, den Amazon Redshift an Amazon Bedrock weitergibt.
+ **Inferenzkonfiguration** und **Zusätzliche Felder für Modellanfragen** (optional): Amazon Redshift übergibt diese Parameter an die entsprechenden Parameter für die Converse-Modell-API.
Das folgende Codebeispiel veranschaulicht die Verwendung einer Inferenzfunktion vom Typ `UNIFIED`.
```
SELECT llm_claude_func(input_text, object('temperature', 0.7, 'maxtokens', 500))
FROM some_data;
```
### Inferenz mit Modellen des Anforderungstyps `RAW`
Die Inferenzfunktion für Modelle mit Anforderungstyp `RAW` verfügt nur über einen Parameter des Datentyps `SUPER`. Die Syntax dieses Parameters hängt vom verwendeten Amazon-Bedrock-Modell ab.
Das folgende Codebeispiel veranschaulicht die Verwendung einer Inferenzfunktion vom Typ `RAW`.
```
SELECT llm_titan_func(
object(
"inputText", "Summarize the following text: " | input_text,
"textGenerationConfig", object("temperature", 0.5, "maxTokenCount", 500)
)
)
FROM some_data;
```
### Inferenzfunktionen als reine Leader-Funktionen
Inferenzfunktionen für Amazon-Bedrock-Modelle können als reine Leader-Knotenfunktionen ausgeführt werden, wenn die Abfrage, die sie verwendet, keine Tabellen referenziert. Dies kann hilfreich sein, wenn Sie einem LLM schnell eine Frage stellen möchten.
Das folgende Codebeispiel veranschaulicht die Verwendung einer reinen Leader-Inferenzfunktion:
```
SELECT general_titan_llm_func('Summarize the benefits of LLM on data analytics in 100 words');
```
### Nutzungshinweise für die Inferenzfunktion
Beachten Sie Folgendes, wenn Sie Inferenzfunktionen mit der Integration von Amazon Redshift ML mit Amazon Bedrock verwenden:
+ Bei den Namen der Parameter für alle Amazon-Bedrock-Modelle wird zwischen Groß- und Kleinschreibung unterschieden. Wenn Ihre Parameter nicht den vom Modell geforderten Parametern entsprechen, werden sie von Amazon Bedrock möglicherweise stillschweigend ignoriert.
+ Der Durchsatz von Inferenzabfragen wird durch die Laufzeitkontingente der verschiedenen Modelle begrenzt, die von Amazon Bedrock in verschiedenen Regionen angeboten werden. Weitere Informationen finden Sie unter [Kontingente für Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/quotas.html) im *Amazon-Bedrock-Benutzerhandbuch*.
+ Wenn Sie einen garantierten und konsistenten Durchsatz benötigen, sollten Sie in Betracht ziehen, für das von Ihnen benötigte Modell bereitgestellten Durchsatz von Amazon Bedrock zu nutzen. Weitere Informationen finden Sie unter [Erhöhen der Modellaufruf-Kapazität mit bereitgestelltem Durchsatz in Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/prov-throughput.html) im *Amazon-Bedrock-Benutzerhandbuch*.
+ Bei Inferenzabfragen mit großen Datenmengen kann es zu Drosselungsausnahmen kommen. Dies liegt an den begrenzten Laufzeitkontingenten für Amazon Bedrock. Amazon Redshift versucht Anforderungen mehrmals erneut, doch Abfragen können dennoch gedrosselt werden, da der Durchsatz für nicht bereitgestellte Modelle variabel sein kann.
+ Wenn Sie auf Drosselungsausnahmen von Amazon Bedrock, wie z. B. `Too many requests, please wait before trying again.`, auch bei kleinen Datenmengen stoßen, überprüfen Sie die Kontingente unter **Service Quotas** in Ihrem Amazon-Bedrock-Konto. Vergewissern Sie sich, dass das angewendete Kontingent auf Kontoebene mindestens dem AWS Standardkontingentwert für die **InvokeModel**Anfragen für das von Ihnen verwendete Modell entspricht.
## Prompt-Engineering für die Integration von Amazon Redshift ML mit Amazon Bedrock
In diesem Abschnitt wird die Verwendung von statischen Prompts mit einem externen Modell erläutert.
Um statische Präfix- und Suffix-Prompts für Ihr externes Modell zu verwenden, geben Sie diese über die Parameter `PROMPT` und `SUFFIX` der Anweisung `CREATE EXTERNAL MODEL` an. Diese Prompts werden jeder Abfrage hinzugefügt, die das externe Modell verwendet.
Im folgenden Beispiel wird gezeigt, wie Sie einem externen Modell Präfix- und Suffix-Prompts hinzufügen:
```
CREATE EXTERNAL MODEL llm_claude
FUNCTION llm_claude_func
IAM_ROLE ''
MODEL_TYPE BEDROCK
SETTINGS (
MODEL_ID 'anthropic.claude-v2:1',
PROMPT 'Summarize the following text:',
SUFFIX 'Respond in an analytic tone');
```
Um dynamische Prompts zu verwenden, können Sie diese bei der Verwendung der Inferenzfunktion angeben, indem Sie sie in der Funktionseingabe verketten. Das folgende Beispiel veranschaulicht die Verwendung von dynamischen Prompts mit einer Inferenzfunktion:
```
SELECT llm_claude_func('Summarize the following review:' | input_text | 'The review should have formal tone.')
FROM some_data
```