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

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

# Tutorial: Erstellen von Regressionsmodellen
<a name="tutorial_regression"></a>

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
<a name="tutorial_regression_tasks"></a>

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
<a name="tutorial_regression_prereqs"></a>

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

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

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)
<a name="tutorial_regression_view_data"></a>

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)
<a name="tutorial_regression_show_correlation"></a>

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
<a name="tutorial_regression_create_model"></a>

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
<a name="tutorial_regression_step_validate"></a>

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
<a name="tutorial_regression_related_topics"></a>

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

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