用于分析的Greenplum MADlib扩展

    上级主题：

    MADlib是一个可扩展数据库分析的开源库。通过Greenplum的MADlib扩展，用户可以在Greenplum数据库中使用MADlib功能。

    MADlib为结构化数据以及非结构化数据提供了数学、统计学以及机器学习方法的数据并行的实现。它提供了一整套基于SQL的机器学习、数据挖掘以及统计学算法，只需要运行在数据库引擎中，而不需要在Greenplum和其它工具之间进行数据的传递。

    MADlib可以与PivotalR一同使用，一个PivotalR包允许用户使用R客户端同Greenplum的数据进行交互。见关于MADlib、R以及PivotalR。

    注意：当使用MADlib，设置配置参数optimizer_control为on （默认值）。如果该参数被设置为off，那么这些MADlib函数将不会工作：决策树、随机森林、LDA、决策树的PMML、随机森林的PMML。参数 optimizer_control控制是配置参数optimizer能够被修改。参数optimizer控制在执行SQL查询时GPORCA优化器是否被打开。一些MADlib安装检查和函数改变optimizer的值来提高性能。如果将optimizer_control设置为off，那么optimizer的值不能修改，同时函数会失败。

    下面是使用GreenplumMADlib扩展的示例：

    见MADlib文档获取更多的示例。

    该示例是在表regr_example执行一个线性回归。因变量数据在y列中，独立变量数据在x1和x2列中。

    下面的语句创建regr_example 表同时加载样本数据：

    MADlib 的linregr_train() 函数产生一个根据一个输入表包含的训练数据产生一个回归模型。下面的SELECT语句在表regr_example执行一个简单的多元回归同时保存模型在表 reg_example_model中。

    2.    'regr_example',         -- source table
    3.    'regr_example_model',   -- output model table
    4.    'y',                    -- dependent variable 
    5.    'ARRAY[1, x1, x2]'      -- independent variables
    6. );

    madlib.linregr_train()函数能够添加参数来设置分组的列以及计算模型的异方差性。

    注释:截距通过将一个独立变量设置为常数1来计算，如前一个例子所示。

    在表regr_example上执行该查询并创建带有一行数据的regr_example_model表：

    1. SELECT * FROM regr_example_model;
    2. -[ RECORD 1 ]------------+------------------------
    3. coef                     | {0.111111111111127,1.14814814814815,1.01851851851852}
    4. r2                       | 0.968612680477111
    5. std_err                  | {1.49587911309236,0.207043331249903,0.346449758034495}
    6. t_stats                  | {0.0742781352708591,5.54544858420156,2.93987366103776}
    7. p_values                 | {0.952799748147436,0.113579771006374,0.208730790695278}
    8. condition_no             | 22.650203241881
    9. num_rows_processed       | 4
    10. num_missing_rows_skipped | 0
    11. variance_covariance      | {{2.23765432098598,-0.257201646090342,-0.437242798353582},
    12.                             {-0.257201646090342,0.042866941015057,0.0342935528120456},
    13.                             {-0.437242798353582,0.0342935528120457,0.12002743484216}}

    被保存到regr_example_model表中的模型能够同MADlib线性回归预测函数使用， madlib.linregr_predict()来查看残差：

    1. SELECT regr_example.*, 
    2.         madlib.linregr_predict ( ARRAY[1, x1, x2], m.coef ) as predict,
    3.         y - madlib.linregr_predict ( ARRAY[1, x1, x2], m.coef ) as residual
    4. FROM regr_example, regr_example_model m;
    5.  id | y  | x1 | x2 |     predict      |      residual
    6. ----+----+----+----+------------------+--------------------
    7.   1 |  5 |  2 |  3 | 5.46296296296297 | -0.462962962962971
    8.   3 |  6 |  4 |  1 | 5.72222222222224 |  0.277777777777762
    9.   2 | 10 |  7 |  2 | 10.1851851851852 | -0.185185185185201
    10.   4 |  8 |  3 |  4 | 7.62962962962964 |  0.370370370370364
    11. (4 rows)

    这个例子说明了关联规则的数据挖掘技术在交易数据集。关联规则挖掘是发现大数据集中的变量之间关系的技术。这个例子将考虑那些在商店中通常一起购买的物品。除了购物篮分析，关联规则也应用在生物信息学中，网络分析，和其他领域。

    这个例子分析利用MADlib函数MADlib.assoc_rules分析存储在表中的关于七个交易的购买信息。函数假定数据存储在两列中，每行有一个物品和交易ID。多个物品的交易，包括多个行，每行一个物品。

    这些命令创建表。

    1. DROP TABLE IF EXISTS test_data;
    2. CREATE TABLE test_data (
    3.    trans_id INT,
    4.    product text
    5. );

    该INSERT命令向表中添加数据。

    1. INSERT INTO test_data VALUES 
    2.    (1, 'beer'),
    3.    (1, 'diapers'),
    4.    (1, 'chips'),
    5.    (2, 'beer'),
    6.    (2, 'diapers'),
    7.    (3, 'beer'),
    8.    (3, 'diapers'),
    9.    (4, 'beer'),
    10.    (4, 'chips'),
    11.    (5, 'beer'),
    12.    (6, 'beer'),
    13.    (6, 'diapers'),
    14.    (6, 'chips'),
    15.    (7, 'beer'),
    16.    (7, 'diapers');
    • 一个值至少为.40的支持率。支持率表示包含X的交易与所有交易的比。
    • 一个值至少为.75的置信率。置信率表示包含X的交易与包含Y的交易的比。可以将该度量看做给定Y下X的条件概率。

    该SELECT命令确定关联规则，创建表assoc_rules同时天啊件统计信息到表中。

    1. SELECT * FROM madlib.assoc_rules (
    2.    .40,          -- support
    3.    .75,          -- confidence
    4.    'trans_id',   -- transaction column
    5.    'product',    -- product purchased column
    6.    'test_data',  -- table name
    7.    'public',     -- schema name

    这是SELECT命令的输出。这有两条符合特征的规则。

    为了查看关联规则，用户可以使用该SELECT命令。

    1. SELECT pre, post, support FROM assoc_rules 
    2.    ORDER BY support DESC;

    这是输出。pre 和post列分别是关联规则左右两边的项集。

    1.     pre    |  post  |      support
    3.  {diapers} | {beer} | 0.714285714285714
    4.  {chips}   | {beer} | 0.428571428571429
    5. (2 rows)

    基于数据，啤酒和尿布经常一起购买。为了增加销售额，用户 可以考虑将啤酒和尿布放在一个架子上。

    朴素贝叶斯分析，基于一个或多个独立变量或属性，预测一类变量或类结果的可能性。类变量是非数值类型变量，一个变量可以有一个数量有限的值或类别。类变量表示的整数，每个整数表示一个类别。例如，如果类别可以是一个“真”、“假”，或“未知”的值，那么变量可以表示为整数1, 2或3。

    属性可以是数值类型、非数值类型以及类类型。训练函数有两个签名 - 一个用于所有属性为数值 另外一个用于混合数值和类类型的情况。后者的附加参数标识那些应该被当做数字值处理的属性。属性以数组的形式提交给训练函数。

    MADlib朴素贝叶斯训练函数产生一个特征概率表和一个类的先验表，该表可以同预测函数使用为属性集提供一个类别的概率。

    朴素贝叶斯示例 1 - 简单的所有都是数值属性

    在第一个示例中，类别变量取值为1或者2，同时这里有三个整型属性。

    1. 下面的命令创建输入表以及加载样本数据。

      1. DROP TABLE IF EXISTS class_example CASCADE;
      2. CREATE TABLE class_example (
      3.    id int, class int, attributes int[]);
      4. INSERT INTO class_example VALUES
      5.    (1, 1, '{1, 2, 3}'),
      6.    (2, 1, '{1, 4, 3}'),
      7.    (3, 2, '{0, 2, 2}'),
      8.    (4, 1, '{1, 2, 1}'),
      9.    (5, 2, '{1, 2, 2}'),
      10.    (6, 2, '{0, 1, 3}');

      在生产环境中的实际数据比该示例中的数据量更大，也能获得更好的结果。更大的训练数据集能够显著地提高分类的精确度。

    2. 使用 create_nb_prepared_data_tables()函数训练模型。

      1. SELECT * FROM madlib.create_nb_prepared_data_tables (
      2.    'class_example',         -- name of the training table 
      3.    'class',                 -- name of the class (dependent) column
      4.    'attributes',            -- name of the attributes column
      5.    3,                       -- the number of attributes
      6.    'example_feature_probs', -- name for the feature probabilities output table
      7.    'example_priors'         -- name for the class priors output table
      8.     );

    3. 为了使用模型进行分类，创建带有数据的表。

      1. DROP TABLE IF EXISTS class_example_topredict;
      2. CREATE TABLE class_example_topredict ( 
      3.    id int, attributes int[]);
      4. INSERT INTO class_example_topredict VALUES 
      5.    (1, '{1, 3, 2}'),
      6.    (2, '{4, 2, 2}'),
      7.    (3, '{2, 1, 1}');

    4. 用特征概率、类的先验和class_example_topredict表创建一个分类视图。

      1. SELECT madlib.create_nb_probs_view (
      2.    'example_feature_probs',    -- 特征概率输出表
      3.    'example_priors',           -- 先验输出表
      4.    'class_example_topredict',  -- 带有要分类数据的表
      5.    'id',                       -- 关键字的列名
      6.    'attributes',               -- 属性列的名称
      7.     3,                         -- 属性的数目
      8.     'example_classified'       -- 要创建的视图的名称
      9.     );

    5. 显示分类结果。

    朴素贝叶斯示例 2 – 天气和户外运动

    该示例计算在给定的天气条件下，用户要进行户外运动，例如高尔夫、网球等的概率。

    表的标识列是day，整型类型。

    play列包含了因变量以及两个类别：

    • 0 - No
    • 1 - Yes

    有四个属性：outlook、temperature、humidity、以及wind。他们是类变量。 MADlib create_nb_classify_view()函数希望属性提供的是INTEGER、NUMERIC、 或者FLOAT8值类型的数组，所以该示例的属性均用为整型进行编码：

    • outlook 可能取值为 sunny (1), overcast (2), or rain (3)。
    • temperature 可能取值为 hot (1), mild (2), or cool (3).
    • humidity 可能取值为 high (1) or normal (2).
    • wind 可能取值为 strong (1) or weak (2).

    下面的表显示了编码钱的训练数据。

    1.   day | play | outlook  | temperature | humidity | wind
    2. -----+------+----------+-------------+----------+--------
    3.  2   | No   | Sunny    | Hot         | High     | Strong
    4.  4   | Yes  | Rain     | Mild        | High     | Weak
    5.  6   | No   | Rain     | Cool        | Normal   | Strong
    6.  8   | No   | Sunny    | Mild        | High     | Weak
    7. 10   | Yes  | Rain     | Mild        | Normal   | Weak
    8. 12   | Yes  | Overcast | Mild        | High     | Strong
    9. 14   | No   | Rain     | Mild        | High     | Strong
    10.  1   | No   | Sunny    | Hot         | High     | Weak
    11.  3   | Yes  | Overcast | Hot         | High     | Weak
    12.  5   | Yes  | Rain     | Cool        | Normal   | Weak
    13.  7   | Yes  | Overcast | Cool        | Normal   | Strong
    14.  9   | Yes  | Sunny    | Cool        | Normal   | Weak
    15. 11   | Yes  | Sunny    | Mild        | Normal   | Strong
    16. 13   | Yes  | Overcast | Hot         | Normal   | Weak
    17. (14 rows)

    1. 创建一个训练表。

      1. DROP TABLE IF EXISTS weather_example;
      2. CREATE TABLE weather_example (
      3.    day int,
      4.    attrs int[]
      5. );
      6. INSERT INTO weather_example VALUES
      8.    ( 4, 1, '{3,2,1,2}'), -- rain, mild, high, weak
      9.    ( 6, 0, '{3,3,2,1}'), -- rain, cool, normal, strong
      10.    ( 8, 0, '{1,2,1,2}'), -- sunny, mild, high, weak
      11.    (10, 1, '{3,2,2,2}'), -- rain, mild, normal, weak
      12.    (12, 1, '{2,2,1,1}'), -- 等
      13.    (14, 0, '{3,2,1,1}'),
      14.    ( 1, 0, '{1,1,1,2}'),
      15.    ( 3, 1, '{2,1,1,2}'),
      16.    ( 5, 1, '{3,3,2,2}'),
      17.    ( 7, 1, '{2,3,2,1}'),
      18.    ( 9, 1, '{1,3,2,2}'),
      19.    (11, 1, '{1,2,2,1}'),
      20.    (13, 1, '{2,1,2,2}');

    2. 根据训练表创建模型。

      1. SELECT madlib.create_nb_prepared_data_tables (
      2.    'weather_example',  -- 训练源数据
      3.    'play',             -- 因变类别列
      4.    'attrs',            -- 属性列
      5.    4,                  -- 属性数目
      6.    'weather_probs',    -- 特征概率输出表
      7.    'weather_priors'    -- 类别先验
      8.    );

    3. 查看特征概率：

      1. SELECT * FROM weather_probs;
      2.  class | attr | value | cnt | attr_cnt
      3. -------+------+-------+-----+----------
      4.      1 |    3 |     2 |   6 |        2
      5.      1 |    1 |     2 |   4 |        3
      6.      0 |    1 |     1 |   3 |        3
      7.      0 |    1 |     3 |   2 |        3
      8.      0 |    3 |     1 |   4 |        2
      9.      1 |    4 |     1 |   3 |        2
      10.      1 |    2 |     3 |   3 |        3
      11.      1 |    2 |     1 |   2 |        3
      12.      0 |    2 |     2 |   2 |        3
      13.      0 |    4 |     2 |   2 |        2
      14.      0 |    3 |     2 |   1 |        2
      15.      0 |    1 |     2 |   0 |        3
      16.      1 |    1 |     1 |   2 |        3
      17.      1 |    1 |     3 |   3 |        3
      18.      1 |    3 |     1 |   3 |        2
      19.      0 |    4 |     1 |   3 |        2
      20.      0 |    2 |     3 |   1 |        3
      21.      0 |    2 |     1 |   2 |        3
      22.      1 |    2 |     2 |   4 |        3
      23.      1 |    4 |     2 |   6 |        2
      24. (20 rows)

    4. 用模型分类一组记录，首先装载数据到一个表中。在该示例中，表t1有四个行将要分类。

      1. DROP TABLE IF EXISTS t1;
      2. CREATE TABLE t1 (
      3.    id integer,
      4.    attributes integer[]);
      5. insert into t1 values 
      6.    (1, '{1, 2, 1, 1}'),
      7.    (2, '{3, 3, 2, 1}'),
      8.    (3, '{2, 1, 2, 2}'),
      9.    (4, '{3, 1, 1, 2}');

    5. 使用 create_nb_classify_view() 函数对表中的行进行分类。

      1. SELECT madlib.create_nb_classify_view (
      2.    'weather_probs',      -- 特征概率表
      3.    'weather_priors',     -- 类先验名
      4.    't1',                 -- 包含要分类值的表
      5.    'id',                 -- 主键列
      6.    'attributes',         -- 属性列
      7.    4,                    -- 属性数目
      9. );

      结果有四行，每行对应表t1中的一条记录。

    MADlib 网站在 http://madlib.incubator.apache.org/.

    MADlib 文档在 .

    PivotalR 是第一类能够让用户使用R客户端对Greenplum驻留的数据和MADLib进行交互的R包。

    R语言是一门用于统计计算的开源编程语言。PivotalR 是一个能够让用户通过R客户端与常驻Greenplum数据库的数据进行交互的R语言包。使用PivotalR要求MADlib已经安装在了Greenplum数据库中。

    PivotalR允许R用户不用离开R命令行就能利用数据库内分析的可扩展性和性能。计算工作在数据库内执行，而终端用户受益于熟悉的R语言接口。与相应的原生R函数相比，在可扩展性上得到提同时在执行时间上有降低。此外，PivotalR消除了对于非常大的数据集需要花费几个小时完成的数据移动。

    PivotalR包的关键特征：

    • 以R语法的方式探索和操作数据库内的数据。SQL翻译由PivotalR来执行。
    • 使用熟悉的R语法的预测分析算法，例如线性和逻辑回归。 PivotalR访问MADlib数据库内分析函数调用。
    • PivotalR包也支持MADlib功能的访问。

    更多关于PivotalR的信息包括支持的MADlib功能的信息，见 https://cwiki.apache.org/confluence/display/MADLIB/PivotalR。

    PivotalR的R语言包可以在找到。