Zementis Predictive Analytics

I got an error uploading a Neural Network model in ADAPA generated in Clementine. Can you help?

2009-07-02T12:50:00.000-07:00

SPSS PASW tools export all kinds of models in PMML. These are usually perfect and ready for being deployed in ADAPA.

We have noticed however that the latest version of Clementine (PASW Modeler) exports Neural Network models in PMML with a small inconsistency which may cause ADAPA to generate an error during model uploading.

If you have defined any of your continuous input variables as integer, Clementine will define them correctly in the DataDictionary in the PMML file as integer. See below:

However, in the MiningSchema, Clementine assigns such variables real numbers. See below:

Note that in this case missing value replacement for variable "Age" is 44.5, not an integer.

In such cases, ADAPA will throw an error since a real number is being assigned to a variable of type integer.

To avoid this problem, the solution is to define any integer continuous variables in the DataDictionary as double. See new DataDictionary below:

We plan to add this correction to the PMML converter tool so that it will automatically do the replacement. Note that in this case, the converter is acting as a corrector since you will be passing a PMML file in version 3.2 through it and getting a corrected version 3.2 file back.

Examining PMML 4.0 - Part I: Pre-Processing

2009-06-22T16:21:00.000-07:00

You may be wondering what is all the fuss around PMML and its latest 4.0 version. So, we decided to explore all that PMML 4.0 has to offer in a series of blogs. In part I, we will be exploring its improved pre-processing capabilities.

All data mining models manipulate the raw data in a way or another before passing it through a a neural network, support vector machine, or regression model. Therefore, a language that wants to represent all the computations that go into a model needs also to be able to represent the data transformations that were applied to the raw data before scoring takes place. PMML is this language! It is the Yin and Yang of data mining.

Let's first re-cap on the pre-processing capabilities available in PMML 3.2. This version of PMML allows for the following out of the box data transformations:

Normalization of continuous variables: this is accomplished via the NormContinuous element of PMML. It is mostly used to normalized a variable between 0 and 1. See example below (real PMML code) in which two variables are normalized. The first between 0 and 1 and the second between 0 and 4.

Normalizing Categorical Inputs: normally used to transform strings into numerical variables. This is accomplished by the element NormDiscrete. In the PMML example below, a categorical variable creates dummy variables that will be assigned values 1 or 0 depending on the category assumed by the input variable.

Discretization: this is used to transform continuous variables into strings. This is accomplished by the Discretize element. In the PMML example below, if the input variable is equal to 500, it is transformed to low; if equal to 5000, it is transformed to medium; and if 50,000, it is high.

Value Mapping: this is accomplished in PMML by the use of a mapping table and the element MapValues. To make things more interesting, in the PMML example below, we combine elements MapValues and NormDiscrete to group small sets of categorical values. In specific, we want to find out if the input variable belongs to a specific group of colors. We do that by using MapValues to map different colors to the same number. We then use the element NormDiscrete to create dummy variables which are used to indicate group membership.

Arithmetic Expressions: PMML offers a range of arithmetic functions (as well as string and date/time maniputation functions) that can be arranged in different ways to express complex arithmetic expressions. The example below solves the following operation:

ResultVar=maximum(round(InputVar1/3.3),2^(1+log(1.3*InputVar2+1)))

PMML 4.0 - Boolean Operations: Not only PMML 4.0 allows for Boolean operations to be fully expressed, but it also allows these to be nested into IF-THEN-ELSE logic. These new buit-in functions offer a vast new array of possibilites for representing data transformations in PMML. So, we devote the rest of this review by looking at transformations that can now be easily expressed in PMML 4.0.

We start with the PMML code below which implements the following logical and arithmetic operations:
IF InputVar1 == "Partner" THEN DerivedVar1 = "P" ELSE DerivedVar2 = 2 * InputVar2

Note that it uses the newly defined 4.0 functions: "if", "equal", and "not" as well as function "*".

The PMML code below assumes that both "then" and "else" parts of the "if" use the same derived variable to implement the following operations:
IF InputVar1 == "Partner" THEN DerivedVar1 = "5.1 * InputVar2" ELSE DerivedVar1 = "InputVar2 / 3.3"

Finally, we end our list of PMML pre-processing examples by showing the use of 4.0 functions "isMissing" and "isIn" combined with function "if". The PMML example below implements the following operations:
IF InputVar is missing THEN DerivedVar = 1 ELSE (IF InputVar is in ("Partner", "Associate", "Colleague") THEN DerivedVar = 2 ELSE DerivedVar = 3)

We finish part I of our PMML tour hoping that this short description of its pre-processing capabilities can help you to easily navigate through all the data transformations now available in PMML 4.0.

PMML 4.0 is here!

2009-06-16T10:32:00.000-07:00

The DMG (Data Mining Group) has just released PMML 4.0, the latest and greatest version of the Predictive Model Markup Language.

Zementis, together with SPSS, SAS, IBM, Open Data Group, Salford Systems, Microstrategy and all the other contributing members of the DMG is proud to be part of the making of PMML, the de facto standard to represent data mining models.

Not only can PMML represent a wide range of statistical techniques, but it can also be used to represent the data transformations necessary to transform raw data into meaningful feature detectors. In this way, PMML offers a standard to represent data manipulation and modeling in a single concise way.

Improved Pre-Processing Capabilities

PMML 4.0 extends the range of pre-processing capabilities supported by older versions by adding a range of boolean operations (e.g., and, or, not, equal, notEqual, greaterOrEqual, ...) to the list of built-in functions. These, combined with an IF-THEN-ELSE function which is also new to PMML, allow for the representation of a wide range of feature detectors.

For examples on how to use these new pre-processing capabilities as well as all the standard PMML transformations, please check the PMML Data Pre-Processing Primer.

Time Series Models

PMML 4.0 also extends the existing standard by allowing for the representation of Time Series Models. In particular, it allows for data miners and data mining tools to represent Exponential Smoothing models and offers place holders for ARIMA, Seasonal Trend Decomposition, and Spectral Analysis which are to be supported in the near future.

Model Explanation

Other additions are Model Explanation and Multiple Models. Model Explanation allows for evaluation and model performance measures to be part of the PMML file itself. In this way, not only data manipulation and models get to be defined, but also associated ROC Graph, Gains/Lift Charts, Confusion Matrix, Field Correlations, Univariate Statistics, and more.

Multiple Models

Multiple Models allows for model composition, ensembles, and segmentation. It replaces the old Model Composition element to offer greater flexibility for combining different models types, such as regression and decision trees.

Extending Existing Elements

Last, but not least, PMML 4.0 offers a range of extensions to existing elements, such as the addition of multi-class classification for Support Vector Machines, improved representation for Association Rules, and the addition of Cox Regression Models.

There is no doubt that PMML is here to stay. The announcement of PMML 4.0 attests to the commitment of the leading data mining vendors to be able to represent their solutions through a single language, a language that can be understood by all. It is our vision that users will be free to share models among many solutions, benefiting from an environment in which interoperability is truly attainable.

For more information on PMML and a list of useful links, please check PMML 101. Also, check the article "PMML: An Open Standard for Sharing Models" just published in The R Journal.

We also invite the entire community to join our on-going PMML discussion at the AnalyticBridge website.

My PMML KXEN exported model has problems, how do I fix it?

2009-06-05T17:05:00.001-07:00

The latest KXEN software exports perfect PMML, however if you are using older versions of KXEN, the PMML model it exports may have some problems which will be picked-up by the PMML Converter during conversion or ADAPA during model upload. These hic-ups can be easily fixed. Here is a list of issues we encountered (and remedies we suggest).

1) Your PMML model needs to contain the URL with the address of the PMML schema. Our PMML Converter will add that to the model automatically once you pass it through the converter.

2) Models may contain DerivedFields for which optype = "continuous" but dataType = "string". Just change the dataType to "double".

3) Models may contain DerivedFields in which the output of a NormContinuous transformation is a float (dataType = "float"). Change the dataType to "double".

4) For clustering models, make sure compareFunction = "absdiff" is expressed with a small "d". Models may refer to "absDiff" instead which is not valid.

5) Again, for clustering models only, delete the element CenterFields (this is not valid PMML).

6) If you have a Mining Model, also check our blog on how to upload KXEN Mining Models into ADAPA.

Your model should be perfect now and ready for uploading into ADAPA.

How to execute PMML Mining Models exported by KXEN in ADAPA?

2009-06-04T16:45:00.000-07:00

KXEN exports PMML models. These can be readily uploaded into ADAPA (regression and clustering models) for execution.

The latest KXEN software exports perfect PMML models. However, if you are using an older version of KXEN, you may want to use the PMML Converter to diagnose the health of your model before attempting upload into ADAPA. Existing hic-ups can be easily resolved.

In this blog we will focus on how to score Mining Models in ADAPA. These are KXEN regression models that output a probability. They are represented in PMML by a MiningModel element which is not currently supported by ADAPA.

First, you need to verify that your Mining Model contains two regression tables. The goal here is to create two PMML files out of the file exported by KXEN. Once the two files are created, they can be easily uploaded into ADAPA. Scoring becomes sequential. You will first pass data through the first model and use its output as input to the second model.

For the first model, delete the LocalTransformations element (containing the normalization of variable "intermediate_value") as well as the second regression table (for which the only NumericPredictor is named "kxen_post_processing". Also, rename your predicted variable in the DataDictionary and MiningSchema elements to "intermediate_value". This is the output of the first model.

For the second model, create a DataDictionary element with two fields: 1) the "intermediate_value" which is the only input for this model; and 2) the predicted field - for this you can use the name of the predicted variable from the original KXEN export. The example below assumes this to be "rr_color". Then create a regression model containing the LocalTransformations element of the original model together with its second regression table. See example below.

The two models will work as expected if executed in sequence. In the ADAPA web console, you can score the input data against the first model, obtain its output and use it as input to the second model. You can also automate these tasks by using web-service calls to ADAPA.

How to Score 300,000,000 Customer Records for $3

2009-06-01T15:28:00.000-07:00

Cloud computing promises lower cost and higher scalability. Translating this to a real-world practical application for predictive analytics, here is what this means for you in simple facts and numbers. With the Zementis ADAPA scoring engine on the Amazon Elastic Compute Cloud, you can score over 300 million (!) records for about $3, all in less than one hour.

Performance and scalability have been key design principles for ADAPA, in addition to open standards and Service Oriented Architecture (SOA). To illustrate this in a real-world benchmark, we measured the batch scoring performance for different Amazon EC2 instance types. Because computational efforts vary across different model types, we report only the average numbers measured for a collection of ten (10) different predictive models, each based on processing a data file containing 10 million records.

Figure: Average number of records processed per hour for each Amazon EC2 instance type. The average is based on 10 different PMML models, with the fastest instance scoring over 300 million records per hour.

We used ten different predictive models, including various regression models, neural network, clustering and decision tree algorithms which were created in several statistical tools and then exported in the Predictive Model Markup Language (PMML) standard. The PMML models subsequently were deployed and executed in the ADAPA Predictive Analytics Edition on Amazon EC2.

The fastest instance (Amazon type High-CPU XL), ADAPA scored on average over 300 million records in one hour. One hour of the High-CPU XL instance costs US$2.49 (two dollars and forty nine cents), plus a few cents for the data transfer; all in all, it adds up to less than $3 for the task.

In addition to raw processing performance for scoring data, note that ADAPA remarkably accelerates the speed of deployment and integration for predictive analytics. While it is possible to scale processing speed with additional hardware, deployment and integration are the real bottlenecks for projects. Only a framework that leverages open standards for interoperability provides the necessary agility required for proper management and deployment of predictive models.

With cloud computing and Software as a Service (SaaS), ADAPA delivers an unprecedented cost/performance ratio for implementing predictive analytics across the enterprise. Sign up for ADAPA on Amazon EC2 instantly and start using it in just a few minutes! Starting at $1 per hour for a small instance and no long-term commitment required, experience for yourself what ADAPA does for your predictive models without breaking the bank. Use your own models or try ADAPA with our PMML model examples.

The R Journal - A Refereed Journal for the R Project Launches

2009-05-28T17:42:00.000-07:00

The R project, a free software environment for statistical computing and graphics, now features a peer-reviewed journal.

The R newsletter has been transformed into The R Journal, a refereed journal for articles covering topics that are of interest to users or developers of R. The first issue is now available online. As a sign of the open source R project gaining significant momentum, The R Journal intends to reach a wide audience with high-quality papers that are focused on R.

As a supporter of the R PMML Package (see blog and video tutorial), Zementis (together with Togaware) is honored that our article "PMML: An Open Standard for Sharing Models" has been selected by the editorial board to be published as part of the inaugural issue.

While our article emphasizes the importance of the Predictive Model Markup Language (PMML) standard, other contributed research papers address a wide range of topics including graphics and parallel computing. Of more general interest are the invited articles on "The Future of R" which provide the reader with an overview of R's programming model and R-Forge, a central, collaborative platform for the development of R packages.

Following the feature in the New York Times in early 2009, this is yet another significant milestone for R.

KDD 2009 Panel on Open Standards and Cloud Computing

2009-05-20T14:18:00.000-07:00

Emerging Trends in Open Standards and Cloud Computing for Data Mining.

Please join us for an exciting panel discussion at the 15th ACM SIGKDD Conference on Knowledge Discovery and Data Mining in Paris.

Over the past decade, we have seen tremendous interest in the application of data mining and statistical algorithms, first in research and science and, more recently, across various industries. Impacting scientific and business applications alike, interoperability and open standards still lack broader adoption in the data mining community. In addition, emerging trends in cloud computing and Software as a Service will play a critical role in promoting the effective implementation and widespread application of predictive models.

The panel will discuss various topics related to open standards and cloud computing, with a particular focus on the practical use of statistical algorithms, reliable production deployment of models and the integration of predictive analytics within other systems.

Moderated by Zementis, the panel is comprised of a distinguished group of thought leaders representing key software vendors in the data mining industry including DMG / Open Data Group, IBM, KNIME, KXEN, Microstrategy, Pervasive, SAS and SPSS.

For details, please see the KDD 2009 web site.

SAP selects Zementis as a winner in the SAP BusinessObjects Explorer Development Contest

2009-05-12T16:30:00.000-07:00

Recently, SAP sponsored a contest that challenged the developer community to create and demonstrate the most innovative use of SAP BusinessObjects Explorer APIs inside of another application or process. The challenge was a great success, and SAP received a large number of high-quality submissions.

In its solution, Zementis combined on-demand, high-performance processing for predictive algorithms through the ADAPA Predictive Analytics scoring engine on Amazon EC2 with dynamic, on-demand visualization of the results in SAP BusinessObjects Explorer. The Zementis innovation leverages services deployed in two distinct cloud computing infrastructures, Amazon EC2 and SAP, demonstrating true interoperability between services, platforms, and vendors.

We also posted a brief VIDEO that illustrates the integration between ADAPA and the SAP BusinessObjects Explorer.

(SAP Announcement Details)

Scoring data in ADAPA via web services using SQL Server Integration Services (SSIS)

2009-04-28T13:25:00.000-07:00

Data integration is a big part of putting your predictive models to work. ADAPA allows for easy model deployment, but how can you actually move the data to ADAPA for scoring? One simple way is by using SQL Server Integration Services (SSIS) and its Web Service Task.

[High Res Video: SSIS Web Service Task]

Microsoft SQL Server 2008 provides a scalable enterprise data integration platform with exceptional Extract, Transform, Load (ETL) and integration capabilities, enabling organizations to more easily manage data from a wide array of data sources. In this blog, we will show you how to score data in ADAPA by using the SSIS Web Service Task.

In this blog, you will assume that you already familiar with SQL Server Business Intelligence Development Studio. All figures shown in this blog are snapshots from this tool since it is the SSIS environment used to develop integration services.

Once you are able to successfully launch the SQL Server Business Intelligence Development Studio (from noow on referred to in here as SSIS development tool), you should be able to easily create a "New Project" and configure data flow or script tasks to read/write your data (which in SSIS can be from/to a variety of sources/destinations).

For this example, we are interested in scoring Iris data against a neural network model which has previously been uploaded in ADAPA (for more information on the Iris dataset and the Iris Neural Network PMML model used here, please visit our Zementis PMML Examples page).

The simplest way for us to achieve this is to set-up a "Web Service Task" in SSIS. By selecting this task from the "Control Flow Items" and dragging it into the main editor, the screen should look like the one shown below. Note that we are not depicting any other SSIS tasks for simplicity reasons.

By double-clicking on the Web Service Task, the SSIS development tool will prompt us with a dialog box asking for the properties used to configure our task. The dialog box is shown below.

So, let's start by creating a new HTTP connection. Once you select "New Connection" from the drop-down menu, you are faced with a new dialog box.

Note that in this figure, we have already provided SSIS with the URL to the ADAPA WSDL file. The WSDL contains a separate operation for each of your PMML models that have been uploaded in ADAPA. In here, we are using an example URL. You can find a link to the correct URL you will need to use in the bottom of the help page of your ADAPA Instance.

We have also provided SSIS with the appropriate security information for accessing ADAPA which includes name and password. These are the same as the e-mail and password you used to login into the ADAPA Web Console (where you uploaded your predictive models).

Once you are done configuring the connection, click on "Test Connection". If everything goes as expected, SSIS will give you a message saying that the connection was successful.

Now, it is time to go back to the original dialog box and finish the configuration of the web service task. For the WSDL file, you will need to give SSIS the location of the file itself. You can first create an empty file and enter that as the WSDL file. Then, set "OverwriteWSDLFile" to true, and click on "Donwload WSDL" on the bottom of the dialog box. The SSIS development tool will download the WSDL into the empty file you created.

Given that all "General" properties have been configured, let's move on to "Input". The dialog box shown below already displays our selections. Thanks to the WSDL file, SSIS will automatically add "adapaModelsService" to the drop-down menu. The same for Method. All the models you uploaded in ADAPA are available for selection in the drop-down menu. In this example, we are using the Iris_NN model. Once the method is specified, all input variables available are displayed. In this case, we have four: sepal_length, sepal_width, petal_length, and petal_width. Note that we entered values by hand for each of these variables. In most cases, however, input values will come from a database or file and will be dynamically passed to the web service.

Continuing with the configuration of the web service task, let's now move on to "Output". In the dialog box shown below, we selected "OutputType" to be a Variable and configure this variable to be "User::WebServiceResponse" (it is very easy to create new variables in the SSIS development tool). Variable "WebServiceResponse" was created to be of type string. This variable will contain the response ADAPA will send back after it executes the Iris_NN model.

Basically, that's all we need to access ADAPA using SSIS. Once we run our project, we can see the value ADAPA computed by placing a break point on the end of the execution of the web service task. See screen below.

Once we do that and execute the task, we can then take a look at the WebServiceResponse variable. Notice that in the screenshot below, the response we got back from ADAPA was "Iris-versicolor" (look for the variable highlighted in blue).

Accessing ADAPA via the "Web Service Task" is a simple and quick way to integrate your data and models using SSIS. Note, however, that you can choose to use the "Script Task" item to access ADAPA via Web Services. You can also use data flow and script tasks to read/write data from/to a file or database.

For more information on how to configure the Web Service Task and use the response you get back from it, please take a look at the Web Service Training Video from Microsoft.

Scoring data in ADAPA via web services using Jitterbit.

2009-04-15T15:14:00.000-07:00

Data integration is a big part of putting your predictive models to work. ADAPA allows for easy model deployment, but how can you actually move data from, say, your database to ADAPA for scoring? One simple way is by using Jitterbit and its web service call operation.

[High Res Video: Jitterbit Database Integration]

Jitterbit is the provider of the most popular open source data and application integration platform. In this blog, we will show you how to score data residing on a database in ADAPA as well as write the resulting scores back to the same database.

Obviously, you will need first to install and launch the Jitterbit Integration Environment as well as the Jitterbit Server (you can find both available for download in the Jitterbit website). If using MySQL, as we are in this example, you will also need to install the MySQL ODBC driver in the same computer where you install Jitterbit. You can download the MySQL ODBC driver from here.

Before using Jitterbit, we highly recommend that you spend sometime getting acquainted with the tool and what it can do for you. The Jitterbit website contains a series of informative webinars. We suggest you watch at least three before attempting to work on your own. These are:

Jitterbit Overview: Introduction to Open Source Integration

Using Jitterbit: A First Look

Integration: Working with Sources

Now that you are a Jitterbit expert, make sure your models are uploaded in ADAPA. Once you do that, they will be automatically available for execution via web-services. It is now time to Jitterbit.

Once you are able to successfully launch the Jitterbit Integration Server, you should be able to easily create a "New Operation". Just select from the top menu: File->New->Operation. Once you do that, you will see the new operation you created in Jitterbit as shown below.

Now it is time for you to name it. For this example, let's call it IrisScoring since we are interested in scoring Iris data (for more information on the Iris dataset and the Iris Neural Network PMML model used here, please visit our Zementis PMML Examples page). Now, right click anywhere on the new IrisScoring operation box and select from the drop-down menu: Activity->Web Service Call. Once you do that, you will see in Jitterbit that the operation now includes a web service call as shown below.

The IrisScoring operation has now all the elements it needs for us to successfully read, score, and write our data from and to a database. Remember that once you upload a model into ADAPA, it is ready to be executed via either the web-console, or web-services. In here, we use web-services to execute the Iris Neural Network model (Iris_NN) and Jitterbit to put the integration puzzle together.

Now, it is just a matter of filling out the blanks. For that, let's work together and follow the 3 steps outlined below.

Step 1

In this step, we will define the "Source" and the "Target" of our operation. Basically, Source defines where we are getting our data from for building our web service request and Target where we are saving the web service response we get back from ADAPA.

Let's start by creating a "New Source". For that, right click on the first block named "Source" of the IrisScoring operation and select from the drop-down menu: "Create New". The screen will now display the form for "New Source". From the drop-down menu for type, select "Database". Notice here that,you can also select to read data from other sources including FTP sites, flat files, etc. Once you select "Database" though, Jitterbit will show all the connection parameters necessary for it to access the database where the Iris data resides. For the driver, if you want to read data from MySQL, select the MySQL ODBC Driver. Enter the server and database names as well as login and password. Jitterbit should now look as shown below.

Now, let's create a "New Target". For that, right click on the last block named "Target" of the IrisScoring operation and select "Create New". In our example, we want to write back the model results to the same MySQL database we read our input data from and so the information we provide to Jitterbit contains the same connection parameters as we did for "New Source".

Step 2

Now that we have our new source and target defined, let's focus on the web service call itself. To create a "New WebServiceCall", right click on the middle block named "Web Service Call" of the IrisScoring operation and select "Create New". You will now need to give Jitterbit the URL of the ADAPA WSDL file. The WSDL contains a separate operation for each of your PMML models that have been uploaded in ADAPA. Once Jitterbit is able to access the WSDL, the screen should look like the one below.

Note that you can find a link to the ADAPA WSDL file in the bottom of the help page of your ADAPA Instance. Also, note that all the models you uploaded in ADAPA are available for selection in the drop-down menu. In this example, we are using the Iris_NN model.

Also make sure you provide Jitterbit with the appropriate Security information for accessing ADAPA by entering name and password. These are the same as the e-mail and password you used to login into the ADAPA Web Console (where you uploaded your predictive models).

Jitterbit will extract the default web service URL and SoapAction HTTP from the WSDL. Congratulations! You have just finished setting up a "New WebServiceCall". See screenshot below.

Step 3

It in this step that we will define the mappings (or transformations) between our database tables and the web service call. We start by defining the transformation between the source database and the web service request. For that, right click on the second block named "Request" of the IrisScoring operation to create a "New Transformation". Select from the drop-down menus for Source - Database and for Target - Web Service Request. Jitterbit will then prompt you for a number of parameters. Enter then accordingly.

Obviously, in order to finish building our request transformation we need to link our database source table to our web service request. After linking all fields (a simple operation in Jitterbit), the screen should look like the one below.

Let's now create a response transformation in which we will map the web service response back to a table in our database so that our model results can be saved appropriately. To create "New Transformation (2)", right click on the fourth block named "Response" and select from the drop-down menus for Source - Web Service Response and for Target - Database. Jitterbit will ask us for all the parameters necessary for the transformation to be completed, including selecting the Target Database as well as the database table we want to write to. Once we do that, Jitterbit will prompt us to link the web service response to the correct field in the target table. After linking is complete, the screen should look like the one below.

Our project is complete. By selecting the IrisScoring operation, the Jitterbit screen will look like the one below.

Now it is time for us to deploy and submit the IrisScoring operation to the Jitterbit server. During execution, Jitterbit will read the data from the database, send it over to ADAPA for scoring via a web service request and write the response back to the same database.

ADAPA Predictive Analytics Scoring Engine - Demo Video

2009-03-24T16:22:00.000-07:00

In order to fully leverage the power of predictive analytics and data mining algorithms, users need the capability to seamlessly integrate statistical decision models into operational systems. Fortunately, the maturity of open standards and cloud computing allow us to finally deliver an agile deployment framework that combines on-demand scalability and a cost-effective Software-as-a-Service (SaaS) licensing model.

The Zementis ADAPA Predictive Analytics Edition on the Amazon Elastic Compute Cloud (EC2) is a deployment and scoring engine, which delivers:

Better ... Support of Open Standards

Faster ... Deployment and Scoring

Cheaper ... Total Cost of Ownership

Easier ... Launch and Integration

Please take a few moments to watch the following video to learn why ADAPA is a true quantum leap for the predictive analytics industry and how it will empower your business to make better decisions today.

Interested to experience ADAPA first hand? Let us take your Enterprise Decision Management (EDM) strategy to the next level and contact us now for a free trial.

[High Res Video: ADAPA Predictive Analytics Scoring - Demo]

ADAPA means business - Predictive Analytics in 90 seconds

2009-03-23T17:36:00.000-07:00

Watch this short video to learn how ADAPA will help you predict future customer behavior today. What can predictive analytics do for you, when you deploy your predictive models in ADAPA and are able to start using them right away?

Combining predictive analytics with cloud computing, ADAPA presents new opportunities to leverage predictive models in real-time or in batch mode, with new flexibility and at a lower total cost of ownership.

[High Res Video: ADAPA Means Business]

Data pre-processing in PMML and ADAPA - A Primer

2009-02-17T09:46:00.000-08:00

PMML defines several kinds of simple data transformations. These are:

Normalization: map values to numbers, the input can be continuous (element NormContinuous) or discrete (element NormDiscrete).
Discretization: map continuous values to discrete values.
Value Mapping: map discrete values to discrete values.
Functions: derive a value by applying a function to one or more parameters.

Below we will see how these transformations can be used and combined to allow for data pre-processing in PMML and ADAPA.

Normalization: NormContinuous

This is a general method to normalize a continuous variable to another continuous variable. In the PMML code below, two normalizations take place and two derived variables are created. The first derived variable is named "DerivedNormalizedVar1" and the second "DerivedNormalizedVar2". The normalization itself is defined under the element NormContinuous. Typically, NormContinuous is used to normalize input values between 0 and 1 as shown in the first normalization example. However, as shown in the second normalization example, one can have as many LinearNorm elements as necessary and these do not need to normalized values between 0 and 1; the only restriction is that the first attribute orig must be in increasing order. The normalized variable is then a linearly interpolated value between the LinearNorm elements.

Note that in the second example, we are using the attribute outliers to specify that any outliers to the normalization should be treated as extreme values. In this case, all "InputVar2" values lower than 100 will be assigned value "0" and all values greater than 900 will be assigned value "4".

Normalization: NormDiscrete

This method is used to transform string values to numeric values. Many models encode string values into numeric values in order to perform mathematical functions. For example, regression and neural network models often split categorical and ordinal variables into multiple dummy
variables.

The PMML code below implements the following logic:

IF CategoricalInputVar1 == Partner
THEN
DerivedVar1 = 1
ELSE
DerivedVar1 = 0

IF CategoricalInputVar1 == Associate
THEN
DerivedVar2 = 1
ELSE
DerivedVar2 = 0

IF CategoricalInputVar1 == Colleague
THEN
DerivedVar1 = 1
ELSE
DerivedVar1 = 0

In this example, variable "CategoricalInputVar1" has three possible valid values: "Partner", "Associate", and "Colleague". By using the NormDiscrete element, we can create derived variables (the dummy variables in this case) that will be assigned values "1" or "0" depending on the value of the categorical input variable being processed.

Note that we are also handling missing values in this example. The mapMissingTo attribute means that if the input value "CategoricalInputVar1" is missing then all three derived variables will be assigned "0".

Discretization

This method maps continuous values to discrete string values. For a continuous variable we define intervals and if the variable falls inside that interval, we assign to it the string value defined for that interval. In the PMML code below, the Discretize element defines the continuous field "InputVar" which is to be discretized. The DiscretizeBin elements define the intervals. The first one defines a bin which has a rightMargin of 1000. By default, its left margin (attribute leftMargin) is negative infinity. The closure attribute finally defines the interval as (-infinity,1000], i.e. the right margin is less than or equal to 1000. So if the value of the variable "InputVar" falls in this interval, we assign to the derived variable "DerivedVar" the string value “low”. Similarly, if the value of "InputVar" is in (1000,100000], the derived value is equal to "medium" and if it is in (100000,1000000), the derived value is equal to "high".

The mapping from a continuous to a discrete variable can be many-to-one but not one-to-many. In other words, two intervals can be mapped to the same string value but the same interval may not have more than one string value. This implies that the intervals defined must be disjoint; there can be no overlap between two defined intervals.

One can establish what should happen if the input is not in any of the defined intervals. The attribute defaultValue in the Discretize element establishes that if the input does not lie in any of the intervals (as for example, if "InputVar"=2,000,000), then by default it is assigned the value "extreme".

Discretization can also be paired up with element NormDiscrete to generate dummy variables which indicate if an input variable belongs to a certain interval. The PMML example shown below implements just that. We assume a numeric input variable named "InputVar" which leads to the creation of three dummy variables: "DerivedVar1", "DerivedVar2", and "DerivedVar3". These are used to indicate membership of "InputVar" to one of the following intervals: (-infinity,100], (100,200], and (200,+infinity).

Note that in this example, we are using the Discretize element to map continuous values to an integer which is then used by the NormDiscrete element to indicate interval membership.

Value Mapping

This method is used to map discrete values to discrete values. This is done by using a table which lists the input values and the mapped output values. Each row in the table refers to a possible value for the input variable. Each column in the table has a name which is used to refer to that column. This is defined inside the element MapValues.

In the PMML code below, the attribute outputColumn in element MapValues establishes that the mapped output value will be found in the column named "color". The element FieldColumnPair uses the attribute field to define the input for mapping which consists of one or more input variables. In this example, we use two variables "InputVar1" and "InputVar2". We find the input value in the "animal" column for "InputVar1" and the input value in the "property" column for "InputVar2" and map them to the output value in the"color" column.

The InlineTable element finally defines the table to be used for value mapping. So for example, if variable "InputVar1" has the value "dog" and variable "InputVar2" has the value "smart", we find "dog" in column "animal" and "smart" in column "property", both in the first row. These are them mapped to the value in the column named "color" in the same row. In this way, derived field "DerivedVar" is assigned the value "red".

As in the Discretize element, the MapValues element can have a defaultValue attribute which specifies what to map the input to if it does not have a matching value in any row.

In the PMML code below, we use elements MapValues and NormDiscrete to group small sets of categorical values. More specifically, we want to find out if input variable "VarInputColor" belongs to a specific group of colors. We do that by using the InLineTable element of MapValues to map different colors to the same number. We then use the element NormDiscrete to create dummy variables which are used to indicate group membership. This problem can be represented schematically in the following way:

IF VarInputColor is in ("Yellow","Red")
THEN
VarColorGroup_1 = 1
ELSE
VarColorGroup_1 = 0

IF VarInputColor is in ("Blue","Green")
THEN
VarColorGroup_2 = 1
ELSE
VarColorGroup_2 = 0

Note that in the example shown above we are mapping missing values to value"2" and setting the default value to "1" inside the MapValues transformation element. Derived field "GroupedInputColor" is assigned the result of the mapping between the input strings and the number representing the group. This variable is then used to generate the desired output. If "GroupedInputColor" contains value "1", variable "VarColorGroup_1" is assigned value "1", otherwise it is assigned value "0". If "GroupedInputColor" contains value "2", variable "VarColorGroup_2" is assigned value "1", otherwise it is assigned value "0". This is accomplished by the use of the NormDiscrete element as described earlier.

Large sets of values can be handled in ADAPA by an external mapping table. For example, imagine that you would like to map all existing colors (that you can imagine) into four different groups and then create dummy variables to indicate such grouping. You can design this table externally (ADAPA allows external tables to be referred from a PMML file) and use the PMML element TableLocator to reference it from inside the MapValues transformation element. The PMML code below implements this functionality.

Note that we are mapping missing values to value "4" and setting the default value to "3" inside the MapValues transformation element. Derived field "GroupedInputColor" is assigned the result of the mapping between the input colors and the number representing the group they belong to. As before, variable "GroupedInputColor" is then used to generate the desired output through the use of the element NormDiscrete.

The mapping table itself is only being referenced inside the element TableLocator. We are using a PMML extension in this case to indicate to ADAPA that the mapping table we want to access is named "GroupedInputColor".

Functions

If a certain transformation is to be applied to input data many times and to multiple fields, it makes sense to encapsulate the transformation inside a function and just use is as many times as necessary. This reduces the complexity of the PMML model and greatly simplifies its application. PMML provides a number of built-in functions as well as providing the capability for the user to define a user-defined function.

Built-in Functions

ADAPA supports all PMML built-in functions. The complete list is shown below.

+, -, * and /
min, max, sum and avg
log10, ln, sqrt, abs, exp, pow, threshold, floor, ceil, round
uppercase
substring
trimBlanks
formatNumber
formatDatetime
dateDaysSinceYear
dateSecondsSinceYear
dateSecondsSinceMidnight

Note that functions such as "min", "max", "sum" and "avg" take a variable number of parameters (derived fields or input fields) and return a single value which can then be assigned to a new derived field. Please refer to the DMG website - Built-in Functions for code examples and descriptions.

The PMML code shown below implements the following arithmetic operation:
ResultVar=maximum(round(InputVar1/3.3),2^(1+log(1.3*InputVar2+1)))

Note that it uses two different input variables: "InputVar1" and "InputVar2" as well as a number of numeric constants. The example shows many built-in functions which are used together to implement such a complex operation. The end result is assigned to derived variable "ResultVar".

ADAPA-Defined Functions

Although PMML does not support boolean types, ADAPA defines many functions that support boolean operations. These are used to compare parameters which are required to be of identical type (e.g., strings or dates) or of compatible type for numeric variables (e.g., double vs. integer). The result is of boolean type: "true" or "false", which is evaluated by functions such as "if" and "not".

ADAPA-defined functions which operate on two input attributes, e.g. "a" and "b", of identical or compatible types are:

equal: evaluates to "true" if "a" is equal to "b", "false" otherwise.
notEqual: evaluates to "true" if "a" is not equal to "b", "false" otherwise.
lessThan: evaluates to "true" if "a" is less than "b", "false" otherwise.
lessOrEqual: evaluates to "true" if "a" is less or equal to "b", "false" otherwise.
greaterThan: evaluates to "true" if "a" is greater than "b", "false" otherwise.
greaterOrEqual: evaluates to "true" if "a" is greater or equal to "b", "false" otherwise.
isIn: evaluates to "true" if "a" is in "b", "false" otherwise. Attribute "b" in this case is an array of values.
isNotIn: evaluates to "true" if "a" is not in "b", "false" otherwise. Attribute "b" in this case is an array of values.

ADAPA-defined functions which operate on a single input attribute, e.g. "a", are:

isMissing: evaluates to true if "a" is missing, i.e. equal to NULL, "false" otherwise.
isNotMissing: evaluates to "true" if "a" is not missing, "false" otherwise.

ADAPA-defined functions which evaluate boolean operations are:

not: operates on a single boolean attribute. Negates existing boolean evaluation result.
and: summarizes the results of two or more independent boolean operations. Evaluates to "true" only if all operations are "true", "false" otherwise.
or: summarizes the results of two or more independent boolean operations. Evaluates to "true" if a single operation is "true", "false" only if all operations are "false".
if: implements IF-THEN-ELSE logic. The ELSE part is optional.

Note that the ADAPA-defined functions were based on the PMML decision tree operators for simple and compound predicates(see DMG website - Tree Model).

Below, we give a few examples of how these ADAPA-defined functions can be used to implement logical operations. We start with the PMML code below which implements the following logical and arithmetic operations:

IF InputVar1 == "Partner"
THEN
DerivedVar1 = "P"
ELSE
DerivedVar2 = 2 * InputVar2

In this example, we are using "InputVar1" which contains a string to assign values to two very different derived variables: "DerivedVar1" which is a string and "DerivedVar2" which is an integer.

Note that the code uses the ADAPA-defined functions: "if", "equal", and "not" as well as the built-in fuction "*". The main reason for not using the "else" part of the "if" function is simply because we want to assign the "then" result to "DerivedVar1" and the "else" result to a different variable, "DerivedVar2". Data transformations in PMML are encapsulated under a single DerivedField element.

The PMML code below assumes that both "then" and "else" parts of the "if" use the same derived variable "DerivedVar1" to implement the following operations:

IF InputVar1 == "Partner"
THEN
DerivedVar1 = "5.1 * InputVar2"
ELSE
DerivedVar1 = "InputVar2 / 3.3"

Note that in this case, "DerivedVar2" is not being used. The "then" and "else" part are being used to assign the same variable "DerivedVar1" the result of two different computations.

We showed earlier how to use the Discretize element in conjunction with NormDiscrete to create dummy variables to indicate membership to numeric intervals. What if we would like to do just that, but this time for strings? The PMML code below exemplifies how this could be accomplished by using ADAPA-defined fuctions "if" and "lessOrEqual" in conjunction with the NormDiscrete element.

The PMML code below implements the following operations:

IF InputVar less or equal to "Denmark"
THEN
DerivedVar1 = 1 (otherwise = 0)
ELSE
IF InputVar less or equal to "France"
THEN
DerivedVar2 = 1 (otherwise = 0)
ELSE
DerivedVar3 = 1 (otherwise = 0)

Note that the three dummy variables: "DerivedVar1", "DerivedVar2", and "DerivedVar3" are used to indicate the membership of input variable "InputVar" to three different string intervals.

Finally, we end our list of PMML code examples by showing the use of functions "isMissing" and "isIn" combined with function "if". The example shown in implements the following operations:

IF InputVar is missing
THEN
DerivedVar = 1
ELSE
IF InputVar is in ("Partner", "Associate", "Colleague")
THEN
DerivedVar = 2
ELSE
DerivedVar = 3

When defining a PMML document, the pre-processing of the input variables is mainly located inside the following PMML elements: TransformationDictionary and LocalTransformations.

For the formal PMML schema definition of the transformations covered here, please refer to the PMML Transformations page on the DMG website.

ADAPA® Web Service for Predictive Models Sample (for ADAPA® Enterprise Edition and Amazon EC2 users)

2009-01-22T11:26:00.000-08:00

The ADAPA® Web Service for Predictive Models allows execution of PMML models through two distinct web service calls. As the first web service option, the ADAPA® Models Web Service exposes each uploaded predictve model as a separate operation. The name of the model becomes the name of the operation, the input mining fields of the model becomes the operation's input parameters and the predicted mining field of the models becomes the output value. As a second option, the ADAPA® JDM Web Service follows the JDM standard.

A sample client has been prepared and demonstrates the use of ADAPA® Models Web Service and ADAPA® JDM Web Service. This sample is available for download here. The sample requires Java (version 5 or later) Development Kit and Apache Ant to execute. To execute the sample client, you need to have Java and Ant available in the system path.

Details regarding configuration and execution of the sample client can be found in the ADAPA® Models WS Guide that you can download from the ADAPA® help page or from here.

Statistical Analysis Software R Featured in NYT Article

2009-01-08T16:01:00.000-08:00

We highly recommend the following article about R in the New York Times: Data Analysts Captured by R's Power.

It shows how excellent open source software can prosper!

NYT, January 6, 2009. Companies as diverse as Google, Pfizer, Merck, Bank of America, the InterContinental Hotels Group and Shell use it.
[...] those most familiar with the software estimate that close to 250,000 people work with it regularly.

Zementis has been working with the R community, specifically to extend the support for the Predictive Model Markup Language (PMML) standard which allows model exchange among various statistical software tools.

Got models in R? Deploy and score them in ADAPA in minutes on the Amazon EC2 cloud computing infrastructure!

If you develop your models in R, you can easily deploy and execute these models in the Zementis ADAPA scoring engine (using the PMML standard). This not only eliminates potential memory constraints in R but also speeds execution and allows SOA-based integration. For the IT department, ADAPA delivers reliability and scalability needed for production-ready deployment and real-time predictive analytics.

Contact us for a free trial!

Rattle Version 2.4.0 Released - Open Source Data Mining and Extensive PMML Support

2009-01-07T16:17:00.000-08:00

Version 2.4.0 of the free data mining software, Rattle, has been released.

Through its extensive PMML support, Rattle perfectly complements the Zementis ADAPA predictive analytics scoring engine. Build your predictive models in Rattle/R and then score/deploy/integrate them via ADAPA in your production environment.

The aim of Rattle is to provide a simple and intuitive interface that allows a user to quickly load data from a CSV file (or via ODBC), transform and explore the data, build and evaluate models, and export models as PMML (Predictive Model Markup Language) or as scores. All of this with little knowledge of R.

For more details, please see the announcement at KDnuggets News.

ADAPA Predictive Analytics Scoring Engine - Security on Amazon EC2

2009-01-05T15:49:00.000-08:00

This posting addresses a question that many of our customers have asked: "Is my data secure with ADAPA on EC2"? The short answer is "yes".

Zementis has implemented extensive security measures to ensure that your data and your predictive models are protected with the ADAPA scoring engine:

- Private: nothing is shared, your ADAPA instance is under your full control and only you have the access keys.

- Secure: access is only granted via HTTPS, management console and web service are password protected.

- Firewall: ADAPA utilizes the Amazon EC2 firewall to the extent of maximum lockdown.

- No residual information: once you terminate your instance, all models/data are deleted within seconds.

We would like to point out the AWS Security Whitepaper which outlines the security processes implemented by AWS. In addition to various technical details, key information in this whitepaper is that AWS is in compliance with Sarbanes Oxley (SOX), SAS70 Type II, and that AWS customers have built HIPAA-compliant healthcare applications.

The Zementis ADAPA predictive analytics scoring engine on Amazon allows you to deploy your PMML models within minutes. It is a fully hosted SaaS solution with no up-front cost. You only pay for what you use, starting at less than $1/hour of machine time. Subscribe now to try it at no risk or read more about the features of ADAPA.

KNIME 2.0 Adds PMML Import and PMML Export

2008-12-18T16:58:00.000-08:00

Zementis is a fervent supporter of open standards for predictive analytics and data mining. As the Predictive Model Markup Language (PMML) standard continues to gain momentum, we are pleased to see that the open source tool KNIME 2.0 has added support for PMML export and import as part of their latest release.

At Zementis, we have already tested the KNIME PMML export quite extensively and we are excited to report that it works well with ADAPA, our PMML scoring engine.

KNIME 2.0 currently exports PMML 3.1 which can be converted to the latest PMML 3.2 format via the Zementis PMML Converter. Once converted to PMML 3.2, you can deploy, integrate, and execute your predictive models in ADAPA in real-time or in batch mode. ADAPA is available as a SaaS cloud computing solution and can be launched in minutes via Amazon EC2.

In addition for the native import/export nodes for PMML, KNIME also provides access to an R node that allows the export of PMML. This node leverages the R PMML export library that Zementis has been supporting and which has been covered extensively in the ADAPA support blog.

The KNIME blog provides a detailed description about how to convert R models into PMML.

Talk at the Forum on Analytics - San Diego

2008-11-26T16:26:00.000-08:00

We recently gave a talk (11/12/08) at the Forum on Analytics (sponsored by the San Diego Software Industry Council - SDSIC). The talk was entitled "Easy Expression and Execution of Data Mining Models through PMML". Please click here to see the presentation slides. The presentation transcripts follow below (after the abstract).

Presentation Abstract

PMML (Predictive Model Markup Language) is an XML-based language used to define data mining models. It was specified by the Data Mining Group, an independent group of leading technology companies. By providing a uniform standard to represent predictive models, PMML allows for the exchange of predictive solutions between different applications and various vendors. Many statistical packages already support the PMML standard; these include, for example, SAS and SPSS. In an effort to broaden the scientific workbench available to data mining scientists and to support the open source community, Zementis recently contributed code to the R project. In particular, we implemented the export of neural network models built with the nnet R package as well as Support Vector Machines built with the ksvm R package. The same PMML exporter can also produce decision trees built with rpart and linear regression models built with lm. The PMML exporter package is currently available through CRAN (the Comprehensive R Archive Network).

All of the R exported PMML 3.2 models are readily available to be uploaded into an execution engine for scoring or classification. For example, the ADAPA engine, which can be used for testing and exploration, can be accessed directly through the Zementis website or it can be downloaded as a gadget which can be added to a personalized iGoogle console. This service is available free of charge and leverages the Amazon Elastic Compute Cloud (Amazon EC2).

Our aim here is to show how one can quickly build a data mining model in R, such as a Support Vector Machine, and use the PMML exporter to produce a model file which can be uploaded and executed in a different application. We demonstrate how one can use data containing expected results to verify correct model deployment. If all computed and expected values match, the model can be considered ready for production, i.e. available for generating predictions on incoming data as part of an overall enterprise decision management strategy. From R to ADAPA, we use PMML as an effective way to express and execute data mining models.

Our work shows how PMML can be effectively used to allow for model exchange between different applications. Also, it highlights how one can benefit from an open-source statistical package such as R to easily export models into PMML and upload them into ADAPA, a light-weight scoring engine which consumes several PMML 3.2 models. The ease of model expression and execution allows data mining scientists to concentrate on the important tasks: data analysis and model building. Real-time, scalable execution is handled through software tools which communicate through a common language, PMML.

Below, please find the transcripts of our talk, organized per slide.

Slide 1 - Title

Slide 2

My talk will be divided in 3 parts all of which are centered around Open Standards. I will start by talking about the Development of Predictive Models using R. I will then talk about Deployment and in doing so I will focus on PMML. Finally, I will talk about the real-time execution of PMML files.

Slide 3

So, R is our software of choice for this presentation, given that it is an open source and a GNU project. R is available for free over the internet. R allows for data manipulation, calculation, and graphical display. It provides a wide variety of statistical techniques and it is highly extensible.

But, how to export models out of R? Once you build your models in R, you can easily export them into PMML.

We recently contributed code to the R PMML package which can now export a variety of modeling techniques which include … to name a few:

Neural Networks
Support Vector Machines
Decision Trees
Regression Models
…

Slide 4

Great! But, what is PMML? PMML stands for Predictive Model Markup Language. It is an XML-based language which is the de facto standard for exchanging predictive models between compliant applications. For this reason, PMML avoids proprietary issues and incompatibilities

PMML provides a clear separation of tasks in which model deployment easily follows model development. In this way, PMML frees scientists to focus on model building. PMML eliminates the need for custom model deployment. In doing so, it ensures scalability and reliability.

Slide 5

PMML is a mature standard and is widely supported by the industry. It is developed and maintained by the Data Mining Group which is a vendor independent consortium with several major supporters including IBM, Oracle, Microsoft, SAS, SPSS, Fair Isaac and Zementis.

Slide 6

A single PMML file can be used to represent data transformations and well as the model itself. In doing so, PMML brings data transformations and statistical models together.

PMML allows for the definition of a data dictionary which is used to define all the raw data fields coming into the model, including missing value strategy and outlier treatment.

Several data transformations can also be expressed in PMML which can be used to extract feature detectors from the raw data.

On the other hand, post-processing of results allows for tailored decisions.

Slide 7

So, here it is, R … The R GUI is very simple.

Imagine that we want to build a neural network model to solve the Iris classification problem. In this case, all we need to do is upload the R neural network package NNET.

We then assign the data file containing the IRIS data set to the R object we called Iris.

And call NNET with the right parameters which include the data set used to train the model as well as the size of the hidden layer. We assign the network to the R object IrisNet

Once trained, this network can be easily exported into PMML. We need to upload the PMML package first and then call it with our neural network object as a parameter.

Slide 8

ET VOILA’!!!

Here is your PMML code. Hot from the oven!

Note the data dictionary which contains a description of the four input variables used to train the model.

Also note that in this simple example, there were no data transformations. We are using the input data AS IS.

Slide 9

So, you did all your data analysis, built your model and generate PMML using R … but what now?

What can you do if you need to execute this model on a Iris Field and use it in real-time?

Slide 10

This is where a predictive analytics scoring engine fits in. We are going to use ADAPA here as an example.

ADAPA allows for data transformations and models to be uploaded and executed in real time via web-services calls.

It is an environment to manage and execute not only one but many predictive models and rule sets.

ADAPA is not a model building environment. We used R for that!

Slide 11

This is a screen-shot of the ADAPA management console.

PMML files are easily uploaded and maintained through this interface.

Note that several models have already been uploaded into ADAPA including the IRIS Neural Network model we just built using R.

Slide 12

Once a model is uploaded, it needs to be validated. This is accomplished via a score matching test.

In this case we uploaded 150 IRIS data records containing the input variables as well as the expected output. ADAPA will then compare and match computed and expected values.

If any mismatches are found, ADAPA allows for complete traceability of its internal decisions.

Slide 1

Great! I just showed you how to Easy Express and Execute Data Mining Models using PMML … all in 6 steps.

R allows for Data Analysis, Model Building, and PMML Export.

PMML can then be uploaded into a compliant decision engine.

Data reaches the engine via web-service calls.

And in so doing,

Model execution is performed in real-time.

Slide 14 - Thank you!

More Analytics Moves to the Amazon Cloud

2008-11-26T14:39:00.000-08:00

Please see James Taylor's excellent blog "More Analytics in the Cloud" regarding an announcement related to cloud computing and analytics. Mathematica and MATLAB are following Zementis and now offer solutions on Amazon EC2 that focus on complex and computationally intensive applications.

We launched our ADAPA predictive analytics decision engine on EC2 which allows users to deploy, integrate, and execute statistical scoring models, e.g., using algorithms like neural networks, support vector machine (SVM), decision tree, and various regression models.

Finally, companies have the option to save a lot of software licensing cost by buying predictive analytics like books, under a cost effective pay-as-you-go SaaS license model.

It is great to see more mathematical applications migrate to the cloud. This is one of the best opportunities where cloud computing can reduce cost and complexity of implementing computational efforts in HPC, large-scale simulations, and predictive analytics.

R to PMML Export Video Tutorial

2008-11-11T13:18:00.001-08:00

We created a brief video to demonstrate how easy it is to export PMML from R. The Predictive Model Markup Language is the industry standard which allows you to exchange statistical models between a variety of software solutions.

[High Res Video: Exporting PMML from R]

This example walks through the steps required to create a neural network model for the Iris classification problem and then export the model as a PMML file. Once exported in PMML format, the model is ready to be deployed and executed, e.g., in the Zementis ADAPA scoring engine.

To follow this example, you will need to download the PMML package, and the Iris.csv data file.

Please refer to the following articles for a more comprehensive introduction to PMML and additional information about PMML export for R.

The Synergy of Rules and Predictive Analytics

2008-11-04T13:45:00.000-08:00

While attending the Business Rules Forum 2008 in Orlando, it was apparent that many of the rules engine vendors have discovered the value of predictive analytics and consider supporting the Predictive Model Markup Language (PMML) standard. As part of the Enterprise Decision Management track of the conference, Zementis presented on open source, open standards, and cloud computing under the title of Agile Deployment of Predictive Analytics Using Amazon EC2.

The synergies of rules and predictive models form the foundation for an Enterprise Decision Management strategy. While rules describe explicit knowledge, predictive analytics leverages implicit knowledge that is embedded in your data.

At Zementis, we have long combined rules and predictive models for better decisions. Our ADAPA decision engine is available as an Enterprise Edition which seamlessly integrates the Drools rules engine. If you are already using Drools, you can effectively deploy predictive models in your business process with minimal effort.

Even if you are using a rules engine from Ilog, Corticon, or another rules engine vendor, ADAPA provides an easy, SOA-based integration via web services. Predictive analytics does not have to be complex or costly to deploy, if you follow open standards and leverage best-of-breed solutions.

Want to learn more about combining rules and predictive analytics? Please contact us!

How are data transformations represented in PMML?

2008-10-28T16:35:00.000-07:00

PMML supports several kinds of data transformations. Below, we list the most common together with examples.

Data transformations involved in the pre-processing of the input variables/fields are mainly located inside the following PMML elements: TransformationDictionary and LocalTransformations.

For the formal PMML schema definition of the transformations covered here, please refer to the PMML Transformations page on the DMG website.

Value Mapping

Value mapping can be used to map discrete values to discrete values. The example below shows how to map a categorical field (color) into a numerical field (derived_color).

Note that in this example, we are mapping yellow to 3, white to 1, blue to 6, and green to 4.

The original input field named color needs to be defined in the DataDictionary element. The derived field, the result of our data transformation is now called derived_color. This field can subsequently be used by the model as an input variable or used as input for another data transformation.

Discretization

Discretization is used to map continuous values to discrete values. The example below shows how to discretize a continuous field (units) into a discrete field (derived_units).

In this example, we are transforming an interval to a discrete value, more specifically, discretize will transform [1,2[ to 1, [2,3[ to 2, and [3,100] to 3.

The new field is now called derived_units and can be used as input to another transformation or to the model itself.

Normalization

As specified in the DMG website, normalization provides a basic framework for mapping input values to specific value ranges, usually the numeric range [0 .. 1].

NormContinuous

Normalization is used, e.g., in neural networks. In fact, if you export your neural network model using SPSS (starting with version 16), the PMML code generated will contain this kind of transformation for the neural inputs. The R PMML package will also generate a file containing the normalization of input variables for Support Vector Machines (SVMs). The example below was extracted from the Iris_SVM.xml file available in the Zementis website.

The PMML element NormContinuous can be used to implement simple normalization functions such as the z-score transformation (X - m ) / s, where m is the mean value and s is the standard deviation.

NormDiscrete

The NormDiscrete element is used to implement the dummyfication of categorical or ordinal fields. For example, if you have a categorical variable called Marital with the following possible values: Absent, Divorced, Married, Married-spouse-absent, Unmarried, and Widowed, you may want these to be dummyfied (i.e. translated into 0s and 1s) for use by a neural network or SVM. The example below shows the use of element NormDiscrete to accomplish just that.

The set of NormDiscrete instances which refer to input field Marital define a fan-out function which maps a single input field to a set of normalized fields. Note that if Marital is equal to Married, the field derived_MaritalMarried will be assigned a value equals to 1.0 and all other derived_MaritalX fields shown will be assigned values equal to 0.

This code was extrated from the Audit_SVM.xml file available in the Zementis website. It is automatically exported by the R PMML package for SVMs built using the R ksvm (kernlab) package.

Functions

PMML offers several built-in functions, all of which are supported by ADAPA. The list is as follows:

1. +, -, * and /
2. min, max, sum and avg
3. log10, ln, sqrt, abs, exp, pow, threshold, floor, ceil, round
4. uppercase
5. substring
6. trimBlanks
7. formatNumber
8. formatDatetime
9. dateDaysSinceYear
10. dateSecondsSinceYear
11. dateSecondsSinceMidnight

You can find several examples of the use of such functions in the DMG website.

Note that functions such as min, max, sum and avg take a variable number of parameters (derived fields or input fields) and return a single value which you would then assign to a new derived field.

List of PMML consumers and producers

2008-10-22T15:19:00.000-07:00

Ever wonder what statistical packages out there consume and produce PMML? And if so, what techniques are supported? With the help of the DMG, we have compiled a table of PMML compliant companies and software. Check it out here (table entries are shown in alphabetical order).

If your company or software is not listed in the table, please let us know and we will update it. Thanks!