这是本节的多页打印视图。点击此处打印.

转换函数

1: APPLY_BISECTING_KMEANS
2: APPLY_IFOREST
3: APPLY_INVERSE_PCA
4: APPLY_INVERSE_SVD
5: APPLY_KMEANS
6: APPLY_NORMALIZE
7: APPLY_ONE_HOT_ENCODER
8: APPLY_PCA
9: APPLY_SVD
10: PREDICT_AUTOREGRESSOR
11: PREDICT_LINEAR_REG
12: PREDICT_LOGISTIC_REG
13: PREDICT_MOVING_AVERAGE
14: PREDICT_NAIVE_BAYES
15: PREDICT_NAIVE_BAYES_CLASSES
16: PREDICT_PMML
17: PREDICT_RF_CLASSIFIER
18: PREDICT_RF_CLASSIFIER_CLASSES
19: PREDICT_RF_REGRESSOR
20: PREDICT_SVM_CLASSIFIER
21: PREDICT_SVM_REGRESSOR
22: PREDICT_TENSORFLOW
23: PREDICT_XGB_CLASSIFIER
24: PREDICT_XGB_CLASSIFIER_CLASSES
25: PREDICT_XGB_REGRESSOR
26: REVERSE_NORMALIZE

机器学习 API 包括一组 UDx 函数，这些函数将每个输入行的列转换为一个或多个对应的输出列。这些转换遵循之前创建的模型中定义的规则。例如， APPLY_SVD 使用 SVD 模型来转换输入数据。

除非另有说明，否则这些函数要求非超级用户具有以下权限：

模型上的 USAGE 权限
对输入关系的 SELECT 权限

通常，给定无效的输入行，这些函数的返回值为 NULL。

1 - APPLY_BISECTING_KMEANS

将已训练的二分 k-means 模型应用于输入关系，并将每个新数据点分配给已训练模型中最接近的匹配群集。

注意

如果输入关系在 Hive 中定义，请使用 SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。

语法

SELECT APPLY_BISECTING_KMEANS( 'input-columns'
        USING PARAMETERS model_name = 'model-name'
            [, num_clusters = 'num-clusters']
            [, match_by_pos = match‑by‑position] ] )

参数

input‑columns: 输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。输入列的数据类型必须为数字。

参数

model_name

模型的名称（不区分大小写）。

num_clusters

介于 1 和 k 之间的整数（包含），其中 k 为模型中的中心数，指定用于预测的群集数。

默认值： 模型为 k 指定的值

match_by_pos

该布尔值指定输入列如何与模型特征匹配：

false （默认值）：按名称匹配。
true：按输入列列表中列的位置匹配。

特权

非超级用户：模型所有者或模型的使用权限

2 - APPLY_IFOREST

将隔离森林 (iForest) 模型应用于输入关系。对于每个输入行，该函数返回包含两个字段的输出行：

anomaly_score：浮点值，表示模型中所有树的平均路径长度，按训练样本大小标准化。
is_anomaly：布尔值，指示输入行是否异常。当 anomaly_score 等于或大于给定阈值时，此值为 true；否则，此值为 false。

语法

APPLY_IFOREST( input‑columns USING PARAMETERS param=value[,...] )

参数

input‑columns: 输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。列类型必须与 model_name 中的预测变量类型匹配。

参数

model_name

模型的名称（不区分大小写）。

threshold

可选。(0.0, 1.0) 范围内的浮点数，指定确定数据点是否为异常的阈值。如果一个数据点的 anomaly_score 等于或大于 threshold 的值，则该数据点被标记为异常值。

或者，您可以指定一个 contamination 值，该值设置一个阈值，其中标记为异常值的训练数据点的百分比约等于 contamination 的值。您不能在同一个函数调用中同时设置 contamination 和 threshold。

默认值： 0.7

match_by_pos

可选。指定输入列如何与模型列匹配的布尔值：

false：按名称匹配。
true：按输入列列表中列的位置匹配。

默认值：false

contamination

可选。(0.0, 1.0) 范围内的浮点数，训练数据中被标记为异常值的数据点的近似比率。该函数根据此 contamination 值计算阈值。如果不设置此参数，该函数将使用指定或默认的 threshold 值标记异常值。

您不能在同一个函数调用中同时设置 contamination 和 threshold。

特权

非超级用户：

模型上的 USAGE 权限
对输入关系的 SELECT 权限

示例

以下示例演示了不同的 threshold 值如何影响对输入关系的异常值检测：

=> SELECT * FROM (SELECT first_name, last_name, APPLY_IFOREST(team, hr, hits, avg, salary USING PARAMETERS model_name='baseball_anomalies',
   threshold=0.75) AS predictions FROM baseball) AS outliers WHERE predictions.is_anomaly IS true;
 first_name | last_name |                      predictions
------------+-----------+-------------------------------------------------------
 Jacqueline | Richards  | {"anomaly_score":0.777757463074347,"is_anomaly":true}
(1 row)

=> SELECT * FROM (SELECT first_name, last_name, APPLY_IFOREST(team, hr, hits, avg, salary USING PARAMETERS model_name='baseball_anomalies',
   threshold=0.55) AS predictions FROM baseball) AS outliers WHERE predictions.is_anomaly IS true;
 first_name | last_name |                      predictions
------------+-----------+--------------------------------------------------------
 Jacqueline | Richards  | {"anomaly_score":0.777757463074347,"is_anomaly":true}
 Debra      | Hall      | {"anomaly_score":0.5714649698133808,"is_anomaly":true}
 Gerald     | Fuller    | {"anomaly_score":0.5980549926114661,"is_anomaly":true}
(3 rows)

您还可以使用不同的 contamination 值来更改异常值阈值：

=> SELECT * FROM (SELECT first_name, last_name, APPLY_IFOREST(team, hr, hits, avg, salary USING PARAMETERS model_name='baseball_anomalies',
   contamination = 0.1) AS predictions FROM baseball) AS outliers WHERE predictions.is_anomaly IS true;
 first_name | last_name |                      predictions
------------+-----------+--------------------------------------------------------
 Marie      | Fields    | {"anomaly_score":0.5307715717521868,"is_anomaly":true}
 Jacqueline | Richards  | {"anomaly_score":0.777757463074347,"is_anomaly":true}
 Debra      | Hall      | {"anomaly_score":0.5714649698133808,"is_anomaly":true}
 Gerald     | Fuller    | {"anomaly_score":0.5980549926114661,"is_anomaly":true}
(4 rows)

=> SELECT * FROM (SELECT first_name, last_name, APPLY_IFOREST(team, hr, hits, avg, salary USING PARAMETERS model_name='baseball_anomalies',
   contamination = 0.01) AS predictions FROM baseball) AS outliers WHERE predictions.is_anomaly IS true;
 first_name | last_name |                      predictions
------------+-----------+--------------------------------------------------------
 Jacqueline | Richards  | {"anomaly_score":0.777757463074347,"is_anomaly":true}
 Debra      | Hall      | {"anomaly_score":0.5714649698133808,"is_anomaly":true}
 Gerald     | Fuller    | {"anomaly_score":0.5980549926114661,"is_anomaly":true}
(3 rows)

另请参阅

3 - APPLY_INVERSE_PCA

将 APPLY_PCA 生成的转换反转回原始坐标系。

语法

APPLY_INVERSE_PCA ( input‑columns
        USING PARAMETERS model_name = 'model‑name'
            [, exclude_columns = 'excluded‑columns']
            [, key_columns = 'key‑columns'] )

参数

input‑columns

输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。需要满足以下要求：

所有列都必须为数字数据类型。
如果列名包含特殊字符，请用双引号将其括起来。

参数

model_name: 模型的名称（不区分大小写）。
exclude_columns: input-columns 中要排除在处理范围之外的列名的逗号分隔列表。
key_columns: 来自 input‑columns 的列名称的逗号分隔列表，用于标识其数据行。这些列包含在输出表中。

示例

以下示例显示了如何使用 APPLY_INVERSE_PCA 函数。它显示了第一条记录的输出。


=> SELECT PCA ('pcamodel', 'world','country,HDI,em1970,em1971,em1972,em1973,em1974,em1975,em1976,em1977,
em1978,em1979,em1980,em1981,em1982,em1983,em1984 ,em1985,em1986,em1987,em1988,em1989,em1990,em1991,em1992,
em1993,em1994,em1995,em1996,em1997,em1998,em1999,em2000,em2001,em2002,em2003,em2004,em2005,em2006,em2007,
em2008,em2009,em2010,gdp1970,gdp1971,gdp1972,gdp1973,gdp1974,gdp1975,gdp1976,gdp1977,gdp1978,gdp1979,gdp1980,
gdp1981,gdp1982,gdp1983,gdp1984,gdp1985,gdp1986,gdp1987,gdp1988,gdp1989,gdp1990,gdp1991,gdp1992,gdp1993,
gdp1994,gdp1995,gdp1996,gdp1997,gdp1998,gdp1999,gdp2000,gdp2001,gdp2002,gdp2003,gdp2004,gdp2005,gdp2006,
gdp2007,gdp2008,gdp2009,gdp2010' USING PARAMETERS exclude_columns='HDI,country');
PCA
---------------------------------------------------------------
Finished in 1 iterations.
Accepted Rows: 96  Rejected Rows: 0
(1 row)
=> CREATE TABLE worldPCA AS SELECT
APPLY_PCA (HDI,country,em1970,em1971,em1972,em1973,em1974,em1975,em1976,em1977,em1978,em1979,
em1980,em1981,em1982,em1983,em1984 ,em1985,em1986,em1987,em1988,em1989,em1990,em1991,em1992,em1993,em1994,
em1995,em1996,em1997,em1998,em1999,em2000,em2001,em2002,em2003,em2004,em2005,em2006,em2007,em2008,em2009,
em2010,gdp1970,gdp1971,gdp1972,gdp1973,gdp1974,gdp1975,gdp1976,gdp1977,gdp1978,gdp1979,gdp1980,gdp1981,gdp1982,
gdp1983,gdp1984,gdp1985,gdp1986,gdp1987,gdp1988,gdp1989,gdp1990,gdp1991,gdp1992,gdp1993,gdp1994,gdp1995,
gdp1996,gdp1997,gdp1998,gdp1999,gdp2000,gdp2001,gdp2002,gdp2003,gdp2004,gdp2005,gdp2006,gdp2007,gdp2008,
gdp2009,gdp2010 USING PARAMETERS model_name='pcamodel', exclude_columns='HDI, country', key_columns='HDI,
country',cutoff=.3)OVER () FROM world;
CREATE TABLE

=> SELECT * FROM worldPCA;
HDI   |       country       |       col1
------+---------------------+-------------------
0.886 | Belgium             |  79002.2946705704
0.699 | Belize              | -25631.6670012556
0.427 | Benin               | -40373.4104598122
0.805 | Chile               | -16805.7940082156
0.687 | China               | -37279.2893141103
0.744 | Costa Rica          | -19505.5631231635
0.4   | Cote d'Ivoire       | -38058.2060339272
0.776 | Cuba                | -23724.5779612041
0.895 | Denmark             |  117325.594028813
0.644 | Egypt               | -34609.9941604549
...
(96 rows)

=> SELECT APPLY_INVERSE_PCA (HDI, country, col1
    USING PARAMETERS model_name = 'pcamodel', exclude_columns='HDI,country',
    key_columns = 'HDI, country') OVER () FROM worldPCA;
HDI  |       country       |      em1970       |      em1971       |      em1972      |      em1973      |
      em1974      |      em1975       |      em1976|      em1977      |      em1978       |      em1979
   |      em1980       |      em1981      |      em1982       |      em1983       |      em1984       |em1985
|      em1986       |      em1987       |      em1988       |      em1989      |      em1990      |      em1991
|      em1992       |      em1993|      em1994      |      em1995       |      em1996       |      em1997
    |      em1998       |      em1999       |      em2000       |      em2001       |em2002       |
em2003      |      em2004       |      em2005      |      em2006       |      em2007       |      em2008
|      em2009      |      em2010       |     gdp1970      |     gdp1971      |     gdp1972      |     gdp1973
|     gdp1974      |     gdp1975      |     gdp1976      |     gdp1977      |gdp1978      |     gdp1979
 |     gdp1980      |     gdp1981      |     gdp1982      |     gdp1983      |     gdp1984      |     gdp1985
      |     gdp1986|    gdp1987      |     gdp1988      |     gdp1989      |     gdp1990      |     gdp1991
     |     gdp1992      |     gdp1993      |     gdp1994      |     gdp1995      |     gdp1996      |
gdp1997      |     gdp1998      |     gdp1999      |     gdp2000      |     gdp2001      |     gdp2002
|     gdp2003      |gdp2004      |     gdp2005      |     gdp2006      |     gdp2007      |     gdp2008
  |     gdp2009      |     gdp2010
-------+---------------------+-------------------+-------------------+------------------+------------------
+------------------+-------------------+------------------+------------------+-------------------+---------
----------+-------------------+------------------+-------------------+-------------------+-----------------
--+------------------+-------------------+-------------------+-------------------+------------------+-------
-----------+------------------+-------------------+-------------------+------------------+------------------
-+-------------------+------------------+-------------------+-------------------+-------------------+-------
------------+--------------------+------------------+-------------------+------------------+----------------
---+-------------------+-------------------+------------------+-------------------+------------------+------
------------+------------------+------------------+------------------+------------------+------------------+
------------------+------------------+------------------+------------------+------------------+-------------
-----+------------------+------------------+------------------+------------------+------------------+-------
-----------+------------------+------------------+------------------+------------------+------------------+-
-----------------+------------------+------------------+------------------+------------------+--------------
----+------------------+------------------+------------------+------------------+------------------+--------
----------+------------------+------------------+------------------+------------------+------------------
0.886 | Belgium             |  18585.6613572407 | -16145.6374560074 |  26938.956253415 | 8094.30475779595 |
 12073.5461203817 | -11069.0567600181 | 19133.8584911727|   5500.312894949 | -4227.94863799987 |  6265.77925410752
|  -10884.749295608 | 30929.4669575201 | -7831.49439429977 |  3235.81760508742 | -22765.9285442662 | 27200
.6767714485 | -10554.9550160917 |   1169.4144482273 | -16783.7961289161 | 27932.2660829329 | 17227.9083196848
| 13956.0524012749 | -40175.6286481088 | -10889.4785920499 | 22703.6576872859 | -14635.5832197402 |
2857.12270512168 | 20473.5044214494 | -52199.4895696423 | -11038.7346460738 |  18466.7298633088 | -17410.4225137703 |
-3475.63826305462 | 29305.6753822341 |   1242.5724942049 | 17491.0096310849 | -12609.9984515902 | -17909.3603476248
|  6276.58431412381 | 21851.9475485178 | -2614.33738160397 | 3777.74134131349 | 4522.08854282736 | 4251.90446379366
| 4512.15101396876 | 4265.49424538129 | 5190.06845330997 | 4543.80444817989 | 5639.81122679089 | 4420.44705213467
|  5658.8820279283 | 5172.69025294376 | 5019.63640408663 | 5938.84979495903 | 4976.57073629812 | 4710.49525137591
| 6523.65700286465 | 5067.82520773578 | 6789.13070219317 | 5525.94643553563 | 6894.68336419297 | 5961.58442474331
| 5661.21093840818 | 7721.56088518218 |  5959.7301109143 | 6453.43604137202 | 6739.39384033096 | 7517.97645468455
| 6907.49136910647 | 7049.03921764209 | 7726.49091035527 | 8552.65909911844 | 7963.94487647115 | 7187.45827585515
| 7994.02955410523 | 9532.89844418041 | 7962.25713582666 | 7846.68238907624 | 10230.9878908643 | 8642.76044946519
| 8886.79860331866 |  8718.3731386891
...
(96 rows)

另请参阅

4 - APPLY_INVERSE_SVD

将数据转换回原始域。这实质上是通过将三个矩阵相乘来计算原始数据的近似版本：矩阵 U（此函数的输入）、矩阵 S 和 V（存储在模型中）。

语法

APPLY_INVERSE_SVD ( 'input‑columns'
        USING PARAMETERS model_name = 'model‑name'
            [, match_by_pos = match‑by‑position]
            [, exclude_columns = 'excluded‑columns']
            [, key_columns = 'key‑columns'] )

参数

input‑columns

输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。需要满足以下要求：

所有列都必须为数字数据类型。
如果列名包含特殊字符，请用双引号将其括起来。

参数

model_name

模型的名称（不区分大小写）。

match_by_pos

该布尔值指定输入列如何与模型特征匹配：

false （默认值）：按名称匹配。
true：按输入列列表中列的位置匹配。

exclude_columns

input-columns 中要排除在处理范围之外的列名的逗号分隔列表。

key_columns

来自 input‑columns 的列名称的逗号分隔列表，用于标识其数据行。这些列包含在输出表中。

示例

=> SELECT SVD ('svdmodel', 'small_svd', 'x1,x2,x3,x4');
SVD
--------------------------------------------------------------
Finished in 1 iterations.
Accepted Rows: 8  Rejected Rows: 0
(1 row)

=> CREATE TABLE transform_svd AS SELECT
     APPLY_SVD (id, x1, x2, x3, x4 USING PARAMETERS model_name='svdmodel', exclude_columns='id', key_columns='id')
     OVER () FROM small_svd;
CREATE TABLE

=> SELECT * FROM transform_svd;
id  |       col1        |        col2         |        col3         |        col4
----+-------------------+---------------------+---------------------+--------------------
4   |  0.44849499240202 |  -0.347260956311326 |   0.186958376368345 |  0.378561270493651
6   |  0.17652411036246 | -0.0753183783382909 |  -0.678196192333598 | 0.0567124770173372
1   | 0.494871802886819 |   0.161721379259287 |  0.0712816417153664 | -0.473145877877408
2   |  0.17652411036246 | -0.0753183783382909 |  -0.678196192333598 | 0.0567124770173372
3   | 0.150974762654569 |   0.589561842046029 | 0.00392654610109522 |  0.360011163271921
5   | 0.494871802886819 |   0.161721379259287 |  0.0712816417153664 | -0.473145877877408
8   |  0.44849499240202 |  -0.347260956311326 |   0.186958376368345 |  0.378561270493651
7   | 0.150974762654569 |   0.589561842046029 | 0.00392654610109522 |  0.360011163271921
(8 rows)

=> SELECT APPLY_INVERSE_SVD (* USING PARAMETERS model_name='svdmodel', exclude_columns='id',
key_columns='id') OVER () FROM transform_svd;
id  |        x1        |        x2        |        x3        |        x4
----+------------------+------------------+------------------+------------------
4 | 91.4056627665577 | 44.7629617207482 | 83.1704961993117 | 38.9274292265543
6 | 20.6468626294368 | 9.30974906868751 | 8.71006863405534 |  6.5855928603967
7 | 31.2494347777156 | 20.6336519003026 | 27.5668287751507 | 5.84427645886865
1 |  107.93376580719 | 51.6980548011917 | 97.9665796560552 | 40.4918236881051
2 | 20.6468626294368 | 9.30974906868751 | 8.71006863405534 |  6.5855928603967
3 | 31.2494347777156 | 20.6336519003026 | 27.5668287751507 | 5.84427645886865
5 |  107.93376580719 | 51.6980548011917 | 97.9665796560552 | 40.4918236881051
8 | 91.4056627665577 | 44.7629617207482 | 83.1704961993117 | 38.9274292265543
(8 rows)

另请参阅

5 - APPLY_KMEANS

按照已知 k-means 模型将输入关系的每一行分配给一个群集中心。

语法

APPLY_KMEANS ( input‑columns
       USING PARAMETERS model_name = 'model‑name' [, match_by_pos = match‑by‑position] )

参数

input‑columns: 输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。

参数

model_name

模型的名称（不区分大小写）。

match_by_pos

该布尔值指定输入列如何与模型特征匹配：

false （默认值）：按名称匹配。
true：按输入列列表中列的位置匹配。

特权

非超级用户：模型所有者或模型的使用权限

示例

以下示例创建 k-means 模型 myKmeansModel 并将其应用于输入表 iris1。APPLY_KMEANS 的调用混合了列名和常量。当传递一个常量代替列名称时，该常量将替换该列在所有行中的值：

=> SELECT KMEANS('myKmeansModel', 'iris1', '*', 5
USING PARAMETERS max_iterations=20, output_view='myKmeansView', key_columns='id', exclude_columns='Species, id');
           KMEANS
----------------------------
 Finished in 12 iterations

(1 row)
=> SELECT id, APPLY_KMEANS(Sepal_Length, 2.2, 1.3, Petal_Width
USING PARAMETERS model_name='myKmeansModel', match_by_pos='true') FROM iris2;
 id  | APPLY_KMEANS
-----+--------------
   5 |            1
  10 |            1
  14 |            1
  15 |            1
  21 |            1
  22 |            1
  24 |            1
  25 |            1
  32 |            1
  33 |            1
  34 |            1
  35 |            1
  38 |            1
  39 |            1
  42 |            1
...
 (60 rows)

另请参阅

6 - APPLY_NORMALIZE

UDTF 函数，用于将保存在模型中的标准化参数应用于一组指定的输入列。如果函数中指定的任何列不在模型中，则其数据都会原封不动地传递到 APPLY_NORMALIZE。

注意

注意： 如果一列仅包含一个不同的值，则 APPLY_NORMALIZE 为该列中的值返回 NaN。

语法

APPLY_NORMALIZE ( input‑columns USING PARAMETERS model_name = 'model‑name');

参数

input‑columns: 输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。如果您提供星号，APPLY_NORMALIZE 会规范化模型中的所有列。

参数

model_name: 模型的名称（不区分大小写）。

示例

以下示例使用表 mtcars 中的 wt 和 hp 列创建具有 NORMALIZE_FIT 的模型，然后在对 APPLY_NORMALIZE 和 REVERSE_NORMALIZE 的连续调用中使用此模型。

=> SELECT NORMALIZE_FIT('mtcars_normfit', 'mtcars', 'wt,hp', 'minmax');
NORMALIZE_FIT
---------------
Success
(1 row)

以下对 APPLY_NORMALIZE 的调用指定表 mtcars 中的 hp 和 cyl 列，其中 hp 在标准化模型中，而 cyl 不在标准化模型中：

=> CREATE TABLE mtcars_normalized AS SELECT APPLY_NORMALIZE (hp, cyl USING PARAMETERS model_name = 'mtcars_normfit') FROM mtcars;
CREATE TABLE
=> SELECT * FROM mtcars_normalized;
          hp        | cyl
--------------------+-----
  0.434628975265018 | 8
  0.681978798586572 | 8
  0.434628975265018 | 6
                  1 | 8
  0.540636042402827 | 8
                  0 | 4
  0.681978798586572 | 8
 0.0459363957597173 | 4
  0.434628975265018 | 8
  0.204946996466431 | 6
  0.250883392226148 | 6
  0.049469964664311 | 4
  0.204946996466431 | 6
  0.201413427561837 | 4
  0.204946996466431 | 6
  0.250883392226148 | 6
  0.049469964664311 | 4
  0.215547703180212 | 4
 0.0353356890459364 | 4
  0.187279151943463 | 6
  0.452296819787986 | 8
  0.628975265017668 | 8
  0.346289752650177 | 8
  0.137809187279152 | 4
  0.749116607773852 | 8
  0.144876325088339 | 4
  0.151943462897526 | 4
  0.452296819787986 | 8
  0.452296819787986 | 8
  0.575971731448763 | 8
  0.159010600706714 | 4
  0.346289752650177 | 8
(32 rows)

=> SELECT REVERSE_NORMALIZE (hp, cyl USING PARAMETERS model_name='mtcars_normfit') FROM mtcars_normalized;
  hp | cyl
-----+-----
 175 | 8
 245 | 8
 175 | 6
 335 | 8
 205 | 8
  52 | 4
 245 | 8
  65 | 4
 175 | 8
 110 | 6
 123 | 6
  66 | 4
 110 | 6
 109 | 4
 110 | 6
 123 | 6
  66 | 4
 113 | 4
  62 | 4
 105 | 6
 180 | 8
 230 | 8
 150 | 8
  91 | 4
 264 | 8
  93 | 4
  95 | 4
 180 | 8
 180 | 8
 215 | 8
  97 | 4
 150 | 8
(32 rows)

以下对 REVERSE_NORMALIZE 的调用还指定了表 mtcars 中的 hp 和 cyl 列，其中 hp 在标准化模型 mtcars_normfit 中，而 cyl 不在标准化模型中。

=> SELECT REVERSE_NORMALIZE (hp, cyl USING PARAMETERS model_name='mtcars_normfit') FROM mtcars_normalized;
       hp        | cyl
-----------------+-----
205.000005722046 |   8
150.000000357628 |   8
150.000000357628 |   8
93.0000016987324 |   4
 174.99999666214 |   8
94.9999992102385 |   4
214.999997496605 |   8
97.0000009387732 |   4
245.000006556511 |   8
 174.99999666214 |   6
             335 |   8
245.000006556511 |   8
62.0000002086163 |   4
 174.99999666214 |   8
230.000002026558 |   8
              52 |   4
263.999997675419 |   8
109.999999523163 |   6
123.000002324581 |   6
64.9999996386468 |   4
66.0000005029142 |   4
112.999997898936 |   4
109.999999523163 |   6
180.000000983477 |   8
180.000000983477 |   8
108.999998658895 |   4
109.999999523163 |   6
104.999999418855 |   6
123.000002324581 |   6
180.000000983477 |   8
66.0000005029142 |   4
90.9999999701977 |   4
(32 rows)

另请参阅

7 - APPLY_ONE_HOT_ENCODER

用户定义的转换函数 (UDTF)，用于加载独热编码器模型并写出包含编码列的表。

语法

APPLY_ONE_HOT_ENCODER( input‑columns
        USING PARAMETERS model_name = 'model‑name'
            [, drop_first = 'is‑first']
            [, ignore_null = 'ignore']
            [, separator = 'separator‑character']
            [, column_naming = 'name‑output']
            [, null_column_name = 'null‑column‑name'] )

参数

input‑columns: 输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。

参数

model_name

模型的名称（不区分大小写）。

存储类别及其对应的级别。

drop_first

布尔值，可以是以下值之一：

true （默认值）：将分类变量的第一个级别视为引用级别。
false：分类变量的每个级别都在输出视图中具有对应的列

ignore_null

布尔值，可以是以下值之一：

true （默认值）：Null 值将所有对应的 one-hot 二进制列设置为 null。
false：将 input-columns 中的 Null 值视为分类级别

separator

在输出表中用于分隔输入变量名称和指示变量级别的字符。要避免使用任何分隔符，可将此参数设置为 null 值。

默认值： 下划线 (_)

column_naming

根据指定的方法将分类级别附加到列名：

indices （默认值）：使用整数索引来表示分类级别。
values/values_relaxed：两种方法都使用分类级别名称。如果出现重复的列名称，该函数会尝试通过附加 _n 来消除其歧义，其中 n 是从零开始的整数索引（_0、_1、...）。

如果该函数无法生成唯一的列名称，它将根据所选的方法来处理：
- values 返回错误。
- values_relaxed 恢复使用索引。

重要

如果 column_naming 设置为 values 或 values_relaxed，则以下列命名规则适用：

超过 128 个字符的输入列名称会被截断。
列名可以包含特殊字符。
如果参数 ignore_null 设置为 true，则 APPLY_ONE_HOT_ENCODER 根据参数 null_column_name 中设置的值构造列名。如果省略此参数，则使用字符串 null。

null_column_name

用于命名 null 值指示列的字符串，仅在 ignore_null 设置为 false 且 column_naming 设置为 values 或 values_relaxed 时使用。

默认值： null

注意

注意： 如果输入行包含模型中未存储的级别，则与该分类级别对应的输出行列将作为 null 值返回。

示例

=> SELECT APPLY_ONE_HOT_ENCODER(cyl USING PARAMETERS model_name='one_hot_encoder_model',
drop_first='true', ignore_null='false') FROM mtcars;
cyl | cyl_1 | cyl_2
----+-------+-------
8   |     0 |     1
4   |     0 |     0
4   |     0 |     0
8   |     0 |     1
8   |     0 |     1
8   |     0 |     1
4   |     0 |     0
8   |     0 |     1
8   |     0 |     1
4   |     0 |     0
8   |     0 |     1
6   |     1 |     0
4   |     0 |     0
4   |     0 |     0
6   |     1 |     0
6   |     1 |     0
8   |     0 |     1
8   |     0 |     1
4   |     0 |     0
4   |     0 |     0
6   |     1 |     0
8   |     0 |     1
8   |     0 |     1
6   |     1 |     0
4   |     0 |     0
8   |     0 |     1
8   |     0 |     1
8   |     0 |     1
6   |     1 |     0
6   |     1 |     0
4   |     0 |     0
4   |     0 |     0
(32 rows)

另请参阅

8 - APPLY_PCA

使用 PCA 模型转换数据。该函数将返回每个数据点的新坐标。

语法

APPLY_PCA ( input‑columns
        USING PARAMETERS model_name = 'model‑name'
            [, num_components = num‑components]
            [, cutoff = cutoff‑value]
            [, match_by_pos = match‑by‑position]
            [, exclude_columns = 'excluded‑columns']
            [, key_columns = 'key‑columns'] )

参数

input‑columns

包含数据矩阵的列的逗号分隔列表，或星号 (*) 以选择所有列。需要满足以下要求：

所有列都必须为数字数据类型。
如果列名包含特殊字符，请用双引号将其括起来。

参数

model_name

模型的名称（不区分大小写）。

num_components

要保留在模型中的组件的数量。这是将生成的输出列数。如果忽略此参数和 cutoff 参数，则保留所有模型组件。

cutoff

设置为 1，指定最小累积解释方差。如果累积解释方差未达到该值，将使用组件。

match_by_pos

该布尔值指定输入列如何与模型特征匹配：

false （默认值）：按名称匹配。
true：按输入列列表中列的位置匹配。

exclude_columns

input-columns 中要排除在处理范围之外的列名的逗号分隔列表。

key_columns

来自 input‑columns 的列名称的逗号分隔列表，用于标识其数据行。这些列包含在输出表中。

示例


=> SELECT PCA ('pcamodel', 'world','country,HDI,em1970,em1971,em1972,em1973,em1974,em1975,em1976,em1977,
em1978,em1979,em1980,em1981,em1982,em1983,em1984 ,em1985,em1986,em1987,em1988,em1989,em1990,em1991,em1992,
em1993,em1994,em1995,em1996,em1997,em1998,em1999,em2000,em2001,em2002,em2003,em2004,em2005,em2006,em2007,
em2008,em2009,em2010,gdp1970,gdp1971,gdp1972,gdp1973,gdp1974,gdp1975,gdp1976,gdp1977,gdp1978,gdp1979,gdp1980,
gdp1981,gdp1982,gdp1983,gdp1984,gdp1985,gdp1986,gdp1987,gdp1988,gdp1989,gdp1990,gdp1991,gdp1992,gdp1993,
gdp1994,gdp1995,gdp1996,gdp1997,gdp1998,gdp1999,gdp2000,gdp2001,gdp2002,gdp2003,gdp2004,gdp2005,gdp2006,
gdp2007,gdp2008,gdp2009,gdp2010' USING PARAMETERS exclude_columns='HDI,country');
PCA
---------------------------------------------------------------
Finished in 1 iterations.
Accepted Rows: 96  Rejected Rows: 0
(1 row)
=> CREATE TABLE worldPCA AS SELECT
APPLY_PCA (HDI,country,em1970,em1971,em1972,em1973,em1974,em1975,em1976,em1977,em1978,em1979,
em1980,em1981,em1982,em1983,em1984 ,em1985,em1986,em1987,em1988,em1989,em1990,em1991,em1992,em1993,em1994,
em1995,em1996,em1997,em1998,em1999,em2000,em2001,em2002,em2003,em2004,em2005,em2006,em2007,em2008,em2009,
em2010,gdp1970,gdp1971,gdp1972,gdp1973,gdp1974,gdp1975,gdp1976,gdp1977,gdp1978,gdp1979,gdp1980,gdp1981,gdp1982,
gdp1983,gdp1984,gdp1985,gdp1986,gdp1987,gdp1988,gdp1989,gdp1990,gdp1991,gdp1992,gdp1993,gdp1994,gdp1995,
gdp1996,gdp1997,gdp1998,gdp1999,gdp2000,gdp2001,gdp2002,gdp2003,gdp2004,gdp2005,gdp2006,gdp2007,gdp2008,
gdp2009,gdp2010 USING PARAMETERS model_name='pcamodel', exclude_columns='HDI, country', key_columns='HDI,
country',cutoff=.3)OVER () FROM world;
CREATE TABLE

=> SELECT * FROM worldPCA;
HDI   |       country       |       col1
------+---------------------+-------------------
0.886 | Belgium             |  79002.2946705704
0.699 | Belize              | -25631.6670012556
0.427 | Benin               | -40373.4104598122
0.805 | Chile               | -16805.7940082156
0.687 | China               | -37279.2893141103
0.744 | Costa Rica          | -19505.5631231635
0.4   | Cote d'Ivoire       | -38058.2060339272
0.776 | Cuba                | -23724.5779612041
0.895 | Denmark             |  117325.594028813
0.644 | Egypt               | -34609.9941604549
...
(96 rows)

=> SELECT APPLY_INVERSE_PCA (HDI, country, col1
    USING PARAMETERS model_name = 'pcamodel', exclude_columns='HDI,country',
    key_columns = 'HDI, country') OVER () FROM worldPCA;
HDI  |       country       |      em1970       |      em1971       |      em1972      |      em1973      |
      em1974      |      em1975       |      em1976|      em1977      |      em1978       |      em1979
   |      em1980       |      em1981      |      em1982       |      em1983       |      em1984       |em1985
|      em1986       |      em1987       |      em1988       |      em1989      |      em1990      |      em1991
|      em1992       |      em1993|      em1994      |      em1995       |      em1996       |      em1997
    |      em1998       |      em1999       |      em2000       |      em2001       |em2002       |
em2003      |      em2004       |      em2005      |      em2006       |      em2007       |      em2008
|      em2009      |      em2010       |     gdp1970      |     gdp1971      |     gdp1972      |     gdp1973
|     gdp1974      |     gdp1975      |     gdp1976      |     gdp1977      |gdp1978      |     gdp1979
 |     gdp1980      |     gdp1981      |     gdp1982      |     gdp1983      |     gdp1984      |     gdp1985
      |     gdp1986|    gdp1987      |     gdp1988      |     gdp1989      |     gdp1990      |     gdp1991
     |     gdp1992      |     gdp1993      |     gdp1994      |     gdp1995      |     gdp1996      |
gdp1997      |     gdp1998      |     gdp1999      |     gdp2000      |     gdp2001      |     gdp2002
|     gdp2003      |gdp2004      |     gdp2005      |     gdp2006      |     gdp2007      |     gdp2008
  |     gdp2009      |     gdp2010
-------+---------------------+-------------------+-------------------+------------------+------------------
+------------------+-------------------+------------------+------------------+-------------------+---------
----------+-------------------+------------------+-------------------+-------------------+-----------------
--+------------------+-------------------+-------------------+-------------------+------------------+-------
-----------+------------------+-------------------+-------------------+------------------+------------------
-+-------------------+------------------+-------------------+-------------------+-------------------+-------
------------+--------------------+------------------+-------------------+------------------+----------------
---+-------------------+-------------------+------------------+-------------------+------------------+------
------------+------------------+------------------+------------------+------------------+------------------+
------------------+------------------+------------------+------------------+------------------+-------------
-----+------------------+------------------+------------------+------------------+------------------+-------
-----------+------------------+------------------+------------------+------------------+------------------+-
-----------------+------------------+------------------+------------------+------------------+--------------
----+------------------+------------------+------------------+------------------+------------------+--------
----------+------------------+------------------+------------------+------------------+------------------
0.886 | Belgium             |  18585.6613572407 | -16145.6374560074 |  26938.956253415 | 8094.30475779595 |
 12073.5461203817 | -11069.0567600181 | 19133.8584911727|   5500.312894949 | -4227.94863799987 |  6265.77925410752
|  -10884.749295608 | 30929.4669575201 | -7831.49439429977 |  3235.81760508742 | -22765.9285442662 | 27200
.6767714485 | -10554.9550160917 |   1169.4144482273 | -16783.7961289161 | 27932.2660829329 | 17227.9083196848
| 13956.0524012749 | -40175.6286481088 | -10889.4785920499 | 22703.6576872859 | -14635.5832197402 |
2857.12270512168 | 20473.5044214494 | -52199.4895696423 | -11038.7346460738 |  18466.7298633088 | -17410.4225137703 |
-3475.63826305462 | 29305.6753822341 |   1242.5724942049 | 17491.0096310849 | -12609.9984515902 | -17909.3603476248
|  6276.58431412381 | 21851.9475485178 | -2614.33738160397 | 3777.74134131349 | 4522.08854282736 | 4251.90446379366
| 4512.15101396876 | 4265.49424538129 | 5190.06845330997 | 4543.80444817989 | 5639.81122679089 | 4420.44705213467
|  5658.8820279283 | 5172.69025294376 | 5019.63640408663 | 5938.84979495903 | 4976.57073629812 | 4710.49525137591
| 6523.65700286465 | 5067.82520773578 | 6789.13070219317 | 5525.94643553563 | 6894.68336419297 | 5961.58442474331
| 5661.21093840818 | 7721.56088518218 |  5959.7301109143 | 6453.43604137202 | 6739.39384033096 | 7517.97645468455
| 6907.49136910647 | 7049.03921764209 | 7726.49091035527 | 8552.65909911844 | 7963.94487647115 | 7187.45827585515
| 7994.02955410523 | 9532.89844418041 | 7962.25713582666 | 7846.68238907624 | 10230.9878908643 | 8642.76044946519
| 8886.79860331866 |  8718.3731386891
...
(96 rows)

另请参阅

9 - APPLY_SVD

使用 SVD 模型转换数据。可计算 SVD 分解的矩阵 U。

语法

APPLY_SVD ( input‑columns
        USING PARAMETERS model_name = 'model‑name'
            [, num_components = num-components]
            [, cutoff = cutoff‑value]
            [, match_by_pos = match‑by‑position]
            [, exclude_columns = 'excluded‑columns']
            [, key_columns = 'key‑columns'] )

参数

input‑columns

包含数据矩阵的列的逗号分隔列表，或星号 (*) 以选择所有列。需要满足以下要求：

所有列都必须为数字数据类型。
如果列名包含特殊字符，请用双引号将其括起来。

参数

model_name

模型的名称（不区分大小写）。

num_components

要保留在模型中的组件的数量。这是将生成的输出列数。如果既未提供此参数，也未提供 cutoff 参数，则保留模型中的所有组件。

cutoff

设置为 1，指定最小累积解释方差。如果累积解释方差未达到该值，将使用组件。如果忽略此参数和 num_components 参数，则保留所有模型组件。

match_by_pos

指定输入列如何与模型列匹配的布尔值：

false （默认值）：按名称匹配。
true：按输入列列表中列的位置匹配。

exclude_columns

input-columns 中要排除在处理范围之外的列名的逗号分隔列表。

key_columns

来自 input‑columns 的列名称的逗号分隔列表，用于标识其数据行。这些列包含在输出表中。

示例

=> SELECT SVD ('svdmodel', 'small_svd', 'x1,x2,x3,x4');
SVD
--------------------------------------------------------------
Finished in 1 iterations.
Accepted Rows: 8  Rejected Rows: 0
(1 row)

=> CREATE TABLE transform_svd AS SELECT
     APPLY_SVD (id, x1, x2, x3, x4 USING PARAMETERS model_name='svdmodel', exclude_columns='id', key_columns='id')
     OVER () FROM small_svd;
CREATE TABLE

=> SELECT * FROM transform_svd;
id  |       col1        |        col2         |        col3         |        col4
----+-------------------+---------------------+---------------------+--------------------
4   |  0.44849499240202 |  -0.347260956311326 |   0.186958376368345 |  0.378561270493651
6   |  0.17652411036246 | -0.0753183783382909 |  -0.678196192333598 | 0.0567124770173372
1   | 0.494871802886819 |   0.161721379259287 |  0.0712816417153664 | -0.473145877877408
2   |  0.17652411036246 | -0.0753183783382909 |  -0.678196192333598 | 0.0567124770173372
3   | 0.150974762654569 |   0.589561842046029 | 0.00392654610109522 |  0.360011163271921
5   | 0.494871802886819 |   0.161721379259287 |  0.0712816417153664 | -0.473145877877408
8   |  0.44849499240202 |  -0.347260956311326 |   0.186958376368345 |  0.378561270493651
7   | 0.150974762654569 |   0.589561842046029 | 0.00392654610109522 |  0.360011163271921
(8 rows)

=> SELECT APPLY_INVERSE_SVD (* USING PARAMETERS model_name='svdmodel', exclude_columns='id',
key_columns='id') OVER () FROM transform_svd;
id  |        x1        |        x2        |        x3        |        x4
----+------------------+------------------+------------------+------------------
4 | 91.4056627665577 | 44.7629617207482 | 83.1704961993117 | 38.9274292265543
6 | 20.6468626294368 | 9.30974906868751 | 8.71006863405534 |  6.5855928603967
7 | 31.2494347777156 | 20.6336519003026 | 27.5668287751507 | 5.84427645886865
1 |  107.93376580719 | 51.6980548011917 | 97.9665796560552 | 40.4918236881051
2 | 20.6468626294368 | 9.30974906868751 | 8.71006863405534 |  6.5855928603967
3 | 31.2494347777156 | 20.6336519003026 | 27.5668287751507 | 5.84427645886865
5 |  107.93376580719 | 51.6980548011917 | 97.9665796560552 | 40.4918236881051
8 | 91.4056627665577 | 44.7629617207482 | 83.1704961993117 | 38.9274292265543
(8 rows)

另请参阅

10 - PREDICT_AUTOREGRESSOR

对输入关系应用自回归 (AR) 模型。

自回归模型使用以前的值进行预测。更具体地说，用户指定的“滞后”决定计算期间考虑的早期时间步长数量，而预测值则是这些滞后的线性组合。

语法

PREDICT_AUTOREGRESSOR ( 'timeseries‑column'
        USING PARAMETERS
            model‑name = 'model-name'
            [, start = starting‑index]
            [, npredictions = npredictions]
            [, missing = "imputation‑method" ] )
        OVER (ORDER BY 'timestamp‑column')
        FROM input‑relation

注意

如书面所示，以下实参为必需，既不能省略，也不能使用其他类型的子句代替。

OVER (ORDER BY '<span class="code-variable">timestamp‑column</span>')

参数

timeseries‑column: 用于进行预测的时间序列列（仅使用模型创建期间指定的最后一个 p 值）。
timestamp‑column: 用于进行预测的时间戳列，时间步长一致。
input‑relation: 包含 timeseries-column 和 timestamp-column 的输入关系。
请注意，input‑relation 在 start 之前的任何 p（训练期间设置）行中都不能包含缺失值。要处理缺失值，请参阅 IMPUTE 或线性插值。

参数

model_name

模型的名称（不区分大小写）。

start

INTEGER >p 或 ≤0，预测的起始 input-relation 索引（行）。如果省略，则从 input-relation 末尾开始预测。

如果 start 索引大于 timeseries-column 中的行数 N，则预测 N 到 start 之间的值并使用这些值进行预测。

如果为负，则从 input-relation 末尾倒数，对 start 索引进行标识。

对于 N 行的 input-relation，负值的下限为 -1000 或 -(N-p)，以其中较大者为准。

默认： input‑relation 的末尾

npredictions

INTEGER ≥1，预测时间戳的数量。

默认值： 10

missing

用于处理缺失值的方法，为以下之一：

drop：忽略缺失值。
error：缺失值会引发错误。
zero：将缺失值替换为 0。
linear_interpolation：将缺失值替换为基于缺失值前后最近的有效条目的线性插值。如果预测范围内缺失值之前或之后的所有值缺失或无效，则无法指定插值且函数会出错。

默认值： linear_interpolation

示例

请参阅自回归模型示例。

另请参阅

11 - PREDICT_LINEAR_REG

对输入关系应用线性回归模型，并将预测值以 FLOAT 形式返回。

语法

PREDICT_LINEAR_REG ( input‑columns
        USING PARAMETERS model_name = 'model‑name' [, match_by_pos = match‑by‑position] )

参数

input‑columns: 输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。

参数

model_name

模型的名称（不区分大小写）。

match_by_pos

该布尔值指定输入列如何与模型特征匹配：

false （默认值）：按名称匹配。
true：按输入列列表中列的位置匹配。

示例

=> SELECT PREDICT_LINEAR_REG(waiting USING PARAMETERS model_name='myLinearRegModel')FROM
faithful ORDER BY id;


 PREDICT_LINEAR_REG
--------------------
   4.15403481386324
   2.18505296804024
   3.76023844469864
    2.8151271587036
   4.62659045686076
   2.26381224187316
   4.86286827835952
   4.62659045686076
   1.94877514654148
   4.62659045686076
   2.18505296804024
...
 (272 rows)

以下示例显示了如何使用 match_by_pos 参数对输入表使用 PREDICT_LINEAR_REG 函数。请注意，您可以将 column 实参替换为不同于输入列的常量：

=> SELECT PREDICT_LINEAR_REG(55 USING PARAMETERS model_name='linear_reg_faithful',
                     match_by_pos='true')FROM faithful ORDER BY id;
 PREDICT_LINEAR_REG
--------------------
2.28552115094171
2.28552115094171
2.28552115094171
2.28552115094171
2.28552115094171
2.28552115094171
2.28552115094171
...
 (272 rows)

12 - PREDICT_LOGISTIC_REG

对输入关系应用逻辑回归模型。

PREDICT_LOGISTIC_REG 以 FLOAT 形式返回预测类或预测类的概率，具体取决于 type 参数的设置方式。当返回值位于预测类的概率范围之内时，您可以将返回值转换为 INTEGER 或其他 numeric 类型。

语法

PREDICT_LOGISTIC_REG ( input‑columns
        USING PARAMETERS model_name = 'model‑name'
            [, type = 'prediction‑type']
            [, cutoff = probability‑cutoff]
            [, match_by_pos = match‑by‑position] )

参数

input‑columns: 输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。

参数

model_name

模型的名称（不区分大小写）。

type

逻辑回归的预测类型，为以下之一：

response （默认值）：预测值为 0 或 1。
probability：输出是预测类别为 1 的概率。

cutoff

与 type 参数一起使用，FLOAT 介于 0 和 1 之间且专用。当 type 设置为 response 时，如果相应概率大于或等于 cutoff 的值，则预测返回值为 1；否则，返回值为 0。

默认值： 0.5

match_by_pos

该布尔值指定输入列如何与模型特征匹配：

false （默认值）：按名称匹配。
true：按输入列列表中列的位置匹配。

示例

=> SELECT car_model,
            PREDICT_LOGISTIC_REG(mpg, cyl, disp, drat, wt, qsec, vs, gear, carb
                                 USING PARAMETERS model_name='myLogisticRegModel')
          FROM mtcars;
      car_model      | PREDICT_LOGISTIC_REG
---------------------+----------------------
 Camaro Z28          |                    0
 Fiat 128            |                    1
 Fiat X1-9           |                    1
 Ford Pantera L      |                    1
 Merc 450SE          |                    0
 Merc 450SL          |                    0
 Toyota Corona       |                    0
 AMC Javelin         |                    0
 Cadillac Fleetwood  |                    0
 Datsun 710          |                    1
 Dodge Challenger    |                    0
 Hornet 4 Drive      |                    0
 Lotus Europa        |                    1
 Merc 230            |                    0
 Merc 280            |                    0
 Merc 280C           |                    0
 Merc 450SLC         |                    0
 Pontiac Firebird    |                    0
 Porsche 914-2       |                    1
 Toyota Corolla      |                    1
 Valiant             |                    0
 Chrysler Imperial   |                    0
 Duster 360          |                    0
 Ferrari Dino        |                    1
 Honda Civic         |                    1
 Hornet Sportabout   |                    0
 Lincoln Continental |                    0
 Maserati Bora       |                    1
 Mazda RX4           |                    1
 Mazda RX4 Wag       |                    1
 Merc 240D           |                    0
 Volvo 142E          |                    1
(32 rows)

以下示例显示了如何使用 match_by_pos 参数对输入表使用 PREDICT_LOGISTIC_REG。请注意，您可以将任何列输入替换为不同于输入列的常量。在此示例中，列 mpg 被替换为常量 20：

=> SELECT car_model,
            PREDICT_LOGISTIC_REG(20, cyl, disp, drat, wt, qsec, vs, gear, carb
                                 USING PARAMETERS model_name='myLogisticRegModel', match_by_pos='true')
          FROM mtcars;
      car_model     | PREDICT_LOGISTIC_REG
--------------------+----------------------
AMC Javelin         |                    0
Cadillac Fleetwood  |                    0
Camaro Z28          |                    0
Chrysler Imperial   |                    0
Datsun 710          |                    1
Dodge Challenger    |                    0
Duster 360          |                    0
Ferrari Dino        |                    1
Fiat 128            |                    1
Fiat X1-9           |                    1
Ford Pantera L      |                    1
Honda Civic         |                    1
Hornet 4 Drive      |                    0
Hornet Sportabout   |                    0
Lincoln Continental |                    0
Lotus Europa        |                    1
Maserati Bora       |                    1
Mazda RX4           |                    1
Mazda RX4 Wag       |                    1
Merc 230            |                    0
Merc 240D           |                    0
Merc 280            |                    0
Merc 280C           |                    0
Merc 450SE          |                    0
Merc 450SL          |                    0
Merc 450SLC         |                    0
Pontiac Firebird    |                    0
Porsche 914-2       |                    1
Toyota Corolla      |                    1
Toyota Corona       |                    0
Valiant             |                    0
Volvo 142E          |                    1
(32 rows)

13 - PREDICT_MOVING_AVERAGE

将由 MOVING_AVERAGE 创建的移动平均值 (MA) 模型应用于输入关系。

移动平均值模型使用早期预测误差进行未来预测。更具体地说，用户指定的“滞后”决定计算期间考虑的早期预测和错误数量。

语法

PREDICT_MOVING_AVERAGE ( 'timeseries‑column'
        USING PARAMETERS
            model_name = 'model‑name'
            [, start = starting‑index]
            [, npredictions = npredictions]
            [, missing = "imputation‑method" ] )
        OVER (ORDER BY 'timestamp‑column')
        FROM input‑relation

注意

如书面所示，以下实参为必需，既不能省略，也不能使用其他类型的子句代替。

OVER (ORDER BY '<span class="code-variable">timestamp‑column</span>')

参数

timeseries‑column: 用于进行预测的时间序列列（仅使用模型创建期间指定的最后一个 q 值）。
timestamp‑column: 用于进行预测的时间戳列，时间步长一致。
input‑relation: 包含 timeseries-column 和 timestamp-column 的输入关系。
请注意，input‑relation 在 start 之前的任何 q（训练期间设置）行中都不能包含缺失值。要处理缺失值，请参阅 IMPUTE 或线性插值。

参数

model_name

模型的名称（不区分大小写）。

start

INTEGER >q 或 ≤0，预测的起始 input-relation 索引（行）。如果省略，则从 input-relation 末尾开始预测。

如果 start 索引大于 timeseries-column 中的行数 N，则预测 N 到 start 之间的值并使用这些值进行预测。

如果为负，则从 input-relation 末尾倒数，对 start 索引进行标识。

对于 N 行的 input-relation，负值的下限为 -1000 或 -(N-q)，以其中较大者为准。

默认： input‑relation 的末尾

npredictions

INTEGER ≥1，预测时间戳的数量。

默认值： 10

missing

用于处理缺失值的方法，为以下之一：

drop：忽略缺失值。
error：缺失值会引发错误。
zero：将缺失值替换为 0。
linear_interpolation：将缺失值替换为基于缺失值前后最近的有效条目的线性插值。如果预测范围内缺失值之前或之后的所有值缺失或无效，则无法指定插值且函数会出错。

默认值： linear_interpolation

示例

请参阅移动平均模型示例。

另请参阅

14 - PREDICT_NAIVE_BAYES

对输入关系应用朴素贝叶斯模型。

PREDICT_NAIVE_BAYES 返回指定预测类或预测类概率的 VARCHAR，具体取决于 type 参数的设置方式。如果函数返回概率，您可以将返回值转换为 INTEGER 或其他 numeric 数据类型。

语法

PREDICT_NAIVE_BAYES ( input‑columns
        USING PARAMETERS model_name = 'model‑name'
            [, type = ' return‑type ']
            [, class = 'user‑input‑class']
            [, match_by_pos = match‑by‑position] )

参数

input‑columns: 输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。

参数

model_name

模型的名称（不区分大小写）。

type

以下几项之一：

response （默认值）：返回概率最高的类。
probability：仅当设置 class 参数的情况下才有效，返回属于指定类实参的概率。

class

如果 type 参数设置为 probability，则是必需的。如果省略此参数，“PREDICT_NAIVE_BAYES”返回经预测概率最高的类。

match_by_pos

该布尔值指定输入列如何与模型特征匹配：

false （默认值）：按名称匹配。
true：按输入列列表中列的位置匹配。

示例

=> SELECT party, PREDICT_NAIVE_BAYES (vote1, vote2, vote3
                                        USING PARAMETERS model_name='naive_house84_model',
                                                         type='response')
                                        AS Predicted_Party
                                        FROM house84_test;
   party    | Predicted_Party
------------+-----------------
 democrat   | democrat
 democrat   | democrat
 democrat   | democrat
 republican | republican
 democrat   | democrat
 democrat   | democrat
 democrat   | democrat
 democrat   | democrat
 democrat   | democrat
 republican | republican
 democrat   | democrat
 democrat   | democrat
 democrat   | democrat
 democrat   | republican
 republican | republican
 democrat   | democrat
 republican | republican
...
(99 rows)

另请参阅

15 - PREDICT_NAIVE_BAYES_CLASSES

对输入关系应用 Naive Bayes 模型并返回类的概率：

VARCHAR predicted 列包含概率最高的类标签。
多个 FLOAT 列，其中第一个 probability 列包含预测列中指定的类的概率。其他列包含属于 classes 参数中指定的每个类的概率。

语法

PREDICT_NAIVE_BAYES_CLASSES ( predictor‑columns
        USING PARAMETERS model_name = 'model‑name'
            [, key_columns = 'key‑columns']
            [, exclude_columns = 'excluded‑columns]
            [, classes = 'classes']
            [, match_by_pos = match‑by‑position] )
OVER( [window-partition-clause] )

参数

predictor‑columns: 输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。

参数

model_name

模型的名称（不区分大小写）。

key_columns

用于标识输出行的预测工具列名称的逗号分隔列表。要排除这些和其他预测工具列用于预测，请将其包含在参数 exclude_columns 的实参列表中。

exclude_columns

要从处理中排除来自 predictor‑columns 列的逗号分隔列表。

classes

以逗号分隔的模型类标签列表。分类器预测属于此给定类的概率。值区分大小写。

match_by_pos

布尔值，指定预测指标列如何匹配模型特征：

false （默认值）：按名称匹配。
true：按预测指标列列表中列的位置匹配。

示例

=> SELECT PREDICT_NAIVE_BAYES_CLASSES (id, vote1, vote2 USING PARAMETERS
model_name='naive_house84_model',key_columns='id',exclude_columns='id',
classes='democrat, republican', match_by_pos='false')
        OVER() FROM house84_test;
 id  | Predicted  |    Probability    |     democrat      |    republican
-----+------------+-------------------+-------------------+-------------------
  21 | democrat   | 0.775473383353576 | 0.775473383353576 | 0.224526616646424
  28 | democrat   | 0.775473383353576 | 0.775473383353576 | 0.224526616646424
  83 | republican | 0.592510497724379 | 0.407489502275621 | 0.592510497724379
 102 | democrat   | 0.779889432167111 | 0.779889432167111 | 0.220110567832889
 107 | republican | 0.598662714551597 | 0.401337285448403 | 0.598662714551597
 125 | republican | 0.598662714551597 | 0.401337285448403 | 0.598662714551597
 132 | republican | 0.592510497724379 | 0.407489502275621 | 0.592510497724379
 136 | republican | 0.592510497724379 | 0.407489502275621 | 0.592510497724379
 155 | republican | 0.598662714551597 | 0.401337285448403 | 0.598662714551597
 174 | republican | 0.592510497724379 | 0.407489502275621 | 0.592510497724379
...
(1 row)

另请参阅

16 - PREDICT_PMML

对输入关系应用导入的 PMML 模型。函数返回采用 PMML 模型编码的模型类型预期的结果。

在以下情况下，PREDICT_PMML 返回 NULL：

预测指标为无效值或 NULL 值
分类预测指标属于未知类

注意

PREDICT_PMML 针对使用 Output 标记的模型返回复杂类型 ROW 的值。Vertica 目前不支持直接将此数据插入表中。

您可以通过在将输出插入表之前使用 TO_JSON 将其更改为 JSON 来消除此限制：

=> CREATE TABLE predicted_output AS SELECT TO_JSON(PREDICT_PMML(X1,X2,X3
USING PARAMETERS model_name='pmml_imported_model'))
AS predicted_value
FROM input_table;

语法

PREDICT_PMML ( input‑columns
        USING PARAMETERS model_name = 'model-name' [, match_by_pos = match-by-position] )

参数

input‑columns: 输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。

参数

model_name

模型的名称（不区分大小写）。函数支持对以下模型类型进行编码的 PMML 模型：

K-means
线性回归
逻辑回归

match_by_pos

该布尔值指定输入列如何与模型特征匹配：

false （默认值）：按名称匹配。
true：按输入列列表中列的位置匹配。

示例

在此示例中，函数调用使用表中的所有列作为预测指标，同时使用 PMML 格式的 "my_kmeans" 模型预测值：

SELECT PREDICT_PMML(* USING PARAMETERS model_name='my_kmeans') AS predicted_label FROM table;

在此示例中，函数调用仅将列 col1, col2 作为预测指标，使用架构 "my_schema" 中的模型 "my_kmeans" 预测每一行的值：

SELECT PREDICT_PMML(col1, col2 USING PARAMETERS model_name='my_schema.my_kmeans') AS predicted_label FROM table;

在此示例中，函数调用返回的错误既非 schema 也非 model-name，可以接受 * 作为值：

SELECT PREDICT_PMML(* USING PARAMETERS model_name='*.*') AS predicted_label FROM table;
SELECT PREDICT_PMML(* USING PARAMETERS model_name='*') AS predicted_label FROM table;
SELECT PREDICT_PMML(* USING PARAMETERS model_name='models.*') AS predicted_label FROM table;

另请参阅

17 - PREDICT_RF_CLASSIFIER

对输入关系应用随机森林模型。PREDICT_RF_CLASSIFIER 返回 VARCHAR 数据类型，指定以下几项之一，具体取决于 type 参数的设置方式：

预测类（基于公民投票）
每个输入实例的类概率。

注意

仅根据森林中决策树的公民投票选择预测类。因此，在特殊情况下，预测类的计算概率可能不是最高的。

语法

PREDICT_RF_CLASSIFIER ( input‑columns
        USING PARAMETERS model_name = 'model‑name'
            [, type = 'prediction‑type']
            [, class = 'user‑input‑class']
            [, match_by_pos = match‑by‑position] )

参数

input-columns: 输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。

参数

model_name

模型的名称（不区分大小写）。

type

要返回的预测类型，为以下之一：

response （默认值）：所有可能的类中概率最高的类。
probability：仅当设置 class 参数的情况下才有效，返回指定类的概率。

class

当 type 参数设置为 probability 时使用的类。如果您省略此参数，函数将使用预测类 — 公民投票排名最高的类。因此，预测函数返回输入实例属于其预测类的概率。

match_by_pos

该布尔值指定输入列如何与模型特征匹配：

false （默认值）：按名称匹配。
true：按输入列列表中列的位置匹配。

示例

=> SELECT PREDICT_RF_CLASSIFIER (Sepal_Length, Sepal_Width, Petal_Length, Petal_Width
       USING PARAMETERS model_name='myRFModel') FROM iris;
PREDICT_RF_CLASSIFIER
-----------------------
setosa
setosa
setosa
...
versicolor
versicolor
versicolor
...
virginica
virginica
virginica
...
(150 rows)

此示例显示了如何通过 match_by_pos 参数使用 PREDICT_RF_CLASSIFIER 函数：

=> SELECT PREDICT_RF_CLASSIFIER (Sepal_Length, Sepal_Width, Petal_Length, Petal_Width
                                USING PARAMETERS model_name='myRFModel', match_by_pos='true') FROM iris;
PREDICT_RF_CLASSIFIER
-----------------------
setosa
setosa
setosa
...
versicolor
versicolor
versicolor
...
virginica
virginica
virginica
...
(150 rows)

另请参阅

18 - PREDICT_RF_CLASSIFIER_CLASSES

对输入关系应用随机森林模型并返回类的概率：

VARCHAR predicted 列包含投票（公民投票）排名最高的类标签。
多个 FLOAT 列，其中第一个 probability 列包含预测列中报告的类的概率。其他列包含 classes 参数中指定的每个类的概率。
与参数 key_columns 中指定的匹配输入列具有相同值和数据类型的关键字列。

注意

预测类的选择取决于森林中决策树的公民投票。因此，在特殊情况下，预测类的计算概率可能不是最高的。

语法

PREDICT_RF_CLASSIFIER_CLASSES ( predictor‑columns
        USING PARAMETERS model_name = 'model‑name'
            [, key_columns = 'key‑columns']
            [, exclude_columns = 'excluded‑columns']
            [, classes = 'classes']
            [, match_by_pos = match‑by‑position] )
OVER( [window-partition-clause] )

参数

predictor‑columns: 输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。

参数

model_name

模型的名称（不区分大小写）。

key_columns

用于标识输出行的预测工具列名称的逗号分隔列表。要排除这些和其他预测工具列用于预测，请将其包含在参数 exclude_columns 的实参列表中。

exclude_columns

要从处理中排除来自 predictor‑columns 列的逗号分隔列表。

classes

以逗号分隔的模型类标签列表。分类器预测属于此给定类的概率。值区分大小写。

match_by_pos

布尔值，指定预测指标列如何匹配模型特征：

false （默认值）：按名称匹配。
true：按预测指标列列表中列的位置匹配。

示例

=> SELECT PREDICT_RF_CLASSIFIER_CLASSES(Sepal_Length, Sepal_Width, Petal_Length, Petal_Width
                               USING PARAMETERS model_name='myRFModel') OVER () FROM iris;
predicted  |    probability
-----------+-------------------
setosa     |                 1
setosa     |              0.99
setosa     |                 1
setosa     |                 1
setosa     |                 1
setosa     |              0.97
setosa     |                 1
setosa     |                 1
setosa     |                 1
setosa     |                 1
setosa     |              0.99
...
(150 rows)

此示例显示了如何通过 match_by_pos 参数使用函数 PREDICT_RF_CLASSIFIER_CLASSES：

=> SELECT PREDICT_RF_CLASSIFIER_CLASSES(Sepal_Length, Sepal_Width, Petal_Length, Petal_Width
                          USING PARAMETERS model_name='myRFModel', match_by_pos='true') OVER () FROM iris;
predicted  |    probability
-----------+-------------------
setosa     |                 1
setosa     |                 1
setosa     |                 1
setosa     |                 1
setosa     |                 1
setosa     |                 1
setosa     |                 1
setosa     |                 1
setosa     |                 1
setosa     |                 1
setosa     |                 1
...
(150 rows)s

另请参阅

19 - PREDICT_RF_REGRESSOR

对输入关系应用随机森林模型，并返回 FLOAT 数据类型，该数据类型用于指定随机森林模型的预测值，即森林中树木的平均预测值。

语法

PREDICT_RF_REGRESSOR ( input‑columns
        USING PARAMETERS model_name = 'model‑name' [, match_by_pos = match‑by‑position] )

参数

input‑columns: 输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。

参数

model_name

模型的名称（不区分大小写）。

match_by_pos

该布尔值指定输入列如何与模型特征匹配：

false （默认值）：按名称匹配。
true：按输入列列表中列的位置匹配。

示例

=> SELECT PREDICT_RF_REGRESSOR (mpg,cyl,hp,drat,wt
USING PARAMETERS model_name='myRFRegressorModel')FROM mtcars;
PREDICT_RF_REGRESSOR
----------------------
2.94774203574204
2.6954087024087
2.6954087024087
2.89906346431346
2.97688489288489
2.97688489288489
2.7086587024087
2.92078965478965
2.97688489288489
2.7086587024087
2.95621822621823
2.82255155955156
2.7086587024087
2.7086587024087
2.85650394050394
2.85650394050394
2.97688489288489
2.95621822621823
2.6954087024087
2.6954087024087
2.84493251193251
2.97688489288489
2.97688489288489
2.8856467976468
2.6954087024087
2.92078965478965
2.97688489288489
2.97688489288489
2.7934087024087
2.7934087024087
2.7086587024087
2.72469441669442
(32 rows)

另请参阅

20 - PREDICT_SVM_CLASSIFIER

使用 SVM 模型预测输入关系中样本的类标签，并将预测值以 FLOAT 数据类型返回。

语法

PREDICT_SVM_CLASSIFIER (input‑columns
     USING PARAMETERS model_name = 'model‑name'
            [, match_by_pos = match‑by‑position]
            [, type = 'return‑type']
            [, cutoff = 'cutoff‑value'] ] )

参数

input‑columns: 输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。

参数

model_name

模型的名称（不区分大小写）。

match_by_pos

该布尔值指定输入列如何与模型特征匹配：

false （默认值）：按名称匹配。
true：按输入列列表中列的位置匹配。

type

一个字符串，指定针对每个输入行返回的输出，为以下之一：

response：输出 0 或 1 的预测类。
probability：输出位于 (0,1) 范围内的值，即使用逻辑函数转换的预测得分。

cutoff

仅当 type 参数设置为 probability 的情况下才有效，这是一个 FLOAT 值，用于与转换的预测得分进行比较以确定预测类。

默认值： 0

示例


=> SELECT PREDICT_SVM_CLASSIFIER (mpg,cyl,disp,wt,qsec,vs,gear,carb
USING PARAMETERS model_name='mySvmClassModel') FROM mtcars;
PREDICT_SVM_CLASSIFIER
------------------------
0
0
1
0
0
1
1
1
1
0
0
1
0
0
1
0
0
0
0
0
0
1
1
0
0
1
1
1
1
0
0
0
(32 rows)

此示例显示了如何通过 match_by_pos 参数对 mtcars 表使用 PREDICT_SVM_CLASSIFIER。在此示例中，列 mpg 被替换为常量 40：


=> SELECT PREDICT_SVM_CLASSIFIER (40,cyl,disp,wt,qsec,vs,gear,carb
USING PARAMETERS model_name='mySvmClassModel', match_by_pos ='true') FROM mtcars;
PREDICT_SVM_CLASSIFIER
------------------------
0
0
0
0
1
0
0
1
1
1
1
1
0
0
0
1
1
1
1
0
0
0
0
0
0
0
0
1
1
0
0
1
(32 rows)

另请参阅

21 - PREDICT_SVM_REGRESSOR

使用 SVM 模型对输入关系中的样本执行回归，并将预测值以 FLOAT 数据类型返回。

语法

PREDICT_SVM_REGRESSOR(input‑columns
        USING PARAMETERS model_name = 'model‑name' [, match_by_pos = match‑by‑position] )

参数

input‑columns: 输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。

参数

model_name

模型的名称（不区分大小写）。

match_by_pos

该布尔值指定输入列如何与模型特征匹配：

false （默认值）：按名称匹配。
true：按输入列列表中列的位置匹配。

示例


=> SELECT PREDICT_SVM_REGRESSOR(waiting USING PARAMETERS model_name='mySvmRegModel')
           FROM faithful ORDER BY id;
 PREDICT_SVM_REGRESSOR
--------------------
   4.06488248694445
   2.30392277646291
   3.71269054484815
   2.867429883817
   4.48751281746003
   2.37436116488217
   4.69882798271781
   4.48751281746003
   2.09260761120512
...
 (272 rows)

此示例显示了如何通过 match_by_pos 参数对有信心的表使用 PREDICT_SVM_REGRESSOR 函数。在此示例中，等待列被替换为常量 40：


=> SELECT PREDICT_SVM_REGRESSOR(40 USING PARAMETERS model_name='mySvmRegModel', match_by_pos='true')
           FROM faithful ORDER BY id;
 PREDICT_SVM_REGRESSOR
--------------------
   1.31778533859324
   1.31778533859324
   1.31778533859324
   1.31778533859324
   1.31778533859324
   1.31778533859324
   1.31778533859324
   1.31778533859324
   1.31778533859324
...
 (272 rows)

另请参阅

22 - PREDICT_TENSORFLOW

对输入关系应用 TensorFlow 模型，并返回编码模型类型的预期结果。

语法

PREDICT_TENSORFLOW ( input‑columns
        USING PARAMETERS model_name = 'model‑name' [, num_passthru_cols = 'n-first-columns-to-ignore'] )
OVER( [window-partition-clause] )

参数

input‑columns: 输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。

参数

model_name: 模型的名称（不区分大小写）。
num_passthru_cols: 指定要跳过的输入列数的整数。

示例

使用 PREDICT_TENSORFLOW 和 num_passthru_cols 跳过前两个输入列：


SELECT PREDICT_TENSORFLOW ( pid,label,x1,x2
        USING PARAMETERS model_name='spiral_demo', num_passthru_cols=2 )
OVER(PARTITION BEST) as predicted_class FROM points;

--example output, the skipped columns are displayed as the first columns of the output
  pid  | label |         col0         |         col1
-------+-------+----------------------+----------------------
     0 |     0 |    0.990638732910156 |  0.00936129689216614
     1 |     0 |    0.999036073684692 | 0.000963933940511197
     2 |     1 |   0.0103802494704723 | 0.989619791507721

另请参阅

23 - PREDICT_XGB_CLASSIFIER

对输入关系应用 XGBoost 分类器模型。 PREDICT_XGB_CLASSIFIER 返回 VARCHAR 数据类型，指定以下几项之一，具体取决于 type 参数的设置方式：

预测类（基于概率得分）
每个输入实例的类概率。

语法

PREDICT_XGB_CLASSIFIER ( input‑columns
          USING PARAMETERS model_name = 'model‑name'
              [, type = 'prediction-type' ]
              [, class = 'user‑input‑class' ]
              [, match_by_pos = 'match‑by‑position' ]
              [, probability_normalization = 'prob-normalization' ] )

参数

input‑columns: 输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。

参数

model_name

模型的名称（不区分大小写）。

type

要返回的预测类型，为以下之一：

response （默认值）：所有可能的类中概率最高的类。
probability：仅当设置 class 参数的情况下才有效，针对每个输入实例返回指定类或预测类的概率。

class

当 type 参数设置为 probability 时使用的类。如果您省略此参数，函数将使用预测类 — 概率得分最高的类别。因此，预测函数返回输入实例属于指定类或预测类的概率。

match_by_pos

该布尔值指定输入列如何与模型特征匹配：

false （默认值）：按名称匹配。
true：按输入列列表中列的位置匹配。

probability_normalization

分类器的标准化方法，它可以是 logit``softmax（多类分类器）或（二元分类器）。如果未指定，则使用默认的 logit 函数进行标准化。

示例

使用 PREDICT_XGB_CLASSIFIER 将分类器应用于测试数据：

=> SELECT PREDICT_XGB_CLASSIFIER (Sepal_Length, Sepal_Width, Petal_Length, Petal_Width
    USING PARAMETERS model_name='xgb_iris', probability_normalization='logit') FROM iris1;
PREDICT_XGB_CLASSIFIER
------------------------
setosa
setosa
setosa
.
.
.
versicolor
versicolor
versicolor
.
.
.
virginica
virginica
virginica
.
.
.

(90 rows)

有关更多示例，请参阅 XGBoost 用于分类。

24 - PREDICT_XGB_CLASSIFIER_CLASSES

对输入关系应用 XGBoost 分类器模型并返回类的概率：

VARCHAR predicted 列包含概率最高的类标签。
多个 FLOAT 列，其中第一个 probability 列包含预测列中报告的类的概率。其他列包含 classes 参数中指定的每个类的概率。
与参数 key_columns 中指定的匹配输入列具有相同值和数据类型的关键字列。

所有树都会影响每个响应类的预测概率，选择概率最高的类。

语法

PREDICT_XGB_CLASSIFIER_CLASSES ( predictor‑columns)
        USING PARAMETERS model_name = 'model‑name'
            [, key_columns = 'key‑columns']
            [, exclude_columns = 'excluded‑columns']
            [, classes = 'classes']
            [, match_by_pos = match‑by‑position]
            [, probability_normalization = 'prob-normalization' ] )
OVER( [window-partition-clause] )

参数

input‑columns: 输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。

参数

model_name

模型的名称（不区分大小写）。

key_columns

用于标识输出行的预测工具列名称的逗号分隔列表。要排除这些和其他预测工具列用于预测，请将其包含在参数 exclude_columns 的实参列表中。

exclude_columns

要从处理中排除来自 predictor‑columns 列的逗号分隔列表。

classes

以逗号分隔的模型类标签列表。分类器预测属于每个给定类的概率。值区分大小写。

match_by_pos

布尔值，指定预测指标列如何匹配模型特征：

false （默认值）：按名称匹配。
true：按预测指标列列表中列的位置匹配。

probability_normalization

分类器的标准化方法，它可以是 logit``softmax（多类分类器）或（二元分类器）。如果未指定，则使用默认的 logit 函数进行标准化。

示例

使用 XGB_CLASSIFIER 创建 XGBoost 分类器模型后，您可以使用 PREDICT_XGB_CLASSIFIER_CLASSES 查看每个分类的概率。在此示例中，XGBoost 分类器模型 "xgb_iris" 用于预测给定花属于“鸢尾 (iris)”属的概率：

=> SELECT PREDICT_XGB_CLASSIFIER_CLASSES(Sepal_Length, Sepal_Width, Petal_Length, Petal_Width
    USING PARAMETERS model_name='xgb_iris') OVER (PARTITION BEST) FROM iris1;
  predicted  |    probability
------------+-------------------
 setosa     |   0.9999650465368
 setosa     |   0.9999650465368
 setosa     |   0.9999650465368
 setosa     |   0.9999650465368
 setosa     | 0.999911552783011
 setosa     |   0.9999650465368
 setosa     |   0.9999650465368
 setosa     |   0.9999650465368
 setosa     |   0.9999650465368
 setosa     |   0.9999650465368
 setosa     |   0.9999650465368
 setosa     |   0.9999650465368
 versicolor |  0.99991871763563
 .
 .
 .
(90 rows)

您还可以指定其他类。在此示例中，PREDICT_XGB_CLASSIFIER_CLASSES 与上一个示例进行相同的预测，但同样返回花属于指定的 classes“北美车前 (virginica)”和“花叶芦竹 (versicolor)”的概率：

=> SELECT PREDICT_XGB_CLASSIFIER_CLASSES(Sepal_Length, Sepal_Width, Petal_Length, Petal_Width
    USING PARAMETERS model_name='xgb_iris', classes='virginica,versicolor', probability_normalization='logit') OVER (PARTITION BEST) FROM iris1;
 predicted  |    probability    |      virginica       |      versicolor
------------+-------------------+----------------------+----------------------
 setosa     |   0.9999650465368 | 1.16160301545536e-05 | 2.33374330460065e-05
 setosa     |   0.9999650465368 | 1.16160301545536e-05 | 2.33374330460065e-05
 setosa     |   0.9999650465368 | 1.16160301545536e-05 | 2.33374330460065e-05
 .
 .
 .
 versicolor |  0.99991871763563 | 6.45697562080953e-05 |     0.99991871763563
 versicolor | 0.999967282051702 | 1.60052775404199e-05 |    0.999967282051702
 versicolor | 0.999648819964864 |  0.00028366342010669 |    0.999648819964864
 .
 .
 .
 virginica  | 0.999977039257386 |    0.999977039257386 | 1.13305901169304e-05
 virginica  | 0.999977085131063 |    0.999977085131063 | 1.12847163501674e-05
 virginica  | 0.999977039257386 |    0.999977039257386 | 1.13305901169304e-05
(90 rows)

25 - PREDICT_XGB_REGRESSOR

对输入关系应用 XGBoost 回归模型。 PREDICT_XGB_REGRESSOR 返回 FLOAT 数据类型，指定 XGBoost 模型的预测值：模型中每个树的贡献加权总和。

语法

PREDICT_XGB_REGRESSOR ( input‑columns
        USING PARAMETERS model_name = 'model‑name' [, match_by_pos = match‑by‑position] )

参数

input‑columns: 输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。

参数

model_name

模型的名称（不区分大小写）。

match_by_pos

该布尔值指定输入列如何与模型特征匹配：

false （默认值）：按名称匹配。
true：按输入列列表中列的位置匹配。

示例

请参阅用于回归的 XGBoost。

26 - REVERSE_NORMALIZE

对标准化数据进行反向标准化转换，从而使标准化数据非标准化。如果您指定的列并非位于指定模型，则 REVERSE_NORMALIZE 会按原样返回该列。

语法

REVERSE_NORMALIZE ( input‑columns USING PARAMETERS model_name = 'model‑name' );

参数

input‑columns: 使用输入关系中的列，或使用星号 (*) 选择所有列。

参数

model_name: 模型的名称（不区分大小写）。

示例

对表 mtcars 中的 hp 和 cyl 列使用 REVERSE_NORMALIZE，其中 hp 位于标准化模型 mtcars_normfit，cyl 并非位于标准化模型。

=> SELECT REVERSE_NORMALIZE (hp, cyl USING PARAMETERS model_name='mtcars_normfit') FROM mtcars;
hp    | cyl
------+-----
42502 |   8
58067 |   8
26371 |   4
42502 |   8
31182 |   6
32031 |   4
26937 |   4
34861 |   6
34861 |   6
50992 |   8
50992 |   8
49577 |   8
25805 |   4
18447 |   4
29767 |   6
65142 |   8
69387 |   8
14768 |   4
49577 |   8
60897 |   8
94857 |   8
31182 |   6
31182 |   6
30899 |   4
69387 |   8
49577 |   6
18730 |   4
18730 |   4
74764 |   8
17598 |   4
50992 |   8
27503 |   4
(32 rows)