| /* ----------------------------------------------------------------------- *//** |
| * @file ordinal.sql_in |
| * |
| * @brief SQL functions for ordinal regression |
| * @date July 2014 |
| * |
| * @sa For a brief introduction to ordinal regression, see the |
| * module description \ref grp_ordinal. |
| *//* ----------------------------------------------------------------------- */ |
| |
| m4_include(`SQLCommon.m4') |
| |
| /** |
| @addtogroup grp_ordinal |
| |
| <div class="toc"><b>Contents</b> |
| <ul> |
| <li class="level1"><a href="#train">Training Function</a></li> |
| <li class="level1"><a href="#predict">Prediction Function</a></li> |
| <li class="level1"><a href="#examples">Examples</a></li> |
| <li class="level1"><a href="#background">Model Details</a></li> |
| <li class="level1"><a href="#literature">Literature</a></li> |
| <li class="level1"><a href="#related">Related Topics</a></li> |
| </ul> |
| </div> |
| |
| @brief Regression to model data with ordinal response variable. |
| |
| In statistics, ordinal regression is a type of regression analysis |
| used for predicting an ordinal variable, i.e. a variable whose |
| value exists on an arbitrary scale where only the relative ordering |
| between different values is significant. The two most common types |
| of ordinal regression models are ordered logit, which applies to |
| data that meet the proportional odds assumption, and ordered probit. |
| |
| @anchor train |
| @par Training Function |
| The ordinal regression training function has the following syntax: |
| <pre class="syntax"> |
| ordinal(source_table, |
| model_table, |
| dependent_varname, |
| independent_varname, |
| cat_order, |
| link_func, |
| grouping_col, |
| optim_params, |
| verbose |
| ) |
| </pre> |
| |
| \b Arguments |
| <DL class="arglist"> |
| <DT>source_table</DT> |
| <DD>VARCHAR. Name of the table containing the training data.</DD> |
| |
| <DT>model_table</DT> |
| <DD>VARCHAR. Name of the generated table containing the model. |
| |
| The model table produced by ordinal() contains the following columns: |
| |
| <table class="output"> |
| <tr> |
| <th><...></th> |
| <td>Grouping columns, if provided in input. This could be |
| multiple columns depending on the \c grouping_col input.</td> |
| </tr> |
| |
| <tr> |
| <th>coef_threshold</th> |
| <td>FLOAT8[]. Vector of the threshold coefficients in linear predictor. |
| The threshold coefficients are the intercepts specific to each categorical levels</td> |
| </tr> |
| |
| <tr> |
| <th>std_err_threshold</th> |
| <td>FLOAT8[]. Vector of the threshold standard errors |
| of the threshold coefficients.</td> |
| </tr> |
| |
| <tr> |
| <th>z_stats_threshold</th> |
| <td>FLOAT8[]. Vector of the threshold z-statistics of |
| the thresholdcoefficients.</td> |
| </tr> |
| |
| <tr> |
| <th>p_values_threshold</th> |
| <td>FLOAT8[]. Vector of the threshold p-values of the threshold coefficients.</td> |
| </tr> |
| |
| <tr> |
| <th>log_likelihood</th> |
| <td>FLOAT8. The log-likelihood \f$ l(\boldsymbol \beta) \f$. The value will |
| be the same across categories within the same group.</td> |
| </tr> |
| |
| <tr> |
| <th>coef_feature</th> |
| <td>FLOAT8[]. Vector of the feature coefficients in linear predictor. The |
| feature coefficients are the coefficients for the independent variables. |
| They are the same across categories.</td> |
| </tr> |
| |
| <tr> |
| <th>std_err_feature</th> |
| <td>FLOAT8[]. Vector of the feature standard errors of the feature coefficients.</td> |
| </tr> |
| |
| <tr> |
| <th>z_stats_feature</th> |
| <td>FLOAT8[]. Vector of the feature z-statistics of the feature coefficients.</td> |
| </tr> |
| |
| <tr> |
| <th>p_values_feature</th> |
| <td>FLOAT8[]. Vector of the feature p-values of the feature coefficients.</td> |
| </tr> |
| |
| <tr> |
| <th>num_rows_processed</th> |
| <td>BIGINT. Number of rows processed.</td> |
| </tr> |
| |
| <tr> |
| <th>num_rows_skipped</th> |
| <td>BIGINT. Number of rows skipped due to missing values or failures.</td> |
| </tr> |
| |
| <tr> |
| <th>num_iterations</th> |
| <td>INTEGER. Number of iterations actually completed. This would be different |
| from the \c nIterations argument if a \c tolerance parameter is provided and the |
| algorithm converges before all iterations are completed.</td> |
| </tr> |
| </table> |
| |
| A summary table named \<model_table\>_summary is also created at the same time, which has the following columns: |
| <table class="output"> |
| |
| <tr> |
| <th>method</th> |
| <td>VARCHAR. String describes the model: 'ordinal'.</td> |
| </tr> |
| |
| <tr> |
| <th>source_table</th> |
| <td>VARCHAR. Data source table name.</td> |
| </tr> |
| |
| <tr> |
| <th>model_table</th> |
| <td>VARCHAR. Model table name.</td> |
| </tr> |
| |
| <tr> |
| <th>dependent_varname</th> |
| <td>VARCHAR. Expression for dependent variable.</td> |
| </tr> |
| |
| <tr> |
| <th>independent_varname</th> |
| <td>VARCHAR. Expression for independent variables. The independent variables |
| should not include intercept term. Otherwise there will be an error message |
| indicating Hessian matrix is not finite. In that case, the user should |
| drop the intercept and rerun the function agian.</td> |
| </tr> |
| |
| <tr> |
| <th>cat_order</th> |
| <td>VARCHAR. String representation of category order. Default is the sorted categories in data using python sort</td> |
| </tr> |
| |
| <tr> |
| <th>link_func</th> |
| <td>VARCHAR. String that contains link function parameters: 'logit' and 'probit' links are implemented now</td> |
| </tr> |
| |
| <tr> |
| <th>grouping_col</th> |
| <td>VARCHAR. String representation of grouping columns.</td> |
| </tr> |
| |
| <tr> |
| <th>optimizer_params</th> |
| <td>VARCHAR. String that contains optimizer parameters, and has the form |
| of 'optimizer=..., max_iter=..., tolerance=...'.</td> |
| </tr> |
| |
| <tr> |
| <th>num_all_groups</th> |
| <td>INTEGER. Number of groups in ordinal regression training.</td> |
| </tr> |
| |
| <tr> |
| <th>num_failed_groups</th> |
| <td>INTEGER. Number of failed groups in ordinal regression training.</td> |
| </tr> |
| |
| <tr> |
| <th>total_rows_processed</th> |
| <td>BIGINT. Total number of rows processed in all groups.</td> |
| </tr> |
| |
| <tr> |
| <th>total_rows_skipped</th> |
| <td>BIGINT. Total number of rows skipped in all groups due to missing values or failures.</td> |
| </tr> |
| |
| </table> |
| </DD> |
| |
| <DT>dependent_varname</DT> |
| <DD>VARCHAR. Name of the dependent variable column.</DD> |
| |
| <DT>independent_varname</DT> |
| <DD>VARCHAR. Expression list to evaluate for the |
| independent variables. The intercept should not be included here since the cumulative probability |
| force to have intercepts for each category level.</DD> |
| |
| <DT>cat_order</DT> |
| <DD>VARCHAR, String that represents the order of category. The order is specified by charactor '<'. |
| </DD> |
| |
| <DT>link_function (optional)</DT> |
| <DD>VARCHAR, default: 'logit'. Parameters for link function. Currently, we support logit and probit. |
| </DD> |
| |
| <DT>grouping_col (optional)</DT> |
| <DD>VARCHAR, default: NULL. An expression list used to group |
| the input dataset into discrete groups, running one regression per group. |
| Similar to the SQL "GROUP BY" clause. When this value is NULL, no |
| grouping is used and a single model is generated.</DD> |
| |
| <DT>optim_params (optional)</DT> |
| <DD>VARCHAR, default: 'max_iter=100,optimizer=irls,tolerance=1e-6'. |
| Parameters for optimizer. Currently, we support |
| tolerance=[tolerance for relative error between log-likelihoods], |
| max_iter=[maximum iterations to run], optimizer=irls.</DD> |
| |
| <DT>verbose (optional)</DT> |
| <DD>BOOLEAN, default: FALSE. Provides verbose output of the results of training.</DD> |
| </DL> |
| |
| <dd>@note To calculate the standard error the coefficient, we are using the square root of the diagnal |
| elements of the expected Fisher information matrix, which is a by-product of iteratively reweighted |
| least square. This method is used in the original ordinal regression paper by McCullagh(1980). In some |
| software like Stata, the standard error is calculated by the observed information matrix, which is supported |
| by Efron and Hinkley (1978). In R, polr() uses the approximated observed information matrix while the |
| optimization is achieved by first order optimization method. Therefore, there will be some difference on |
| standard error, z-stats and p-value from other software.</dd> |
| |
| @anchor predict |
| @par Prediction Function |
| Ordinal regression prediction function has the following format: |
| <pre class="syntax"> |
| ordinal_predict( |
| model_table, |
| predict_table_input, |
| output_table, |
| predict_type, |
| verbose |
| ) |
| </pre> |
| \b Arguments |
| <DL class="arglist"> |
| <DT>model_table</DT> |
| <DD>TEXT. Name of the generated table containing the model, which is the output table from |
| ordinal().</DD> |
| |
| <DT>predict_table_input</DT> |
| <DD>TEXT. The name of the table containing the data to predict on. The table must contain |
| id column as the primary key.</DD> |
| |
| <DT>output_table</DT> |
| <DD>TEXT. Name of the generated table containing the predicted values. |
| |
| The model table produced by ordinal_predict contains the following columns: |
| |
| <table class="output"> |
| <tr> |
| <th>id</th> |
| <td>SERIAL. Column to identify the predicted value.</td> |
| </tr> |
| |
| <tr> |
| <th>category</th> |
| <td>TEXT. Available if the predicted type = 'response'. Column contains the predicted |
| categories</td> |
| </tr> |
| |
| <tr> |
| <th>category_value</th> |
| <td>FLOAT8. The predicted probability for the specific category_value.</td> |
| </tr> |
| </table> |
| |
| <DT>predict_type</DT> |
| <DD>TEXT. Either 'response' or 'probability'. Using 'response' will give the predicted category with |
| the largest probability. Using probability will give the predicted probabilities for all |
| categories</DD> |
| |
| <DT>verbose</DT> |
| <DD>BOOLEAN. Whether verbose is displayed</DD> |
| </DL> |
| |
| |
| @anchor examples |
| @examp |
| |
| -# Create the training data table. |
| <pre class="example"> |
| DROP TABLE IF EXISTS test3; |
| CREATE TABLE test3 ( |
| feat1 INTEGER, |
| feat2 INTEGER, |
| cat INTEGER |
| ); |
| INSERT INTO test3(feat1, feat2, cat) VALUES |
| (1,35,1), |
| (2,33,0), |
| (3,39,1), |
| (1,37,1), |
| (2,31,1), |
| (3,36,0), |
| (2,36,1), |
| (2,31,1), |
| (2,41,1), |
| (2,37,1), |
| (1,44,1), |
| (3,33,2), |
| (1,31,1), |
| (2,44,1), |
| (1,35,1), |
| (1,44,0), |
| (1,46,0), |
| (2,46,1), |
| (2,46,2), |
| (3,49,1), |
| (2,39,0), |
| (2,44,1), |
| (1,47,1), |
| (1,44,1), |
| (1,37,2), |
| (3,38,2), |
| (1,49,0), |
| (2,44,0), |
| (3,61,2), |
| (1,65,2), |
| (3,67,1), |
| (3,65,2), |
| (1,65,2), |
| (2,67,2), |
| (1,65,2), |
| (1,62,2), |
| (3,52,2), |
| (3,63,2), |
| (2,59,2), |
| (3,65,2), |
| (2,59,0), |
| (3,67,2), |
| (3,67,2), |
| (3,60,2), |
| (3,67,2), |
| (3,62,2), |
| (2,54,2), |
| (3,65,2), |
| (3,62,2), |
| (2,59,2), |
| (3,60,2), |
| (3,63,2), |
| (3,65,2), |
| (2,63,1), |
| (2,67,2), |
| (2,65,2), |
| (2,62,2); |
| </pre> |
| -# Run the multilogistic regression function. |
| <pre class="example"> |
| DROP TABLE IF EXISTS test3_output; |
| DROP TABLE IF EXISTS test3_output_summary; |
| SELECT madlib.ordinal('test3', |
| 'test3_output', |
| 'cat', |
| 'ARRAY[feat1, feat2]', |
| '0<1<2', |
| 'logit' |
| ); |
| </pre> |
| |
| -# View the regression results. |
| <pre class="example"> |
| -- Set extended display on for easier reading of output |
| \\x on |
| SELECT * FROM test3_output; |
| </pre> |
| |
| Result: |
| <pre class="result"> |
| -[ RECORD 1 ]------+------------------------------------------- |
| coef_threshold | {4.12831944358935,6.55999442887089} |
| std_err_threshold | {1.3603408170882,1.54843501580999} |
| z_stats_threshold | {3.03476848722806,4.23653195768075} |
| p_values_threshold | {0.00240720390579325,2.26998625331282e-05} |
| log_likelihood | -42.1390192418541 |
| coef_feature | {0.574822563129293,0.108115645059558} |
| std_err_feature | {0.394064908788145,0.0276025960683975} |
| z_stats_feature | {1.45870020473791,3.91686509456046} |
| p_values_feature | {0.144647639733733,8.9707915817562e-05} |
| num_rows_processed | 57 |
| num_rows_skipped | 0 |
| iteration | 7 |
| </pre> |
| |
| -# Predicting dependent variable using ordinal model. |
| (This example uses the original data table to perform the prediction. Typically |
| a different test dataset with the same features as the original training dataset |
| would be used for prediction.) |
| |
| <pre class="example"> |
| \\x off |
| -- Add the id column for prediction function |
| ALTER TABLE test3 ADD COLUMN id SERIAL; |
| -- Predict probabilities for all categories using the original data |
| SELECT ordinal_predict('test3_output','test3', 'test3_prd_prob', 'probability'); |
| -- Display the predicted value |
| SELECT * FROM test3_prd_prob; |
| </pre> |
| |
| @anchor background |
| @par Model Details |
| |
| The function ordinal() fit the ordinal response model using a cumulative link model. The ordinal reponse variable, denoted by \f$ Y_i \f$, can fall in \f$ j = 1,.. , J\f$ categories. Then \f$ Y_i \f$ follows a multinomial distribution with parameter \f$\pi\f$ where \f$\pi_{ij}\f$ denote the probability that the \f$i\f$th observation falls in response category \f$j\f$. We define the cumulative probabilities as |
| \f[ |
| \gamma_{ij} = \Pr(Y_i \le j)= \pi_{i1} +...+ \pi_{ij} . |
| \f] |
| Next we will consider the logit link for illustration purpose. The logit function is defined as \f$ \mbox{logit}(\pi) = \log[\pi/(1-\pi)] \f$ and cumulative logits are defined as: |
| \f[ |
| \mbox{logit}(\gamma_{ij})=\mbox{logit}(\Pr(Y_i \le j))=\log \frac{\Pr(Y_i \le j)}{1-\Pr(Y_i\le j)}, j=1,...,J−1 |
| \f] |
| so that the cumulative logits are defined for all but the last category. |
| |
| A cumulative link model with a logit link, or simply cumulative logit model is a regression model for cumulative logits: |
| \f[ |
| \mbox{logit}(\gamma_{ij}) = \theta_j - x^T_i \beta |
| \f] |
| where \f$x_i\f$ is a vector of explanatory variables for the \f$i\f$th observation and \f$\beta\f$ is the corresponding set of regression parameters. The \f$\{\theta_j\}\f$ parameters provide each cumulative logit (for each \f$j\f$) with its own intercept. A key point is that the regression part \f$x^T_i\beta\f$ is independent of \f$j\f$, so \f$\beta\f$ has the same effect for each of the J − 1 cumulative logits. Note that \f$x^T_i\beta\f$ does not contain an intercept, since the \f$\{\theta_j\}\f$ act as intercepts. For small values of \f$x^T_i\beta\f$ the response is likely to fall in the first category and for large values of \f$x^T_i\beta\f$ the response is likely to fall in the last category. The horizontal displacements of the curves are given by the values of \f$\{\theta_j\}\f$. |
| |
| @anchor literature |
| @literature |
| |
| A collection of nice write-ups, with valuable pointers into further literature: |
| |
| [1] Peter McCullagh: Regression Models for Ordinal Data, Journal of the Royal Statistical Society. Series B (Methodological), Volume 42, Issue 2 (1980), 109-142 |
| |
| [2] Rune Haubo B Christensen: Analysis of ordinal data with cumulative link models -- estimation with the R-package ordinal. cran.r-project.org/web/packages/ordinal/vignettes/clm_intro.pdf |
| |
| @anchor related |
| @par Related Topics |
| |
| File ordinal.sql_in documenting the ordinal regression functions |
| |
| \ref grp_multinom |
| |
| @internal |
| @sa Namespace ordinal (documenting the driver/outer loop implemented in |
| Python), Namespace |
| \ref madlib::modules::glm documenting the implementation in C++ |
| @endinternal |
| |
| */ |
| ------------------------------------------------------------------------ |
| |
| DROP TYPE IF EXISTS MADLIB_SCHEMA.__ordinal_result_type CASCADE; |
| CREATE TYPE MADLIB_SCHEMA.__ordinal_result_type AS ( |
| coef_alpha double precision[], |
| std_err_alpha double precision[], |
| z_stats_alpha double precision[], |
| p_values_alpha double precision[], |
| loglik double precision, |
| coef_beta double precision[], |
| std_err_beta double precision[], |
| z_stats_beta double precision[], |
| p_values_beta double precision[], |
| num_rows_processed bigint |
| ); |
| |
| ------------------------------------------------------------------------ |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.__ordinal_merge_states( |
| state1 MADLIB_SCHEMA.bytea8, |
| state2 MADLIB_SCHEMA.bytea8) |
| RETURNS MADLIB_SCHEMA.bytea8 |
| AS 'MODULE_PATHNAME', 'ordinal_merge_states' |
| LANGUAGE C IMMUTABLE STRICT |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `'); |
| |
| ------------------------------------------------------------------------ |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.__ordinal_final( |
| state MADLIB_SCHEMA.bytea8) |
| RETURNS MADLIB_SCHEMA.bytea8 |
| AS 'MODULE_PATHNAME', 'ordinal_final' |
| LANGUAGE C IMMUTABLE STRICT |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `'); |
| |
| ------------------------------------------------------------------------ |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.__ordinal_logit_transition( |
| MADLIB_SCHEMA.bytea8, |
| double precision, |
| double precision[], |
| MADLIB_SCHEMA.bytea8, |
| smallint) |
| RETURNS MADLIB_SCHEMA.bytea8 |
| AS 'MODULE_PATHNAME', 'ordinal_logit_transition' |
| LANGUAGE C IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `'); |
| |
| ------------------------------------------------------------------------ |
| |
| DROP AGGREGATE IF EXISTS MADLIB_SCHEMA.__ordinal_logit_agg( |
| double precision, double precision[], MADLIB_SCHEMA.bytea8, smallint); |
| CREATE AGGREGATE MADLIB_SCHEMA.__ordinal_logit_agg( |
| /*+ y */ double precision, |
| /*+ x */ double precision[], |
| /*+ previous_state */ MADLIB_SCHEMA.bytea8, |
| /*+ numer of categor.*/ smallint) ( |
| |
| STYPE=MADLIB_SCHEMA.bytea8, |
| SFUNC=MADLIB_SCHEMA.__ordinal_logit_transition, |
| m4_ifdef(`__POSTGRESQL__', `', `prefunc=MADLIB_SCHEMA.__ordinal_merge_states,') |
| FINALFUNC=MADLIB_SCHEMA.__ordinal_final, |
| INITCOND='' |
| ); |
| |
| ------------------------------------------------------------------------ |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.__ordinal_probit_transition( |
| MADLIB_SCHEMA.bytea8, |
| double precision, |
| double precision[], |
| MADLIB_SCHEMA.bytea8, |
| smallint) |
| RETURNS MADLIB_SCHEMA.bytea8 |
| AS 'MODULE_PATHNAME', 'ordinal_probit_transition' |
| LANGUAGE C IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `'); |
| |
| ------------------------------------------------------------------------ |
| |
| DROP AGGREGATE IF EXISTS MADLIB_SCHEMA.__ordinal_probit_agg( |
| double precision, double precision[], MADLIB_SCHEMA.bytea8, smallint); |
| CREATE AGGREGATE MADLIB_SCHEMA.__ordinal_probit_agg( |
| /*+ y */ double precision, |
| /*+ x */ double precision[], |
| /*+ previous_state */ MADLIB_SCHEMA.bytea8, |
| /*+ numer of categor.*/ smallint) ( |
| |
| STYPE=MADLIB_SCHEMA.bytea8, |
| SFUNC=MADLIB_SCHEMA.__ordinal_probit_transition, |
| m4_ifdef(`__POSTGRESQL__', `', `prefunc=MADLIB_SCHEMA.__ordinal_merge_states,') |
| FINALFUNC=MADLIB_SCHEMA.__ordinal_final, |
| INITCOND='' |
| ); |
| |
| ------------------------------------------------------------------------------ |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.__ordinal_result( |
| /*+ state */ MADLIB_SCHEMA.bytea8) |
| RETURNS MADLIB_SCHEMA.__ordinal_result_type |
| AS 'MODULE_PATHNAME', 'ordinal_result' |
| LANGUAGE C IMMUTABLE STRICT |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `'); |
| |
| ------------------------------------------------------------------------ |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.__ordinal_loglik_diff( |
| /*+ state1 */ MADLIB_SCHEMA.bytea8, |
| /*+ state2 */ MADLIB_SCHEMA.bytea8) |
| RETURNS double precision |
| AS 'MODULE_PATHNAME', 'ordinal_loglik_diff' |
| LANGUAGE C IMMUTABLE STRICT |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `'); |
| |
| ------------------------------------------------------------------------ |
| ------------------------------------------------------------------------ |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.ordinal( |
| source_table varchar, |
| model_table varchar, |
| dependent_varname varchar, |
| independent_varname varchar, |
| cat_order varchar, |
| link_func varchar, |
| grouping_col varchar, |
| optim_params varchar, |
| verbose boolean |
| ) RETURNS void AS $$ |
| PythonFunction(glm, ordinal, ordinal) |
| $$ LANGUAGE plpythonu |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| -- entry functions with default values |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.ordinal( |
| source_table varchar, |
| model_table varchar, |
| dependent_varname varchar, |
| independent_varname varchar, |
| cat_order varchar, |
| link_func varchar, |
| grouping_col varchar, |
| optim_params varchar |
| ) RETURNS void AS $$ |
| SELECT MADLIB_SCHEMA.ordinal($1, $2, $3, $4, $5, $6, $7, $8, FALSE); |
| $$ LANGUAGE sql |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.ordinal( |
| source_table varchar, |
| model_table varchar, |
| dependent_varname varchar, |
| independent_varname varchar, |
| cat_order varchar, |
| link_func varchar, |
| grouping_col varchar |
| ) RETURNS void AS $$ |
| SELECT MADLIB_SCHEMA.ordinal($1, $2, $3, $4, $5, $6, $7, NULL, FALSE); |
| $$ LANGUAGE sql |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.ordinal( |
| source_table varchar, |
| model_table varchar, |
| dependent_varname varchar, |
| independent_varname varchar, |
| cat_order varchar, |
| link_func varchar |
| ) RETURNS void AS $$ |
| SELECT MADLIB_SCHEMA.ordinal($1, $2, $3, $4, $5, $6, NULL, NULL, FALSE); |
| $$ LANGUAGE sql |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.ordinal( |
| source_table varchar, |
| model_table varchar, |
| dependent_varname varchar, |
| independent_varname varchar, |
| cat_order varchar |
| ) RETURNS void AS $$ |
| SELECT MADLIB_SCHEMA.ordinal($1, $2, $3, $4, $5, NULL, NULL, NULL, FALSE); |
| $$ LANGUAGE sql |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.ordinal( |
| source_table varchar, |
| model_table varchar, |
| dependent_varname varchar, |
| independent_varname varchar |
| ) RETURNS void AS $$ |
| SELECT MADLIB_SCHEMA.ordinal($1, $2, $3, $4, NULL, NULL, NULL, NULL, FALSE); |
| $$ LANGUAGE sql |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| -- Help messages ------------------------------------------------------- |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.ordinal( |
| message TEXT |
| ) RETURNS TEXT AS $$ |
| PythonFunction(glm, ordinal, ordinal_help_msg) |
| $$ LANGUAGE plpythonu IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.ordinal() |
| RETURNS TEXT |
| AS $$ |
| SELECT MADLIB_SCHEMA.ordinal(NULL::TEXT); |
| $$ LANGUAGE SQL IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| ------------------------------------------------------------------------------ |
| --------- prediction function ------------------------------------------------ |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.ordinal_predict( |
| model_table varchar, |
| predict_table varchar, |
| predicted_value_tab varchar, |
| predict_type varchar, |
| verbose boolean |
| ) RETURNS void AS $$ |
| PythonFunction(glm, ordinal, ordinal_predict) |
| $$ LANGUAGE plpythonu |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.ordinal_predict( |
| model_table varchar, |
| predict_table varchar, |
| predicted_value_tab varchar, |
| predict_type varchar |
| ) RETURNS void AS $$ |
| SELECT MADLIB_SCHEMA.ordinal_predict($1,$2,$3,$4,FALSE); |
| $$ LANGUAGE sql |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.ordinal_predict( |
| model_table varchar, |
| predict_table varchar, |
| predicted_value_tab varchar |
| ) RETURNS void AS $$ |
| SELECT MADLIB_SCHEMA.ordinal_predict($1,$2,$3,NULL,FALSE); |
| $$ LANGUAGE sql |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `MODIFIES SQL DATA', `'); |
| |
| |
| -- Help messages ------------------------------------------------------- |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.ordinal_predict( |
| message TEXT |
| ) RETURNS TEXT AS $$ |
| PythonFunction(glm, ordinal, ordinal_predict_help_msg) |
| $$ LANGUAGE plpythonu IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |
| |
| CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.ordinal_predict() |
| RETURNS TEXT |
| AS $$ |
| SELECT MADLIB_SCHEMA.ordinal_predict(NULL::TEXT); |
| $$ LANGUAGE SQL IMMUTABLE |
| m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `'); |