With all the news around ChatGPT lately, I thought I would see how it performed when asked questions about SAS 9 Metadata Security. This is a niche specialty with some complex rules when you get down into the details, so I was not expecting it to do very well. I was both impressed and disappointed. … Continue reading “ChatGPT and SAS 9 Metadata Security”

This post was kindly contributed by platformadmin.com - go there to comment and to read the full post.

The post ChatGPT and SAS 9 Metadata Security first appeared on PROC-X.com.

SAS has released SAS 9.4 Maintenance 8, a major update to SAS 9.4.

Security is the primary focus of the Maintenance 8 update. This release contains updates for many of the third-party technologies that are used by the platform, including the Java runtime environment (JRE) and many of the third-party JAR files. This release also adds support for major releases of supported operating systems, while limiting support for operating systems that are no longer supported by their respective suppliers. My colleague Margaret Crevar has summarized these changes in this SAS Communities post.

As with all SAS maintenance releases, this release “rolls up” the hotfixes and enhancements delivered since the last major update (SAS 9.4 Maintenance 7). Most SAS platform products and solutions have also been updated to remain compatible with this release and take advantage of enhancements. However, there are some products and solutions that will not be available immediately, or that will not deliver support for SAS 9.4 Maintenance 8.

Because SAS 9.4 Maintenance 8 is a major software release for SAS 9.4, it is covered by the SAS Support policy for the “Standard Support” timeframe according to its general availability date: Jan 31, 2023. (Current policy offers Standard Support for 5 years from the GA date.)

While this maintenance release doesn’t contain new features, it does demonstrate the commitment of SAS to support users of the SAS 9.4 platform for many years to come. (See “Your platform, your way” in “Your analytics, your way” from Shadi Shahin.) New data and analytics capabilities are delivered in the SAS Viya platform, which offers monthly cadence releases via its continuous delivery model.

For an overview of all product changes and updates in SAS 9.4 Maintenance 8, see the What’s New topic in the SAS documentation.

SAS 9.4 Maintenance 8 is available was published on SAS Users.

This post was kindly contributed by SAS Users - go there to comment and to read the full post.

The post SAS 9.4 Maintenance 8 is available first appeared on PROC-X.com.

Welcome to the continuation of my series Getting Started with Python Integration to SAS Viya. In previous posts, I discussed how to connect to the CAS server, working with CAS actions and CASResults objects, and how to summarize columns. Now it’s time to focus on how to get the count of unique values in a CAS table column.

Load and prepare data

First, I connected my Python client to the distributed CAS server and named my connection conn. Then I created a function to load and prepare my CAS table. The custom function loads the WARRANTY_CLAIMS_0117.sashdat file from the Samples caslib into memory, renames the columns using the column labels and drops unnecessary columns. This simplifies the table for the demonstration.

The Samples caslib should be available in your SAS Viya environment and contains sample tables. For more information on how to rename columns in a CAS table view Part 11 – Rename Columns.

## Packages
import swat
import pandas as pd
 
## Options
pd.set_option('display.max_columns', 50)
 
## Connect to CAS
conn = ## your connection information
 
def prep_data():
    ## Load the data into CAS
    conn.loadTable(path='WARRANTY_CLAIMS_0117.sashdat', caslib='samples',
                   casout={'name':'warranty_claims', 'caslib':'casuser'})
 
    ## Reference the CAS table in an object
    castbl = conn.CASTable('warranty_claims', caslib = 'casuser')
 
    ## Store the column names and labels in a dataframe
    df_col_names = castbl.columnInfo()['ColumnInfo'].loc[:,['Column','Label']]
 
    ## Create a list of dictionaries of how to rename each column using the column labels
    renameColumns = []
    for row in df_col_names.iterrows():
        colName = row[1].values[0]
        labelName = row[1].values[1].replace(' ','_')
        renameColumns.append(dict(name=colName, rename=labelName))
 
    ## List of columns to keep in the CAS table
    keepColumns = {'Campaign_Type', 'Platform','Trim_Level','Make','Model_Year','Engine_Model',
                   'Vehicle_Assembly_Plant','Claim_Repair_Start_Date', 'Claim_Repair_End_Date'}
 
    ## Rename and drop columns to make the table easier to use
    castbl.alterTable(columns = renameColumns, keep = keepColumns)
 
    return castbl

Next, I’ll execute the user defined function and store the CAS table object in the variable tbl  and view it’s type.

tbl = prep_data()
type(tbl)
 
# and the results
NOTE: Cloud Analytic Services made the file WARRANTY_CLAIMS_0117.sashdat available as table WARRANTY_CLAIMS in caslib CASUSER(Peter).
swat.cas.table.CASTable

The results show that the WARRANTY_CLAIMS_0117.sashdat is available in the CAS server, and tbl is a CASTable object.

Lastly, I’ll preview the distributed CAS table using the SWAT package head method.

tbl.head()

The results show a preview of the WARRANTY_CLAIMS CAS table. The table provides data on warranty claims for car repairs. The data in this example is small for training purposes. Processing data in the CAS server’s massively parallel processing environment is typically reserved for larger data.

Using the Pandas API in the SWAT package – value_counts method

I’ll begin by using the Pandas API in the SWAT package which provides the value_counts method. The value_counts method works like it’s Pandas counterpart. For example, I’ll obtain the count of unique values in the Engine_Model CAS table column. I’ll store the results of in vc, then display the type and value of vc.

vc = (tbl               ## CAS table
      .Engine_Model     ## CAS table column
      .value_counts()   ## SWAT value_counts method
     )
 
## Display the type and value
display(type(vc),vc)

The SWAT value_counts method summarizes the data in the distributed CAS server and returns a Pandas Series to the Python client. Once you have the Pandas Series on the client, you can work with it as you normally would. For example, I’ll plot the Series using the Pandas plot method.

vc.plot(kind = 'bar', figsize=(8,6));

In this example, I used the Pandas API in the SWAT package to summarize data on the CAS server’s massively parallel processing environment to return smaller, summarized results to the Python client. Once the summarized results are on the client, I’ll work with them using other Python packages like Pandas.

Using the freq CAS action

Instead of using the Pandas API in the SWAT package you can achieve similar results using native CAS actions. In SWAT, CAS actions are simply specified as a method. One action that provides the count of unique values is the simple.freq CAS action.

For example, I can find the count of unique values for multiple columns within the freq action. Here, I’ll specify the Engine_Model, Model_Year and Campaign_Type columns in the the inputs parameter. Then, I’ll call the Frequency key after the action to obtain the SASDataFrame stored in the dictionary returned to the Python client. Remember, CAS actions always return a dictionary, or CASResults object, to the Python client. You must use familiar dictionary manipulation techniques to work with the results of an action. For more information on working with results of CAS actions, check out Part 2 – Working with CAS Actions and CASResults Objects.

## Columns to analyze
colNames = ['Engine_Model', 'Model_Year', 'Campaign_Type']
 
## Execute the freq CAS action and store the SASDataFrame
freq_df = tbl.freq(inputs = colNames)['Frequency']
 
## Display the type and DataFrame
display(type(freq_df), freq_df)

Again, the action processes the data in the distributed CAS server and returns results to the Python client. The results show the freq action counts the unique values of each column and stores the results in a single SASDataFrame. Once you have the SASDataFrame on the client, you can work with it like you would a Pandas DataFrame.

For example, I’ll loop over each analysis column, query the SASDataFrame for the specific column name, and then plot the count of unique values of each column using the familiar Pandas package.

for column in colNames:
    (freq_df
     .query('Column == @column')
     .loc[:,['CharVar','Frequency']]
     .set_index('CharVar')
     .sort_values(by = 'Frequency', ascending=False)
     .plot(kind='bar', figsize=(8,6), title = f'The {column} Column')
    )

The loop produces a visualization of the count of unique values for each analysis column. This was all done using familiar Pandas code on the client side. Remember, the distributed CAS server did all of the processing and summarization, then returned smaller summarized results to the Python client.

Using the freqTab CAS action

Lastly, you can use the freqTab.freqTab CAS action to construct frequency and crosstabulation tables. The freqTab action provides a variety of additional features and information. The action is not loaded by default, so I’ll begin by loading the action set.

conn.loadActionSet('freqTab')

Then I’ll use the freqTab action in the freqTab action set to count the unique values for the Model_Year and Engine_Model columns, and also count the unique values of Engine_Model by Model_Year.

tbl.freqTab(tabulate = [
                'Model_Year',
                'Engine_Model',
                {'vars':['Engine_Model','Model_Year']}
            ]
    )

The results above show the freqTab action returns a dictionary with a variety of information. The first SASDataFrame is level information, the second SASDataFrame shows the number of observations used, and the remaining SASDataFrames show the two one-way frequency tables for Model_Year, and Engine_Model, and the crosstabulation between Engine_Model by Model_Year (also includes the totals).

With the results on the Python client, you can begin accessing and manipulating the SASDataFrames as needed.

Summary

The SWAT package blends the world of Pandas and CAS. You can use many of the familiar Pandas methods within the SWAT package like value_counts, or the flexible, highly optimized CAS actions like simple.freq and freqTab.freqTab to obtain counts of unique values in the massively parallel processing CAS engine. For more examples on the freq or freqTab CAS actions, check out my CAS action four part series (part 1, part 2, part 3 and part 4). The four part series executes CAS actions using the native CAS language. However, with some small changes to the syntax you can execute the same actions using Python.

Additional and related resources

• Getting Started with Python Integration to SAS® Viya® – Index
• SWAT API Reference
• simple.freq CAS action
• freqTab.freqTab CAS action
• SAS® Cloud Analytic Services: Fundamentals
• CAS Action Documentation
• CAS Action! – a series on fundamentals
• SAS Course – SAS® Viya® and Python Integration Fundamentals 

Getting started with Python integration to SAS® Viya® – Part 12 – Count of Unique Values was published on SAS Users.

This post was kindly contributed by SAS Users - go there to comment and to read the full post.

The post Getting started with Python integration to SAS® Viya® – Part 12 – Count of Unique Values first appeared on PROC-X.com.

In this blog post, we tackle automating the SAS Intelligence Platform administrator’s task of replicating (cloning) metadata users’ groups and roles from one user to another.

As more people become new SAS users or move to new projects or teams, their data and applications access credentials need to be set up or modified in SAS Metadata. In this scenario, a typical request to SAS platform administrators looks like one of the following:

• Add Mr. A Smith as SAS user and make him a member of the groups and roles matching those of Ms. B. Brown.
• For an existing SAS user Mr. A. Smith, replace his memberships of the groups and roles to mimic those of Ms. B. Brown.
• For an existing SAS user Mr. A. Smith, add to his memberships of the groups and roles those that are missing from those of Ms. B. Brown.

SAS administrators routinely fulfill such requests by manually clicking through SAS Users plug-in in SAS Management Console. However, when a number of groups/roles to assign becomes rather large, this seemingly straightforward process can become overwhelming and error-prone.

Let’s change the conventional practice of manually replicating group memberships from one user to another. Let’s do it programmatically, which will make it easy, repeatable, fast, consistent, efficient and reliable.

Using SAS metadata functions to GET user-group associations

While you can employ macro %MDUEXTR to produce a list of groups for metadata users, here we are going to dive deeper and implement this task by using SAS data step metadata functions.

First, we connect to the SAS metadata server:

/* Connect to the SAS metadata server */
options
   metaserver = 'your_metadata_server'
   metaport = 8561
   metarepository = Foundation
   metauser = 'sasadm@saspw'
   metapass = '{SAS002}encrypted_password'
   ;
Then, let’s run the following code:
/* User Name (not Display Name) */ 
%let user_name = B Brown;
 
data USER_GROUPS;
   length UserName UserURI GroupURI GroupName GroupDisplayName $256;
   call missing(of _char_);
   UserName = "&user_name";
   UserURI = "omsobj:Person?@Name='&user_name'"; 
   do j=1 by 1 while(metadata_getnasn(UserURI, 'IdentityGroups', j, GroupURI)>0);
      rc = metadata_getattr(GroupURI, 'Name', GroupName); 
      rc = metadata_getattr(GroupURI, 'DisplayName', GroupDisplayName);
      output; 
   end;
run;

Code highlights

In this code, we loop through user’s groups while the following condition is true:

metadata_getnasn(UserURI, 'IdentityGroups', j, GroupURI) > 0

It is important to realize that function METADATA_GETNASN returns two values. Besides its return value (number of associated objects) referenced by the function itself, its 4-th argument (GroupURI) also returns a value of the j-th associated object of the specified association (‘IdentityGroups’) for the specified object (UserURI).  When j becomes greater than the number of groups associated with the user, this function returns value of -4 ( “j is out of range” ) which effectively stops further iterations of the do-loop.

Within the do-loop, we use function METADATA_GETATTR which returns the value (GroupName) of the specified attribute (‘Name’) for the specified object (GroupURI). Successful completion is indicated by its return value rc=0.

Similarly, the second call of the METADATA_GETATTR function returns GroupDisplayName.

Output

As a result, we are going to get the following USER_GROUPS table:

Using SAS metadata functions to SET user-group associations

Analogous to retrieving user groups associations using METADATA_GETNASN function, we can SET (or assign) such associations using METADATA_SETASSN function.  For example, the following statement will modify existing list of members for the group referenced by the first argument (pguri) by adding a new user referenced by the 4-th argument (curi):

rc = metadata_setassn(pguri, 'MemberIdentities', 'Merge',curi);

SAS macro to automatically clone group memberships from one user to another

Now, let’s cut all the exploratory code and wrap everything together into a little nice macro:

%macro mm_clone_user_groups 
   (
   child_name=,  /* Child's User Name (not a Display Name)                   */
   parent_name=, /* Parent's User Name (not a Display Name)                  */
   mod=ADD       /* Modifier (optional, values – ADD or Replace, default=ADD */
   );
 
data _null_;
   length curi cguri puri pguri $256;
   call missing(of _char_);
   curi = "omsobj:Person?@Name='&child_name'";  /* Child's URI  */
   puri = "omsobj:Person?@Name='&parent_name'"; /* Parent's URI */
 
   /* Conditionally remove existing Child's Groups */
   if upcase("&mod")="REPLACE" then
   /* Loop through Child's Groups */
   do i=1 by 1 while(metadata_getnasn(curi,'IdentityGroups',i,cguri)>0);
      /* Remove Child User from each Child's Group */ 
      rc = metadata_setassn(cguri,'MemberIdentities','Remove',curi);
   end;
 
   /* Loop through Parent's Groups */
   do j=1 by 1 while(metadata_getnasn(puri,'IdentityGroups',j,pguri)>0);
      /* Add Child User to each Parent's Group */ 
      rc = metadata_setassn(pguri,'MemberIdentities','Merge',curi);
   end;
run;
 
%mend mm_clone_user_groups;

Code highlights

The first do-loop executes conditionally only when Modifier is REPLACE (case-insensitive). It iterates through all the groups that child user belongs to and remove that child user from each such a group. Please note that removing a user from a group’s “Current Members” list is equivalent to removing this group from the user’s “Member of” list.

Similarly, adding a group to a user’s “Member of” list is equivalent to adding this user to the group’s “Current Members” list. We use this fact in the second do-loop when for each group associated with the parent we add the child as the group member.

Unless we need to report on the groups we are “cloning” from the parent, we may skip capturing their attributes (like Name or Display Name) using METADATA_GETATTR function as we did in the previous section.

Macro usage

Here are a couple examples of the macro invocation:

Example 1

%mm_clone_user_groups(child_name=A. Smith, parent_name=B Brown, mod=replace)

In this example, the macro will remove all the child’s group associations and replace them by those of the parent user.

Example 2

%mm_clone_user_groups(child_name=A. Smith, parent_name=B Brown)

Here, by default mod=ADD and the macro will augment the child’s group associations by those of the parent user.

Note, that these two examples cover all three scenarios of the group membership cloning outlined in the beginning of this post.

Acknowledgement

Great thanks to Carl Sommer of SAS Technical Support for his invaluable assistance and guidance in navigating through the SAS metadata functions and metadata object associations.

Questions? Thoughts? Comments?

Do you find this blog post useful? How do you administer user group identities/memberships in SAS metadata? Do you have questions, concerns, suggestions, or comments? Please share with us below in the Comments section.

Additional Resources

• Metadata management – Building Blocks
• SAS administrators tip: Keeping track of SAS users
• Duplicating or Copying SAS Users
• SASjs MacroCore Library: Metadata Aware Macros

Automatic cloning of SAS metadata user groups and roles was published on SAS Users.

This post was kindly contributed by SAS Users - go there to comment and to read the full post.

The post Automatic cloning of SAS metadata user groups and roles first appeared on PROC-X.com.

I asked Matthew Slaughter to briefly explain what SAS Viya is. Here is his answer:

There are many different products marketed under the label of “Viya,” and it’s not always clear how they relate to each other or how SAS Viya is different from previous versions of SAS. In a nutshell, SAS Viya is the version of SAS which runs on CAS. This begs the next question….

What is CAS?

CAS stands for “Cloud Analytic Services” and is the name of a massively parallel-processing platform for fast in-memory analytics on big data, with dynamic spillover to disk when data sets (also called data tables) get larger than available memory.

Traditional SAS reads data to and from disk row by row, which is potentially slow, but minimizes the amount of memory needed at any point in time which is why it scales well. (People comparing Viya to traditional SAS often refer to “SAS 9,” but SAS has always worked this way.)

Competing analytical tools are often designed to load entire data sets into memory all at once, which can be faster but will slow down and eventually fail as the size of a data set grows and exceeds the available memory.

CAS provides a “best of both worlds” approach, where large data sets can be loaded entirely into memory but will transition to disk-based processing automatically as needed.

The many faces of SAS Viya

The common element of all of the products included in Viya is that they all have the ability to use CAS as the underlying analytic engine. This includes point-and-click products such as SAS Visual Analytics and SAS Visual Statistics, but it also includes traditional SAS code running in CAS. In many cases the only change needed to make a SAS program take advantage of Viya is to point it at a CAS data set. Viya also includes R and Python packages which allow programmers to manipulate CAS data sets using those languages. Viya has its own environment for instructors and students called SAS Viya for Learners which is separate from SAS OnDemand for Academics which uses SAS 9.

This post was kindly contributed by Avocet Solutions - go there to comment and to read the full post.

The post What is SAS Viya? first appeared on PROC-X.com.

When you use PROC MEANS or PROC SUMMARY to create a summary data set and include a CLASS statement, SAS includes two variables, _FREQ_ and _TYPE_, in the output data set.

This blog shows you two ways to interpret and use _TYPE_ using the data set Shoes in the SASHELP library.

Here is a listing showing the first five observations in this data set:

Because there are many regions and products, we are going to include a filter (WHERE statement) to restrict the number of Regions and Products. The first program looks at the sum of Sales for each Region.

title "Using a Single CLASS Variable";
proc means data=Sashelp.Shoes noprint;
   where Region in ('Asia','United States') and
         Product in ('Boot','Sport Shoe','Sandle');
   class Region;
   var Sales;
   output out=Summary_Region n= sum= / autoname;
run;

The option NOPRINT suppresses the printed output (remember we are creating a summary data set).  The WHERE statement is selecting two Regions and three Products. The AUTONAME option in the OUTPUT statement automatically names the variables in the output data set. It uses the variable name(s) in the VAR statement, adds an underscore, followed by the name of the statistic. Here is the output:

The variable named Sales_Sum is the sum of the variable Sales and is given this name because of the AUTONAME option mentioned above. The first observation in the output data set shows the sum of sales for all Regions and the value of _TYPE_ is 0. The second and third observations are the sum of Sales for each Region and _TYPE_ has a value of 1. We will get into a detailed discussion of the _TYPE_ variable in the next example where we use two CLASS variables.

This next example uses two CLASS variables—Region and Product.

title "Using Two CLASS Variables";
proc means data=Sashelp.Shoes noprint;
   where Region in ('Asia','United States') and
         Product in ('Boot','Sport Shoe','Sandle');
   class Region Product;
   var Sales;
   output out=Summary_Region_Product n= sum= / autoname;
run;

The listing is shown below:

Notice that there are now four values for the variable _TYPE_. _Type_ 0 is the sum of Sales for all Regions and all Products; _TYPE_ 1 is the sum of sales for each Product; _TYPE_ 2 is the sum of sales for each Region; and finally, _TYPE_ 3 is the sum of sales for each Region and Product. There is a somewhat complicated way to know what each value of _TYPE_ describes. Rather than go through that explanation, we are going to add the option CHARTYPE to PROC MEANS, making the explanation much simpler. Now let’s run the program above, but add the PROC MEANS option CHARTYPE as shown below.

title "Using Two CLASS Variables";
title2 "Adding the Option CHARTYPE";
proc means data=Sashelp.Shoes noprint chartype;
   where Region in ('Asia','United States') and
         Product in ('Boot','Sport Shoe','Sandle');
   class Region Product;
   var Sales;
   output out=Summary_Region_Product n= sum= / autoname;
run;

Here is the output:

_TYPE_ is now a character variable with a string of 0s and 1s replacing the values of 0 to 3 with their binary values. To determine what each value of _TYPE_ describes, list the two CLASS variables and below them, the value of CHARTYPE, like this:

A 1 under the CLASS variable indicates that the statistic (sums and N in this example) is being computed for each value of that CLASS variable. Thus, _TYPE_ equal to 01 is the sum for each Product; _TYPE_ 10 is the sum for each Region; and _TYPE_ 11 is the sum for each combination of Region and Product.

If you want only the statistics for every combination of the CLASS variables, add the PROC MEAN option NWAY. Here is the result of adding the PROC MEANS option NWAY:

Because you usually want the statistics broken down by each of the CLASS variables, in most cases you will want to include the NWAY option. I like to remember to write NOPRINT and NWAY together so that I don’t forget.

In this last program, I’m going to show you how to use the _TYPE_ variable to create a separate data set for each value of _TYPE_. First, you need to run PROC MEANS without the NWAY option and include the CHARTYPE option. You follow this with a DATA step that create four data sets, each one corresponding to a different value of _TYPE_. Here is the program:

title "Using Two CLASS Variables";
proc means data=Sashelp.Shoes noprint chartype;
   where Region in ('Asia','United States') and
         Product in ('Boot','Sport Shoe','Sandle');
   class Region Product;
   var Sales;
   output out=Summary n= sum= / autoname;
run;
 
*Creating seperate data sets for each _TYPE_ value;
data Grand(keep=Sales_N Sales_Sum) 
     By_Region(keep=Sales_N Sales_Sum Region)
     By_Product(keep=Sales_N Sales_Sum Product)
     Cell_Sums(keep=Sales_N Sales_Sum Region Product);
   set Summary;
   if _TYPE_ = '00' then output Grand;
   else if _TYPE_ = '10' then output By_Region;
   else if _TYPE_ = '01' then output By_Product;
   else if _TYPE_ = '11' then output Cell_Sums;
run;

Use a KEEP= data set option to select which variables will be in each data set. For example, the value of Product will be a missing value for each observation in the By_Region data set. Also, the value of Region will be a missing value for each observation in the By_Product data set. The following figures show a listing of the four data sets:

Hopefully, this blog has given you the confidence to use and understand the _TYPE_ variable. If you want to learn more about programming in SAS, check out my book Learning SAS^® by Example: A Programmer’s Guide, Second Edition.

Understanding the _TYPE_ variable in output data sets was published on SAS Users.

This post was kindly contributed by SAS Users - go there to comment and to read the full post.

The post Understanding the _TYPE_ variable in output data sets first appeared on PROC-X.com.

Thank you to my co-author Raymond Thomas for his assistance on this post.

Learn more about the SAS Certified Specialist: Administration of SAS Viya and how to prepare.

Certification overview

SAS is pleased to announce a new SAS Viya Administration certification. Recognizing the growing need of cloud computing and Kubernetes, this new credential will help create a standard of knowledge within these areas.

Because of the growing skills required in cloud computing and Kubernetes, it’s critical that users can validate the skills they’ve learned and acquired to represent their knowledge. SAS developed the exam to cover the following major content areas:

• Manage a SAS Viya environment.
• Monitor, log and troubleshoot a SAS Viya environment.
• Manage identities and users.
• Manage content and functionality.
• Manage data in SAS Cloud Analytic Services (CAS).

View more details about the certification: SAS Viya Administration Specialist | SAS.

To see a full list of topics covered, select the “Exam Content Guide.”

Why it’s so important

This certification validates SAS Viya administration skills you have with employers. Proving your skillset through a certification shows your knowledge of managing and troubleshooting in SAS Viya, which greatly increases the opportunity for advancement in your career as a SAS administrator. Also, this certification is recognized worldwide by many leading industries, and obtaining this certification shows employers you are proactive and committed to your career.

Related job roles & industries

SAS Viya Administration applies to job roles across many industries such as Pharmaceutical, Banking, and Government. A few examples of job roles that may benefit from using the SAS Viya Administration include System Architects, Cloud System Administrators, Systems Analyst, System Administrator, System Engineer, and Linux or Windows Administrators.

The certification is intended for anyone with direct responsibility in administering SAS Viya or anyone administering a SAS 9 environment migrating to SAS Viya. SAS Viya administrators support users across many industries and this skill is highly prevalent.

How to prepare

While there are no prerequisites to take this exam, students often use a combination of training and experience to study for this exam. To prepare for the exam, these resources are available:

Courses

• SAS Training in the United States — SAS® Viya® Administration
• SAS Training in the United States — SAS® Viya® Operations

There are two free e-learning courses that are no prerequisites that may also be beneficial during your exam preparation:

• SAS Training in the United States — SAS® Viya® Administration: Getting Started
• SAS Training in the United States — Getting Started with SAS® and Kubernetes
• SAS Training in the United States — SAS® Viya® Administration Fast Track

Practice exam

• Exam Prep | SAS

Sample questions

• SAS Viya Admin – Sample Questions

Registration details

Follow this link to create an account or access your existing account to register: Certification Manager.

For detailed exam topics, hit the “Exam Content Guide” links on each credential’s web page. The content guides contain exam sections, objectives, and expanded detail about the important topics.

The Specialist exam is A00-451. There are no pre-requisites for this exam, so anyone who is interested in this credential can register.

Summary

You can learn more about these new credentials at the links above. There you will find detailed exam content guides, free sample questions, and free practice exams (yes – free full length practice exams!).

We hope you tackle the recommended training, develop your skills, and register soon to be the first candidates to earn these credentials. Good luck with your preparations!

If you have additional questions, please ask in the comments below.

New certification alert: SAS® Certified Specialist: Administration of SAS® Viya® was published on SAS Users.

This post was kindly contributed by SAS Users - go there to comment and to read the full post.

The post New certification alert: SAS® Certified Specialist: Administration of SAS® Viya® first appeared on PROC-X.com.

Data scientists are in short supply. McKinsey found the U.S. labor market alone is short 190,000 data scientists, and demand is growing. According to the World Data Science Initiative, “the data science market size is expected to grow from USD 95.3.9 billion in 2021 to USD 322.9 billion by 2026.” To help equip more data scientists to be ready for the world ahead, SAS created SAS Explore.

Created by technologists for technologists, SAS Explore has more than 100 free SAS training sessions. Data scientists, programmers, and analytics enthusiasts tuned in globally for our inaugural event.

Thanks to the high interest, these SAS training courses available to the public at no cost. Now, data scientists (and aspiring data scientists) can learn for free on demand.

With so many sessions to choose from, it’s hard to choose only a few to highlight. In this article, you’ll find the top five technical sessions, according to audience rankings. Keep reading to get a peek at what you can learn with SAS Explore!

#1: Creating Reports Again and Again… and Again with Macro

You know you can create a flexible report with SAS using macro variables, but what about when it comes to multiple reports? What about sending the report to Microsoft Excel? This presentation focuses on using %if/%then logic and %do loops to enable you to create multiple excel reports. The macro definitions that create the reports are flexible, customizable, and, best of all, able to run repeatedly without needing to manually change anything!

In this session, you’ll learn how to create reports with Macro, how to define the ‘underperform’ value, exporting to excel, adding parameters, excel ODS options, and more.

What attendees had to say about this session:

• “Everything was helpful. Thank you so much!”
• “Walking through all the code is something I value highly. There are many resources available online for SAS, but nothing beats someone explaining all the different code options.”
• “In this session, I learned about non-positional in macros. Didn’t know that you could set defaults like that. I will be using that in my coding. Also, more in depth usage of %if %then %else macros that weren’t in the Coursera SAS training.”
• “This is easily actionable content that will make a real difference to my coding efficiency.”

Watch the full training session for free now on YouTube:

#2: Using Python for Data Analytics in SAS® Viya®

Unite the Python language with the analytic power of SAS. In this presentation, you’ll learn how to use the SWAT (SAS wrapper for analytics transfer) package to take advantage of the SAS Cloud Analytic Services (CAS) engine in SAS Viya for massively parallel processing (MPP).

This training begins with a quick overview of SAS Viya and the CAS engine and then discusses how to leverage the strengths of the CAS engine and your local Python client, how to connect Python to CAS, and how to access and load data into CAS’s MPP environment.

Then, you’ll dive into exploring, preparing, and analyzing data using the CAS server, taking advantage of the CAS server’s distributed processing power using familiar pandas API and CAS actions from the SWAT package. Lastly, you’ll learn how to unite traditional python packages such as Pandas and matplotlib with the summarized results from the CAS server for additional processing and visualization.

What attendees had to say about this session:

• “Lots of valuable information on using python in SAS!”
• “The jupyter notebook format really made it easy to follow the presentation.”
• “Overall, this session was outstanding.”

Watch the full training session for free now on YouTube:

#3: Software Workshop: End-to-End Machine Learning in Model Studio

Effective predictive modeling projects follow the SAS analytics life cycle, from data to discovery and then deployment. SAS Viya provides the capability to perform all these steps from one graphical user interface, making the transition between stages of the analytics life cycle seamless.

In this training, you’ll load data into memory, prepare input variables for modeling, and build complex analytics pipelines to demonstrate powerful machine learning models. Need to better understand your model? No problem. We’ll show you how to produce model interpretability plots. Need to integrate open-source models? No problem. We’ll show you how to do that and deploy any model with one click. Then the best-performing model is saved and packaged for deployment, and you can still retrain this model on new data – all from the same shared interface.

What attendees had to say about this session:

• “The best session of all. Well explained!”
• “Having a virtual lab where I can follow the training step-by-step gave me a fantastic experience. The instructor is amazing. Thank you all!”
• “I learned about options that I did not know existed.”
• “Being walked through the entire process from end to end was amazing!”

Watch the full training session for free now on YouTube:

#4: Speaking to Microsoft Excel with PROC SQL in SAS® Viya®

Microsoft Excel, SQL and SAS are all equally loved for their unique strengths. Excel has been a go-to for a long time. Database workers live in SQL. SAS Viya is a cloud-enabled, in-memory analytics engine that provides quick, accurate, and reliable analytical insights. What would it be like to stay in the comfort of SAS while beckoning Excel in to join data using PROC SQL?

If you have wondered how this is possible, this is the session for you. Watch this incredible trio in action. You will learn to bring in data from Excel to SAS Viya using SAS engines, join multiple Excel spreadsheets, summarize data within SAS Viya using PROC SQL, and send the results to Excel. And you do all these things within SAS. Charu will show you a great way to build a bridge between SAS coders and colleagues who never code. All levels welcome!

What attendees are saying:

• “The whole session is useful!”
• “Charu, thank you! Your teaching skills are excellent. The presentation was exceptionally clear. You add detail just where it is needed. Very easily understood. The steps in code were very logical. I think this presentation is the best I viewed in SAS Explore!”
• “I loved the combination of the presenter’s communication skills and the step-by-step examples! Great job!!!!!!!!!!!!!!!!!!!!!!!!”

Watch the full training session for free now on YouTube:

#5: Struggling with Syntax? SAS® Studio to the Rescue!

One of the more frustrating elements of learning to code in SAS is mastering the syntax. In this hands-on SAS training, you’ll learn how to use SAS Studio tasks in SAS OnDemand for Academics to automatically generate code for a range of statistical analyses such as t-tests, analysis of variance, linear regression, and logistic regression. For even more flexibility in our modeling, you’ll also learn also the autocomplete and dynamic syntax tooltips in the programming editor of SAS Studio – which aids in the construction of more dynamic statistical models.

Both sets of SAS Studio tools will help you obtain results from statistical analyses faster – so that you can focus more on the results… rather than the syntax errors. For our academic partners, this means more time covering course content – which makes you, and your students, more productive.

What attendees are saying:

• “This was a great session. Simple data but the analysis was laid out in a logical way and then shown how easy it was to code using pre-built tasks. The instructor was also very knowledgeable.”
• “Concise and interesting demonstration. I liked that she used the same data set in all analyses.”
• “I have never used the left menu before. Helpful to know a different way to do things.”

Watch the full training session for free now on YouTube:

Keep exploring free SAS training

If you loved these free SAS trainings, you’ll love the rest too. Explore 50+ free virtual sessions on our YouTube channel now.

You’ll find topics like: SAS Viya in Microsoft Azure, Connected Supply Chain Planning, Building Analytical Applications, Demystifying SAS Certification, Automated Large-Scale Forecasting, Preventing Bias in AI, and so much more.

All the sessions are full of tips and tricks to help you do more with SAS. Now that you’ve gotten a peek into the goodness that awaits, it’s time to dive into SAS Explore 2022 on demand!

SAS training: 5 free sessions technologists love was published on SAS Users.

This post was kindly contributed by SAS Users - go there to comment and to read the full post.

The post SAS training: 5 free sessions technologists love first appeared on PROC-X.com.

The addition of the PYTHON procedure and Python editor in SAS Viya enables users to execute Python code in SAS Studio. This new capability in SAS Viya adds another tool to SAS’s existing collection. With this addition I thought, how can I utilize this new found power?

In this example, I’ll keep it simple. I want to create a Microsoft Excel report using a combination of SAS, Python and SQL. I’ll use data that’s stored in a SAS library; however, the library could be using data stored anywhere, like a path, database or in the cloud. I’ll write a program that executes the following:

• the SAS ODS EXCEL statement to create and Excel workbook
• the PRINT procedure and to print the detailed data
• the PYTHON procedure to create violin plots using the matplotlib package
• the SQL procedure for a simple aggregation
• the ODSTEXT procedure to write a text in Excel

All code used in this post is located on GitHub, here.

Set folder path and file name

To begin, I’ll create a macro variable to specify the output folder path and Microsoft Excel workbook name.

%let path=/*Enter your output folder path*/;
%let xlFileName = myExcelReport.xlsx;

Prepare data

Further, I’ll prepare the data using the SAS DATA step. I’ll use the available sashelp.cars table, create a new column named MPG_Avg, and drop unnecessary columns. Instead of using the DATA step you can use Python or SQL to prepare the data. Whatever tool works best for you.

data work.cars;
    set sashelp.cars;
    MPG_Avg=mean(MPG_City, MPG_Highway);
    drop Wheelbase Weight Length;
run;

Create the Microsoft Excel workbook

After the data is ready, I’ll use the ODS EXCEL statement to create the Excel spreadsheet. The following ODS options are used:

• FILE – specifies the file path and name.
• STYLE – modifies the appearance of the SAS output
• EMBEDDED_TITLES – specifies titles should appear in the worksheet
• SHEET_INTERVAL – enables manual control when to create a new worksheet

ods excel file="&path./&xlFileName" 
		  style=ExcelMidnight   
		  options(embedded_titles="on");

Worksheet 1

Print the data using SAS

With the ODS EXCEL destination open I’ll name the first worksheet Data, and manually specify when a new sheet is created. Next, I’ll use the PRINT procedure to print the detailed data to Excel. The PRINT procedure will print the entire SAS data set with the associated formats and styles to Excel.

* Sheet 1 - Print the data using SAS *;
ods excel options(sheet_name='Data' sheet_interval='none');
title height=16pt color=white "Detailed Car Data";
proc print data=work.cars noobs;
run;

Worksheet 2

Create violin plots using Python

Next, I want to create violin plots on a new worksheet named Origin_MPG. Now, these can be created in SAS, but I personally found the matplotlib package in Python a bit easier to use . With the PYTHON procedure, I can include the Python code within the SAS program (or you can reference a .py file) to create the visualization. Then I’ll use the SAS.pyplot method to save and render the visualization. Since the pyplot callback renders the image in the results tab, it exports the image to the Excel workbook by default.

First I’ll use ODS EXCEL to create the new worksheet and the TITLE statement to add a title to the Excel worksheet.

ods excel options(sheet_name='Origin_MPG' sheet_interval='now');
title justify=left height=16pt color=white "Analyzing MPG by Each Car Origin";

Then I’ll execute the PYTHON procedure to execute my Python code to create the violin plot.

* Create violin plots using Python *;
proc python;
submit;
 
##
## Import packages and options
##
 
import pandas as pd
import matplotlib.pyplot as plt
plt.style.use('fivethirtyeight')
outpath = SAS.symget('path')
 
##
## Data prep for the visualization
##
 
## Load the SAS table as a DataFrame
df = (SAS
      .sd2df('work.cars')                 ## SAS callback method to load the SAS data set as a DataFrame
      .loc[:,['Origin','MPG_Avg']]        ## Keep the necessary columns
)
 
 
## Create a series of MPG_Avg for each distinct origin for the violin plots
listOfUniqueOrigins = df.Origin.unique().tolist()
 
mpg_by_origin = {}
for origin in listOfUniqueOrigins:
    mpg_by_origin[origin] = df.query(f'Origin == @origin ').MPG_Avg
 
 
##
## Create the violin plots
##
 
## Violin plot
fig, ax = plt.subplots(figsize = (8,6))
ax.violinplot(mpg_by_origin.values(), showmedians=True)
 
## Plot appearance
ax.set_title('Miles per Gallon (MPG) by Origin')
rename_x_axis = {'position': [1,2,3], 'labels':listOfUniqueOrigins}
ax.set_xticks(rename_x_axis['position'])
ax.set_xticklabels(rename_x_axis['labels']);
 
## Save and render the image file
SAS.pyplot(plt, filename='violinPlot',filepath=outpath)
 
endsubmit;
quit;
title;

SQL Aggregation

SQL is an extremely common and useful language for data analysts and scientists. I find using SQL for aggregation easy, so I will create a simple aggregation and add it below the visualization on the same worksheet in the the Excel report.

* SQL Aggregation *;
title justify=left "Average MPG by Car Makes";
proc sql;
select Origin, round(mean(MPG_Avg)) as AverageMPG
	from work.cars
	group by Origin
	order by AverageMPG desc;
quit;
title;

Add text

At the end of the same worksheet I’ll add some simple text using the ODSTEXT procedure to give some information about the data.

proc odstext;
   heading 'NOTES';
   p 'Using the SASHELP.CARS data. The following car Origins were analyzed:';
   list ;
      item 'Asia';
      item 'Europe';
      item 'USA';
   end;    
   p 'Created by Peter S';
quit;

Close the Excel workbook

Lastly, I’ll close the ODS EXCEL destination since I am done writing out to Excel.

ods excel close;

Results

That’s it! Now I’ll execute the entire program and view the Excel workbook.

Summary

With the capabilities of SAS and the new ability to execute Python code in SAS Studio, teams have a variety of tools in SAS Viya for their analytic needs.

Additional resources

PYTHON Procedure documentation
SAS opens its code editor interface to Python users
Using PROC PYTHON to augment your SAS programs
ODS Excel Statement

Creating a Microsoft Excel report using SAS, Python and SQL! was published on SAS Users.

This post was kindly contributed by SAS Users - go there to comment and to read the full post.

The post Creating a Microsoft Excel report using SAS, Python and SQL! first appeared on PROC-X.com.

How often have you wanted a secret decoder ring to view the resolved values of your macro variables or to isolate an error or warning that is occurring in your SAS macro code logic? Well, the MFILE option can be that decoder!

When you use the MFILE and MPRINT options and use a FILENAME statement with the MPRINT fileref, SAS routes the code that is generated and submitted by your macro to a text file the next time that you call your macro. You can then examine and run all or part of the code in the text file to help debug your program. This blog post provides three examples of how you can use these options to improve your use of macro code.

Example 1: Understanding the macro code

Here’s an example where I am using code that was written by another programmer. I want to understand what the macro variables inside the TEST macro resolve to and what SAS code the TEST macro creates:

 %macro test(value);
 
   ods rtf file="&value..rtf";
     proc print data=one(where=(state="&value"));
     run;
   ods rtf close;
 
   %mend;
 
data one;
     input state $ age;
   datalines;
   VA 21
   VA 23
   MD 23
   MD 12
   MA 12
   MA 34
   ;
 
   proc sort ;
     by state;
   run;
 
  data _null_;
     set one;
     by state;
     if first.state then
       call execute('%test('||state||')');
   run;

Here is how I call the TEST macro with the MFILE and MPRINT options in effect and a FILENAME statement that uses the MPRINT fileref:

   options mprint mfile;
   filename mprint "c:\temp\nomacro.sas";
 
  data _null_;
     set one;
     by state;
     if first.state then
       call execute('%test('||state||')');
   run;

This program results in the following code being sent to the nomacro.sas file:

ods rtf file="MA.rtf";
proc print data=one(where=(state="MA"));
run;
ods rtf close;
ods rtf file="MD.rtf";
proc print data=one(where=(state="MD"));
run;
ods rtf close;
ods rtf file="VA.rtf";
proc print data=one(where=(state="VA"));
run;
ods rtf close;

In the file, I see that all of the macro variables resolved to state abbreviations, and I can then choose to run all or part of the code as desired. That was easy!

Example 2: Understanding exactly where an issue occurs in macro code

In the following log file, I’m confused because the NOTE about an invalid argument to the INPUT function seems to occur on the line where I invoked my macro and I want more specific information:

Kevin Russell explains why the NOTE occurs in this location in his Surviving the SAS® Macro Jungle by Using Your Own Programming Toolkit paper:

The line number in the NOTE points to the line where the macro is invoked instead of pointing to the line that contains the INPUT function. The NOTE points to this line because it is the invocation of the macro that generates the INPUT function code that then generates the NOTE. Because there is currently no option other than having the NOTE point to the line where the macro is invoked, you can use the MFILE system option to debug.

I can use the MFILE option to discover where the problem with the INPUT function actually occurs:

filename mprint "c:\temp\nomacro_note.sas";
options mprint mfile;
%cars

The resulting submission of the code from the nomacro_note.sas file helps me find the problematic line, line 75. It is not hard to find the issue when you use the problematic function only one time; but in the real world, these functions are used OFTEN:

Example 3: Including dependent code for the macro

What if I have some precode that is outside of the macro, or another macro that I need to use as part of my debugging? In this case, I am not sure that I will need a PROC PRINT step to debug my CARS macro, but I would like to ensure that it is included in my decoded file (using MFILE). So, I can use the MFILE option to include that code in a file that I can parse out later. Here’s the code that I want to run:

%let name1=Asia;
%let i=1;
 
proc print data=sashelp.cars; 
 title "&&name&i";
run;
 
%macro cars;
data cars;
 set sashelp.cars;
 new=input(origin,1.);
run;
%mend;

I wrap the code in the OUTER macro and then use MFILE and MPRINT to “decode”:

%macro outer;
%let name1=Asia;
%let i=1;
 
proc print data=sashelp.cars; 
 title "&&name&i";
run;
 
%macro cars;
data cars;
set sashelp.cars;
new=input(origin,1.);
run;
%mend;
 
%cars
 
%mend outer;
 
filename mprint "c:\temp\outer.sas";
options mprint mfile;
%outer

Here is the outer.sas file for later decoding:

proc print data=sashelp.cars;
title "Asia";
run;
data cars;
set sashelp.cars;
new=input(origin,1.);
run;

Conclusion

Paired with the MPRINT option, the MFILE option is especially helpful if you are seeing errors, warning messages, or code behavior that you cannot explain or diagnose easily from reading your SAS log. MFILE gives you clean code that you can submit, without having to copy the MPRINT output from the log window to another file and remove the (MPRINT) headers. It is a code strategy that might also prove useful if you need to involve SAS Technical Support, because it’s especially helpful for you to provide SAS Technical Support with the smallest subset of your code that demonstrates the problem that you are encountering.

Although these options are useful, note these restrictions:

• If you generate code with MFILE, it does not contain any formatting such as code indention.
• If you generate code with MFILE, it does not contain PL1 style comments (/* comment here */).
• If the macro is a stored compiled macro that was compiled with the NOMPRINT option in effect, then the MFILE and MPRINT options do not generate a file.

Tell me how you have found this blog useful!

References:

SAS Help Center: MFILE Macro System Option

23138 – How can I remove macro code from my original program and create a file of the code that is generated by SAS so debugging the code is easier?

Surviving the SAS® Macro Jungle by Using Your Own Programming Toolkit

Decode your SAS® macro code with the MFILE and MPRINT options was published on SAS Users.

This post was kindly contributed by SAS Users - go there to comment and to read the full post.

The post Decode your SAS® macro code with the MFILE and MPRINT options first appeared on PROC-X.com.