Generative Adversarial Network Action Set

This section contains PROC CAS code.

Note: Input data must be accessible in your CAS session, either as a CAS table or as a transient-scope table. A CAS table has a two-level name: the first level is your CAS engine libref, and the second level is the table name. You refer to this table in the CAS procedure by specifying only the second level. For more information about two-level names, see Chapter 2, Shared Concepts (SAS Visual Data Mining and Machine Learning: Procedures). A transient-scope table is called directly from the action and exists in memory for the duration of the action. For more information about accessing data, see SAS Viya: System Programming Guide. For more information about PROC CAS and programming in CASL, see SAS Cloud Analytic Services: CASL Programmer’s Guide and SAS Cloud Analytic Services: CASL Reference.

This example shows how to use the tabularGanTrain action to analyze and augment the hmeq data table, which contains data about mortgage applicants. The following DATA step creates the input data table mycas.hmeq in your CAS session. These statements assume that your CAS engine libref is named mycas, but you can substitute any appropriately defined CAS engine libref.

data mycas.hmeq;
   set sampsio.hmeq;
run;

The following code uses the GMM action to cluster the value and clage variables and to generate the centroids table to be used in the tabularGanTrain action. This step saves the weight, centroid ID, mean, and standard deviation for each cluster in the centroids data table.

 /* Define the runloop macro */
 %macro runloop;
     /* Specify all interval input variables*/
     %let names=value clage;
     /* Loop over all variables that need centroids generation */
     %do i=1 %to %sysfunc(countw(&names));
         %let name&i = %scan(&names, &i, %str( ));
         /* Call the GMM action to cluster each variable */
         proc cas ;
             action nonParametricBayes.gmm result=R/
                 table       = {name="hmeq"},
                 inputs      = {"&&name&i"},/*'value'*/
                 seed        = 1234567890,
                 maxClusters = 10,
                 alpha       = 1,
                 infer       = {method="VB",
                                maxVbIter =30,
                                covariance="diagonal",
                                threshold=0.01},
                 output      = {casOut={name='Score', replace=true},
                                copyVars={'value'}},
                 display     = {names={ "ClusterInfo"}}
                ;
             run;
             saveresult R.ClusterInfo replace dataset=work.weights&i;
         run;
         quit;

         /* Save variable name, weights, mean,     */
         /* and standard deviation of each cluster */
         data  weights&i;
             varname = "&&name&i";
             set  weights&i(rename=(&&name&i.._Mean=Mean
                                    &&name&i.._Variance=Var));
             /* Calculate standard deviation from variance*/
             std = sqrt(Var);
             drop Var;
         run;

         /* Construct centroids table from saved weights */
         %if &i=1 %then %do;
             data centroids;
             set weights&i;
             run;
         %end;
         %else %do;
             data centroids;
             set centroids weights&i;
             run;
         %end;
     %end;
 %mend;

 /* Run the runloop macro to generate the centroids table */
 %runloop;

The following DATA step uploads the centroids table to your CAS session:

data mycas.centroids;
   set centroids;
run;

The following PROC CAS statements use the tabularGanTrain action to train a tabular GAN model and save the trained model in an analytic store. The PROC PRINT statement prints the generated samples.

 proc cas;
     loadactionset "generativeAdversarialNet";
     action tabularGanTrain result = r /
         table           = {name = "hmeq",
                            vars = {'bad','value','clage','job'}},
         centroidsTable  = "centroids",
         nominals        = {"bad","job"},
         gpu             = {useGPU = True, device = 0},
         optimizerAe     = {method = "ADAM", numEpochs = 3},
         optimizerGan    = {method = "ADAM", numEpochs = 5},
         seed            = 12345,
         scoreSeed       = 0,
         numSamples      = 5,
         saveState       = {name = 'cpctStore', replace = True},
         casOut          = {name = 'out', replace = True};
     print r;
 run;
 quit;

 proc print data = mycas.out;
 run;

The table parameter names the input data table, hmeq, to be analyzed. The vars subparameter specifies the input variables in the hmeq, including bad, value, clage, and job. The centroidsTable parameter specifies the centroids column table. The nominals parameter specifies the nominal variables from the input. The method subparameter in the optimizerAe parameter list specifies that the autoencoder optimizer be used in the training process; currently only the Adam method is supported. The numEpochs subparameter in the optimizerAe parameter list specifies the number of epochs to use for training the autoencoder; one epoch processes all the training data once. The method subparameter in the optimizerGAN parameter list specifies the GAN optimizer to use in the training process; currently only the Adam method is supported. The numEpochs subparameter in the optimizerGAN parameter list specifies the number of epochs to use for training the GAN model; one epoch processes all the training data once. The seed parameter specifies the random seed 12345 be used in the training process. The numSamples parameter specifies the number of synthetic samples to generate. The useGPU subparameter in the gpu parameter list specifies whether you want to run the action on the GPU. If you set it to True, then the action uses the GPU device whose ID you specify in the device subparameter. The scoreSeed parameter specifies that the random seed 0 be used in generating the out data table. The saveState parameter saves the trained model to the cpctStore data table in the active caslib for future scoring. The casOut parameter outputs the score output to the out data table.

The tabularGanTrain action generates four ODS tables, which are shown in Output 17.2.1 through Output 17.2.4.

In this example, the tabularGanTrain action generates the score output table out in the active caslib. The out table contains five generated samples from the trained model.