Regression Action Set

The following DATA step runs on the CAS server and creates the data table mycas.analysisData, which contains one million observations and 28 variables. This DATA step assumes that your CAS engine libref is named mycas and your CAS session is named mysess, but you can substitute any appropriately defined CAS engine libref and session name.

The DATA step forms the response y by adding an error term to a true model. Variables x1–x20 are used as the continuous regressors, and variables c1–c3 are used as classification variables. The true model response, yTrue, is a linear combination of the main effects, x1, x5, x10, x20, and c1(only for levels 3 and 7), and the interaction effects, x1*x7, x6*x7, and c1*c3.

%let nTotalObs=1000000;
%let seed=1;
data mycas.analysisData / sessref=mysess single=no;
    drop i j c3Num nObsPerThread nExtras rew;
    length c3$ 7;

    array x{20} x1-x20;
    call streamInit(&seed);
    nObsPerThread  = int(&nTotalObs/_nthreads_);
    nExtras        = mod(&nTotalObs,_nthreads_);
    if _threadid_ <= nExtras then nObsPerThread =  nObsPerThread + 1;

    do i=1 to nObsPerThread;

       id = (_threadid_-1)*nObsPerThread +i;
       if _threadid_ > nExtras then id=id+nExtras;
       rew = rand('rewind', id);

       do j=1 to 20;
          x{j} = rand('UNIFORM');
       end;

       if  rand('UNIFORM') < 0.4 then byVar='A';
                                 else byVar='B';

       c1 = 1 + mod(id,8);
       c2 = rand('BERNOULLI',0.6);

       if      id < (0.001 * &nTotalObs) then do; c3 = 'tiny';     c3Num=1;end;
       else if id < (0.3   * &nTotalObs) then do; c3 = 'small';    c3Num=1;end;
       else if id < (0.7   * &nTotalObs) then do; c3 = 'average';  c3Num=2;end;
       else if id < (0.9   * &nTotalObs) then do; c3 = 'big';      c3Num=3;end;
       else                                   do; c3 = 'huge';     c3Num=5;end;

       yTrue = 10 + x1 + 2*x5 + 3*x10 + 4*x20  + 3*x1*x7 + 8*x6*x7
                  + 5*c3Num   + 8*(c1=7) + 8*(c1=3)*c2;

       error = 5*rand('NORMAL');

       y = yTrue + error;

            if mod(id,3)=1 then Role = 'TRAIN';
       else if mod(id,3)=2 then Role = 'VAL';
       else                     Role = 'TEST';

       output;
   end;
run;

There are several noteworthy aspects of the preceding DATA step. When you submit a DATA step with a CAS engine libref, a determination is made whether this DATA step can be run directly on the CAS server. If the DATA step uses any features that are not supported by the CAS DATA step that runs on the CAS server, then the client executes the DATA step and then the CAS engine sends the results to the server. The preceding DATA step can execute directly on the CAS server. By default, the CAS server executes this DATA step in a single thread on a single node and then distributes the results across the worker nodes in your CAS session. When you specify the SINGLE=NO option in a DATA step that executes on the CAS server, the DATA step code executes in parallel in every thread on every node in your session. For example, if your DATA step creates 10 observations and executes in parallel on a session that has three worker nodes each of which uses 16 threads, then the resulting CAS table has 160 observations on each worker node, yielding a CAS table with a total of 480 observations.

The following excerpt from the preceding DATA step uses this technique to create a table with a specified number of observations in parallel on your CAS server: It divides the total number of observations (n) by the total number of threads (_nthreads_); if the number of observations cannot be exactly divided by the number of threads, the code adds one observation to each of a subset of the threads until all observations are accounted for.

 nObsPerThread  = int(1000000/_nthreads_);
 nExtras        =  mod(1000000,_nthreads_);
 if _threadid_ <= nExtras then nObsPerThread =  nObsPerThread + 1;
 do i=1 to nObsPerThread;
    . . .
    output;
 end;

The glm action supports two mutually exclusive modes for specifying the variables in a model: one mode uses target, inputs, and nominals parameters; the other mode uses class and model parameters. You can use the target, inputs, and nominals parameters to specify main-effect models that use the default settings for modeling and classification variable properties. This mode for specifying the model effects is called "machine-learning" mode because it mirrors the syntax for specifying models that is used by many machine-learning learning actions in which more complex model specifications are not needed. The following statements show how you can use PROC CAS to run the glm action with machine-learning mode syntax:

proc cas;
   regression.glm  /
      table='analysisData',
      target='y',
      inputs={'c1','c2','c3','x1','x2','x3'},
      nominals={'c1','c2'};
run;

The target parameter names the response variable, and the inputs parameter names the regressor variables. By default, the numeric variables that you specify in the inputs parameter are treated as continuous regressors and all character variables that you specify in the inputs parameter are treated as classification (nominal) variables. If you want to use a numeric variable in the inputs parameter as a classification variable, then you must also specify that variable in the nominals parameter. The preceding code explicitly defines the numeric variables c1 and c2 as classification variables. The character variable c3 is automatically treated as a classification variable.

The output from this analysis is displayed by default, and is presented in Output 19.3.1. For an explanation of the tables shown in Output 19.3.1, see the example in Getting Started: REGSELECT Procedure (SAS Visual Statistics: Procedures).

The glm action also supports a more general form of model specification that uses class and model parameters as alternatives to the target, inputs, and nominals parameters that are used in the machine-learning mode. By using the class and model parameters, you can specify models that cannot be expressed in the machine-learning mode. The following functionalities (which are not available in machine learning mode) are supported:

The remaining examples in this section use the class and model parameters to specify regression models.

The following code fits a model that is identical to the model shown Output 19.3.1. In the class-and-model syntax, the target variable and model effects are specified as subparameters of the model parameter and the classification variables are identified by using the class parameter. Because PROC CAS is an interactive procedure, it is not necessary to resubmit the PROC CAS statement.

   regression.glm
      table='analysisData',
      class={'c1','c2','c3'},
      model={depVar='y',
             effects={'c1','c2','c3','x1','x2','x3'}
            };
run;

You can use Perl regular expressions to specify sets of variables in all the variable lists that you can specify in the class and model parameters. Any string that is enclosed in forward slashes is treated as a Perl regular expression and is matched against the variable names in the input CAS table that you specify in the table parameter. For example, the following code uses regular expressions to specify the same model that is shown in Output 19.3.1:

   regression.glm /
      table='analysisData',
      class={'/c/'},
      model={ depVar='y',
              effects={'/c/','/x[1-3]$/'}
            };
run;

The Perl regular expression /c/ matches any variable in the analysisData table whose name contains the character "c" ( c1, c2, and c3), and the regular expression /x[1-3]$/ matches variable names that end in the character "x" followed by a digit in the range 1–3 (x1, x2, and x3).

The status of each action submission is available in the _status variable, which contains several fields that you can access programmatically. You can display the contents of _status by using the PRINT statement as follows:

   print _status;
run;

For an action that runs without error, this PRINT statement displays the following line in the SAS log:

   {severity=0,reason=0,,statusCode=0}

You can access and print individual fields in the status by using dot notation as follows:

   print _status.severity;
run;

This PRINT statement displays the number 0 (the contents of _status.severity) in the SAS log.

The following code submits the glm action without specifying a response variable (which is an error). It also illustrates how you can assign the status of the action to a variable that you name.

   regression.glm status=myStatus/
      table='analysisData',
      model={ effects='x1'};
 run;
    print myStatus;
 run;

This code produces the following errors in the SAS log:

   ERROR: A response variable is required.
   ERROR: The action stopped due to errors.

The nature of the error is also saved in the myStatus status variable, which you can display as follows:

    print myStatus;
 run;

This PRINT statement produces the following line in the SAS log:

   {severity=2,reason=6,status=A response variable is required.,statusCode=3240083}

For more information about severity and reason codes, see the section "Programming with Severity and Reason Codes" in SAS Viya: System Programming Guide.

The following code shows how you request stepwise selection by using the selection parameter in the glm action:

   regression.glm  /
      table='analysisData',
      class={'/c/'},
      model={ depVar='y',
              effects={'/c/','/x/'}
            },
      selection={method='STEPWISE'};
 run;

In this case, the regular expression /x/ matches all variables in the analysisData table that contain the character "x", namely x1–x20.

The "Selection Information" table is shown in Output 19.3.2.

Output 19.3.3 displays the "Stop Reason," "Selection Reason," and "Selected Effects" tables, which are displayed without any titles. The "Stop Reason" table indicates that selection stopped because adding or removing any effect would worsen the SBC value that is used as the selection criterion. In this case, no choose subparameter is specified in the selection parameter, so the final model is the selected model, as indicated in the "Selection Reason" table. The "Selected Effects" table lists the effects in the selected model.

The "Analysis of Variance," "Fit Statistics" (which is displayed without a title), and "Parameter Estimates" tables shown in Output 19.3.4 display details of the selected model.

In the previous examples, the output of the glm action is immediately displayed. If you route the results to a named result, then the output is saved in the named result and is not displayed. The following code shows how you can do this:

   regression.glm  result=myresult /
      table='analysisData',
      class={'/c/'},
      model={ depVar='y',
              effects={'/c/','/x/'}
            },
      selection={method='STEPWISE'};
 run;

After you run the preceding code, the results of running the glm action are stored in the result object named myresult, but no output is displayed. You can display the tables stored in myresult by using the PRINT statement in PROC CAS as follows:

   print myresult;
run;

The output of running this PRINT statement is the same as when you run the glm action without assigning the results and is not reproduced here. You can also display specific tables that are stored in myresult. The following code shows how you can print the "Selected Effects" and "Parameter Estimates" tables:

    print myresult['Summary.SelectedEffects']
          myresult['SelectedModel.ParameterEstimates'];
 run;

The requested output is shown in Output 19.3.5.

In order to use the PRINT statement to print specific tables in a stored result, you need to know the paths of those tables in the stored result. One way you can get this information is to specify the ODS TRACE ON command and then print the entire result. Another way to get the paths is to use the DESCRIBE statement in PROC CAS as follows:

   describe myresult;
 run;

This displays in the SAS log a dictionary of the tables and the columns in those tables that are stored in myresult. A subset of this dictionary for the "ModelInfo" and "SelectionSummary" tables follows:

   dictionary ( 13 entries, 13 used);
    [ModelInfo] Table ( [2] Rows [3] columns
   Column Names:
    [1] RowId            [                ] (string)
    [2] Description      [Description     ] (string)
    [3] Value            [Value           ] (string)
    [Summary.SelectionSummary] Table[SelectionSummary] ( [9] Rows [7] columns
   Column Names:
    [1] Control          [                ] (string)
    [2] Step             [Step            ] (int32)
    [3] EffectEntered    [Effect Entered  ] (string)
    [4] EffectRemoved    [Effect Removed  ] (string)
    [5] nEffectsIn       [Number Of Effects] (int32)
    [6] SBC              [SBC             ] (double)
    [7] OptSBC           [Optimal SBC     ] (int32)

This dictionary contains the paths (such as Summary.SelectionSummary) of all tables in myresult. You must use the complete path to request specific tables in the PRINT statement.

The glm action supports a display parameter, which provides functionality that corresponds to that of ODS SELECT, ODS EXCLUDE, and ODS TRACE statements on a SAS client. The major advantage of using the action’s display parameter is that you can use it with Lua, Python, and Java clients, where the ODS system is not available. The following code shows how you can use the traceNames subparameter of the display parameter to obtain the paths of the tables that the glm action produces:

   regression.glm  result=myresult /
      table='analysisData',
      class={'/c/'},
      model={ depVar='y',
              effects={'/c/','/x/'}
            },
      selection={method='STEPWISE'},
      display={traceNames=true};
run;

This code produces the following notes in the SAS log:

   NOTE: Name:'ModelInfo' Label:'Model Information' Path:'ModelInfo'
   NOTE: Name:'SelectionInfo' Label:'Selection Information' Path:'SelectionInfo'
   NOTE: Name:'NObs' Label:'Number of Observations' Path:'NObs'
   NOTE: Name:'ClassInfo' Label:'Class Level Information' Path:'ClassInfo'
   NOTE: Name:'Dimensions' Label:'Dimensions' Path:'Dimensions'
   NOTE: Name:'SelectionSummary' Label:'Selection Summary'
         Path:'Summary.SelectionSummary'
   NOTE: Name:'StopReason' Label:'Stop Reason' Path:'Summary.StopReason'
   NOTE: Name:'SelectionReason' Label:'Selection Reason'
         Path:'Summary.SelectionReason'
   NOTE: Name:'SelectedEffects' Label:'Selected Effects'
         Path:'Summary.SelectedEffects'
   NOTE: Name:'ANOVA' Label:'Analysis of Variance' Path:'SelectedModel.ANOVA'
   NOTE: Name:'FitStatistics' Label:'Fit Statistics'
         Path:'SelectedModel.FitStatistics'
   NOTE: Name:'ParameterEstimates' Label:'Parameter Estimates'
         Path:'SelectedModel.ParameterEstimates'
   NOTE: Name:'Timing' Label:'Task Timing' Path:'Timing'

You can also use the display parameter to select which tables produced by the glm action are returned to the client. The following code uses the display parameter to select the "ANOVA" and "Fit Statistics" tables:

    regression.glm  /
      table='analysisData',
      class={'/c/'},
      model={ depVar='y',
              effects={'/c/','/x/'}
            },
      selection={method='FORWARD'},
      display={names={'ANOVA','FitStatistics'} };
run;

Specifying full paths is optional—the path-matching rules that the display parameter uses are consistent with rules that the ODS SELECT statement uses. The tables that you request by using the display parameter match all tables whose paths end with the specified path. For example, display={names={’ANOVA"} } matches all the paths ANOVA, SelectedModel.ANOVA, and BYGroup1.SelectedModel.ANOVA, and display={names={’SelectedModel.ANOVA"} } matches SelectedModel.ANOVA and BYGroup1.SelectedModel.ANOVA, but not ANOVA.

Output 19.3.6 shows the filtered output that contains only "Analysis of Variance" and "Fit Statistics" tables.

If you enclose the strings in the names subparameter of the display parameter within forward slashes, then those strings are treated as Perl regular expressions that are matched against the full paths of the tables that the action produces. For example, display={names={’/Summary/’}} selects the paths Summary.SelectionSummary, Summary.StopReason, Summary.SelectionReason, and Summary.SelectedEffects.

The glm action supports an OutputTables parameter, which you can use to save any displayed table as a CAS table in the active caslib. This functionality is analogous to the ODS OUTPUT functionality, which saves ODS output as SAS data sets. The following code provides an example of using this parameter:

    regression.glm  /
      table='analysisData',
      class={'/c/'},
      model={ depVar='y',
              effects={'/c/','/x/'}
            },
      selection={method='STEPWISE',details='ALL',maxsteps=3},
      outputTables={names={'NObs','Anova'}};
run;

Output 19.3.7 displays the "Output CAS Tables," which provide information about all the CAS tables that are produced by the action. You see that the preceding code created CAS tables named "NObs" and "Anova."

The following PROC PRINT code displays the "Anova" CAS table on the SAS client by using the CAS engine to bring the table back to the SAS client.

 proc print data=mycas.anova;
 run;

Output 19.3.8 shows contents of the "Anova" CAS table. Because you specified the details='ALL' subparameter of the selection parameter, ANOVA tables are produced at each step of the selection process. Notice that the CAS tables that you request in the outputTables parameter consist of all the tables whose paths end with the specified name and that grouping variables are added to the CAS table so that you can distinguish between the tables. This behavior matches the behavior of ODS OUTPUT. If you want to see a specific table, you can specify the complete path to the table. Furthermore, you can optionally supply your own name for the CAS table that is created, as illustrated in the following code:

 proc cas;
    regression.glm  /
      table='analysisData',
      class={'/c/'},
      model={ depVar='y',
              effects={'/c/','/x/'}
            },
      selection={method='FORWARD',details='ALL',maxsteps=3},
      outputTables={names={'Step1.Anova'='myStep1Anova'}};
 run;

The following PROC PRINT code displays the myStep1Anova CAS table on the SAS client by using the CAS engine to bring the table back to the SAS client.

  proc print data=mycas.myStep1Anova;
  run;

Output 19.3.9 shows the ANOVA table at step 1 that is saved in the myStep1Anova CAS table.

The following code shows how you can add all two-way interactions of the continuous regressor variables and an interaction of c1 and c2 to the effects from which the model is selected. Because there is a danger of overfitting your data when you add these interactions, this example uses the Role variable in the analysisData table to partition the data into training, validation, and test sets and uses the ASE (average square error) on validation data to choose the final model.

 proc cas;
    regression.glm  /
      table='analysisData',
      partByVar={name='Role',train='TRAIN',validate='VAL',test='TEST'},
      class={'/c/'},
      model={ depVar='y',
              effects={  '/c/',
                         { vars={'c1','c2'},interact='CROSS' },
                         { vars='/x/'      ,interact='BAR'   ,maxinteract=2 }
                      }
            },
      selection={method='FORWARDSWAP',choose='VALIDATE',hierarchy='SINGLE'};
 run;

The partByVar parameter identifies the Role as the variable whose values are used to split the data into training, validation, and test roles. If your data do not contain a suitable variable to specify for the partitioning, then you can instead use the partByFrac parameter to randomly assign observations to roles in proportions that you specify.

Output 19.3.10 shows the "Number of Observations" table. You see that each role contains approximately one third of the observations.

The effects subparameter of the model parameter enables you to add interactions in your model. The effects subparameter defines a list of terms enclosed in braces and separated by commas. Each such term contains a list of variables defined by the vars parameter and optionally other parameters that specify how the variables in that term interact. In this example, the terms are {vars={’/c/’}} , {vars={’c1’,’c2’},interact=’CROSS’}, and {vars={’/x/’},interact=’BAR’,maxinteract=2}. These terms define the model effects that correspond to the following syntax that you would use in the GLM procedure in SAS/STAT:

c1 c2 c3
c1*c2
x1|x2|x3|x4|x5|x6|x7|x8|x9|x10|x11|x12|x13|x14|x15|x16|x17|x18|x9|x20@2

If a term contains only a vars parameter, then you can directly specify the variables named in the vars parameter in the effects parameter without the enclosing braces. This type of simplification is a general property of action syntax that is referred to as "coercion." You can exploit coercion to simplify the specification {vars={’/c/’}} to be simply ’/c/’. You can also use coercion to simplify the specification of the vars subparameter when the list within braces that it defines consists of a single string. In this case, you can omit the braces and specify the string directly in the vars subparameter. Thus the term {vars={’/x/’},interact=’BAR’,maxinteract=2} can be specified as {vars=’/x/’,interact=’BAR’,maxinteract=2}.

For more examples of specifying complex models, see Chapter 3, Specifying Linear Models for SAS Viya Analytical Actions.

Output 19.3.11 shows the "Dimensions" table. You see that the model specification defines a model that has 215 effects and 242 parameters.

Output 19.3.12 shows the "Selection Summary" table. Both the SBC and Validation ASE statistics achieve their optimal value at step 13, and the model at step 13 is the selected model.

Output 19.3.13 shows the "Selected Effects" table. You see that the selected effects are precisely the effects that by construction are systematically related to the response.

The "Analysis of Variance" and "Fit Statistics" tables shown in Output 19.3.14 confirm that the selected model is highly significant. Furthermore, the average square error (ASE) on the training, validation, and test data are approximately equal, indicating that the model is not overfitting the training data.

Output 19.3.15 shows the "Parameter Estimates" table for the selected model.

If you examine the p-values of the parameters of the classification variable c1, you see that the only the parameters that correspond to levels 3 and 7 of this variable are significant. This suggests that a more parsimonious model might be obtained if your model could select parameters for this effect independently. The following code shows how you can do this:

   regression.glm  /
      table='analysisData',
      partByVar={name='Role',train='TRAIN',validate='VAL',test='TEST'},
      class={ 'c2','c3',
              {vars='c1',split=true}
            },
      model={ depVar='y',
              effects={  '/c/',
                         { vars={'c1','c2'},interact='CROSS' },
                         { vars='/x/'      ,interact='BAR'   ,maxinteract=2 }
                      }
            },
      selection={method='FORWARDSWAP',choose='VALIDATE',hierarchy='SINGLE'};
 run;

As in the definition of the effects parameter, the class parameter specifies a list of terms enclosed in braces and separated by commas. Each such term contains a list of variables that are defined by the vars subparameter and optionally contains other subparameters that specify additional properties of the variables that are defined by the vars parameter. Similarly, you can use the coercion property of the action syntax to simplify the specification of terms when the optional parameters are not needed. The uncoerced version of the class specification is as follows:

      class={ {vars={'c2','c3'}},
              {vars={'c1'},split=true} }

By using coercion, this simplifies to the following:

      class={ 'c2','c3',
              {vars='c1',split=true} }

Output 19.3.16 shows details of the selected model.

You see that the selected model consists of precisely the parameters that by construction are systematically related to the response. Furthermore, the selected effects for c1 correspond to levels 3 and 7 only. This yields a model with 16 model degrees of freedom as compared to the 27 model degrees of freedom in the selected model where the classification variable c1 is not split. Finally, by examining the fit statistics of this model, you see that it achieves this parsimony without loss in predictive accuracy on the training data, and yet produces a slightly better generalization on the validation and test data.

The attributes parameter provides similar functionality to that of LABEL and FORMAT statements that you can use with SAS procedures. You can use the attributes parameter to specify formats and labels for variables in the input CAS table as shown in the following code:

   regression.glm  /
      table='analysisData',
      attributes={ {name='c1',format='roman4.'} },
      class='/c/',
      model={ depVar='y',
              effects={  '/c/', '/x/'}
            };
 run;

The "Class Level Information" table in Output 19.3.17 shows that the glm action applies the specified format for the c1 variable.

Attributes that you specify for a variable in the attributes parameter override those same attributes for that variable in the input data. However, the input data attributes are unchanged after the action completes.

You can use the output parameter to create an output CAS table that contains observationwise statistics, which are computed after the model is fitted. The variables in the input data table are not included in the output data table in order to avoid data duplication for large data tables; however, variables that you specify in the copyVars subparameter are included. Strings enclosed in forward slashes that you specify in the copyVars subparameter are interpreted as Perl regular expressions.

The output statistics are computed based on the parameter estimates for the selected model. For observations in which only the response variable is missing, predicted values are computed even though these observations do not affect the model fit. This enables, for example, predicted values to be computed for new observations.

You name the statistics to be included and identify which variables to copy from the input CAS table as shown in the following code:

   regression.glm  /
      table='analysisData',
      attributes={ {name='c1',format='roman4.'} , {name='y',label='Response'} },
      class='/c/',
      model={ depVar='y',
              effects={  '/c/', '/x/'}
            },
      output={casout='myOutputTable',pred='Predicted',resid='Residual',
              h='Leverage',cooksD='CooksD', copyVars={'/c/','/x/','y'}
             };
 run;

Output 19.3.18 displays the "Output CAS Tables," which provide information about all the CAS tables that are produced by the action. You see that the preceding code created a CAS table named "myOutputTable."

The following code runs the columnInfo action in the table action set to display information about the columns in the myOutputTable:

    table.columnInfo / table='myOutputTable';
run;

Output 19.3.19 shows the columns in the myOutputTable CAS table. You see that the format for the variable c1 and the label for y that you specified in the attributes parameter are retained in the output CAS table.

Instead of explicitly listing variables to copy in the copyVars parameter, you can instead use one of the following shortcuts:

You can use the groupby subparameter of the table parameter to specify BY processing in the glm action. Unlike BY processing in SAS procedures, the input table is not required to be sorted by the variable or variables that you name in the groupBy subparameter. In the preceding code snippets in this example, the table parameter is specified simply as table=’analysisData’. This form is the coerced simplification of the general specification of the table parameter when only the name subparameter is needed. You can use a partially coerced form to specify BY processing with a single BY variable as shown in the following code:

   regression.glm /
      table={ name='analysisData', groupBy='byVar'},
      attributes={ {name='c1',format='roman4.'} , {name='y',label='Response'} },
      class='/c/',
      model={ depVar='y',
              effects={  '/c/', '/x/'}
            },
      display={names={'NObs','ANOVA'},traceNames=true};
  run;

Output 19.3.20 shows the output. You see that the output of BY group is identified by a title that contains the name and value of the BY variable.

Furthermore, the following notes in the SAS log (which you request with the traceNames subparameter of the display parameter) show that the table paths contain a prefix that identifies the BY group index:

   NOTE: Name:'NObs' Label:'Number of Observations' Path:'ByGroup1.NObs'
   NOTE: Name:'ANOVA' Label:'Analysis of Variance' Path:'ByGroup1.ANOVA'
   NOTE: Name:'NObs' Label:'Number of Observations' Path:'ByGroup2.NObs'
   NOTE: Name:'ANOVA' Label:'Analysis of Variance' Path:'ByGroup2.ANOVA'