Tutorial: Erstellen von Regressionsmodellen mit linearem Lernen

PDFRSS

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 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 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 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, 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 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, 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
   );

2. Die folgende Abfrage kopiert die Beispieldaten aus dem Abalone-Datensatz 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';

3. 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 |
   +-----+--------------------+

2. Verwenden Sie die folgende Abfrage, um die Operation EXPLAIN_MODEL für Ihre Prognosefunktion auszuführen. Die Operation gibt einen Modellerklärbarkeitsbericht zurück. Weitere Informationen über die Operation EXPLAIN_MODEL finden Sie unter Funktion EXPLAIN_MODEL 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_MODEL 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" 
   };

3. 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

• Operation CREATE MODEL

• Funktion EXPLAIN_MODEL

Weitere Informationen über Machine Learning finden Sie in der folgenden Dokumentation:

• Übersicht zum Machine Learning

• Machine Learning für Anfänger und Experten

• Was ist Fairness und Modellerklärbarkeit für Prognosen mit Machine Learning?