在回归分析中，因变量 y 可能有两种情形：（1）y 是一个定量的变量，这时就用通常的回归函数对 y 进行回归；（2）y 是一个定性的变量，比如y=0或1，这时就不能用通常的回归函数进行回归，而是使用所谓的逻辑回归（Logistic Regression）。逻辑回归方法主要应用在研究某些现象发生的概率p ，比如股票涨跌、公司成败的概率。逻辑回归模型的基本形式为：

    其中，

    至此，我们会发现，只要对因变量p按照

    有了这样的定义，逻辑回归模型就可变形为：

    虽然形式相同，但此时的π为连续函数。然后只需要对原始数据进行合理的映射处理，就可以用线性回归方法得到回归系数。最后再由π和p的映射关系进行反映射而得到p的值。

    MADlib中的二分类逻辑回归模型，对双值因变量和一个或多个预测变量之间的关系建模。因变量可以是布尔值，或者是可以用布尔表达式表示的分类变量。在该模型中，训练函数作为预测变量的函数，描述一次训练可能结果的概率。

    逻辑回归训练函数形式如下：

logregr_train (source_table,    
               out_table,    
               dependent_varname,    
               independent_varname,    
               grouping_cols,    
               max_iter,    
               optimizer,    
               tolerance,    
               verbose ) 

    训练函数在产生输出表的同时，还会创建一个名为<out\_table>\_summary的概要表，具有以下列：

    MADlib提供了两个预测函数，预测因变量的布尔值，或预测因变量是“真”的概率值。两个函数语法相同。

    预测因变量的布尔值的函数：

logregr_predict(coefficients, ind_var)

    预测因变量是“真”的概率值的函数：

logregr_predict_prob(coefficients,ind_var)

    企业到金融商业机构贷款，金融商业机构需要对企业进行评估。设评估结果为0或1两种形式，0表示企业两年后破产，将拒绝贷款，而1表示企业两年后具备还款能力，可以贷款。在表4中，已知20家企业（编号1-20）的三项评价指标值和评估结果，试建立模型对其他5家企业（编号21-25）进行评估。

    对于该问题，很明显可以用逻辑回归模型来求解，已知的三项评价指标为自变量，能否贷款的评价结果是因变量。我们可以调用madlib.logregr\_train函数，用已知的20条数据进行训练，然后调用madlib.logregr\_predict函数对其他5条数据执行预测，还可以用madlib.logregr\_predict\_prob函数得到预测值为“真”的概率。

    通常训练数据与被预测数据是不同的数据集合，因此这里分别建立两个表。

drop table if exists source_data;    
create table source_data    
(id integer not null, x1 float8, x2 float8, x3 float8, y int);    
    
copy source_data from stdin with delimiter '|';    
  1 |         -62.8 |     -89.5 |     1.7 |    0    
  2 |           3.3 |      -3.5 |     1.1 |    0    
  3 |        -120.8 |    -103.2 |     2.5 |    0    
  4 |         -18.1 |     -28.8 |     1.1 |    0    
  5 |          -3.8 |     -50.6 |     0.9 |    0    
  6 |         -61.2 |     -56.2 |     1.7 |    0    
  7 |         -20.3 |     -17.4 |     1   |    0    
  8 |        -194.5 |     -25.8 |     0.5 |    0    
  9 |          20.8 |      -4.3 |     1   |    0    
 10 |        -106.1 |     -22.9 |     1.5 |    0    
 11 |          43   |      16.4 |     1.3 |    1    
 12 |          47   |      16   |     1.9 |    1    
 13 |          -3.3 |       4   |     2.7 |    1    
 14 |          35   |      20.8 |     1.9 |    1    
 15 |          46.7 |      12.6 |     0.9 |    1    
 16 |          20.8 |      12.5 |     2.4 |    1    
 17 |          33   |      23.6 |     1.5 |    1    
 18 |          26.1 |      10.4 |     2.1 |    1    
 19 |          68.6 |      13.8 |     1.6 |    1    
 20 |          37.3 |      33.4 |     3.5 |    1    
\.    
    
drop table if exists source_data_predict;    
create table source_data_predict    
(id integer not null, x1 float8, x2 float8, x3 float8, y int);    
    
copy source_data_predict from stdin with delimiter '|' NULL AS '';    
 21 |         -49.2 |     -17.2 |     0.3 |
 22 |         -19.2 |     -36.7 |     0.8 |
 23 |          40.6 |       5.8 |     1.8 |
 24 |          34.6 |      26.4 |     1.8 |
 25 |          19.9 |      26.7 |     2.3 |
\.

drop table if exists loan_logregr, loan_logregr_summary;    
select madlib.logregr_train ('source_data',    
                             'loan_logregr',    
                             'y',    
                             'array[1, x1, x2, x3]',    
                             null,    
                             20,    
                             'irls' ); 

    注意本例中我们从列名动态创建自变量数组。如果自变量的数目很大，以至于超过了PostgreSQL对于每个表中最多列数的限制时（一个表中的列不能超过1600个，这是个硬限制），应该建立自变量数组，并存储于一个单一列中。

\x off    
select round(unnest(coef)::numeric,4) as coefficient,    
       round(unnest(std_err)::numeric,4) as standard_error,    
       round(unnest(z_stats)::numeric,4) as z_stat,    
       round(unnest(p_values)::numeric,4) as pvalue,    
       round(unnest(odds_ratios)::numeric,4) as odds_ratio    
  from loan_logregr; 

    结果：

 coefficient | standard_error | z_stat  | pvalue | odds_ratio 
-------------+----------------+---------+--------+------------
    -20.3054 |      1101.1738 | -0.0184 | 0.9853 |     0.0000
      0.1347 |        24.8599 |  0.0054 | 0.9957 |     1.1442
      1.2877 |        49.3232 |  0.0261 | 0.9792 |     3.6243
     10.7682 |       581.7361 |  0.0185 | 0.9852 | 47486.3813
(4 rows)

\x off    
select p.id, madlib.logregr_predict(coef, array[1, x1, x2, x3])    
  from source_data_predict p, loan_logregr m    
 order by p.id;

    结果：

 id | logregr_predict   
----+-----------------  
 21 | f  
 22 | f  
 23 | t  
 24 | t  
 25 | t  
(5 rows)

    预测的结果是21、22两家企业应拒绝贷款，其他三家企业可以贷款。

\x off    
select p.id, madlib.logregr_predict_prob(coef, array[1, x1, x2, x3])    
  from source_data_predict p, loan_logregr m    
 order by p.id; 

    结果：

 id | logregr_predict_prob   
----+----------------------  
 21 | 1.22296014464276e-20  
 22 | 1.88777536644339e-27  
 23 |    0.999993946936041  
 24 |                    1  
 25 |                    1  
(5 rows)

    21、22为“真”的概率几乎为0，其他三个为“真”的概率为1。

\x off    
select p.id, madlib.logregr_predict(coef, array[1, x1, x2, x3]), p.y    
  from source_data p, loan_logregr m    
 order by p.id; 

    结果：

 id | logregr_predict | y   
----+-----------------+---  
  1 | f               | 0  
  2 | f               | 0  
  3 | f               | 0  
  4 | f               | 0  
  5 | f               | 0  
  6 | f               | 0  
  7 | f               | 0  
  8 | f               | 0  
  9 | f               | 0  
 10 | f               | 0  
 11 | t               | 1  
 12 | t               | 1  
 13 | t               | 1  
 14 | t               | 1  
 15 | t               | 1  
 16 | t               | 1  
 17 | t               | 1  
 18 | t               | 1  
 19 | t               | 1  
 20 | t               | 1  
(20 rows) 

    可以看到，Logistic模型预测的结果与训练数据完全一致。

    实际应用中，以下因素对Logistic回归分析预测模型的可靠性有较大影响：