ftp.tcs3.com/ftp.tcs3.com.tar/ftp.tcs3.com/DRIVERS/Audio/Office2010/ProPlus.WW/ProPsWW.cab/AS_msmdlocal_dll_32.C16C67A1_5ADC_4C44_B6AE_A40000020FCC/HTML/DMS2Y.XSL

Extensible Markup Language | 2009-09-03 | 33KB | 794 lines

<?xml version="1.0"?>
<!--

*****************************************************************************
*                                                                           *
*                                                                           *
*     Copyright (c) Microsoft Corporation.  All rights reserved.                *
*                                                                           *
*    File:        dmS2Y.xsl                                                    *
*    Owner:       Bogdan Crivat (BogdanC)                                   *
*___________________________________________________________________________*
*                                                                           *
*    Description:                                                           *
*                                                                           *
*        This XSLT transform generates XML DDL from an old( Shiloh) XML     *
*         persistence format (extended PMML)                                    *
*                                                                             *
*         @todo: bogdanc - check whether the following are structural         *
*        elements and need conversion to DDL                                    *
*            - compound-categories|compound-category|categoryref|parent        *
*            - hierarchy-parent                                                *
*            - simple -attribute                                                *
*            - compound-attribute, key-val,                                     *
*            - derived-attribute                                                *
*            - predicate/compound-predicate                                    *
*                                                                            *
*                                                                            *
*        The DDL contains an internal element                                 *
*        (MiningStructure\PMMLSourceVersion) -  that marks it  as being         *
*        generated from PMML                                                 *
*****************************************************************************

-->
<xsl:transform
    version="1.0"
    xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:xsd="http://www.w3.org/2001/XMLSchema"
    xmlns:msxsl="urn:schemas-microsoft-com:xslt"
    xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"
    xmlns:msxmla="urn:schemas-microsoft-com:xml-analysis"
    xmlns:msddl="http://schemas.microsoft.com/analysisservices/2003/engine"
    xmlns="http://schemas.microsoft.com/analysisservices/2003/engine"
    xmlns:prefix="msddl"
>

<xsl:strip-space elements="*"/>
<xsl:output method="xml" omit-xml-declaration="yes" indent="yes" standalone="yes" />


<!--
/////////////////////////////////////////////////////////////////////////
//                                                                     //
// This transform can parse the following tree:                        //
//                                                                     //
//    <PMML name=>                                                       //
//        <statements>                                                    //
//            <statement type="CREATE"...>                                //
//            ...                                                            //
//        </statements>                                                    //
//        <data-dictionary>                                                //
//            <key...>                                                    //
//            <categorical...>                                            //
//            <ordinal....>                                                //
//            <categorical-continuous....>                                //
//            <continuous-categorical....>                                //
//            <probability....>                                            //
//            <value-variance....>                                        //
//            <value-std....>                                                //
//            <probability-variance....>                                    //
//            <probability-std....>                                        //
//            <support....>                                                //
//            <data-dictionary>                                            //
//                ...                                                        //
//            </data-dictionary>                                            //
//        </data-dictionary>                                                //
//    </PMML>                                                               //
//////////////////////////////////////////////////////////////////////////
-->

<!-- ================================================================ -->
<!--                                                                  -->
<!--   Main Program                                                   -->
<!--   Creates a SOAP Envelope then launches a Command template       -->
<!-- ================================================================ -->

<xsl:template match="/">
    <xsl:element name="soap:Envelope">
        <xsl:element name="soap:Body">
            <xsl:call-template name="generate-DDL-command"/>
        </xsl:element>
    </xsl:element>
</xsl:template>



<!--
/////////////////////////////////////////////////////////////////////////
// generate-DDL-command:                                               //
// Generates an Execute/Command object                                   //
// Then, calls generate-DDL-Dataabse to get a Database element         //
/////////////////////////////////////////////////////////////////////////
-->
<xsl:template match="*" name="generate-DDL-command">
    <xsl:element name="msxmla:Execute">
        <!-- Command element-->
        <xsl:element name="msxmla:Command">
            <!-- Generate Mining Model DDL -->
            <xsl:element name="Create">
                <!-- Generate object definition -->
                <xsl:call-template name="generate-DDL-database-ref"/>
                <xsl:element name="ObjectDefinition">
                    <xsl:call-template name="generate-olap-miningstructures"/>
                </xsl:element>
            </xsl:element>
        </xsl:element>
        <xsl:element name="msxmla:Properties"/>
    </xsl:element>

</xsl:template>


<!--
/////////////////////////////////////////////////////////////////////////
// generate-DDL-database:                                               //
// Generates a Database element, populates it with ID and Name            //
//    based on the PMML                                                      //
// Then, calls generate-olap-miningstructures                           //
/////////////////////////////////////////////////////////////////////////
-->
<xsl:template match="*" name="generate-DDL-database-ref">
    <xsl:element name="ParentObject">
        <xsl:element name="DatabaseID">
            <xsl:value-of select="/pmml/Injected_DatabaseID"/>
        </xsl:element>
    </xsl:element>
</xsl:template>






<!--
/////////////////////////////////////////////////////////////////////////
// OLAP Mining Structures:                                             //
// Generate the Mininng Structures                                     //
/////////////////////////////////////////////////////////////////////////
-->
<xsl:template match="*" name="generate-olap-miningstructures">
        <xsl:element name="MiningStructure">
        <!--xsl:attribute name="dwd:design-time-name">miningStructure_<xsl:value-of select="/pmml/@name"/></xsl:attribute-->

            <xsl:for-each select="pmml">

                <!-- generate the mining structure section of the ddl-->
                <xsl:call-template name="generate-olap-miningstructure">
                    <xsl:with-param name="in_pmmlName" select="/pmml/Injected_ModelID"/>
                    <xsl:with-param name="in_pmmlCreationTime" select="@creation-time"/>
                    <xsl:with-param name="in_pmmlModifiedTime" select="@modified-time"/>
                </xsl:call-template>



                <!--
                This element is unsupported
                <xsl:element name="State">UnProcessed</xsl:element>
                -->

                <!-- generate the mining model -->
                <xsl:call-template name="generate-olap-miningmodel">
                    <xsl:with-param name="in_pmmlName" select="/pmml/Injected_ModelID"/>
                    <xsl:with-param name="in_pmmlCreationTime" select="@creation-time"/>
                    <xsl:with-param name="in_pmmlModifiedTime" select="@modified-time"/>
                </xsl:call-template>

                </xsl:for-each>

        </xsl:element>
</xsl:template>



<!--
/////////////////////////////////////////////////////////////////////////
// OLAP Mining Structure:                                              //
// Generate elements of an OLAP mining structure                       //
/////////////////////////////////////////////////////////////////////////
-->
<xsl:template match="pmml" name="generate-olap-miningstructure">
    <xsl:param name="in_pmmlName"/>
    <xsl:param name="in_pmmlCreationTime"/>
    <xsl:param name="in_pmmlModifiedTime"/>

    <xsl:element name="PMMLSourceVersion"><xsl:value-of select="/pmml/Injected_PMMLVersion"/></xsl:element>


    <xsl:element name="ID">
        <xsl:choose>
            <xsl:when test="$in_pmmlName">
                <xsl:call-template name="render-valid-ID-from-string">
                    <xsl:with-param name="in_strBaseName" select="$in_pmmlName"/>
                </xsl:call-template>
            </xsl:when>
            <xsl:otherwise>
                <xsl:call-template name="render-valid-ID-from-string">
                    <xsl:with-param name="in_strBaseName" select="@name"/>
                </xsl:call-template>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:element>
    <xsl:element name="Name">
        <xsl:choose>
            <xsl:when test="$in_pmmlName">
                <xsl:call-template name="render-valid-ID-from-string">
                    <xsl:with-param name="in_strBaseName" select="$in_pmmlName"/>
                </xsl:call-template>
            </xsl:when>
            <xsl:otherwise>
                <xsl:call-template name="render-valid-ID-from-string">
                    <xsl:with-param name="in_strBaseName" select="@name"/>
                </xsl:call-template>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:element>

    <!--  The Created/Updated stuff seems not to be needed

    <xsl:call-template name="create-updated-dateTime-format-element">
        <xsl:with-param name="in_tagName" >CreatedTimeStamp</xsl:with-param>
        <xsl:with-param name="in_oldDateTime" select="$in_pmmlCreationTime"/>
    </xsl:call-template>

    <xsl:call-template name="create-updated-dateTime-format-element">
        <xsl:with-param name="in_tagName" >LastSchemaUpdate</xsl:with-param>
        <xsl:with-param name="in_oldDateTime" select="$in_pmmlModifiedTime"/>
    </xsl:call-template>

    -->


    <xsl:comment>The SOURCE section might have to be filled</xsl:comment>

    <!--  The Created/Updated stuff seems not to be needed
    <xsl:call-template name="create-updated-dateTime-format-element">
        <xsl:with-param name="in_tagName" >LastProcessed</xsl:with-param>
        <xsl:with-param name="in_oldDateTime" select="$in_pmmlModifiedTime"/>
    </xsl:call-template>
    -->

    <xsl:for-each select="./data-dictionary">
        <xsl:call-template name="olap-mininingstruct-columns-from-datadictionary" />
    </xsl:for-each>

</xsl:template>








<!--
/////////////////////////////////////////////////////////////////////////
// OLAP Mining Model:                                                  //
// Generate elements of an OLAP mining model                           //
/////////////////////////////////////////////////////////////////////////
-->
<xsl:template match="pmml" name="generate-olap-miningmodel">
    <xsl:param name="in_pmmlName"/>
    <xsl:param name="in_pmmlCreationTime"/>
    <xsl:param name="in_pmmlModifiedTime"/>

    <xsl:element name="MiningModels">
        <xsl:element name="MiningModel">
            <!--xsl:attribute name="dwd:design-time-name">miningModel_<xsl:value-of select="@name"/></xsl:attribute-->

            <xsl:element name="ID">
                <xsl:choose>
                    <xsl:when test="$in_pmmlName">
                        <xsl:call-template name="render-valid-ID-from-string">
                            <xsl:with-param name="in_strBaseName" select="$in_pmmlName"/>
                        </xsl:call-template>
                    </xsl:when>
                    <xsl:otherwise>
                        <xsl:call-template name="render-valid-ID-from-string">
                            <xsl:with-param name="in_strBaseName" select="@name"/>
                        </xsl:call-template>
                    </xsl:otherwise>
                </xsl:choose>
            </xsl:element>
            <xsl:element name="Name">
                <xsl:choose>
                    <xsl:when test="$in_pmmlName">
                        <xsl:call-template name="render-valid-ID-from-string">
                            <xsl:with-param name="in_strBaseName" select="$in_pmmlName"/>
                        </xsl:call-template>
                    </xsl:when>
                    <xsl:otherwise>
                        <xsl:call-template name="render-valid-ID-from-string">
                            <xsl:with-param name="in_strBaseName" select="@name"/>
                        </xsl:call-template>
                    </xsl:otherwise>
                </xsl:choose>
            </xsl:element>

            <!--  The Created/Updated stuff seems not to be needed
            <xsl:call-template name="create-updated-dateTime-format-element">
                <xsl:with-param name="in_tagName" >CreatedTimeStamp</xsl:with-param>
                <xsl:with-param name="in_oldDateTime" select="$in_pmmlCreationTime"/>
            </xsl:call-template>

            <xsl:call-template name="create-updated-dateTime-format-element">
                <xsl:with-param name="in_tagName" >LastSchemaUpdate</xsl:with-param>
                <xsl:with-param name="in_oldDateTime" select="$in_pmmlModifiedTime"/>
            </xsl:call-template>
            -->

            <xsl:element name="Algorithm">
                <xsl:choose>
                    <!-- If a tree-model exists, then Decision_Trees -->
                    <xsl:when test="/pmml/tree-model">
                        <xsl:value-of select="'Microsoft_Decision_Trees'"/>
                    </xsl:when>
                    <!-- Otherwise, Clustering -->
                    <xsl:otherwise>
                        <xsl:value-of select="'Microsoft_Clustering'"/>
                    </xsl:otherwise>
                </xsl:choose>
            </xsl:element>

            <xsl:element name="AlgorithmParameters">
                <xsl:call-template name="render-algorithm-parameters"/>
            </xsl:element>

            <!--  The Created/Updated stuff seems not to be needed
            <xsl:call-template name="create-updated-dateTime-format-element">
                <xsl:with-param name="in_tagName" >LastProcessed</xsl:with-param>
                <xsl:with-param name="in_oldDateTime" select="$in_pmmlModifiedTime"/>
            </xsl:call-template>
            -->

            <xsl:for-each select="./data-dictionary">
                <xsl:call-template name="olap-mininingmodel-columns-from-datadictionary" />
            </xsl:for-each>
        </xsl:element>
    </xsl:element>
</xsl:template>






<!--
/////////////////////////////////////////////////////////////////////////
// OLAP Mining Structure columns:                                      //
// Generates the content of a  Mining Structure Columns tag from a     //
// pmml data-dictionary                                                //
/////////////////////////////////////////////////////////////////////////
-->

<xsl:template match="data-dictionary" name="olap-mininingstruct-columns-from-datadictionary">

   <xsl:element name="Columns">
    <xsl:for-each select="./*">
    <!-- call a template to generate a column for each child element-->
      <xsl:choose>
        <xsl:when test="'data-dictionary'=local-name()">
          <!--nested table column-->
          <xsl:call-template name="olap-miningstructure-column">
            <xsl:with-param name="in_columnType">TableMiningStructureColumn</xsl:with-param>
          </xsl:call-template>
        </xsl:when>
        <xsl:otherwise>
          <!--regular, simple column-->
          <xsl:call-template name="olap-miningstructure-column">
            <xsl:with-param name="in_columnType">ScalarMiningStructureColumn</xsl:with-param>
          </xsl:call-template>
        </xsl:otherwise>
      </xsl:choose>
    </xsl:for-each>
   </xsl:element>

</xsl:template>






<!--
/////////////////////////////////////////////////////////////////////////
// OLAP Mining Model columns:                                          //
// Generates the content of a  Mining Model Columns tag from a         //
// pmml data-dictionary                                                //
/////////////////////////////////////////////////////////////////////////
-->

<xsl:template match="data-dictionary" name="olap-mininingmodel-columns-from-datadictionary">

   <xsl:element name="Columns">
    <xsl:for-each select="./*">
    <!-- Call a template to generate a column for each child element
         Also, treat all columns as regular, simple columns-->
      <xsl:call-template name="olap-miningmodel-column"/>
    </xsl:for-each>
   </xsl:element>

</xsl:template>


<!--
/////////////////////////////////////////////////////////////////////////
// Creates one OLAP Mining Structure column:                           //
/////////////////////////////////////////////////////////////////////////
-->
<xsl:template match="*" name="olap-miningstructure-column">
    <xsl:param name="in_columnType"/>

    <xsl:element name="Column">
        <xsl:attribute name="xsi:type"><xsl:value-of select="$in_columnType"/></xsl:attribute>
        <!--xsl:attribute name="dwd:design-time-name"><xsl:value-of select="$in_columnType"/>_<xsl:value-of select="@name"/></xsl:attribute-->

        <xsl:element name="ID" >
            <xsl:call-template name="render-valid-ID-from-string">
                <xsl:with-param name="in_strBaseName" select="@name"/>
            </xsl:call-template>
        </xsl:element>
        <xsl:element name="Name" ><xsl:value-of select="@name"/></xsl:element>

        <xsl:choose>
           <xsl:when test="'ScalarMiningStructureColumn' = $in_columnType">
                <!-- generate Scalar Column -->
                <xsl:element name="Type" >
                    <!-- Type has to be Phrase-case the type name
                         bogdanc - Look for a better way to do this
                         Exceptions
                             - Real has to become Double
                     -->
                   <xsl:choose>
                           <xsl:when test="'REAL'=@datatype">Double</xsl:when>
                           <xsl:otherwise>
                           <xsl:variable name="TmpString1" select="substring(@datatype,1,1)"/>
                            <xsl:value-of select="translate($TmpString1, 'abcdefghijklmnopqrstuvwxyz', 'ABCDEFGHIJKLMNOPQRSTUVWXYZ')"/>
                            <xsl:variable name="TmpString2" select="substring(@datatype,2)"/>
                            <xsl:value-of select="translate($TmpString2, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz')"/>
                         </xsl:otherwise>
                     </xsl:choose>
                </xsl:element>
                <xsl:if test="'key' = local-name()">
                    <!-- this element is a key - add a IsKey tag -->
                    <xsl:element name="IsKey" >true</xsl:element>
                </xsl:if>

                <!-- TODO - find out whether a Key can be input and/or predict,and how to represent it in Usage -->

                <xsl:element name="Content" >
                    <!-- MAPPING : determine the Content value based on the key name -->
                    <xsl:choose>
                        <xsl:when test="'key'=local-name()">Key</xsl:when>
                        <xsl:when test="'categorical'=local-name()">Discrete</xsl:when>
                        <xsl:when test="'continuous'=local-name()">Continuous</xsl:when>
                        <xsl:when test="('continuous-categorical'=local-name()) or ('categorical-continuous'=local-name())">Discretized</xsl:when>
                        <xsl:when test="'categorical-continuous'=local-name()">Discretized</xsl:when>
                        <!-- MAPPING - how to interpret the old spec for <!ELEMENT ordinal /page115? -->
                        <xsl:when test="'ordinal'=local-name()">
                            <xsl:choose>
                                <xsl:when test="'true'=@cyclical">Cyclical</xsl:when>
                                <xsl:when test="'true'=@timesequence">Sequence</xsl:when> <!-- OR should it be Time??? -->
                                <xsl:otherwise>Ordered</xsl:otherwise>
                            </xsl:choose>
                        </xsl:when>
                        <xsl:when test="'probability'=local-name()">Probability</xsl:when>
                        <xsl:when test="'value-variance'=local-name()">Variance</xsl:when>
                        <xsl:when test="'value-std'=local-name()">StdDev</xsl:when>
                        <xsl:when test="'probability-variance'=local-name()">ProbabilityVariance</xsl:when>
                        <xsl:when test="'probability-std'=local-name()">ProbabilityStdDev</xsl:when>
                        <xsl:when test="'support'=local-name()">Support</xsl:when>
                        <xsl:when test="'hierarchy-parent'=local-name()">Discrete</xsl:when>
                    </xsl:choose>
                </xsl:element>

                <!-- for hierarchy-parent columns, add a ClassifiedColumnID element -->
                <xsl:if test="'hierarchy-parent'=local-name()">
                    <xsl:element name="ClassifiedColumns">
                        <xsl:element name="ClassifiedColumnID">
                            <xsl:value-of select="@relates-to"/>
                        </xsl:element>
                    </xsl:element>
                </xsl:if>

                <xsl:element name="ModelingFlags">
                    <xsl:if test="'true'=@model-not-null">
                        <xsl:element name="ModelingFlag">NOT NULL</xsl:element>
                    </xsl:if>
                </xsl:element>
                <!-- for discretized types, try too figure out the discretization method -->
                <xsl:if test="('continuous-categorical'=local-name()) or ('categorical-continuous'=local-name())">
                  <xsl:element name="DiscretizationMethod">
                    <xsl:choose>
                      <!-- MAPPING: determine the discretization method and the buckets count based on the @discretization-method attributes-->
                      <xsl:when test="'EQUALAREA'=@discretization-method">EqualAreas</xsl:when>
                      <xsl:when test="'CLUSTER'=@discretization-method">Clusters</xsl:when>
                      <xsl:when test="'THRESHOLD'=@discretization-method">Thresholds</xsl:when>
                      <xsl:otherwise>Automatic</xsl:otherwise>
                    </xsl:choose>
                  </xsl:element>
                  <xsl:element name="DiscretizationBucketCount">
                    <xsl:choose>
                      <!-- MAPPING: determine the discretization method and the buckets count based on the @discretization-method attributes-->
                      <xsl:when test="@number-of-buckets"><xsl:value-of select="@number-of-buckets"/></xsl:when>
                      <xsl:otherwise>5</xsl:otherwise>
                    </xsl:choose>
                  </xsl:element>
                </xsl:if>

                <!-- add KeyColumns although there is not enough information to fill them now -->
                <xsl:element name="KeyColumns"/>
           </xsl:when>

           <xsl:when test="'TableMiningStructureColumn' = $in_columnType">
                <!-- generate Table Column(nested) -->
                <xsl:element name="ForeignKeyColumns"/>

                <!-- now generate the Columns section of the nested table-->
                <xsl:call-template name="olap-mininingstruct-columns-from-datadictionary" />
           </xsl:when>
        </xsl:choose>



    </xsl:element>
</xsl:template>





<!--
/////////////////////////////////////////////////////////////////////////
// Creates one OLAP Mining Model column:                               //
/////////////////////////////////////////////////////////////////////////
-->
<xsl:template match="*" name="olap-miningmodel-column">

    <xsl:element name="Column">
        <!--xsl:attribute name="dwd:design-time-name">miningModelColumn_<xsl:value-of select="@name"/></xsl:attribute-->

        <xsl:element name="ID" >
            <xsl:call-template name="render-valid-ID-from-string">
                <xsl:with-param name="in_strBaseName" select="@name"/>
            </xsl:call-template>
        </xsl:element>
        <xsl:element name="Name" ><xsl:value-of select="@name"/></xsl:element>
        <xsl:element name="SourceColumnID" ><xsl:value-of select="@name"/></xsl:element>

        <!-- MAPPING - Generate Usage element if necessary
            from the attributes of the PMML element
            ASSUMING - that isinput AND ispredict = Predict
                     - that ispredict AND NO isinput = PredictOnly
                     - that isinput AND NO ispredict= Input
        -->


        <!-- Key element name => <IsKey>true</IsKey> -->
        <xsl:if test="'key' = local-name()">
            <xsl:element name="Usage" >Key</xsl:element>
        </xsl:if>

        <xsl:element name="ModelingFlags">
            <xsl:if test="'true'=@model-as-binary">
                <xsl:element name="ModelingFlag">MODEL_EXISTENCE_ONLY</xsl:element>
            </xsl:if>
        </xsl:element>


        <xsl:choose>
            <!-- isinput AND ispredict => Predict -->
            <xsl:when test="('true'=@isinput) and ('true'=@ispredict) and not ('key'=local-name())">
                <xsl:element name="Usage" >Predict</xsl:element>
            </xsl:when>

            <!-- NOT isinput AND ispredict => Predict -->
            <xsl:when test="('true'!=@isinput) and ('true'=@ispredict) and not ('key'=local-name())">
                <xsl:element name="Usage" >PredictOnly</xsl:element>
            </xsl:when>

            <!-- isinput AND NOT ispredict => Predict -->
            <xsl:when test="('true'=@isinput) and ('true'!=@ispredict) and not ('key'=local-name())">
                <xsl:element name="Usage" >Input</xsl:element>
            </xsl:when>

        </xsl:choose>


        <xsl:if test="'data-dictionary'=local-name()">
          <!--nested table column, restart this template and generate another Columns element-->
          <xsl:call-template name="olap-mininingmodel-columns-from-datadictionary"/>
        </xsl:if>


    </xsl:element>
</xsl:template>





<!--
/////////////////////////////////////////////////////////////////////////
// Converts an old dateTime representation to teh 2001 schema form     //
/////////////////////////////////////////////////////////////////////////
-->

<xsl:template match="*" name="create-updated-dateTime-format-element">
    <xsl:param name="in_tagName"/>
    <xsl:param name="in_oldDateTime"/>
    <!-- TODO :  look for a way to get locale GMT time offset -->
    <xsl:element name="{$in_tagName}"><xsl:value-of select="$in_oldDateTime"/>.0000000-08:00</xsl:element>
</xsl:template>



<!--
///////////////////////////////////////////////////////////////////////////
// Renders a  string as a valid ID value, therefore removes all entities //
///////////////////////////////////////////////////////////////////////////
-->

<xsl:template match="*" name="render-valid-ID-from-string">
    <xsl:param name="in_strBaseName"/>

    <xsl:variable name="postApos" select="translate($in_strBaseName,"'",'')"/>
    <xsl:variable name="postAmp" select="translate($postApos,"&",'')"/>
    <xsl:value-of select="$postAmp"/>
</xsl:template>




<!--
///////////////////////////////////////////////////////////////////////////
// Renders a  string as a valid ID value, therefore removes all entities //
// Note -  modifying this requires modifications in the                  //
// DMParserShilohPMMLToDDL::startElement which generates the IDs of      //
// the mining struct and mining model on the same rule                     //
///////////////////////////////////////////////////////////////////////////
-->

<xsl:template match="*" name="render-algorithm-parameters">




    <!--
    ///////////////////////////////////////////////////////////////////////////
    // Common parameters (Classification and clustering)                     //
    ///////////////////////////////////////////////////////////////////////////
    -->
    <!-- Checking for MAXIMUM_INPUT_ATTRIBUTES-->
    <xsl:call-template name="render-one-algorithm-parameter">
        <xsl:with-param name="in_DDAttrName" select="/pmml/data-dictionary/@maximum-input-attributes"/>
        <xsl:with-param name="in_DDLName" select="'MAXIMUM_INPUT_ATTRIBUTES'"/>
        <xsl:with-param name="in_XSDType" select="'xsd:int'"/>
    </xsl:call-template>

    <!-- Checking for MAXIMUM_OUTUT_ATTRIBUTES-->
    <xsl:call-template name="render-one-algorithm-parameter">
        <xsl:with-param name="in_DDAttrName" select="/pmml/data-dictionary/@maximum-output-attributes"/>
        <xsl:with-param name="in_DDLName" select="'MAXIMUM_OUTPUT_ATTRIBUTES'"/>
        <xsl:with-param name="in_XSDType" select="'xsd:int'"/>
    </xsl:call-template>

    <!--
    ///////////////////////////////////////////////////////////////////////////
    // Parameters for Decision Trees (Classification)                         //
    ///////////////////////////////////////////////////////////////////////////
    -->

    <!-- Checking for SPLIT_METHOD-->
    <xsl:call-template name="render-one-algorithm-parameter">
        <xsl:with-param name="in_DDAttrName" select="/pmml/data-dictionary/@split-method"/>
        <xsl:with-param name="in_DDLName" select="'SPLIT_METHOD'"/>
        <xsl:with-param name="in_XSDType" select="'xsd:int'"/>
    </xsl:call-template>


    <!-- Checking for SCORE_METHOD-->
    <xsl:call-template name="render-one-algorithm-parameter">
        <xsl:with-param name="in_DDAttrName" select="/pmml/data-dictionary/@score-method"/>
        <xsl:with-param name="in_DDLName" select="'SCORE_METHOD'"/>
        <xsl:with-param name="in_XSDType" select="'xsd:int'"/>
    </xsl:call-template>

    <!-- Checking for MINIMUM_LEAF_CASES-->
    <xsl:call-template name="render-one-algorithm-parameter">
        <xsl:with-param name="in_DDAttrName" select="/pmml/data-dictionary/@minimum-leaf-cases"/>
        <xsl:with-param name="in_DDLName" select="'MINIMUM_SUPPORT'"/>
        <xsl:with-param name="in_XSDType" select="'xsd:int'"/>
    </xsl:call-template>

    <!-- Checking for COMPLEXITY_PENALTY-->
    <xsl:call-template name="render-one-algorithm-parameter">
        <xsl:with-param name="in_DDAttrName" select="/pmml/data-dictionary/@complexity-penalty"/>
        <xsl:with-param name="in_DDLName" select="'COMPLEXITY_PENALTY'"/>
        <xsl:with-param name="in_XSDType" select="'xsd:double'"/>
    </xsl:call-template>



    <!--
    ///////////////////////////////////////////////////////////////////////////
    // Parameters for Clustering                                               //
    ///////////////////////////////////////////////////////////////////////////
    -->

    <!-- Checking for CLUSTERING_METHOD-->
    <xsl:call-template name="render-one-algorithm-parameter">
        <xsl:with-param name="in_DDAttrName" select="/pmml/data-dictionary/@clustering-method"/>
        <xsl:with-param name="in_DDLName" select="'CLUSTERING_METHOD'"/>
        <xsl:with-param name="in_XSDType" select="'xsd:int'"/>
    </xsl:call-template>

    <!-- Checking for CLUSTER_COUNT-->
    <xsl:call-template name="render-one-algorithm-parameter">
        <xsl:with-param name="in_DDAttrName" select="/pmml/data-dictionary/@cluster-count"/>
        <xsl:with-param name="in_DDLName" select="'CLUSTER_COUNT'"/>
        <xsl:with-param name="in_XSDType" select="'xsd:int'"/>
    </xsl:call-template>

    <!-- Checking for MINIMUM_CLUSTER_CASES-->
    <xsl:call-template name="render-one-algorithm-parameter">
        <xsl:with-param name="in_DDAttrName" select="/pmml/data-dictionary/@minimum-cluster-cases"/>
        <xsl:with-param name="in_DDLName" select="'MINIMUM_SUPPORT'"/>
        <xsl:with-param name="in_XSDType" select="'xsd:double'"/>
    </xsl:call-template>

    <!-- Checking for MODELLING_CARDINALITY-->
    <xsl:call-template name="render-one-algorithm-parameter">
        <xsl:with-param name="in_DDAttrName" select="/pmml/data-dictionary/@modelling-cardinality"/>
        <xsl:with-param name="in_DDLName" select="'MODELLING_CARDINALITY'"/>
        <xsl:with-param name="in_XSDType" select="'xsd:int'"/>
    </xsl:call-template>

    <!-- Checking for STOPPING_TOLERANCE-->
    <xsl:call-template name="render-one-algorithm-parameter">
        <xsl:with-param name="in_DDAttrName" select="/pmml/data-dictionary/@stopping-tolerance"/>
        <xsl:with-param name="in_DDLName" select="'STOPPING_TOLERANCE'"/>
        <xsl:with-param name="in_XSDType" select="'xsd:double'"/>
    </xsl:call-template>

    <!-- Checking for SAMPLE_SIZE does not appear in Shiloh-->
    <!-- xsl:call-template name="render-one-algorithm-parameter">
        <xsl:with-param name="in_DDAttrName" select="/pmml/data-dictionary/@sample-size"/>
        <xsl:with-param name="in_DDLName" select="'SAMPLE_SIZE'"/>
        <xsl:with-param name="in_XSDType" select="'xsd:int'"/>
    </xsl:call-template-->

    <!-- Checking for MAXIMUM_STATES does not appear in Shiloh-->
    <!-- xsl:call-template name="render-one-algorithm-parameter">
        <xsl:with-param name="in_DDAttrName" select="/pmml/data-dictionary/@maximum-states"/>
        <xsl:with-param name="in_DDLName" select="'MAXIMUM_STATES'"/>
        <xsl:with-param name="in_XSDType" select="'xsd:int'"/>
    </xsl:call-template-->
</xsl:template>



<xsl:template match="*" name="render-one-algorithm-parameter">
    <xsl:param name="in_DDAttrName"/>
    <xsl:param name="in_DDLName"/>
    <xsl:param name="in_XSDType"/>

    <xsl:if test="string-length($in_DDAttrName) > 0">
        <xsl:element name="AlgorithmParameter">
            <xsl:element name="Name">
                <xsl:value-of select="$in_DDLName"/>
            </xsl:element>
            <xsl:element name="Value">
                <xsl:attribute name="xsi:type">
                    <xsl:value-of select="$in_XSDType"/>
                </xsl:attribute>
                <xsl:value-of select="$in_DDAttrName"/>
            </xsl:element>
        </xsl:element>
    </xsl:if>

</xsl:template>


</xsl:transform>