利用机器学习函数可以处理数据分析过程不同阶段的数据集：
准备模型
训练模型
评估模型
应用模型
管理模型
一些 Vertica 机器学习函数作为 Vertica UDx 函数实施，另一些函数则作为元函数实施：
UDx 函数接受来自 FROM 子句的输入关系名称。调用函数的 SELECT 语句可组合 — 可用作其他 SELECT 语句的子查询。
元函数接受将输入关系名称作为单引号字符串传递，以作为实参或命名参数。SELECT 语句返回的数据不能用于子查询。机器学习元函数不支持临时表。
所有机器学习函数都会自动将 NUMERIC 实参转换为 FLOAT。
Vertica 支持机器学习函数，可在对数据进行分析之前根据需要准备数据。
根据 response_column 返回输入数据的平均分布视图。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
BALANCE ( 'output‑view', 'input‑relation', 'response‑column', 'balance‑method'
[ USING PARAMETERS sampling_ratio=ratio ] )
SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。hybrid_sampling：对不同类执行过采样和欠采样，因此平等展现每个类。
over_sampling：对所有类过采样，多数类除外，适用于多数类的基数。
under_sampling：对所有类欠采样，少数类除外，适用于少数类的基数。
weighted_sampling：under_sampling 的别名。
ratiohybrid_sampling 配合使用时，此值无效。
默认值： 1.0
非超级用户：
对输入关系的 SELECT 权限
输出视图架构的 CREATE 权限
=> CREATE TABLE backyard_bugs (id identity, bug_type int, finder varchar(20));
CREATE TABLE
=> COPY backyard_bugs FROM STDIN;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 1|Ants
>> 1|Beetles
>> 3|Ladybugs
>> 3|Ants
>> 3|Beetles
>> 3|Caterpillars
>> 2|Ladybugs
>> 3|Ants
>> 3|Beetles
>> 1|Ladybugs
>> 3|Ladybugs
>> \.
=> SELECT bug_type, COUNT(bug_type) FROM backyard_bugs GROUP BY bug_type;
bug_type | COUNT
----------+-------
2 | 1
1 | 3
3 | 7
(3 rows)
=> SELECT BALANCE('backyard_bugs_balanced', 'backyard_bugs', 'bug_type', 'under_sampling');
BALANCE
--------------------------
Finished in 1 iteration
(1 row)
=> SELECT bug_type, COUNT(bug_type) FROM backyard_bugs_balanced GROUP BY bug_type;
----------+-------
2 | 1
1 | 2
3 | 1
(3 rows)
采用数字列的输入关系，计算其每对输入列之间的皮尔逊相关系数。函数作为多阶段转换函数实施。
CORR_MATRIX ( input-columns ) OVER()
input-columnsCORR_MATRIX 以三元组格式返回关联矩阵。也就是说，每个成对关联通过三个返回的列标识：第一个变量的名称、第二个变量的名称和每对输入列的关联值。函数还会返回两个额外的列： number_of_ignored_input_rows 和 number_of_processed_input_rows。第四/五列的值表示输入中忽略/用于计算相应关联值的行数。任何包含 NULL、Inf 或 NaN 的输入对都将被忽略。
关联矩阵对称，所有对角元素的值均为 1；因此，只能返回对角线以上元素的值 — 即上三角。尽管如此，函数返回整个矩阵以简化任何后续操作。因此，输出行数为：
(#input‑columns)^2
前两个输出列为 VARCHAR(128) 类型，第三个输出列为 FLOAT 类型，最后两个输出列为 INT 类型。
OVER 子句的内容必须为空。
当输入表为空时，函数不会返回任何行。
当 X_i 和 Y_i 中的任何一个为 NULL、Inf 或 NaN 时，该对将不纳入 CORR(X, Y) 计算。也就是说，任何包含 NULL、Inf 或 NaN 的输入对都将被忽略。
对于 (X,X) 对，无论 X 的内容如何：CORR(X,X) = 1、number_of_ignored_input_rows = 0 且 number_of_processed_input_rows = #input_rows。
当 (NSUMX2 == SUMXSUMX) 或 (NSUMY2 == SUMYSUMY) 时，则 CORR(X, Y) 的值将为 NULL。理论上，可能发生在具有常数值的列的情况；然而，由于舍入误差，可能无法始终观察到。
在特殊情况下，即 (X_i,Y_i) 的所有对值均包含 NULL、inf 或 NaN 且 X != Y：CORR(X,Y)=NULL。
下面的示例使用 iris 数据集。*
根据异常值阈值返回数据集中的异常值。输出为包含异常值的表。 DETECT_OUTLIERS 使用检测方法 robust_szcore 使每个输入列实现标准化。然后，函数将包含大于默认或指定阈值的标准化值的所有行标识为异常值。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
DETECT_OUTLIERS ( 'output‑table', 'input‑relation','input‑columns', 'detection‑method'
[ USING PARAMETERS
[outlier_threshold = threshold]
[, exclude_columns = 'excluded‑columns']
[, partition_columns = 'partition‑columns'] ] )
input_columns 的异常值行的表的名称。所有列均存在于此表中。SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。robust_zscore。outlier_threshold默认值： 3.0
exclude_columnsinput-columns 中要排除在处理范围之外的列名的逗号分隔列表。
partition_columnsDETECT_OUTLIERS 分别检测每个分区中的异常值。
默认值： 空列表
非超级用户：
对输入关系的 SELECT 权限
对输出表的 CREATE 权限
以下示例显示了 DETECT_OUTLIERS 的用法：
=> CREATE TABLE baseball_roster (id identity, last_name varchar(30), hr int, avg float);
CREATE TABLE
=> COPY baseball_roster FROM STDIN;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> Polo|7|.233
>> Gloss|45|.170
>> Gus|12|.345
>> Gee|1|.125
>> Laus|3|.095
>> Hilltop|16|.222
>> Wicker|78|.333
>> Scooter|0|.121
>> Hank|999999|.8888
>> Popup|35|.378
>> \.
=> SELECT * FROM baseball_roster;
id | last_name | hr | avg
----+-----------+--------+--------
3 | Gus | 12 | 0.345
4 | Gee | 1 | 0.125
6 | Hilltop | 16 | 0.222
10 | Popup | 35 | 0.378
1 | Polo | 7 | 0.233
7 | Wicker | 78 | 0.333
9 | Hank | 999999 | 0.8888
2 | Gloss | 45 | 0.17
5 | Laus | 3 | 0.095
8 | Scooter | 0 | 0.121
(10 rows)
=> SELECT DETECT_OUTLIERS('baseball_outliers', 'baseball_roster', 'id, hr, avg', 'robust_zscore' USING PARAMETERS
outlier_threshold=3.0);
DETECT_OUTLIERS
--------------------------
Detected 2 outliers
(1 row)
=> SELECT * FROM baseball_outliers;
id | last_name | hr | avg
----+-----------+------------+-------------
7 | Wicker | 78 | 0.333
9 | Hank | 999999 | 0.8888
(2 rows)
训练并返回隔离森林 (iForest) 模型。训练模型后，可以使用 APPLY_IFOREST 函数预测输入关系中的异常值。
有关 iForest 算法工作原理的详细信息，请参阅隔离森林。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
IFOREST( 'model‑name', 'input‑relation', 'input‑columns' [ USING PARAMETERS param=value[,...] ] )
CHAR、VARCHAR 和 BOOL 类型的列视为分类特征；所有其他类型的列则视为数字特征。
exclude_columns默认值： 空字符串 ('')
ntree默认值： 100
sampling_size默认值： 0.632
col_sample_by_tree默认值： 1.0
max_depth默认值： 10
nbins默认值： 32
detailspredictor：预测变量的名称与训练模型时指定的顺序相同。
type：预测变量的类型的顺序与其名称在 predictor 中的顺序相同。
tree_countrejected_row_countaccepted_row_countrejected_row_count。call_string非超级用户：
对创建模型的架构的 CREATE 权限
对输入关系的 SELECT 权限
在以下示例中，函数的输入数据包含 INT、VARCHAR 和 FLOAT 类型的列：
=> SELECT IFOREST('baseball_anomalies','baseball','team, hr, hits, avg, salary' USING PARAMETERS ntree=75, sampling_size=0.7,
max_depth=15);
IFOREST
----------
Finished
(1 row)
您可以通过调用 GET_MODEL_SUMMARY 并检查详细信息部分来验证是否正确读取所有输入列：
=> SELECT GET_MODEL_SUMMARY(USING PARAMETERS model_name='baseball_anomalies');
GET_MODEL_SUMMARY
-------------------------------------------------------------------------------------------------------------------------------------
===========
call_string
===========
SELECT iforest('public.baseball_anomalies', 'baseball', 'team, hr, hits, avg, salary' USING PARAMETERS exclude_columns='', ntree=75,
sampling_size=0.7, col_sample_by_tree=1, max_depth=15, nbins=32);
=======
details
=======
predictor| type
---------+----------------
team |char or varchar
hr | int
hits | int
avg |float or numeric
salary |float or numeric
===============
Additional Info
===============
Name |Value
------------------+-----
tree_count | 75
rejected_row_count| 0
accepted_row_count|1000
(1 row)
根据每列中变量的观察值，使用平均值或众数估算数据集中的缺失值。此函数支持数字和分类数据类型。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
IMPUTE( 'output‑view', 'input‑relation', 'input‑columns', 'method'
[ USING PARAMETERS [exclude_columns = 'excluded‑columns'] [, partition_columns = 'partition‑columns'] ] )
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。mean：每列中的缺失值将替换为该列的平均值。此方法仅适用于数字数据。
mode：每列中的缺失值将替换为该列中出现频率最高的值。此方法仅适用于分类数据。
exclude_columnsinput-columns 中要排除在处理范围之外的列名的逗号分隔列表。
partition_columns非超级用户：
对输入关系的 SELECT 权限
输出视图架构的 CREATE 权限
在 small_input_impute 表上执行 IMPUTE，指定平均值方法：
=> SELECT impute('output_view','small_input_impute', 'pid, x1,x2,x3,x4','mean'
USING PARAMETERS exclude_columns='pid');
impute
--------------------------
Finished in 1 iteration
(1 row)
执行IMPUTE，指定模式方法：
=> SELECT impute('output_view3','small_input_impute', 'pid, x5,x6','mode' USING PARAMETERS exclude_columns='pid');
impute
--------------------------
Finished in 1 iteration
(1 row)
对输入关系运行标准化算法。输出是具有标准化数据的视图。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
NORMALIZE ( 'output‑view', 'input‑relation', 'input‑columns', 'normalization‑method'
[ USING PARAMETERS exclude_columns = 'excluded‑columns' ] )
SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。minmax
zscore
robust_zscore
如果表中出现无穷大值，该方法将自动忽略这些值。
exclude_columnsinput-columns 中要排除在处理范围之外的列名的逗号分隔列表。
非超级用户：
对输入关系的 SELECT 权限
输出视图架构的 CREATE 权限
这些示例显示了如何在 mtcars 表的 wt 和 hp 列上使用 NORMALIZE 函数。
执行 NORMALIZE 函数，并指定 minmax 方法：
=> SELECT NORMALIZE('mtcars_norm', 'mtcars',
'wt, hp', 'minmax');
NORMALIZE
--------------------------
Finished in 1 iteration
(1 row)
执行 NORMALIZE 函数，并指定 zscore 方法：
=> SELECT NORMALIZE('mtcars_normz','mtcars',
'wt, hp', 'zscore');
NORMALIZE
--------------------------
Finished in 1 iteration
(1 row)
执行 NORMALIZE 函数，并指定 robust_zscore 方法：
=> SELECT NORMALIZE('mtcars_normz', 'mtcars',
'wt, hp', 'robust_zscore');
NORMALIZE
--------------------------
Finished in 1 iteration
(1 row)
NORMALIZE_FIT 计算输入关系中每个指定列的标准化参数。生成的模型将存储标准化参数。例如，对于 MinMax 标准化，每列的最小值和最大值都存储在模型中。生成的模型用作函数 APPLY_NORMALIZE 和 REVERSE_NORMALIZE 的输入。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
NORMALIZE_FIT ( 'model‑name', 'input‑relation', 'input‑columns', 'normalization‑method'
[ USING PARAMETERS [exclude_columns = 'excluded‑columns'] [, output_view = 'output‑view'] ] )
SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。minmax
zscore
robust_zscore
如果指定 robust_zscore，则 NORMALIZE_FIT 使用函数 APPROXIMATE_MEDIAN [聚合]。
所有标准化方法都将忽略输入关系中的无穷大、负无穷大或 NULL 值。
exclude_columnsinput-columns 中要排除在处理范围之外的列名的逗号分隔列表。
output_viewdataminmax：
colNames：模型列名称
mins：每列的最小值
maxes：每列的最大值
非超级用户：
对创建模型的架构的 CREATE 权限
对输入关系的 SELECT 权限
输出视图架构的 CREATE 权限
以下示例使用表 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)
为要编码的每个功能生成每个类别级别的排序列表，并存储模型。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
ONE_HOT_ENCODER_FIT ( 'model‑name', 'input‑relation','input‑columns'
[ USING PARAMETERS
[exclude_columns = 'excluded‑columns']
[, output_view = 'output‑view']
[, extra_levels = 'category‑levels'] ] )
SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。exclude_columnsinput-columns 中要排除在处理范围之外的列名的逗号分隔列表。
output_viewextra_levelscall_stringvarchar_categories integer_categories boolean_categories date_categoriescategory_name：列名称
category_level：类别的级别，按类别排序
category_level_index：此分类级别在类别级别的排序列表中的索引。
非超级用户：
对创建模型的架构的 CREATE 权限
对输入关系的 SELECT 权限
输出视图架构的 CREATE 权限
=> SELECT ONE_HOT_ENCODER_FIT ('one_hot_encoder_model','mtcars','*'
USING PARAMETERS exclude_columns='mpg,disp,drat,wt,qsec,vs,am');
ONE_HOT_ENCODER_FIT
--------------------
Success
(1 row)
通过输入表/视图计算主组件。结果保存在 PCA 模型中。在内部，PCA 使用基于输入日期构建的协方差矩阵的 SVD 来查找组件。该分解的奇异值也保存在 PCA 模型中，作为其一部分。可以在不同的运行中同时翻转一个主组件的所有元素符号。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
PCA ( 'model‑name', 'input‑relation', 'input‑columns'
[ USING PARAMETERS
[exclude_columns = 'excluded‑columns']
[, num_components = num‑components]
[, scale = is‑scaled]
[, method = 'method'] ] )
exclude_columnsinput-columns 中要排除在处理范围之外的列名的逗号分隔列表。
num_componentsscaleTrue：使用相关系数矩阵，而非协方差矩阵。
False （默认值）
methodLAPACK。columnsindex
name
singular_valuesindex
value
explain_variance：对应于该奇异值的数据方差的百分比
accumulated_explained_variance：删除当前奇异值之后的所有奇异值后，可以保留的数据方差的百分比
principal_componentsindex：各组件中元素的索引
PC1
PC2
...
counterscounter_name
Accepted_row_count：数据中有效行的数量
denied_row_count：数据中无效行（具有 NULL、INF 或 NaN）的数量
iteration_count：迭代次数，对于当前的 PCA 操作，始终为 1
counter_value
call_string非超级用户：
对创建模型的架构的 CREATE 权限
对输入关系的 SELECT 权限
=> 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)
分三列返回分类数据输入的统计摘要：
CATEGORY：分类级别，与汇总列具有相同的 SQL 数据类型
COUNT：类别级别的数量，类型为 INTEGER
PERCENT：表示类别百分比，类型为 FLOAT
SUMMARIZE_CATCOL (target‑column
[ USING PARAMETERS TOPK = topk‑value [, WITH_TOTALCOUNT = show‑total] ] )
OVER()
BOOLEAN
FLOAT
INTEGER
DATE
CHAR/VARCHAR
TOPKWITH_TOTALCOUNT默认值： true
此示例显示了 salary_data 表中 current_salary 列的分类摘要。查询输出中显示列类别、计数和百分比。第一列列出分类级别，其与输入列具有相同的 SQL 数据类型，第二列列出该值的计数，第三列列出百分比。
=> SELECT SUMMARIZE_CATCOL (current_salary USING PARAMETERS TOPK = 5) OVER() FROM salary_data;
CATEGORY | COUNT | PERCENT
---------+-------+---------
| 1000 | 100
39004 | 2 | 0.2
35321 | 1 | 0.1
36313 | 1 | 0.1
36538 | 1 | 0.1
36562 | 1 | 0.1
(6 rows)
返回 Vertica 表中列的统计摘要：
Count
平均值
标准偏差
最小值/最大值
近似百分位
中间值
除了计数为 INTEGER 类型，所有汇总值均为 FLOAT 数据类型。
SUMMARIZE_NUMCOL (input‑columns [ USING PARAMETERS exclude_columns = 'excluded‑columns'] ) OVER()
SUMMARIZE_NUMCOL 将标准化模型中的所有列exclude_columnsinput-columns 中要排除在处理范围之外的列名的逗号分隔列表。
显示 employee 表中 age 和 salary 列的统计摘要：
=> SELECT SUMMARIZE_NUMCOL(* USING PARAMETERS exclude_columns='id,name,gender,title') OVER() FROM employee;
COLUMN | COUNT | MEAN | STDDEV | MIN | PERC25 | MEDIAN | PERC75 | MAX
---------------+-------+------------+------------------+---------+---------+---------+-----------+--------
age | 5 | 63.4 | 19.3209730603818 | 44 | 45 | 67 | 71 | 90
salary | 5 | 3456.76 | 1756.78754300285 | 1234.56 | 2345.67 | 3456.78 | 4567.89 | 5678.9
(2 rows)
计算输入关系的 SVD 分解的奇异值（S 矩阵的对角线）和右奇异向量（V 矩阵）。结果将保存为 SVD 模型。可以在不同的运行中同时翻转 SVD 中奇异向量的所有元素符号。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
SVD ( 'model‑name', 'input‑relation', 'input‑columns'
[ USING PARAMETERS
[exclude_columns = 'excluded‑columns']
[, num_components = num‑components]
[, method = 'method'] ] )
exclude_columnsinput-columns 中要排除在处理范围之外的列名的逗号分隔列表。
num_componentsmethodLAPACK。columnsindex
name
singular_valuesindex
value
explain_variance：对应于该奇异值的数据方差的百分比
accumulated_explained_variance：删除当前奇异值之后的所有奇异值后，可以保留的数据方差的百分比
right_singular_vectorsindex：每个向量中元素的索引
vector1
vector2
...
counterscounter_name
Accepted_row_count：数据中有效行的数量
denied_row_count：数据中无效行（具有 NULL、INF 或 NaN）的数量
iteration_count：迭代次数，对于当前的 SVD 操作，始终为 1
counter_value
call_string非超级用户：
对创建模型的架构的 CREATE 权限
对输入关系的 SELECT 权限
=> 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)
Vertica 支持各种机器学习函数，这些函数使用一组数据训练模型，并返回可进行保存以用于稍后执行的模型。
这些函数要求非超级用户具有以下权限：
对创建模型的架构的 CREATE 权限
对输入关系的 SELECT 权限
通过具有一致时间步长的平稳时间序列创建自回归 (AR) 模型，此模型可用于通过 PREDICT_AUTOREGRESSOR 进行预测。
自动回归模型将根据先前的值来预测时间序列的未来值。更具体地说，用户指定的 lag 决定了该模型在计算过程中要考虑多少个先前的时间段，且预测值为每个 lag 的线性组合。
由于输入数据必须按时间戳排序，因此，此算法为单线程算法。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
AUTOREGRESSOR ('model‑name', 'input‑relation', 'data‑column', 'timestamp‑column'
[ USING PARAMETERS
[ p = lags ]
[, missing = "imputation‑method" ]
[, regularization = "regularization‑method" ]
[, lambda = regularization‑value ]
[, compute_mse = boolean ]
] )
model‑nameinput‑relation该算法需要平稳的时间序列作为输入；使用平均值随着时间变化的时间序列可能会导致结果欠佳。
data‑columntimestamp‑columnpp 值会削弱相关性。
默认值： 3
missingdrop：忽略缺失值。
error：缺失值会引发错误。
zero：将缺失值替换为 0。
linear_interpolation：将缺失值替换为基于缺失值前后最近的有效条目的线性插值。这意味着如果数据集中第一个或最后一个值缺失，会将其直接删除。
默认值： linear_interpolation
regularization无
L2：权重正则化项，即惩罚权重的平方值
默认值： 无
lambda默认值： 1.0
compute_mse默认值： False
请参阅自回归模型示例。
对输入关系运行二分 k-means 算法。结果将生成一个具有群集中心层次结构的已训练模型，其包含一系列 k 值，每个值都可用于预测。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
BISECTING_KMEANS('model-name', 'input-relation', 'input-columns', 'num-clusters'
[ USING PARAMETERS
[exclude_columns = 'exclude-columns']
[, bisection_iterations = bisection-iterations]
[, split_method = 'split-method']
[, min_divisible_cluster_size = min-cluster-size]
[, kmeans_max_iterations = kmeans-max-iterations]
[, kmeans_epsilon = kmeans-epsilon]
[, kmeans_center_init_method = 'kmeans-init-method']
[, distance_method = 'distance-method']
[, output_view = 'output-view']
[, key_columns = 'key-columns'] ] )
SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。exclude_columnsinput-columns 中要排除在处理范围之外的列名的逗号分隔列表。
bisection_iterations如果设置为 >1，则允许算法运行并选择在每个二等分步骤中运行的最佳 k 均值。如果使用 kmeanspp，bisection_iterations 的值始终为 1，因为 kmeanspp 的运行成本更高（但也好过替代方案），因此它不需要多次运行。
默认值： 1
split_methodsize：选择最大群集进行二等分。
sum_squares：选择群集内平方和最大的群集进行二等分。
默认值： sum_squares
min_divisible_cluster_size默认值： 2
kmeans_max_iterations默认值： 10
kmeans_epsilon默认值： 1e-4
kmeans_center_init_methodkmeanspp （默认）：kmeans++ 算法
pseudo：使用 Spark 所用的“伪中心”方法，将给定中心二等分，但不迭代点
distance_method默认值： euclidean
output_viewkey_columnsexclude_columns 中。centershierarchyParentCluster：每个质心的父群集质心 — 即基于其通过二等分得到一个群集的群集质心。
LeftChildCluster：每个质心的左子群集质心 — 即将一个群集二等分后得到的第一个子群集的质心。
RightChildCluster：每个质心的右子群集质心 — 即将一个群集二等分得到的第二个子群集的质心。
BisectionLevel：指定通过其得到一个群集的二等分步骤。
WithinSS：当前群集的群集内平方和
TotalWithinSS：迄今为止获得的叶群集的群集内总平方和。
metrics总平方和
群集内总平方和
群集间总平方和
群集间平方和/总平方和
群集 x、center_id y[...] 的平方和
SELECT BISECTING_KMEANS('myModel', 'iris1', '*', '5'
USING PARAMETERS exclude_columns = 'Species,id', split_method ='sum_squares', output_view = 'myBKmeansView');
对输入关系执行 k-means 算法。结果是包含群集中心列表的模型。
您可以采用 VERTICA_MODELS 或 PMML 格式导出生成的 k 均值模型，以将其应用于 Vertica 外部的数据。您还可以在其他位置训练 k 均值模型，然后以 PMML 格式将其导入 Vertica，以对 Vertica 中的数据进行预测。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
KMEANS ( 'model‑name', 'input‑relation', 'input‑columns', 'num‑clusters'
[ USING PARAMETERS
[exclude_columns = 'excluded‑columns']
[, max_iterations = max‑iterations]
[, epsilon = epsilon‑value]
[, { init_method = 'init‑method' } | { initial_centers_table = 'init‑table' } ]
[, output_view = 'output‑view']
[, key_columns = 'key‑columns'] ] )
SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。init_method 和 initial_centers_table 互斥。如果同时设置两者，此函数将返回错误。
exclude_columnsinput-columns 中要排除在处理范围之外的列名的逗号分隔列表。
max_iterations默认值： 10
epsilon默认值： 1e-4
init_methodrandom
kmeanspp （默认）：kmeans++ 算法
如果 k 值过高，可能会占用大量内存。如果函数返回错误，提示可用内存不足，请减小 k 值或使用 random 方法。
initial_centers_tableoutput_viewkey_columnsoutput_view 的列。应选择这些列，以便其内容可以标识每个输入数据点。此参数仅在指定 output_view 时使用。input‑columns 中所列的仅用作 key_columns 而不用于训练的列应在 exclude_columns 中列出。centersmetrics以下示例创建 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)
对输入关系执行线性回归，并返回线性回归模型。
您可以采用 VERTICA_MODELS 或 PMML 格式导出生成的线性回归模型，以将其应用于 Vertica 外部的数据。您还可以在其他位置训练线性回归模型，然后以 PMML 格式将其导入 Vertica，以对 Vertica 中的数据进行预测。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
LINEAR_REG ( 'model‑name', 'input‑relation', 'response‑column', 'predictor‑columns'
[ USING PARAMETERS
[exclude_columns = 'excluded‑columns']
[, optimizer = 'optimizer‑method']
[, regularization = 'regularization‑method']
[, epsilon = epsilon‑value]
[, max_iterations = iterations]
[, lambda = lamda‑value]
[, alpha = alpha‑value]
[, fit_intercept = boolean‑value] ] )
SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。输入关系中表示模型自变量的列的逗号分隔列表，或者使用星号 (*) 以选择所有列。如果选择所有列，则参数 exclude_columns 的实参列表必须包含 response‑column，以及任何无效的列作为预测工具列。
所有预测工具列的类型必须为 numeric 或 BOOLEAN；否则模型无效。
exclude_columnsoptimizer默认值： 如果 regularization-method 设置为 L1 或 ENet，则为 CGD，否则将为 Newton。
regularizationNone （默认值）
L1
L2
ENet
epsilon在范围 (0.0，1.0) 内浮动，停止定型时的错误值。如果实际值和预测值之差小于或等于 epsilon，或者迭代次数超过 max_iterations，则定型停止。
默认值： 1e-6
max_iterations(0，1000000) 范围内的整数，指最大定型迭代次数。如果迭代次数超过 max_iterations，或者实际值与预测值之差小于或等于 epsilon，则定型停止。
默认值： 100
lambdaregularization 参数的值。
默认值： 1
alpharegularization 参数的值，该参数用于定义要提供的 L1 与 L2 正则化量。值 1 相当于 L1，值 0 相当于 L2。
值范围： [0,1]
默认值： 0.5
fit_interceptfit_intercept 设置为 false 不适用于 BFGS 优化器。
默认值： True
=> SELECT LINEAR_REG('myLinearRegModel', 'faithful', 'eruptions', 'waiting'
USING PARAMETERS optimizer='BFGS', fit_intercept=true);
LINEAR_REG
----------------------------
Finished in 10 iterations
(1 row)
对输入关系执行逻辑回归。结果是一个逻辑回归模型。
您可以以 VERTICA_MODELS 或 PMML 格式导出生成的逻辑回归模型，以将其应用于 Vertica 外部的数据。您还可以在其他位置训练逻辑回归模型，然后以 PMML 格式将其导入 Vertica，以对 Vertica 中的数据进行预测。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
LOGISTIC_REG ( 'model‑name', 'input‑relation', 'response‑column', 'predictor‑columns'
[ USING PARAMETERS [exclude_columns = 'excluded‑columns']
[, optimizer = 'optimizer‑method']
[, regularization = 'regularization‑method']
[, epsilon = epsilon‑value]
[, max_iterations = iterations]
[, lambda = lamda‑value]
[, alpha = alpha‑value]
[, fit_intercept = boolean‑value] ] )
SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。输入关系中表示模型自变量的列的逗号分隔列表，或者使用星号 (*) 以选择所有列。如果选择所有列，则参数 exclude_columns 的实参列表必须包含 response‑column，以及任何无效的列作为预测工具列。
所有预测工具列的类型必须为 numeric 或 BOOLEAN；否则模型无效。
exclude_columnsoptimizer默认值： 如果 regularization-method 设置为 L1 或 ENet，则为 CGD，否则将为 Newton。
regularizationNone （默认值）
L1
L2
ENet
epsilon在范围 (0.0，1.0) 内浮动，停止定型时的错误值。如果实际值和预测值之差小于或等于 epsilon，或者迭代次数超过 max_iterations，则定型停止。
默认值： 1e-6
max_iterations(0，1000000) 范围内的整数，指最大定型迭代次数。如果迭代次数超过 max_iterations，或者实际值与预测值之差小于或等于 epsilon，则定型停止。
默认值： 100
lambdaregularization 参数的值。
默认值： 1
alpharegularization 参数的值，该参数用于定义要提供的 L1 与 L2 正则化量。值 1 相当于 L1，值 0 相当于 L2。
值范围： [0,1]
默认值： 0.5
fit_interceptfit_intercept 设置为 false 不适用于 BFGS 优化器。
默认值： True
超级用户，或对输入关系的 SELECT 权限
=> SELECT LOGISTIC_REG('myLogisticRegModel', 'mtcars', 'am',
'mpg, cyl, disp, hp, drat, wt, qsec, vs, gear, carb'
USING PARAMETERS exclude_columns='hp', optimizer='BFGS', fit_intercept=true);
LOGISTIC_REG
----------------------------
Finished in 20 iterations
(1 row)
通过具有一致时间步长的平稳时间序列创建移动平均 (MA) 模型，此模型随后可用于通过 PREDICT_MOVING_AVERAGE 进行预测。
移动平均值模型使用早期预测误差进行未来预测。更具体地说，用户指定的 lag 决定了它在计算过程中要考虑多少先前的预测和错误。
由于输入数据必须按时间戳排序，因此，此算法为单线程算法。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
MOVING_AVERAGE ('model‑name', 'input‑relation', 'data‑column', 'timestamp‑column'
[ USING PARAMETERS
[ q = lags ]
[, missing = "imputation‑method" ]
[, regularization = "regularization‑method" ]
[, lambda = regularization‑value ]
[, compute_mse = boolean ]
] )
model‑nameinput‑relation该算法需要平稳的时间序列作为输入；使用平均值随着时间变化的时间序列可能会导致结果欠佳。
data‑columntimestamp‑columnq默认值： 1
missingdrop：忽略缺失值。
error：缺失值会引发错误。
zero：将缺失值替换为 0。
linear_interpolation：将缺失值替换为基于缺失值前后最近的有效条目的线性插值。这意味着如果数据集中第一个或最后一个值缺失，会将其直接删除。
默认值： linear_interpolation
regularization无
L2：权重正则化项，即惩罚权重的平方值
默认值： 无
lambda默认值： 1.0
compute_mse此参数仅接受“true”或“false”，不接受 BOOLEAN 的标准字面量等效项，如 1 或 0。
默认值： False
请参阅移动平均模型示例。
对输入关系执行朴素贝叶斯算法，并返回朴素贝叶斯模型。
根据数据类型处理列：
FLOAT：假定值遵循某种高斯分布。
INTEGER：假定值属于一个多项分布。
CHAR/VARCHAR：假定值遵循某种分类分布。这些列中存储的字符串值不得超过 128 个字符。
BOOLEAN：值被视为具有两个值的分类值。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
NAIVE_BAYES ( 'model‑name', 'input‑relation', 'response‑column', 'predictor‑columns'
[ USING PARAMETERS [exclude_columns = 'excluded‑columns'] [, alpha = alpha-value] ] )
SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。响应列的类型必须为数字、CHAR/VARCHAR 或 BOOLEAN；否则模型无效。
输入关系中表示模型自变量的列的逗号分隔列表，或者使用星号 (*) 以选择所有列。如果选择所有列，则参数 exclude_columns 的实参列表必须包含 response‑column，以及任何无效的列作为预测工具列。
所有预测变量列的类型必须为数字、CHAR/VARCHAR 或 BOOLEAN；否则模型无效。BOOLEAN 列值在训练前转换为 FLOAT 值：0 表示 false，1 表示 true。
exclude_columnsalpha默认值： 1.0
colsInfoindex：训练中提供的列的索引（从 0 开始）。索引 0 用于响应列。
name：列的名称。
type：用于响应的标签，其值为 Gaussian、Multinominal、Categorical 或 Bernoulli。
alphapriorlabel：类标签。
value：每个类的百分比。
nRowsTotalnRowsRejectedcallStrGaussianindex：预测变量列的索引。
mu：模型的平均值。
sigmaSq：模型的标准差平方。
Multinominalindex：预测变量列的索引。
prob：概率取决于由 class_name 指示的类。
Bernoulliindex：预测变量列的索引。
probTrue：此预测变量列中值为 TRUE 的概率。
Categoricalcategory：预测变量名称中的值。
<class_name>：具有该值的概率取决于由 class_name 指示的类。
超级用户或输入关系的 SELECT 权限。
=> SELECT NAIVE_BAYES('naive_house84_model', 'house84_train', 'party', '*'
USING PARAMETERS exclude_columns='party, id');
NAIVE_BAYES
--------------------------------------------------
Finished. Accepted Rows: 324 Rejected Rows: 0
(1 row)
训练随机森林模型，以对输入关系进行分类。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
RF_CLASSIFIER ( 'model‑name', input‑relation, 'response‑column', 'predictor‑columns'
[ USING PARAMETERS
[exclude_columns = 'excluded‑columns']
[, ntree = num‑trees]
[, mtry = num‑features]
[, sampling_size = sampling‑size]
[, max_depth = depth]
[, max_breadth = breadth]
[, min_leaf_size = leaf-size]
[, min_info_gain = threshold]
[, nbins = num‑bins] ] )
SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。输入关系中表示模型自变量的列的逗号分隔列表，或者使用星号 (*) 以选择所有列。如果选择所有列，则参数 exclude_columns 的实参列表必须包含 response‑column，以及任何无效的列作为预测工具列。
所有预测变量列的类型必须为数字、CHAR/VARCHAR 或 BOOLEAN；否则模型无效。
Vertica XGBoost 和随机森林算法为分类列 (BOOL/VARCHAR) 提供原生支持。仅需将分类列作为预测工具传递给模型，算法就会自动将这些列视为分类列，且不会尝试以与数值列相同的方式将它们拆分为多个二进制文件；Vertica 将这些列视为真正的分类值，而不是简单地将它们转换为底层的连续值。
exclude_columnsinput-columns 中要排除在处理范围之外的列名的逗号分隔列表。
ntree[1，1000] 范围内的整数，指森林中的树木数量。
默认值： 20
mtry默认值： 预测变量总数的平方根
sampling_size在 (0.0，1.0] 范围内浮动，指为定型每棵树而随机挑选的输入数据部分。
默认值： 0.632
max_depth[1，100] 范围内的整数，指每个树的最大深度。例如，max_depth 为 0 时，表示树只有一个根节点；max_depth 为 2 时，表示树有四个叶节点。
默认值： 5
max_breadth[1，1e9] 范围内的整数，指树可以拥有的最大叶节点数。
默认值： 32
min_leaf_size[1, 1e6] 范围内的整数，拆分节点后每个分支必须具有的最小样本数。在其左分支或右分支中导致较少剩余样本的拆分将被丢弃，并且该节点被视为叶节点。
默认值： 1
min_info_gain在 [0.0，1.0) 范围内浮动，指用于包括拆分的最小阈值。信息增益小于此阈值的拆分将被丢弃。
默认值： 0.0
nbins[2，1000] 范围内的整数，指用于离散连续特征的二进制文件数量。
默认值： 32
=> SELECT RF_CLASSIFIER ('myRFModel', 'iris', 'Species', 'Sepal_Length, Sepal_Width,
Petal_Length, Petal_Width' USING PARAMETERS ntree=100, sampling_size=0.3);
RF_CLASSIFIER
--------------------------------------------------
Finished training
(1 row)
训练随机森林模型，以对输入关系执行回归。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
RF_REGRESSOR ( 'model‑name', input‑relation, 'response‑column', 'predictor‑columns'
[ USING PARAMETERS
[exclude_columns = 'excluded‑columns']
[, ntree = num‑trees]
[, mtry = num‑features]
[, sampling_size = sampling‑size]
[, max_depth = depth]
[, max_breadth = breadth]
[, min_leaf_size = leaf-size]
[, min_info_gain = threshold]
[, nbins = num‑bins] ] )
SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。输入关系中表示模型自变量的列的逗号分隔列表，或者使用星号 (*) 以选择所有列。如果选择所有列，则参数 exclude_columns 的实参列表必须包含 response‑column，以及任何无效的列作为预测工具列。
所有预测变量列的类型必须为数字、CHAR/VARCHAR 或 BOOLEAN；否则模型无效。
Vertica XGBoost 和随机森林算法为分类列 (BOOL/VARCHAR) 提供原生支持。仅需将分类列作为预测工具传递给模型，算法就会自动将这些列视为分类列，且不会尝试以与数值列相同的方式将它们拆分为多个二进制文件；Vertica 将这些列视为真正的分类值，而不是简单地将它们转换为底层的连续值。
exclude_columnsntree[1，1000] 范围内的整数，指森林中的树木数量。
默认值： 20
mtry默认值： 预测变量总数的三分之一
sampling_size在 (0.0，1.0] 范围内浮动，指为定型每棵树而随机挑选的输入数据部分。
默认值： 0.632
max_depth[1，100] 范围内的整数，指每个树的最大深度。例如，max_depth 为 0 时，表示树只有一个根节点；max_depth 为 2 时，表示树有四个叶节点。
默认值： 5
max_breadth[1，1e9] 范围内的整数，指树可以拥有的最大叶节点数。
默认值： 32
min_leaf_size此参数的默认值与 sklearn 等库中的类似参数不同，因此会产生一个预测值与原始响应值不同的模型。
默认值： 5
min_info_gain在 [0.0，1.0) 范围内浮动，指用于包括拆分的最小阈值。信息增益小于此阈值的拆分将被丢弃。
默认值： 0.0
nbins[2，1000] 范围内的整数，指用于离散连续特征的二进制文件数量。
默认值： 32
=> SELECT RF_REGRESSOR ('myRFRegressorModel', 'mtcars', 'carb', 'mpg, cyl, hp, drat, wt' USING PARAMETERS
ntree=100, sampling_size=0.3);
RF_REGRESSOR
--------------
Finished
(1 row)
针对输入关系训练 SVM 模型。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
SVM_CLASSIFIER ( 'model‑name', input‑relation, 'response‑column', 'predictor‑columns'
[ USING PARAMETERS
[exclude_columns = 'excluded‑columns']
[, C = 'cost']
[, epsilon = 'epsilon‑value']
[, max_iterations = 'max‑iterations']
[, class_weights = 'weight']
[, intercept_mode = 'intercept‑mode']
[, intercept_scaling = 'scale'] ] )
SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。输入关系中表示模型自变量的列的逗号分隔列表，或者使用星号 (*) 以选择所有列。如果选择所有列，则参数 exclude_columns 的实参列表必须包含 response‑column，以及任何无效的列作为预测工具列。
所有预测工具列的类型必须为 numeric 或 BOOLEAN；否则模型无效。
exclude_columnsC默认值： 1.0
epsilon默认值： 1e-3
max_iterations默认值： 100
class_weightsNone （默认值）：不使用权重
value0、value1：两个逗号分隔的字符串，指定两个正 FLOAT 值，其中 value0 将权重分配给类 0，value1 将权重分配给类 1。
auto：根据样本数量对每个类别进行加权。
intercept_moderegularized （默认值）：适合截距并对其应用正则化。
unregularized：适合截距，但不包括在正则化中。
intercept_scaling以下示例在 mtcars 表上使用 SVM_CLASSIFIER：
=> SELECT SVM_CLASSIFIER(
'mySvmClassModel', 'mtcars', 'am', 'mpg,cyl,disp,hp,drat,wt,qsec,vs,gear,carb'
USING PARAMETERS exclude_columns = 'hp,drat');
SVM_CLASSIFIER
----------------------------------------------------------------
Finished in 15 iterations.
Accepted Rows: 32 Rejected Rows: 0
(1 row)
针对输入关系训练 SVM 模型。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
SVM_REGRESSOR ( 'model‑name', input‑relation, 'response‑column', 'predictor‑columns'
[ USING PARAMETERS
[exclude_columns = 'excluded‑columns']
[, error_tolerance = error-tolerance]
[, C = cost]
[, epsilon = epsilon‑value]
[, max_iterations = max‑iterations]
[, intercept_mode = 'mode']
[, intercept_scaling = 'scale'] ] )
SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。输入关系中表示模型自变量的列的逗号分隔列表，或者使用星号 (*) 以选择所有列。如果选择所有列，则参数 exclude_columns 的实参列表必须包含 response‑column，以及任何无效的列作为预测工具列。
所有预测工具列的类型必须为 numeric 或 BOOLEAN；否则模型无效。
exclude_columns默认值： 0.1
C默认值： 1.0
epsilon默认值： 1e-3
max_iterations默认值： 100
intercept_moderegularized （默认值）：适合截距并对其应用正则化。
unregularized：适合截距，但不包括在正则化中。
intercept_scaling
=> SELECT SVM_REGRESSOR('mySvmRegModel', 'faithful', 'eruptions', 'waiting'
USING PARAMETERS error_tolerance=0.1, max_iterations=100);
SVM_REGRESSOR
----------------------------------------------------------------
Finished in 5 iterations.
Accepted Rows: 272 Rejected Rows: 0
(1 row)
训练 XGBoost 模型以对输入关系执行分类。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
XGB_CLASSIFIER ('model-name', 'input-relation', 'response-column', 'predictor-columns'
[ USING PARAMETERS
[ exclude_columns = 'excluded-columns' ]
[, max_ntree = max-trees ]
[, max_depth = max-depth ]
[, objective = 'optimization-strategy' ]
[, learning_rate = learning-rate ]
[, min_split_loss = minimum ]
[, weight_reg = regularization ]
[, nbins = num-bins ]
[, sampling_size = fraction-of-rows ]
[, col_sample_by_tree = sample-ratio-per-tree ]
[, col_sample_by_node = sample-ratio-per-node ]
] )
model-name模型的名称（不区分大小写）。
input-relationSYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。response-columnpredictor-columnsCHAR、VARCHAR 和 BOOL 类型的列视为分类特征；所有其他类型的列则视为数字特征。
Vertica XGBoost 和随机森林算法为分类列 (BOOL/VARCHAR) 提供原生支持。仅需将分类列作为预测工具传递给模型，算法就会自动将这些列视为分类列，且不会尝试以与数值列相同的方式将它们拆分为多个二进制文件；Vertica 将这些列视为真正的分类值，而不是简单地将它们转换为底层的连续值。
exclude_columnsinput-columns 中要排除在处理范围之外的列名的逗号分隔列表。
max_ntree默认值： 10
max_depth默认值： 6
objective默认值： 'crossentropy'
split_proposal_methodglobal：/*describe */
local: /describe/
默认值： global
learning_rate默认值： 0.3
min_split_loss如果设置为 0 或省略，则不设置最小值。在这种情况下，根据正或负目标函数值修剪树。
默认值： 0.0（禁用）
weight_reg默认值： 1.0
nbins默认值： 32
sampling_size值 1 表示使用所有行。
默认值： 1.0
col_sample_by_tree值 1 表示使用所有列。
col_sample_by 如果指定多个参数，则参数彼此上下“堆叠”。即：假如有 24 列，对于 col_sample_by_tree=0.5 和 col_sample_by_node=0.5，col_sample_by_tree 将采样 12 列。这样将可用的未采样列池减少到 12。 col_sample_by_node 然后对剩余池的一半进行采样，因此每个节点采样 6 列。
此算法始终对至少一列进行采样。
默认值： 1
col_sample_by_node值 1 表示使用所有列。
col_sample_by 如果指定多个参数，则参数彼此上下“堆叠”。即：假如有 24 列，对于 col_sample_by_tree=0.5 和 col_sample_by_node=0.5，col_sample_by_tree 将采样 12 列。这样将可用的未采样列池减少到 12。 col_sample_by_node 然后对剩余池的一半进行采样，因此每个节点采样 6 列。
此算法始终对至少一列进行采样。
默认值： 1
请参阅XGBoost 用于分类。
训练 XGBoost 模型以对输入关系执行回归。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
XGB_REGRESSOR ('model-name', 'input-relation', 'response-column', 'predictor-columns'
[ USING PARAMETERS
[ exclude_columns = 'excluded-columns' ]
[, max_ntree = max-trees ]
[, max_depth = max-depth ]
[, objective = 'optimization-strategy' ]
[, learning_rate = learning-rate ]
[, min_split_loss = minimum ]
[, weight_reg = regularization ]
[, nbins = num-bins ]
[, sampling_size = fraction-of-rows ]
[, col_sample_by_tree = sample-ratio-per-tree ]
[, col_sample_by_node = sample-ratio-per-node ]
] )
model-name模型的名称（不区分大小写）。
input-relationSYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。response-columnpredictor-columnsCHAR、VARCHAR 和 BOOL 类型的列视为分类特征；所有其他类型的列则视为数字特征。
Vertica XGBoost 和随机森林算法为分类列 (BOOL/VARCHAR) 提供原生支持。仅需将分类列作为预测工具传递给模型，算法就会自动将这些列视为分类列，且不会尝试以与数值列相同的方式将它们拆分为多个二进制文件；Vertica 将这些列视为真正的分类值，而不是简单地将它们转换为底层的连续值。
exclude_columnsinput-columns 中要排除在处理范围之外的列名的逗号分隔列表。
max_ntree默认值： 10
max_depth默认值： 6
objectivesquarederror' 是唯一的选项。
默认值： 'squarederror'
split_proposal_methodglobal：/*describe */
local: /describe/
默认值： global
learning_rate默认值： 0.3
min_split_loss如果设置为 0 或省略，则不设置最小值。在这种情况下，根据正或负目标函数值修剪树。
默认值： 0.0（禁用）
weight_reg默认值： 1.0
nbins默认值： 32
sampling_size值 1 表示使用所有行。
默认值： 1.0
col_sample_by_tree值 1 表示使用所有列。
col_sample_by 如果指定多个参数，则参数彼此上下“堆叠”。即：假如有 24 列，对于 col_sample_by_tree=0.5 和 col_sample_by_node=0.5，col_sample_by_tree 将采样 12 列。这样将可用的未采样列池减少到 12。 col_sample_by_node 然后对剩余池的一半进行采样，因此每个节点采样 6 列。
此算法始终对至少一列进行采样。
默认值： 1
col_sample_by_node值 1 表示使用所有列。
col_sample_by 如果指定多个参数，则参数彼此上下“堆叠”。即：假如有 24 列，对于 col_sample_by_tree=0.5 和 col_sample_by_node=0.5，col_sample_by_tree 将采样 12 列。这样将可用的未采样列池减少到 12。 col_sample_by_node 然后对剩余池的一半进行采样，因此每个节点采样 6 列。
此算法始终对至少一列进行采样。
默认值： 1
请参阅用于回归的 XGBoost。
机器学习 API 包括一组 UDx 函数，这些函数将每个输入行的列转换为一个或多个对应的输出列。这些转换遵循之前创建的模型中定义的规则。例如，
APPLY_SVD 使用 SVD 模型来转换输入数据。
除非另有说明，否则这些函数要求非超级用户具有以下权限：
模型上的 USAGE 权限
对输入关系的 SELECT 权限
通常，给定无效的输入行，这些函数的返回值为 NULL。
将已训练的二分 k-means 模型应用于输入关系，并将每个新数据点分配给已训练模型中最接近的匹配群集。
SELECT APPLY_BISECTING_KMEANS( 'input-columns'
USING PARAMETERS model_name = 'model-name'
[, num_clusters = 'num-clusters']
[, match_by_pos = match‑by‑position] ] )
model_name模型的名称（不区分大小写）。
num_clusters 默认值： 模型为 k 指定的值
match_by_pos该布尔值指定输入列如何与模型特征匹配：
false （默认值）：按名称匹配。
true：按输入列列表中列的位置匹配。
非超级用户：模型所有者或模型的使用权限
将隔离森林 (iForest) 模型应用于输入关系。对于每个输入行，该函数返回包含两个字段的输出行：
anomaly_score：浮点值，表示模型中所有树的平均路径长度，按训练样本大小标准化。is_anomaly：布尔值，指示输入行是否异常。当 anomaly_score 等于或大于给定阈值时，此值为 true；否则，此值为 false。APPLY_IFOREST( input‑columns USING PARAMETERS param=value[,...] )
model_name 中的预测变量类型匹配。model_name模型的名称（不区分大小写）。
thresholdanomaly_score 等于或大于 threshold 的值，则该数据点被标记为异常值。
或者，您可以指定一个 contamination 值，该值设置一个阈值，其中标记为异常值的训练数据点的百分比约等于 contamination 的值。您不能在同一个函数调用中同时设置 contamination 和 threshold。
默认值： 0.7
match_by_posfalse：按名称匹配。
true：按输入列列表中列的位置匹配。
默认值：false
contaminationcontamination 值计算阈值。如果不设置此参数，该函数将使用指定或默认的 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)
将 APPLY_PCA 生成的转换反转回原始坐标系。
APPLY_INVERSE_PCA ( input‑columns
USING PARAMETERS model_name = 'model‑name'
[, exclude_columns = 'excluded‑columns']
[, key_columns = 'key‑columns'] )
所有列都必须为数字数据类型。
如果列名包含特殊字符，请用双引号将其括起来。
model_name模型的名称（不区分大小写）。
exclude_columnsinput-columns 中要排除在处理范围之外的列名的逗号分隔列表。
key_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)
将数据转换回原始域。这实质上是通过将三个矩阵相乘来计算原始数据的近似版本：矩阵 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'] )
所有列都必须为数字数据类型。
如果列名包含特殊字符，请用双引号将其括起来。
model_name模型的名称（不区分大小写）。
match_by_pos该布尔值指定输入列如何与模型特征匹配：
false （默认值）：按名称匹配。
true：按输入列列表中列的位置匹配。
exclude_columnsinput-columns 中要排除在处理范围之外的列名的逗号分隔列表。
key_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)
按照已知 k-means 模型将输入关系的每一行分配给一个群集中心。
APPLY_KMEANS ( input‑columns
USING PARAMETERS model_name = 'model‑name' [, match_by_pos = match‑by‑position] )
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)
UDTF 函数，用于将保存在模型中的标准化参数应用于一组指定的输入列。如果函数中指定的任何列不在模型中，则其数据都会原封不动地传递到 APPLY_NORMALIZE。
APPLY_NORMALIZE 为该列中的值返回 NaN。
APPLY_NORMALIZE ( input‑columns USING PARAMETERS model_name = 'model‑name');
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)
用户定义的转换函数 (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'] )
model_name模型的名称（不区分大小写）。
存储类别及其对应的级别。drop_firsttrue （默认值）：将分类变量的第一个级别视为引用级别。
false：分类变量的每个级别都在输出视图中具有对应的列
ignore_nulltrue （默认值）：Null 值将所有对应的 one-hot 二进制列设置为 null。
false：将 input-columns 中的 Null 值视为分类级别
separator默认值： 下划线 (_)
column_namingindices （默认值）：使用整数索引来表示分类级别。
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_nameignore_null 设置为 false 且 column_naming 设置为 values 或 values_relaxed 时使用。
默认值： 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)
使用 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'] )
所有列都必须为数字数据类型。
如果列名包含特殊字符，请用双引号将其括起来。
model_name模型的名称（不区分大小写）。
num_componentscutoff 参数，则保留所有模型组件。cutoffmatch_by_pos该布尔值指定输入列如何与模型特征匹配：
false （默认值）：按名称匹配。
true：按输入列列表中列的位置匹配。
exclude_columnsinput-columns 中要排除在处理范围之外的列名的逗号分隔列表。
key_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)
使用 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'] )
所有列都必须为数字数据类型。
如果列名包含特殊字符，请用双引号将其括起来。
model_name模型的名称（不区分大小写）。
num_componentscutoff 参数，则保留模型中的所有组件。cutoffnum_components 参数，则保留所有模型组件。match_by_posfalse （默认值）：按名称匹配。
true：按输入列列表中列的位置匹配。
exclude_columnsinput-columns 中要排除在处理范围之外的列名的逗号分隔列表。
key_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)
对输入关系应用自回归 (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>')
p 值）。请注意，input‑relation 在 start 之前的任何 p（训练期间设置）行中都不能包含缺失值。要处理缺失值，请参阅 IMPUTE 或 线性插值。
model_name模型的名称（不区分大小写）。
start如果 start 索引大于 timeseries-column 中的行数 N，则预测 N 到 start 之间的值并使用这些值进行预测。
如果为负，则从 input-relation 末尾倒数，对 start 索引进行标识。
对于 N 行的 input-relation，负值的下限为 -1000 或 -(N-p)，以其中较大者为准。
默认： input‑relation 的末尾
npredictions默认值： 10
missingdrop：忽略缺失值。
error：缺失值会引发错误。
zero：将缺失值替换为 0。
linear_interpolation：将缺失值替换为基于缺失值前后最近的有效条目的线性插值。如果预测范围内缺失值之前或之后的所有值缺失或无效，则无法指定插值且函数会出错。
默认值： linear_interpolation
请参阅自回归模型示例。
对输入关系应用线性回归模型，并将预测值以 FLOAT 形式返回。
PREDICT_LINEAR_REG ( input‑columns
USING PARAMETERS model_name = 'model‑name' [, match_by_pos = match‑by‑position] )
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)
对输入关系应用逻辑回归模型。
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] )
model_name模型的名称（不区分大小写）。
typeresponse （默认值）：预测值为 0 或 1。
probability：输出是预测类别为 1 的概率。
cutofftype 参数一起使用，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)
将由 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>')
q 值）。请注意，input‑relation 在 start 之前的任何 q（训练期间设置）行中都不能包含缺失值。要处理缺失值，请参阅 IMPUTE 或 线性插值。
model_name模型的名称（不区分大小写）。
start如果 start 索引大于 timeseries-column 中的行数 N，则预测 N 到 start 之间的值并使用这些值进行预测。
如果为负，则从 input-relation 末尾倒数，对 start 索引进行标识。
对于 N 行的 input-relation，负值的下限为 -1000 或 -(N-q)，以其中较大者为准。
默认： input‑relation 的末尾
npredictions默认值： 10
missingdrop：忽略缺失值。
error：缺失值会引发错误。
zero：将缺失值替换为 0。
linear_interpolation：将缺失值替换为基于缺失值前后最近的有效条目的线性插值。如果预测范围内缺失值之前或之后的所有值缺失或无效，则无法指定插值且函数会出错。
默认值： linear_interpolation
请参阅移动平均模型示例。
对输入关系应用朴素贝叶斯模型。
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] )
model_name模型的名称（不区分大小写）。
typeresponse （默认值）：返回概率最高的类。
probability：仅当设置 class 参数的情况下才有效，返回属于指定类实参的概率。
classtype 参数设置为 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)
对输入关系应用 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] )
model_name模型的名称（不区分大小写）。
key_columns用于标识输出行的预测工具列名称的逗号分隔列表。要排除这些和其他预测工具列用于预测，请将其包含在参数 exclude_columns 的实参列表中。
exclude_columnsclassesmatch_by_posfalse （默认值）：按名称匹配。
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)
对输入关系应用导入的 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] )
model_nameK-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;
对输入关系应用随机森林模型。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-columnsmodel_name模型的名称（不区分大小写）。
typeresponse （默认值）：所有可能的类中概率最高的类。
probability：仅当设置 class 参数的情况下才有效，返回指定类的概率。
classtype 参数设置为 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)
对输入关系应用随机森林模型并返回类的概率：
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] )
model_name模型的名称（不区分大小写）。
key_columns用于标识输出行的预测工具列名称的逗号分隔列表。要排除这些和其他预测工具列用于预测，请将其包含在参数 exclude_columns 的实参列表中。
exclude_columnsclassesmatch_by_posfalse （默认值）：按名称匹配。
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
对输入关系应用随机森林模型，并返回 FLOAT 数据类型，该数据类型用于指定随机森林模型的预测值，即森林中树木的平均预测值。
PREDICT_RF_REGRESSOR ( input‑columns
USING PARAMETERS model_name = 'model‑name' [, match_by_pos = match‑by‑position] )
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)
使用 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'] ] )
model_name模型的名称（不区分大小写）。
match_by_pos该布尔值指定输入列如何与模型特征匹配：
false （默认值）：按名称匹配。
true：按输入列列表中列的位置匹配。
typeresponse：输出 0 或 1 的预测类。
probability：输出位于 (0,1) 范围内的值，即使用逻辑函数转换的预测得分。
cutofftype 参数设置为 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)
使用 SVM 模型对输入关系中的样本执行回归，并将预测值以 FLOAT 数据类型返回。
PREDICT_SVM_REGRESSOR(input‑columns
USING PARAMETERS model_name = 'model‑name' [, match_by_pos = match‑by‑position] )
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)
对输入关系应用 TensorFlow 模型，并返回编码模型类型的预期结果。
PREDICT_TENSORFLOW ( input‑columns
USING PARAMETERS model_name = 'model‑name' [, num_passthru_cols = 'n-first-columns-to-ignore'] )
OVER( [window-partition-clause] )
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
对输入关系应用 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' ] )
model_name模型的名称（不区分大小写）。
typeresponse （默认值）：所有可能的类中概率最高的类。
probability：仅当设置 class 参数的情况下才有效，针对每个输入实例返回指定类或预测类的概率。
classtype 参数设置为 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 用于分类。
对输入关系应用 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] )
model_name模型的名称（不区分大小写）。
key_columns用于标识输出行的预测工具列名称的逗号分隔列表。要排除这些和其他预测工具列用于预测，请将其包含在参数 exclude_columns 的实参列表中。
exclude_columnsclassesmatch_by_posfalse （默认值）：按名称匹配。
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)
对输入关系应用 XGBoost 回归模型。 PREDICT_XGB_REGRESSOR 返回 FLOAT 数据类型，指定 XGBoost 模型的预测值：模型中每个树的贡献加权总和。
PREDICT_XGB_REGRESSOR ( input‑columns
USING PARAMETERS model_name = 'model‑name' [, match_by_pos = match‑by‑position] )
model_name模型的名称（不区分大小写）。
match_by_pos该布尔值指定输入列如何与模型特征匹配：
false （默认值）：按名称匹配。
true：按输入列列表中列的位置匹配。
请参阅用于回归的 XGBoost。
对标准化数据进行反向标准化转换，从而使标准化数据非标准化。如果您指定的列并非位于指定模型，则 REVERSE_NORMALIZE 会按原样返回该列。
REVERSE_NORMALIZE ( input‑columns USING PARAMETERS model_name = 'model‑name' );
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)
一组 Vertica 机器学习函数评估训练模型生成的预测数据，或返回有关模型本身的信息。
使用响应变量的观察值和预测值计算表的混淆矩阵。 CONFUSION_MATRIX 生成具有以下尺寸的表格：
行：类的数量
列：类的数量 + 2
CONFUSION_MATRIX ( targets, predictions [ USING PARAMETERS num_classes = num‑classes ] OVER()
实参 targets 和 predictions 必须设置为数据类型相同的输入列，即以下之一：INTEGER、BOOLEAN 或 CHAR/VARCHAR。根据数据类型，这些列将按如所示标识类：
INTEGER：从零开始的连续整数（介于 0 和 (num-classes-1) 之间），其中 num-classes 为类数。例如，给定以下输入列值 — {0, 1, 2, 3, 4} — Vertica 假定有五个类。
{0, 1, 3, 5, 6,} — Vertica 假设有七个类。
BOOLEAN：“是”或“否”
CHAR/VARCHAR：类名。如果输入列的类型为 CHAR/VARCHAR 列，则还必须将参数 num_classes 设置为类数。
Vertica 将类数计算为两个输入列中值的并集。例如，假如 targets 和 predictions 中的值集输入列为如下所示，则 Vertica 将计为四个类：
{'milk', 'soy milk', 'cream'}
{'soy milk', 'almond milk'}
num_classes一个整数 > 1，指定要传递给该函数的类数。
如果指定的输入列为 CHAR/VARCHAR 类型，则必须设置此参数。否则，该函数将根据列数据类型处理此参数：
INTEGER：默认设置为 2，如果类数为任何其他值，则必须正确设置此参数。
BOOLEAN：默认设置为 2，不能设置为任何其他值。
此示例计算逻辑回归模型的混淆矩阵，该模型将 mtcars 数据集中的汽车分为自动档或手动档。观察值在输入列 obs 中，而预测值在输入列 pred 中。因为这是一个二元分类问题，所以所有值都是 0 或 1。
在返回的表中，列 am 中值为 0 的所有 19 辆汽车都被 PREDICT_LOGISTIC_REGRESSION 正确预测其值为 0。在 am 列中值为 1 的 13 辆汽车中，12 辆被正确预测其值为 1，而 1 辆汽车被错误地分类为值 0：
=> SELECT CONFUSION_MATRIX(obs::int, pred::int USING PARAMETERS num_classes=2) OVER()
FROM (SELECT am AS obs, PREDICT_LOGISTIC_REG(mpg, cyl, disp,drat, wt, qsec, vs, gear, carb
USING PARAMETERS model_name='myLogisticRegModel')AS PRED
FROM mtcars) AS prediction_output;
actual_class | predicted_0 | predicted_1 | comment
-------------+-------------+-------------+------------------------------------------
0 | 19 | 0 |
1 | 0 | 13 | Of 32 rows, 32 were used and 0 were ignored
(2 rows)
使用输入关系对学习算法执行 k-fold 交叉验证，并对超参数执行网格搜索。输出是所选算法的平均性能指标。该函数支持 SVM 分类、朴素贝叶斯和逻辑回归。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
CROSS_VALIDATE ( 'algorithm', 'input‑relation', 'response‑column', 'predictor‑columns'
[ USING PARAMETERS
[exclude_columns = 'excluded‑columns']
[, cv_model_name = 'model']
[, cv_metrics = 'metrics']
[, cv_fold_count = num‑folds]
[, cv_hyperparams = 'hyperparams']
[, cv_prediction_cutoff = prediction‑cutoff] ] )
SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。输入关系中表示模型自变量的列的逗号分隔列表，或者使用星号 (*) 以选择所有列。如果选择所有列，则参数 exclude_columns 的实参列表必须包含 response‑column，以及任何无效的列作为预测工具列。
exclude_columnscv_model_nameGET_MODEL_ATTRIBUTE 和
GET_MODEL_SUMMARY 检索结果cv_metricsaccuracy （默认值）
error_rate
TP：真阳性，预测为 1 类的 1 类案例数
FP：假阳性，预测为 1 类的 0 类案例数
TN：真阴性，预测为 0 类的 0 类案例数
FN：假阴性，预测 0 类的 1 类案例数
TPR 或 recall：真阳性率，1 类中的正确预测
FPR：假阳性率，0 类中的错误预测
TNR：真阴性率，0 类中的正确预测
FNR：假阴性率，1 类中的错误预测
PPV 或 precision：阳性预测值，预测为 1 类案例中的正确预测
NPV：阴性预测值，预测为 0 类案例中的正确预测
MSE：均方误差
MAE：平均绝对误差
rsquared：决定系数
explained_variance
fscore
(1 + beta˄2) * precison * recall / (beta˄2 * precision + recall)
beta 默认等于 1
auc_roc：使用指定数量 bin 的 ROC 的 AUC，默认为 100
auc_prc：使用指定数量 bin 的 PRC 的 AUC，默认为 100
counts：解析为其他四个指标的快捷方式：TP、FP、TN 和 FN
count：仅在 JSON 语法中有效，计算由一个类 (case-class-label) 标记但预测为另一类 (predicted-class-label) 的案例数：
cv_metrics='[{"count":[case-class-label, predicted-class-label]}]'
cv_fold_count默认值： 5
cv_hyperparams{"param1":[value1,value2,...], "param2":{"first":first_value, "step":step_size, "count":number_of_values} }
应使用 JSON 标准引用超参数名称和字符串值。这些参数被传递给训练函数。
cv_prediction_cutoff默认值： 0.5
call_stringCROSS_VALIDATE 时指定的所有输入实参的值。run_averagecv_metrics 中指定的所有指标的所有折叠的平均值（如果指定）；否则为平均精度。fold_infofold_id：折叠的索引。
row_count：折叠中为测试而保留的行数。
countersaccepted_row_count：input_relation 中的总行数减去拒绝的行数。
rejected_row_count：因包含无效值而跳过的 input_relation 行数。
feature_count：输入到机器学习模型的特征数量。
run_detailsfold_id：保留用于测试的折叠的索引。
iteration_count：在非保留折叠的模型训练中使用的迭代数。
accuracy：参数 cv_metrics 中指定的所有指标，或精度（如果未提供 cv_metrics）。
error_rate：参数 cv_metrics 中指定的所有指标，或精度（如果忽略该参数）。
非超级用户：
对输入关系的 SELECT 权限
机器学习算法在其中生成模型的默认架构的 CREATE 和 USAGE 权限。如果提供了 cv_model_name，则交叉验证结果将作为模型保存在同一架构中。
参数 cv_metrics 可以将指标指定为 JSON 对象 的数组，其中每个对象指定一个指标名称。例如，以下表达式将 cv_metrics 设置为指定为 JSON 对象的两个指标，即 accuracy 和 error_rate：
cv_metrics='["accuracy", "error_rate"]'
在下一个示例中，cv_metrics 设置为两个指标，即 accuracy 和 TPR（真阳性率）。此处，TPR 指标被指定为一个 JSON 对象，它接受一个包含两个类标签实参（即 2 和 3）的数组：
cv_metrics='[ "accuracy", {"TPR":[2,3] } ]'
指定为 JSON 对象的指标可以接受参数。在以下示例中，fscore 指标指定参数 beta，该参数设置为 0.5：
cv_metrics='[ {"fscore":{"beta":0.5} } ]'
参数支持对于某些指标特别有用。例如，指标 auc_roc 和 auc_prc 构建一条曲线，然后计算该曲线下的面积。对于 ROC，曲线是通过绘制指标 TPR 与 FPR 而成的；对于 PRC，通过绘制指标 PPV (precision) 与 TPR (recall) 而成。通过将参数 num_bins 设置为大于默认值 100 的值，可以提高此类曲线的精度。例如，以下表达式计算使用 1000 个 bin 构建的 ROC 曲线的 AUC：
cv_metrics='[{"auc_roc":{"num_bins":1000}}]'
所有支持的指标均为二元分类器函数
LOGISTIC_REG 和
SVM_CLASSIFIER 而定义。对于
NAIVE_BAYES 等多类分类器函数，可以针对每个 one-versus-the-rest 二元分类器计算这些指标。使用实参请求每个分类器的指标。例如，如果训练数据具有整数类标签，您可以使用 precision (PPV) 指标设置 cv_metrics，如下所示：
cv_metrics='[{"precision":[0,4]}]'
此设置指定返回为两个分类器计算精度的两列：
第 1 列：对 0 与非 0 进行分类
第 2 列：对 4 与非 4 进行分类
如果忽略类标签实参，则使用索引为 1 的类。不是为单个 one-versus-the-rest 分类器计算指标，而是以下列方式之一计算平均值：macro、micro 或 weighted（默认）。例如，以下 cv_metrics 设置返回按类大小加权的平均值：
cv_metrics='[{"precision":{"avg":"weighted"}}]'
可以采用类似方式为多类分类器定义 AUC 类型的指标。例如，以下 cv_metrics 设置计算每个 one-versus-the-rest 分类器的 ROC 曲线下面积，然后返回按类大小加权的平均值。
cv_metrics='[{"auc_roc":{"avg":"weighted", "num_bins":1000}}]'
=> SELECT CROSS_VALIDATE('svm_classifier', 'mtcars', 'am', 'mpg'
USING PARAMETERS cv_fold_count= 6,
cv_hyperparams='{"C":[1,5]}',
cv_model_name='cv_svm',
cv_metrics='accuracy, error_rate');
CROSS_VALIDATE
----------------------------
Finished
===========
run_average
===========
C |accuracy |error_rate
---+--------------+----------
1 | 0.75556 | 0.24444
5 | 0.78333 | 0.21667
(1 row)
使用输入表返回一个计算错误分类率并将其显示为 FLOAT 值的表。 ERROR_RATE 返回具有以下维度的表：
行：类数加上包含跨类总错误率的一行
列：2
ERROR_RATE ( targets, predictions [ USING PARAMETERS num_classes = num‑classes ] ) OVER()
实参 targets 和 predictions 必须设置为数据类型相同的输入列，即以下之一：INTEGER、BOOLEAN 或 CHAR/VARCHAR。根据数据类型，这些列将按如所示标识类：
INTEGER：从零开始的连续整数（介于 0 和 (num-classes-1) 之间），其中 num-classes 为类数。例如，给定以下输入列值 — {0, 1, 2, 3, 4} — Vertica 假定有五个类。
{0, 1, 3, 5, 6,} — Vertica 假设有七个类。
BOOLEAN：“是”或“否”
CHAR/VARCHAR：类名。如果输入列的类型为 CHAR/VARCHAR 列，则还必须将参数 num_classes 设置为类数。
Vertica 将类数计算为两个输入列中值的并集。例如，假如 targets 和 predictions 中的值集输入列为如下所示，则 Vertica 将计为四个类：
{'milk', 'soy milk', 'cream'}
{'soy milk', 'almond milk'}
num_classes一个整数 > 1，指定要传递给该函数的类数。
如果指定的输入列为 CHAR/VARCHAR 类型，则必须设置此参数。否则，该函数将根据列数据类型处理此参数：
INTEGER：默认设置为 2，如果类数为任何其他值，则必须正确设置此参数。
BOOLEAN：默认设置为 2，不能设置为任何其他值。
非超级用户：模型所有者或模型的使用权限
此示例说明如何对名为 mtcars 的输入表执行 ERROR_RATE 函数。obs 列中显示响应变量，而 pred 列中显示预测值。由于该示例是一个分类问题，因此所有的响应变量值和预测变量值都是 0 或 1，表示二元分类。
在函数返回的表中，第一列显示类 ID 列。第二列显示该类 ID 的相应错误率。第三列表示该函数成功使用了多少行以及是否忽略了任何行。
=> SELECT ERROR_RATE(obs::int, pred::int USING PARAMETERS num_classes=2) OVER()
FROM (SELECT am AS obs, PREDICT_LOGISTIC_REG (mpg, cyl, disp, drat, wt, qsec, vs, gear, carb
USING PARAMETERS model_name='myLogisticRegModel', type='response') AS pred
FROM mtcars) AS prediction_output;
class | error_rate | comment
-------+--------------------+---------------------------------------------
0 | 0 |
1 | 0.0769230797886848 |
| 0.03125 | Of 32 rows, 32 were used and 0 were ignored
(3 rows)
返回一个对比机器学习模型的可预测质量的表。此函数也被称为提升图。
LIFT_TABLE ( targets, probabilities
[ USING PARAMETERS [num_bins = num‑bins] [, main_class = class‑name ] ] )
OVER()
num_bins该整数值用于确定决策边界的数量。决策边界以 0 和 1（包含）之间的等距间隔设置。该函数在每个 num‑bin + 1 点处计算一次表。
默认值：100
main_class仅当 targets 是 CHAR/VARCHAR 类型时使用，请指定要与 probabilities 实参关联的类。
对输入表 mtcars 执行 LIFT_TABLE。
=> SELECT LIFT_TABLE(obs::int, prob::float USING PARAMETERS num_bins=2) OVER()
FROM (SELECT am AS obs, PREDICT_LOGISTIC_REG(mpg, cyl, disp, drat, wt, qsec, vs, gear, carb
USING PARAMETERS model_name='myLogisticRegModel',
type='probability') AS prob
FROM mtcars) AS prediction_output;
decision_boundary | positive_prediction_ratio | lift | comment
-------------------+---------------------------+------------------+---------------------------------------------
1 | 0 | NaN |
0.5 | 0.40625 | 2.46153846153846 |
0 | 1 | 1 | Of 32 rows, 32 were used and 0 were ignored
(3 rows)
第一列 decision_boundary 指示将响应值分类为 0 还是 1 的分界点。例如，对于每行，如果 prob 大于或等于 decision_boundary，将响应值分类为 1。如果 prob 小于 decision_boundary，将响应值分类为 0。
第二列中，positive_prediction_ratio 表示分类 1 中使用相应 decision_boundary 值进行争取分类的样本比例。
第三列中，lift 函数用正确或错误分类为类 1 的行百分比来除 positive_prediction_ratio。
返回一个表，其中显示机器学习模型中预测和响应列的均方误差。
MSE ( targets, predictions ) OVER()
对输入表 faithful_testing 执行 MSE 函数。obs 列中显示响应变量，而 prediction 列中显示预测值。
=> SELECT MSE(obs, prediction) OVER()
FROM (SELECT eruptions AS obs,
PREDICT_LINEAR_REG (waiting USING PARAMETERS model_name='myLinearRegModel') AS prediction
FROM faithful_testing) AS prediction_output;
mse | Comments
-------------------+-----------------------------------------------
0.252925741352641 | Of 110 rows, 110 were used and 0 were ignored
(1 row)
返回一个表，其中显示了接收器 Precision Recall (PR) 曲线上的点。
PRC ( targets, probabilities
[ USING PARAMETERS
[num_bins = num‑bins]
[, f1_score = return‑score ]
[, main_class = class‑name ] )
OVER()
num_bins该整数值用于确定决策边界的数量。决策边界以 0 和 1（包含）之间的等距间隔设置。该函数在每个 num‑bin + 1 点处计算一次表。
默认值：100
f1_score默认值：false
main_class仅当 targets 是 CHAR/VARCHAR 类型时使用，请指定要与 probabilities 实参关联的类。
对名为 mtcars 的输入表执行 PRC 函数。obs 列中显示响应变量，而 pred 列中显示预测变量。
=> SELECT PRC(obs::int, prob::float USING PARAMETERS num_bins=2, f1_score=true) OVER()
FROM (SELECT am AS obs,
PREDICT_LOGISTIC_REG (mpg, cyl, disp, drat, wt, qsec, vs, gear, carb
USING PARAMETERS model_name='myLogisticRegModel',
type='probability') AS prob
FROM mtcars) AS prediction_output;
decision_boundary | recall | precision | f1_score | comment
------------------+--------+-----------+-------------------+--------------------------------------------
0 | 1 | 0.40625 | 0.577777777777778 |
0.5 | 1 | 1 | 1 | Of 32 rows, 32 were used and 0 were ignored
(2 rows)
第一列 decision_boundary 指示将响应值分类为 0 还是 1 的分界点。例如，在每行中，如果概率等于或大于 decision_boundary，则将响应分类为 1。如果概率小于 decision_boundary，则将响应分类为 0。
读取随机森林或 XGBoost 模型中树的内容。
READ_TREE ( USING PARAMETERS model_name = 'model‑name' [, tree_id = tree‑id] [, format = 'format'] )
model_nametree_idformattabular：返回包含 12 个输出列的表。
graphviz：返回可以传递给 graphviz 工具并呈现树的图形可视化的 DOT 语言源。
非超级用户：模型上的 USAGE 权限
从 READ_TREE 获取随机森林模型的表格格式输出：
=> SELECT READ_TREE ( USING PARAMETERS model_name='myRFModel', tree_id=1 ,
format= 'tabular') LIMIT 2;
-[ RECORD 1 ]-------------+-------------------
tree_id | 1
node_id | 1
node_depth | 0
is_leaf | f
is_categorical_split | f
split_predictor | petal_length
split_value | 1.921875
weighted_information_gain | 0.111242236024845
left_child_id | 2
right_child_id | 3
prediction |
probability/variance |
-[ RECORD 2 ]-------------+-------------------
tree_id | 1
node_id | 2
node_depth | 1
is_leaf | t
is_categorical_split |
split_predictor |
split_value |
weighted_information_gain |
left_child_id |
right_child_id |
prediction | setosa
probability/variance | 1
从 READ_TREE 获取 graphviz 格式的输出：
=> SELECT READ_TREE ( USING PARAMETERS model_name='myRFModel', tree_id=1 ,
format= 'graphviz')LIMIT 1;
-[ RECORD 1 ]+-------------------------------------------------------------------
---------------------------------------------------------------------------------
tree_id | 1
tree_digraph | digraph Tree{
1 [label="petal_length < 1.921875 ?", color="blue"];
1 -> 2 [label="yes", color="black"];
1 -> 3 [label="no", color="black"];
2 [label="prediction: setosa, probability: 1", color="red"];
3 [label="petal_length < 4.871875 ?", color="blue"];
3 -> 6 [label="yes", color="black"];
3 -> 7 [label="no", color="black"];
6 [label="prediction: versicolor, probability: 1", color="red"];
7 [label="prediction: virginica, probability: 1", color="red"];
}
此输入呈现如下：
使用平均减少杂质 (MDI) 方法衡量随机森林模型中预测工具的重要性。重要性向量被规范化为总和为 1。
RF_PREDICTOR_IMPORTANCE ( USING PARAMETERS model_name = 'model‑name' [, tree_id = tree‑id] )
model_namerf_classifier 或 rf_regressor 类型。tree_id非超级用户：模型上的 USAGE 权限
此示例说明如何使用 RF_PREDICTOR_IMPORTANCE 函数。
=> SELECT RF_PREDICTOR_IMPORTANCE ( USING PARAMETERS model_name = 'myRFModel');
predictor_index | predictor_name | importance_value
-----------------+----------------+--------------------
0 | sepal.length | 0.106763318092655
1 | sepal.width | 0.0279536658041994
2 | petal.length | 0.499198722346586
3 | petal.width | 0.366084293756561
(4 rows)
返回表，其中显示了操作特征曲线的接收器上的点。在提高模型的鉴别阈值时，ROC 函数会告知分类模型的精度。
ROC ( targets, probabilities
[ USING PARAMETERS
[num_bins = num‑bins]
[, AUC = output]
[, main_class = class‑name ] ) ] )
OVER()
num_bins该整数值用于确定决策边界的数量。决策边界以 0 和 1（包含）之间的等距间隔设置。该函数在每个 num‑bin + 1 点处计算一次表。
默认值：100
更大的值会产生更精确的 AUC 近似值。
AUC默认值： True
main_class仅当 targets 是 CHAR/VARCHAR 类型时使用，请指定要与 probabilities 实参关联的类。
对输入表 mtcars 执行 ROC。观察到的类标签在 obs 列中，预测类标签在 prob 列中：
=> SELECT ROC(obs::int, prob::float USING PARAMETERS num_bins=5, AUC = True) OVER()
FROM (SELECT am AS obs,
PREDICT_LOGISTIC_REG (mpg, cyl, disp, drat, wt, qsec, vs, gear, carb
USING PARAMETERS
model_name='myLogisticRegModel', type='probability') AS prob
FROM mtcars) AS prediction_output;
decision_boundary | false_positive_rate | true_positive_rate | AUC |comment
-------------------+---------------------+--------------------+-----+-----------------------------------
0 | 1 | 1 | |
0.5 | 0 | 1 | |
1 | 0 | 0 | 1 | Of 32 rows,32 were used and 0 were ignoreded
(3 rows)
该函数会返回包含以下结果的表：
decision_boundary 指示是否将响应分类为 0 或 1 的分界点。在每行中，如果 prob 等于或大于 decision_boundary，则将响应分类为 1。如果 prob 小于 decision_boundary，将响应值分类为 0。
false_positive_rate 显示了相应 decision_boundary 中的误报（当 0 被分类为 1 时）百分比。
true_positive_rate 显示了分类为 1 并且还属于类 1 的行的百分比。
返回一个表，其中包含回归模型中预测的 R 平方值。
RSQUARED ( targets, predictions ) OVER()
OVER() 子句必须为空。
此示例演示了如何对名为 faithful_testing 的输入表执行 RSQUARED 函数。obs 列中显示响应变量的观测值，而 pred 列中显示响应变量的预测值。
=> SELECT RSQUARED(obs, prediction) OVER()
FROM (SELECT eruptions AS obs,
PREDICT_LINEAR_REG (waiting
USING PARAMETERS model_name='myLinearRegModel') AS prediction
FROM faithful_testing) AS prediction_output;
rsq | comment
-------------------+-----------------------------------------------
0.801392981147911 | Of 110 rows, 110 were used and 0 were ignored
(1 row)
Vertica 提供了管理模型的多种函数。
导出机器学习模型。Vertica 支持三种模型格式：
原生 Vertica (VERTICA_MODELS)
PMML
TensorFlow
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
EXPORT_MODELS ( 'output-dir', 'export-target' [ USING PARAMETERS category = 'model-category' ] )
output-direxport-target [schema.]{ model‑name | * }
其中 schema 指定从指定的架构导出模型（可选）。如果忽略，EXPORT_MODELS 使用默认架构。提供 *（星号）以从架构中导出所有模型。
categoryVERTICA_MODELS
PMML
TENSORFLOW
EXPORT_MODELS 根据导出操作的范围导出指定类别的模型，即应用于单个模型，还是应用于架构中的所有模型。请参阅下面的导出范围和类别处理。
下文导出的文件描述了 EXPORT_MODELS 为每个类别导出的文件。
如果忽略此参数，EXPORT_MODELS 将根据模型类型导出模型或指定架构中的模型。
超级用户
EXPORT_MODELS 根据以下参数设置执行：
导出操作的范围：单个模型，或给定架构中的所有模型
指定或忽略的类别
下表显示了这两个参数如何控制导出过程：
EXPORT_MODELS 为每个模型类别导出以下文件：
如果 EXPORT_MODELS 指定单个模型并且还设置了 category 参数，则如果模型类型和类别兼容，则函数成功；否则，它会返回错误：
如果 EXPORT_MODELS 指定从架构中导出所有模型并设置类别，它会针对与该类别不兼容的每个模型发出警告消息。该函数随后继续处理该架构中的剩余模型。
EXPORT_MODELS 在
output-dir/export_log.json 中记录所有错误和警告。
导出模型而不更改其类别：
导出模型 myschema.mykmeansmodel 而不更改其类别：
=> SELECT EXPORT_MODELS ('/home/dbadmin', 'myschema.mykmeansmodel');
EXPORT_MODELS
----------------
Success
(1 row)
导出架构 myschema 中的所有模型而不更改其类别：
=> SELECT EXPORT_MODELS ('/home/dbadmin', 'myschema.*');
EXPORT_MODELS
----------------
Success
(1 row)
导出与指定类别兼容的模型：
当您导入在不同版本的 Vertica 中训练的 VERTICA_MODELS 类别模型时，Vertica 会自动升级模型版本以匹配数据库的版本。如果失败，您必须运行 UPGRADE_MODEL。
如果两种方法都失败，则该模型不能用于数据库内评分，也不能导出为 PMML 模型。
类别设置为 PMML。PMML 和 VERTICA_MODELS 类型的模型与 PMML 类别兼容，因此如果 my_keans 属于任一类型，则导出操作成功：
=> SELECT EXPORT_MODELS ('/tmp/', 'my_kmeans' USING PARAMETERS category='PMML');
类别设置为 VERTICA_MODELS。只有 VERTICA_MODELS 类型的模型与 VERTICA_MODELS 类别兼容，因此只有当 my_keans 属于该类型时，导出操作才会成功：
=> SELECT EXPORT_MODELS ('/tmp/', 'public.my_kmeans' USING PARAMETERS category='VERTICA_MODELS');
类别设置为 TENSORFLOW。只有 TensorFlow 类型的模型与 TENSORFLOW 类别兼容，因此模型 tf_mnist_keras 必须为 TensorFlow 类型：
=> SELECT EXPORT_MODELS ('/tmp/', 'tf_mnist_keras', USING PARAMETERS category='TENSORFLOW');
export_models
---------------
Success
(1 row)
导出 TensorFlow 模型 tf_mnist_keras 后，列出导出的文件：
$ ls tf_mnist_keras/
crc.json metadata.json mnist_keras.pb model.json tf_model_desc.json
从模型中提取某个特定属性或从模型中提取所有属性。使用此函数可查看属性列表和行数，或查看有关单个属性的详细信息。GET_MODEL_ATTRIBUTE 的输出是一种表格格式，用户可以在其中选择特定的列或行。
GET_MODEL_ATTRIBUTE ( USING PARAMETERS model_name = 'model‑name' [, attr_name = 'attribute' ] )
model_name模型的名称（不区分大小写）。
attr_name非超级用户：模型所有者或模型的使用权限
此示例返回所有模型属性的摘要。
=> SELECT GET_MODEL_ATTRIBUTE ( USING PARAMETERS model_name='myLinearRegModel');
attr_name | attr_fields | #_of_rows
-------------------+---------------------------------------------------+-----------
details | predictor, coefficient, std_err, t_value, p_value | 2
regularization | type, lambda | 1
iteration_count | iteration_count | 1
rejected_row_count | rejected_row_count | 1
accepted_row_count | accepted_row_count | 1
call_string | call_string | 1
(6 rows)
此示例从 myLinearRegModel 模型中提取 details 属性。
=> SELECT GET_MODEL_ATTRIBUTE ( USING PARAMETERS model_name='myLinearRegModel', attr_name='details');
coeffNames | coeff | stdErr | zValue | pValue
-----------+--------------------+---------------------+-------------------+-----------------------
Intercept | -1.87401598641074 | 0.160143331525544 | -11.7021169008952 | 7.3592939615234e-26
waiting | 0.0756279479518627 | 0.00221854185633525 | 34.0890336307608 | 8.13028381124448e-100
(2 rows)
返回模型的摘要信息。
GET_MODEL_SUMMARY ( USING PARAMETERS model_name = 'model‑name' )
模型的名称（不区分大小写）。
非超级用户：模型所有者或模型的使用权限
此示例说明如何查看线性回归模型的摘要。
=> SELECT GET_MODEL_SUMMARY( USING PARAMETERS model_name='myLinearRegModel');
--------------------------------------------------------------------------------
=======
details
=======
predictor|coefficient|std_err |t_value |p_value
---------+-----------+--------+--------+--------
Intercept| -2.06795 | 0.21063|-9.81782| 0.00000
waiting | 0.07876 | 0.00292|26.96925| 0.00000
==============
regularization
==============
type| lambda
----+--------
none| 1.00000
===========
call_string
===========
linear_reg('public.linear_reg_faithful', 'faithful_training', '"eruptions"', 'waiting'
USING PARAMETERS optimizer='bfgs', epsilon=1e-06, max_iterations=100,
regularization='none', lambda=1)
===============
Additional Info
===============
Name |Value
------------------+-----
iteration_count | 3
rejected_row_count| 0
accepted_row_count| 162
(1 row)
将以下模型导入 Vertica：通过 EXPORT_MODELS 导出的 Vertica 模型，或预测模型标记语言 (PMML) 或 TensorFlow 格式的模型。您可以使用此函数在 Vertica 群集之间移动模型，或导入在其他地方训练的 PMML 和 TensorFlow 模型。
GET_MODEL_SUMMARY 和 GET_MODEL_ATTRIBUTE 等其他 Vertica 模型管理操作支持导入的模型。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
IMPORT_MODELS ( 'source'
[ USING PARAMETERS [ new_schema = 'schema‑name' ] [, category = 'model-category' ] ] )
单个模型的目录：
path/model-directory
多个模型目录的父目录：
parent-dir-path/*
new_schemaIMPORT_MODELS 从其 metadata.json 文件中提取导入模型的名称（如果存在）。否则，该函数使用模型目录的名称。
categoryVERTICA_MODELS
PMML
TENSORFLOW
如果模型目录没有 metadata.json 文件，则需要此参数。如果以下情况之一为 true，则 IMPORT_MODELS 返回错误：
未指定类别且模型目录没有 metadata.json。
指定的类别与模型类型不匹配。
如果类别为 TENSORFLOW，则 IMPORT_MODELS 仅从模型目录中导入以下文件：
超级用户
以下要求和限制适用：
如果您导出模型，然后再次导入，则导出和导入模型目录名称必须匹配。如果发生命名冲突，请使用 new_schema 参数将模型导入不同的架构，然后重命名该模型。
机器学习配置参数 MaxModelSizeKB 设置可以导入 Vertica 的模型的最大大小。
目前不支持某些 PMML 功能和属性。有关详细信息，请参阅PMML 特征和属性。
如果您导入带有 metadata.json 和 crc.json 文件的 PMML 模型，则 CRC 文件必须包含元数据文件的 CRC 值。否则，导入操作会返回错误。
将模型导入指定的架构：
在这两个示例中，都没有指定模型类别，因此 IMPORT_MODEL 使用模型的 metadata.json 文件来确定其类别：
将单个模型 mykmeansmodel 导入到 newschema 架构中：
=> SELECT IMPORT_MODELS ('/home/dbadmin/myschema/mykmeansmodel' USING PARAMETERS new_schema='newschema')
IMPORT_MODELS
----------------
Success
(1 row)
将 myschema 目录中的所有模型导入到 newschema 架构中：
=> SELECT IMPORT_MODELS ('/home/dbadmin/myschema/*' USING PARAMETERS new_schema='newschema')
IMPORT_MODELS
----------------
Success
(1 row)
指定要导入的模型类别：
在前两个示例中，IMPORT_MODELS 只有在指定的模型和类别匹配时才返回成功；否则，它会返回错误：
导入 kmeans_pmml 作为 PMML 模型：
SELECT IMPORT_MODELS ('/root/user/kmeans_pmml' USING PARAMETERS category='PMML')
import_models
---------------
Success
(1 row)
导入 tf_mnist_estimator 作为 TensorFlow 模型：
=> SELECT IMPORT_MODELS ( '/path/tf_models/tf_mnist_estimator' USING PARAMETERS category='TENSORFLOW');
import_models
---------------
Success
(1 row)
从指定目录导入所有 TensorFlow 模型：
=> SELECT IMPORT_MODELS ( '/path/tf_models/*' USING PARAMETERS category='TENSORFLOW');
import_models
---------------
Success
(1 row)
升级之前的 Vertica 版本中的模型。如果您运行 IMPORT_MODELS 函数，Vertica 会在数据库升级期间自动运行此函数。备份或还原后手动调用该函数升级模型。
如果 UPGRADE_MODEL 未能升级模型并且模型属于 VERTICA_MODELS 类别，则它不能用于数据库内评分，也不能作为 PMML 模型导出。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
UPGRADE_MODEL ( [ USING PARAMETERS [model_name = 'model‑name'] ] )
model_name非超级用户：仅升级用户拥有的模型。
升级模型 myLogisticRegModel：
=> SELECT UPGRADE_MODEL( USING PARAMETERS model_name = 'myLogisticRegModel');
UPGRADE_MODEL
----------------------------
1 model(s) upgrade
(1 row)
升级用户拥有的所有模型：
=> SELECT UPGRADE_MODEL();
UPGRADE_MODEL
----------------------------
20 model(s) upgrade
(1 row)