The Free Trade Data

For simplicity of illustration and discussion, we will use a small example consisting of only ten variables. But the power of the principles and techniques you will see are equally relevant and even more valuable in situations where you have a large number of variables, especially if your focus is on prediction.

This example shows you how to conduct a deeper analysis of missing values. The data address the effect of democracy on the trade policy of nine developing countries (or polities) in Asia from 1980 to 1999.³ The table Freetrade.jmp, shown in Exhibit 11.2, includes ten variables: year (year), country (country), average tariff rates (tariff), Polity IV score4 (polity), total population (pop), gross domestic product per capita (gdp.pc), gross international reserves (intresmi), a dummy variable signifying whether the country had signed an IMF agreement in that year (signed), a measure of financial openness (fiveop), and a measure of U.S. hegemony (usheg).

Open the data table Freetrade.jmp. Select Tables > Missing Data Pattern, select all the columns, click Add Columns, and then click OK. This gives the new table Missing Data Pattern shown in Exhibit 11.3. (Running the saved script Missing Data Pattern in Freetrade.jmp generates the same table.)

The Missing Data Pattern data table contains three scripts. Selecting Run Script from the red triangle menu for either the Treemap or Cell Plot script gives a visual representation of the missing data.

Although very useful, Missing Data Pattern may not directly contain all the information you need. For example, suppose that you want to see the number of rows where a given number of columns are missing. Using the Missing Data Pattern table, you need to select Tables > Summary, select Count and then select Statistics > Sum, assign Number of Columns Missing to the Group role, and click OK. Similarly, if you want to rank the columns in order of missingness, you need to use the Cols > Column Viewer menu option with the table Freetrade.jmp active, then make an auxiliary table and sort it appropriately.

To further investigate the pattern of missing data, we will use two complementary techniques to see how the columns group together: Principal Components Analysis (PCA) and Clustering. The first technique can be conducted directly from the Missing Data Pattern table, but the second requires some additional manipulations.

Principal Components Analysis

PCA exploits correlations among variables to produce a data description that is more concise, in the sense that it requires fewer dimensions. In so doing, it can also show which, if any, variables group together to achieve this reduction.⁴ Your hope is that PCA will help you better understand how your missing values are structured.

Because you are interested in how missing values occur across your variables, rows with no missing values contain no useful information. So you begin by excluding the row in the Missing Data Pattern table that represents no missing values. Then you conduct a principal components analysis on the Missing Data Pattern table. (There is a copy of the Missing Data Pattern table, with scripts that reproduce the work in this section, in the journal file. But this table is not linked to Freetrade.jmp.)

Ensure that Missing Data Pattern is your active data table, select the first row, and select Rows > Hide and Exclude. Because the Missing Data Pattern table that you created and the Freetrade.jmp tables are linked, this also hides and excludes the corresponding rows in Freetrade.jmp. (Keep in mind that the Missing Data Pattern table from the journal is not linked to Freetrade.jmp.)

Now select Analyze > Multivariate Methods > Principal Components. Note that Count was automatically assigned to the Freq (Frequency) role in the Missing Data Pattern table. (A column can be assigned the Freq role by right-clicking it in the Columns panel and selecting Preselect Role > Freq.) Enter your original variables, year through usheg, as Y, Columns (see Exhibit 11.4).

Click OK. Click Continue when a JMP Alert warns you that columns are not Continuous. Click OK when a JMP Alert warns you that five columns are being dropped because they are constant. The report appears as shown in Exhibit 11.5.

Keep in mind that, in this analysis, we are not analyzing the data themselves, but the nominal columns that indicate whether a cell is missing. These are the nominal columns marked by the red icons in the Columns panel of Missing Data Pattern.

The plot on the right in Exhibit 11.5 is called a loadings plot. It represents how the indicator variables appear in the reduced two-dimensional space. Note that the plot shows only five points, since five other variables are omitted because they are constant.

The Pareto plot on the left of this figure indicates the amount of variation explained by each eigenvalue. The first two eigenvalues, which define the first two dimensions or principal components, account for about 71 percent of the variability between the indicator variables. The rest of the variability is spread among the higher components. For other data, though, the two first components may not capture enough variability, in which case the alignment and lengths of the arrows in the loadings plot would not be so helpful in seeing which columns group together.

For these data the loadings plot shows, with some credibility, that intresmi, a measure of gross international reserves, groups with fiveop, a measure of financial openness in terms of missing values. As an exercise, see if you can verify that fiveop is missing for the years 1998 and 1999 and that intresmi is missing for all nine countries in 1999, but only missing for four countries in 1998. (In Freetrade.jmp, select the columns intresmi and fiveop. Use the column modeling utility Cols > Modeling Utilities > Explore Missing Values to select the rows where intresmi and fiveop are missing. Then use Tables > Subset.) Given that 1998 and 1999 were the final years for this study, is it possible that the two measures in question either were not available yet, or were just beginning to be available?

Cluster Analysis

As mentioned previously, clustering of variables⁵ is a complementary technique to PCA for grouping variables together. However, it requires some additional manipulations because the entities to be clustered have to appear as rows in a data table. Your Missing Data Pattern table contains an indicator column for each variable that you could transpose. But you also need the information in the Count column. This information would be lost if you simply transposed the columns in the Missing Data Pattern table.

So you need to return to the table Freetrade.jmp to make some progress. Close Missing Data Pattern without saving it.

As you did for the PCA, you will drop all rows that have no missing values. If you have followed the steps above (with your own Missing Data Pattern table), then you find that 96 rows in Freetrade.jmp are hidden and excluded, but also selected. If these rows are not excluded, run the script Hide, Exclude, and Select Complete Rows in the Freetrade.jmp data table that you can open from the journal. Use Rows > Row Selection > Invert Row Selection to select all rows that contain one or more missing values. Then select Tables > Subset and click OK to construct a new table called Subset of Freetrade that has 75 rows.

You now have to create the ten indicator columns that were generated automatically for you in Missing Data Pattern. Although you can do this by defining formula columns like the one shown in Figure 11.6, this becomes very tedious when there are many columns. It is more efficient to use a little JSL instead.

Note that the formula uses the Is Missing() function combined with a conditional If statement to indicate missing values of fiveop with a 1 and nonmissing values with a 0. Your script will use this structure.

Select File > New > Script to open a script editor window, and then type in the lines shown in Exhibit 11.7. (This script is Make Indicator Columns.jsl, found in the journal.)

Select Edit > Run Script to produce a new table with the same number of rows and columns as the original, but containing the appropriate pattern of zeroes and ones. The code works as follows:

• Line 1 saves a reference to the currently active data table (Subset of Freetrade) as dt.
• Line 2 tells JMP to place all columns in dt into the matrix m.
• Line 3 replaces entries in m that are not missing by 0.
• Line 4 replaces entries in m that are missing by 1.
• Line 5 constructs a new data table from the matrix m.

The Is Missing() function returns the value 1 if a value is missing and value 0 otherwise. The exclamation point in Line 3 (!Is Missing()) indicates that a value is not missing. The Loc() function finds all positions in a matrix where a logical condition is satisfied. You can run the lines one by one (select each in the editor window, then Edit > Run Script) and view their effect in the log window.

The new table will be called Untitled X where the value of X is determined by what else you have done in your current JMP session. Note also that, although the columns are in one-to-one correspondence with those in Freetrade.jmp and Subset of Freetrade, the new column names are generic (Col1, Col2, and so on). You can retain the original column names by using the slightly more complicated script shown in Exhibit 11.8 and listed as Make Indicator Columns 2.jsl in the journal. Lines 2 and 7 give the new table a better name, and line 6 (corresponding to line 5 in Make Indicator Columns.jsl) is modified to ensure that the column names are those in the original table.

Close Untitled X without saving it. Run the new script using Edit > Run Script to produce the table Subset of Freetrade Missing Cells shown in Exhibit 11.9. (You can also open this data table by clicking on the link for Subset of Freetrade Missing Cells.jmp in the journal file.)

Now you need to rearrange the data so that each variable occupies a row. Select Tables > Transpose. Add all columns to the Transpose Columns list. Enter For Clustering as the Output table name and Variable as the Label column name. (See Exhibit 11.10.) Click OK to produce the table For Clustering. This table should have 10 rows and 76 columns.

Now your data are in the appropriate form for the cluster analysis. Select Analyze > Multivariate Methods > Cluster. Add Row 1 through Row 75 as Y, Columns. To select all 75 rows easily, click Row 1, scroll to Row 75, then press the Shift key, and click Row 75. In the Method panel, select Fast Ward. (See Exhibit 11.11.) Click OK. (We use the Fast Ward method for efficiency in clustering other data with a large number of rows.)

In the report that appears, the rows in For Clustering (columns in Subset of Freetrade) have been grouped together as shown in the tree-like plot, called a dendrogram. Select Color Clusters and then Mark Clusters from the red triangle menu.

Note that the dendrogram is interactive, and that you can drag the diamond-shaped hotspot to change the number of clusters that you want to consider. In Exhibit 11.12 we have chosen three clusters. The variables year, country, pop, gdp.pc, usheg, polity, and signed form one cluster. These are the variables that are either never or rarely missing. The variables intresmi and fiveop form a second cluster, and tariff forms a singleton cluster.

Remember that the three clusters relate to missing values for these variables, and not to their actual values. In other words, the clusters group variables that are similar in terms of which values could not be obtained, for some reason. Recall that the PCA analysis also indicated that intresmi and fiveop had some commonality in terms of missing values.

This analysis of missing values beyond that provided by Tables > Missing Data Pattern can provide additional insight. As we mentioned earlier, it is likely to be more useful when your data contain many more columns than Freetrade.jmp. If you analyze large observational data sets frequently, you might like to automate the manual process you just performed. Fortunately, it is relatively easy to automate all of the preceding steps using JSL, particularly since, as we mentioned earlier, JMP itself will generate most of the JSL code required. In a sense, you simply string the code together to form an application.

The Missing Data Add-In

When developing applications, an important question to consider is how they can be deployed and updated in a simple and foolproof way. As well as making the application development easy, JMP also eases deployment issues through an “add-in” architecture. An application can be packaged up into a single .jmpadin file that can be given to each user who needs it; the user can install it with a single click.⁶

The file Missing Data.jmpaddin is a JMP add-in that contains the application that automates the above steps. Click on Missing Data.jmpaddin in the journal file. A JMP Alert asks if you would like to install the add-in. Click Install. This creates a new Add-Ins menu in the JMP toolbar and installs a Missing Data submenu in that menu. If you already have an Add-Ins menu, the new item will just be appended.

Making sure that Freetrade.jmp is the active data table, and that no rows are excluded, select Add-Ins > Missing Data > Missing Analysis to produce Exhibit 11.13. The report created by the add-in combines the results in Exhibit 11.5 and 11.12 into a single report, and also includes Pareto charts for missingness by row and by column. In the report generated by the add-in, note that menus are active and plots are interactive.

The Missing Data add-in contains other options:

• Missing Data > Demo Data generates another copy of Freetrade.jmp.
• Missing Data > Missing Map shows the arrangement of missing values in the table in the form of a cell plot.
• Missing Data > Impute Using Amelia provides an advanced way to impute data values using the R package Amelia,⁷ and requires R to be installed locally.⁸

As well as showing some further useful analysis of missingness, this analysis of Freetrade.jmp illustrates a number of points:

• A method for addressing a specific data issue interactively
• An insight into the utility of JSL to assist such one-time data tasks
• A view of the value of add-ins when you need to routinely supplement existing JMP functionality and make this available to others

JMP 12 Functionality for Missing Data

However, JMP itself now offers much of this functionality directly, greatly speeding up and simplifying the workflow for handling missing data.

Make Freetrade.jmp your active table and select all the Continuous columns in the data table. Then select Cols > Modeling Utilities > Explore Missing Values. This generates the report shown in Exhibit 11.14.

The view in Exhibit 11.14 is for the Missing Value Report option. There are four other options:

• Missing Value Clustering provides clustering similar to that described above, but directly.
• Missing Value Snapshot shows the cell plot given by the Missing Map option provided by the add-in.
• Multivariate Normal Imputation imputes missing values of continuous values under the assumption of multivariate normality, but also allows you to shrink the estimated covariance matrix, which can provide more reliable values. Note that this option updates the source data table, highlighting cells containing imputed values in light blue. This option should provide somewhat similar imputed estimates to the add-in that uses the Amelia package, but does not require a local R installation.
• Multivariate SVD Imputation provides an efficient computational approach for imputation for data tables with a large number (hundreds or thousands) of variables.

Note that JMP and JMP Pro also provide other ways to handle missing data, depending on the objectives of the subsequent analysis:

• Analyze > Multivariate Methods > Multivariate allows you to impute missing values from a set of continuous variables. Like Multivariate Normal Imputation, it assumes that the variables follow a multivariate normal distribution. Use Impute Missing Data or Save Imputed Formula from the Multivariate red triangle. Note that this option does not provide shrinkage estimates.
• For predictive modeling, Analyze > Fit Model, Analyze > Modeling > Partition, and Analyze > Modeling > Neural all provide an informative missing approach. For a continuous column, this option replaces missing values with the mean of the nonmissing values and adds an indicator column for the missing values. Both columns are included in the modeling process. By using the informative missing option, you avoid the problem of decimating your data through deletion of rows with one or more missing values. This process usually produces models with better predictive ability.

Finally, note that JMP also provides utilities to explore outliers. Select the columns of interest in the data table and then select Cols > Modeling Utilities > Explore Outliers. Exploring outliers is often of great value in the early phases of handing real-world data.

The Structure of the Add-In

As you have seen, the Missing Data.jmpaddin creates an Add-In submenu, Missing Data, that has the four suboptions shown in Exhibit 11.15. Each option invokes the code in the single JSL file whose name is shown in the table.

The script makeDemoData.jsl, found in the journal, only contains the commands required to make a new copy of the table Freetrade.jmp. This script was generated by using the Copy Table Script option from the red triangle of the table, pasting the results into an editor window, and saving the file with the required name.

Using the Missing Map option when Freetrade.jmp is active produces Exhibit 11.16.

The list shows all the columns in the data table with missing values, but ranked in descending order in terms of how many values in that column are missing. Selecting the first three columns in the list gives Exhibit 11.17, with the positions of missing cells shown in red. Moving the sliders allows you to change the size of the plotted cells.

The JSL Code for the Missing Data Add-In

The script Missing Data.jmpaddin contains all of the elements of an application (Parts A1, A2, and A3) listed earlier. The section of code that creates the window shown in Exhibit 11.16 is shown in Exhibit 11.18. You can see that the user interface is built up from a number of components or objects (display boxes) such as TextBox(), ButtonBox(), and SliderBox() with names describing what they do. As mentioned earlier, you can use the editor tooltips to learn more about these objects. Alternatively, you can use Help > Scripting Index to search for the object you require. The Scripting Index describes the object and provides one or more examples of how that object can be used. You can run these examples and experiment with them.

The display boxes in the script in Exhibit 11.18 are laid out according to the other display boxes that appear at higher levels in the code (PanelBox(), HListBox(), LineUpBox(), SpacerBox(), and VListBox()).

Each object understands a set of messages that influence its behavior. For example, the SetWrap() and FontColor() messages are sent to the first TextBox() using the JSL “≪” operator. Each object can optionally be given a name so that it can be referenced in other parts of your code (for example, clb = ColumnListBox()).

The user interface updates when you interact with the ListBox(), ButtonBox(), or SliderBox() objects. The action that occurs is determined by the JSL expression associated with the object. For example, the expression clbChangeScript is associated with clb. The code in clbChangeScript is shown in Exhibit 11.19.

Note the following:

• To define a JSL expression, you use the syntax variable = Expr(expression) where the required statements are inside Expr(). This postpones the evaluation of these statements until the action is needed. In this case, the action is postponed until the selection in clb is changed by the user.
• Line 72 puts the names of the selected items in clb into a list called sc (by sending the message GetSelected).
• Line 73 calculates ncs, the number of items in the list sc.
• Line 74 invokes the expression gbUpdateScript, which uses the information now in the list sc and the variable ncs. This expression adds or updates a GraphBox(). This is the cell plot that is seen in Exhibit 11.17.

Application Builder

Rather than write the code for the user interface, Part A1, by hand, an alternative approach, preferable for most people, is to use the Application Builder in JMP. As the name implies, the Application Builder is a design-time tool that allows you to build user interfaces simply by “drag and drop,” rather than by coding by hand. You can also add the required processing logic, Part A2, to each object in your application, producing modularized and maintainable code with minimal effort.

Select File > New > Application to open the Application Builder window. This window consists of three parts:

1. On the left is a list of all the objects that you can put into an application, arranged into major groupings by outline nodes (Reports, Data Table, Containers, and so on).
2. In the middle is the canvas, initially blank, on which you will design your application by dragging the required objects from the left.
3. On the right are the Objects and Properties outlines. The Objects panel gives an alternative, tree-based view of your application, and the Properties panel allows you to modify the properties of the object currently selected on the canvas. By unchecking the red triangle option Show Objects and Properties, you can make the canvas bigger if you need to.

The first display box needed is a PanelBox(), found in the Containers outline. Exhibit 11.20 shows the Application Builder after you have dragged this component onto the canvas and updated its properties. In this case, the only property is the text that is displayed as a title.

By dragging the required components into the template and modifying their properties appropriately, you can construct the canvas shown in Exhibit 11.21. You can compare the code in Exhibit 11.18 to Exhibit 11.16 to help figure out which components are needed from the palette and what their relationship should be. (Alternatively, simply open the file missingDataUI.jmpappsource.)

To view the final user interface, select Run Application from the red triangle menu in Application Builder. This produces the window shown in Exhibit 11.22. Compare this with Exhibit 11.16.

Application Builder is a capable and complete platform. If you need additional help to develop applications, we encourage you to look at the relevant documentation (Help > Books > Scripting Guide). Finally, we note in passing that the very useful Window > Combine Windows feature mentioned in Chapter 3 (for combining several report windows into one) actually builds an application, which you can further modify with Application Builder if you wish to.

Interoperability with R

Finally, we turn to the last menu item in the Missing Data add-in, Impute Using Amelia. If you open the associated code in multipleImputationWithAmelia.jsl and run it with Freetrade.jmp as the active table, you will see that a dialog appears that allows you to select columns and options. Having made some selections, when you click OK you see a message indicating that data is being submitted to R. If you do not have R installed, then you receive an error message to that effect. If you do have R installed, along with the Amelia package and all of its dependencies, then a copy of Freetrade.jmp appears with missing cells replaced by imputed values. These cells are colored orange to distinguish them from data that are real.

The code that produces the initial dialog appears in lines 23 to 78 of the script multipleImputationWithAmelia.jsl. You can verify this if you select all the lines from the first down to 78 in the editor window and then Edit > Run Script. Although this interface is more complex than the interface for the Missing Map, the principles are the same, and this code could be generated by Application Builder or written by hand.

The report produced by this script, Part A3, is also simple (just making a new table). So the essentially different feature is the processing logic, Part A2, and the fact that this is not done by JMP, but by another system (in this case R). Even though JMP is incredibly functional, there may be times when you need capabilities that it does not provide. Clearly, using this approach will involve some knowledge of the other system.

To see how JMP can interoperate with R, select Help > Scripting Index, select Functions from the dropdown list, and type “R” in the search box at the upper left (Exhibit 11.23). Select Exact Phrase from the tools menu, which you obtain by clicking the gear icon to the right of the search box. You will see that there are 13 related functions whose names begin with “R”. Essentially we need to be able to connect to an R session (R Init()), and disconnect from an R session (R Term()), to move data both ways across an active connection, to run R code, and to retrieve textual and graphical output from R. The R functions listed handle all these aspects. We will look at some code fragments from multipleImputationWithAmelia.jsl to get a feel for how they are used.

Exhibit 11.24 shows the definition of a JSL function (packageInstalled()), and how it is used in the later code. Similar to the add-in framework in JMP, R uses the concepts of packages that can be downloaded from repositories and installed locally. Amelia is one such package. Once we have an active R connection, we need to check that the required package is available. If it is available, we load it (line 162), and if it is not, we present a warning message and stop the execution of the script (line 161).

Lines 10 to 14 show the syntax for defining a function in JSL. The variable pName contains the name of the package we are looking for. Using R Submit(), line 11 runs the R code required to see which packages are available, and puts the results into plist. Line 12 then uses R Get() to move the contents of plist into a JSL variable, also a list, called pckgLst. Line 13 then evaluates to a Boolean value that is returned when packageInstalled() is evaluated (the value 1 if pckgLst contains pName and the value 0 if not). Line 162 loads the Amelia package once we are sure it is available.

Exhibit 11.25 shows how the imputation is performed. Line 163 sends the JMP data table referenced as dt2 to R: R Send() translates a JMP table to an R data frame with the same name. Line 165 builds the R code for using Amelia, and returns the results to the R structure imputation.results. Note that the Amelia package is very functional and provides a lot of control over how the imputation is carried out. Only the simplest options are surfaced in the initial JMP dialog, and this is reflected in the code in line 165. Line 167 then uses RGet() to retrieve the results into a JSL variable, dt2List. This is actually a list of data tables (each containing imputed values). The variable n comes from the initial dialog and is the number of imputations we asked for. If the dialog option Keep Each Imputation is left at the default value of No, dt2List will contain a single table with imputed values equal to the average of the n that were performed. Otherwise, it contains n tables with no averaging of the imputed values.

To understand all the details of how the code works, see the comments in the code itself.

The mechanics of packaging code and other resources into an add-in are straightforward (see Help > Books > Scripting Guide). If you are working entirely with the Application Builder, you can simply select Save > Save Script to Add-in from the red triangle menu.

Note that JMP provides the same style of interoperation with MATLAB as it does with R. So, if you have an investment in specialized code in this system, you can make its capabilities available to users who might be intimidated by, or unwilling to learn, that software. If you search for MATLAB in the JSL Scripting Index, you will see JSL functions analogous to those used in the Missing Data application. You can compare the results of your search with Exhibit 11.23.

You should also be aware that JMP can act as a client to SAS, and can interoperate with SAS in many different ways. The built-in client functionality allows point-and-click access to many SAS resources such as stored processes, and as a SAS product it has a depth of integration that is deeper than with other software. If you search for SAS in the JSL Scripting Index, you will find 40 associated JSL functions, which indicates a world of many possibilities.