GeneralizedLearner.java

  1. package org.drip.learning.rxtor1;

  3. /*
  4.  * -*- mode: java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  5.  */

  7. /*!
  8.  * Copyright (C) 2020 Lakshmi Krishnamurthy
  9.  * Copyright (C) 2019 Lakshmi Krishnamurthy
  10.  * Copyright (C) 2018 Lakshmi Krishnamurthy
  11.  * Copyright (C) 2017 Lakshmi Krishnamurthy
  12.  * Copyright (C) 2016 Lakshmi Krishnamurthy
  13.  * Copyright (C) 2015 Lakshmi Krishnamurthy
  14.  * 
  15.  *  This file is part of DROP, an open-source library targeting analytics/risk, transaction cost analytics,
  16.  *      asset liability management analytics, capital, exposure, and margin analytics, valuation adjustment
  17.  *      analytics, and portfolio construction analytics within and across fixed income, credit, commodity,
  18.  *      equity, FX, and structured products. It also includes auxiliary libraries for algorithm support,
  19.  *      numerical analysis, numerical optimization, spline builder, model validation, statistical learning,
  20.  *      and computational support.
  21.  *  
  22.  *      https://lakshmidrip.github.io/DROP/
  23.  *  
  24.  *  DROP is composed of three modules:
  25.  *  
  26.  *  - DROP Product Core - https://lakshmidrip.github.io/DROP-Product-Core/
  27.  *  - DROP Portfolio Core - https://lakshmidrip.github.io/DROP-Portfolio-Core/
  28.  *  - DROP Computational Core - https://lakshmidrip.github.io/DROP-Computational-Core/
  29.  * 
  30.  *  DROP Product Core implements libraries for the following:
  31.  *  - Fixed Income Analytics
  32.  *  - Loan Analytics
  33.  *  - Transaction Cost Analytics
  34.  * 
  35.  *  DROP Portfolio Core implements libraries for the following:
  36.  *  - Asset Allocation Analytics
  37.  *  - Asset Liability Management Analytics
  38.  *  - Capital Estimation Analytics
  39.  *  - Exposure Analytics
  40.  *  - Margin Analytics
  41.  *  - XVA Analytics
  42.  * 
  43.  *  DROP Computational Core implements libraries for the following:
  44.  *  - Algorithm Support
  45.  *  - Computation Support
  46.  *  - Function Analysis
  47.  *  - Model Validation
  48.  *  - Numerical Analysis
  49.  *  - Numerical Optimizer
  50.  *  - Spline Builder
  51.  *  - Statistical Learning
  52.  * 
  53.  *  Documentation for DROP is Spread Over:
  54.  * 
  55.  *  - Main                     => https://lakshmidrip.github.io/DROP/
  56.  *  - Wiki                     => https://github.com/lakshmiDRIP/DROP/wiki
  57.  *  - GitHub                   => https://github.com/lakshmiDRIP/DROP
  58.  *  - Repo Layout Taxonomy     => https://github.com/lakshmiDRIP/DROP/blob/master/Taxonomy.md
  59.  *  - Javadoc                  => https://lakshmidrip.github.io/DROP/Javadoc/index.html
  60.  *  - Technical Specifications => https://github.com/lakshmiDRIP/DROP/tree/master/Docs/Internal
  61.  *  - Release Versions         => https://lakshmidrip.github.io/DROP/version.html
  62.  *  - Community Credits        => https://lakshmidrip.github.io/DROP/credits.html
  63.  *  - Issues Catalog           => https://github.com/lakshmiDRIP/DROP/issues
  64.  *  - JUnit                    => https://lakshmidrip.github.io/DROP/junit/index.html
  65.  *  - Jacoco                   => https://lakshmidrip.github.io/DROP/jacoco/index.html
  66.  * 
  67.  *  Licensed under the Apache License, Version 2.0 (the "License");
  68.  *      you may not use this file except in compliance with the License.
  69.  *   
  70.  *  You may obtain a copy of the License at
  71.  *      http://www.apache.org/licenses/LICENSE-2.0
  72.  *  
  73.  *  Unless required by applicable law or agreed to in writing, software
  74.  *      distributed under the License is distributed on an "AS IS" BASIS,
  75.  *      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  76.  *  
  77.  *  See the License for the specific language governing permissions and
  78.  *      limitations under the License.
  79.  */

  81. /**
  82.  * <i>GeneralizedLearner</i> implements the Learner Class that holds the Space of Normed R<sup>x</sup> To
  83.  * Normed R<sup>1</sup> Learning Functions along with their Custom Empirical Loss. Class-Specific Asymptotic
  84.  * Sample, Covering Number based Upper Probability Bounds and other Parameters are also maintained.
  85.  *  
  86.  * <br><br>
  87.  * The References are:
  88.  *  
  89.  * <br><br>
  90.  * <ul>
  91.  *  <li>
  92.  *      Alon, N., S. Ben-David, N. Cesa Bianchi, and D. Haussler (1997): Scale-sensitive Dimensions, Uniform
  93.  *          Convergence, and Learnability <i>Journal of Association of Computational Machinery</i> <b>44
  94.  *          (4)</b> 615-631
  95.  *  </li>
  96.  *  <li>
  97.  *      Anthony, M., and P. L. Bartlett (1999): <i>Artificial Neural Network Learning - Theoretical
  98.  *          Foundations</i> <b>Cambridge University Press</b> Cambridge, UK
  99.  *  </li>
  100.  *  <li>
  101.  *      Kearns, M. J., R. E. Schapire, and L. M. Sellie (1994): <i>Towards Efficient Agnostic Learning</i>
  102.  *          Machine Learning <b>17 (2)</b> 115-141
  103.  *  </li>
  104.  *  <li>
  105.  *      Lee, W. S., P. L. Bartlett, and R. C. Williamson (1998): The Importance of Convexity in Learning with
  106.  *          Squared Loss <i>IEEE Transactions on Information Theory</i> <b>44</b> 1974-1980
  107.  *  </li>
  108.  *  <li>
  109.  *      Vapnik, V. N. (1998): <i>Statistical learning Theory</i> <b>Wiley</b> New York
  110.  *  </li>
  111.  * </ul>
  112.  *
  113.  *  <br><br>
  114.  *  <ul>
  115.  *      <li><b>Module </b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/ComputationalCore.md">Computational Core Module</a></li>
  116.  *      <li><b>Library</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/StatisticalLearningLibrary.md">Statistical Learning</a></li>
  117.  *      <li><b>Project</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/learning">Agnostic Learning Bounds under Empirical Loss Minimization Schemes</a></li>
  118.  *      <li><b>Package</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/learning/rxtor1">Statistical Learning Empirical Loss Penalizer</a></li>
  119.  *  </ul>
  120.  *
  121.  * @author Lakshmi Krishnamurthy
  122.  */

  124. public abstract class GeneralizedLearner implements org.drip.learning.rxtor1.EmpiricalLearningMetricEstimator
  125. {
  126.     private org.drip.learning.bound.CoveringNumberLossBound _funcClassCNLB = null;
  127.     private org.drip.spaces.functionclass.NormedRxToNormedR1Finite _funcClassRxToR1 = null;
  128.     private org.drip.learning.regularization.RegularizationFunction _regularizerFunc = null;

  130.     /**
  131.      * GeneralizedLearner Constructor
  132.      * 
  133.      * @param funcClassRxToR1 R^x To R^1 Function Class
  134.      * @param funcClassCNLB The Function Class Covering Number based Deviation Upper Probability Bound
  135.      *  Generator
  136.      * @param regularizerFunc The Regularizer Function
  137.      * 
  138.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  139.      */

  141.     public GeneralizedLearner (
  142.         final org.drip.spaces.functionclass.NormedRxToNormedR1Finite funcClassRxToR1,
  143.         final org.drip.learning.bound.CoveringNumberLossBound funcClassCNLB,
  144.         final org.drip.learning.regularization.RegularizationFunction regularizerFunc)
  145.         throws java.lang.Exception
  146.     {
  147.         if (null == (_funcClassRxToR1 = funcClassRxToR1) || null == (_funcClassCNLB = funcClassCNLB) || null
  148.             == (_regularizerFunc = regularizerFunc))
  149.             throw new java.lang.Exception ("GeneralizedLearner ctr: Invalid Inputs");
  150.     }

  152.     @Override public org.drip.spaces.functionclass.NormedRxToNormedR1Finite functionClass()
  153.     {
  154.         return _funcClassRxToR1;
  155.     }

  157.     @Override public org.drip.learning.regularization.RegularizationFunction regularizerFunction()
  158.     {
  159.         return _regularizerFunc;
  160.     }

  162.     @Override public org.drip.learning.rxtor1.EmpiricalPenaltySupremum supremumEmpiricalLoss (
  163.         final org.drip.spaces.instance.GeneralizedValidatedVector gvviX,
  164.         final org.drip.spaces.instance.GeneralizedValidatedVector gvviY)
  165.     {
  166.         try {
  167.             return new org.drip.learning.rxtor1.EmpiricalPenaltySupremumEstimator
  168.                 (org.drip.learning.rxtor1.EmpiricalPenaltySupremumEstimator.SUPREMUM_PENALTY_EMPIRICAL_LOSS,
  169.                     this, gvviY, null, null).supremum (gvviX);
  170.         } catch (java.lang.Exception e) {
  171.             e.printStackTrace();
  172.         }

  174.         return null;
  175.     }

  177.     @Override public double structuralLoss (
  178.         final org.drip.function.definition.R1ToR1 funcLearnerR1ToR1,
  179.         final org.drip.spaces.instance.GeneralizedValidatedVector gvvi)
  180.         throws java.lang.Exception
  181.     {
  182.         if (null == gvvi || !(gvvi instanceof org.drip.spaces.instance.ValidatedR1) &&
  183.             (_funcClassRxToR1 instanceof org.drip.spaces.functionclass.NormedR1ToNormedR1Finite))
  184.             throw new java.lang.Exception ("GeneralizedLearner::structuralLoss => Invalid Inputs");

  186.         org.drip.function.definition.R1ToR1 funcRegularizerR1ToR1 = _regularizerFunc.r1Tor1();

  188.         if (null == funcRegularizerR1ToR1)
  189.             throw new java.lang.Exception ("GeneralizedLearner::structuralLoss => Invalid Inputs");

  191.         org.drip.spaces.functionclass.NormedR1ToNormedR1Finite finiteClassR1ToR1 =
  192.             (org.drip.spaces.functionclass.NormedR1ToNormedR1Finite) _funcClassRxToR1;

  194.         org.drip.spaces.metric.GeneralizedMetricVectorSpace gmvsInput =
  195.             finiteClassR1ToR1.inputMetricVectorSpace();

  197.         if (gmvsInput instanceof org.drip.spaces.metric.R1Normed)
  198.             throw new java.lang.Exception ("GeneralizedLearner::structuralLoss => Invalid Inputs");

  200.         org.drip.spaces.metric.GeneralizedMetricVectorSpace gmvsOutput =
  201.             finiteClassR1ToR1.outputMetricVectorSpace();

  203.         if (gmvsOutput instanceof org.drip.spaces.metric.R1Continuous)
  204.             throw new java.lang.Exception ("GeneralizedLearner::structuralLoss => Invalid Inputs");

  206.         org.drip.learning.regularization.RegularizerR1ToR1 regularizerR1ToR1 =
  207.             org.drip.learning.regularization.RegularizerBuilder.ToR1Continuous (funcRegularizerR1ToR1,
  208.                 (org.drip.spaces.metric.R1Normed) gmvsInput, (org.drip.spaces.metric.R1Continuous)
  209.                     gmvsOutput, _regularizerFunc.lambda());

  211.         if (null == regularizerR1ToR1)
  212.             throw new java.lang.Exception ("GeneralizedLearner::structuralLoss => Invalid Inputs");

  214.         return regularizerR1ToR1.structuralLoss (funcLearnerR1ToR1, ((org.drip.spaces.instance.ValidatedR1)
  215.             gvvi).instance());
  216.     }

  218.     @Override public double structuralLoss (
  219.         final org.drip.function.definition.RdToR1 funcLearnerRdToR1,
  220.         final org.drip.spaces.instance.GeneralizedValidatedVector gvvi)
  221.         throws java.lang.Exception
  222.     {
  223.         if (null == gvvi || !(gvvi instanceof org.drip.spaces.instance.ValidatedRd) &&
  224.             (_funcClassRxToR1 instanceof org.drip.spaces.functionclass.NormedRdToNormedR1Finite))
  225.             throw new java.lang.Exception ("GeneralizedLearner::structuralLoss => Invalid Inputs");

  227.         org.drip.function.definition.RdToR1 funcRegularizerRdToR1 = _regularizerFunc.rdTor1();

  229.         if (null == funcRegularizerRdToR1)
  230.             throw new java.lang.Exception ("GeneralizedLearner::structuralLoss => Invalid Inputs");

  232.         org.drip.spaces.functionclass.NormedRdToNormedR1Finite finiteClassRdToR1 =
  233.             (org.drip.spaces.functionclass.NormedRdToNormedR1Finite) _funcClassRxToR1;

  235.         org.drip.spaces.metric.GeneralizedMetricVectorSpace gmvsInput =
  236.             finiteClassRdToR1.inputMetricVectorSpace();

  238.         if (gmvsInput instanceof org.drip.spaces.metric.RdNormed)
  239.             throw new java.lang.Exception ("GeneralizedLearner::structuralLoss => Invalid Inputs");

  241.         org.drip.spaces.metric.GeneralizedMetricVectorSpace gmvsOutput =
  242.             finiteClassRdToR1.outputMetricVectorSpace();

  244.         if (gmvsOutput instanceof org.drip.spaces.metric.R1Continuous)
  245.             throw new java.lang.Exception ("GeneralizedLearner::structuralLoss => Invalid Inputs");

  247.         org.drip.learning.regularization.RegularizerRdToR1 regularizerRdToR1 =
  248.             org.drip.learning.regularization.RegularizerBuilder.ToRdContinuous (funcRegularizerRdToR1,
  249.                 (org.drip.spaces.metric.RdNormed) gmvsInput, (org.drip.spaces.metric.R1Continuous)
  250.                     gmvsOutput, _regularizerFunc.lambda());

  252.         if (null == regularizerRdToR1)
  253.             throw new java.lang.Exception ("GeneralizedLearner::structuralLoss => Invalid Inputs");

  255.         return regularizerRdToR1.structuralLoss (funcLearnerRdToR1, ((org.drip.spaces.instance.ValidatedRd)
  256.             gvvi).instance());
  257.     }

  259.     @Override public org.drip.learning.rxtor1.EmpiricalPenaltySupremum supremumStructuralLoss (
  260.         final org.drip.spaces.instance.GeneralizedValidatedVector gvviX)
  261.     {
  262.         try {
  263.             return new org.drip.learning.rxtor1.EmpiricalPenaltySupremumEstimator
  264.                 (org.drip.learning.rxtor1.EmpiricalPenaltySupremumEstimator.SUPREMUM_PENALTY_STRUCTURAL_LOSS,
  265.                     this, null, null, null).supremum (gvviX);
  266.         } catch (java.lang.Exception e) {
  267.             e.printStackTrace();
  268.         }

  270.         return null;
  271.     }

  273.     @Override public double regularizedLoss (
  274.         final org.drip.function.definition.R1ToR1 funcLearnerR1ToR1,
  275.         final org.drip.spaces.instance.GeneralizedValidatedVector gvviX,
  276.         final org.drip.spaces.instance.GeneralizedValidatedVector gvviY)
  277.         throws java.lang.Exception
  278.     {
  279.         return empiricalLoss (funcLearnerR1ToR1, gvviX, gvviY) + structuralLoss (funcLearnerR1ToR1, gvviX);
  280.     }

  282.     @Override public double regularizedLoss (
  283.         final org.drip.function.definition.RdToR1 funcLearnerRdToR1,
  284.         final org.drip.spaces.instance.GeneralizedValidatedVector gvviX,
  285.         final org.drip.spaces.instance.GeneralizedValidatedVector gvviY)
  286.         throws java.lang.Exception
  287.     {
  288.         return empiricalLoss (funcLearnerRdToR1, gvviX, gvviY) + structuralLoss (funcLearnerRdToR1, gvviX);
  289.     }

  291.     @Override public org.drip.learning.rxtor1.EmpiricalPenaltySupremum supremumRegularizedLoss (
  292.         final org.drip.spaces.instance.GeneralizedValidatedVector gvviX,
  293.         final org.drip.spaces.instance.GeneralizedValidatedVector gvviY)
  294.     {
  295.         try {
  296.             return new org.drip.learning.rxtor1.EmpiricalPenaltySupremumEstimator
  297.                 (org.drip.learning.rxtor1.EmpiricalPenaltySupremumEstimator.SUPREMUM_PENALTY_REGULARIZED_LOSS,
  298.                 this, gvviY, null, null).supremum (gvviX);
  299.         } catch (java.lang.Exception e) {
  300.             e.printStackTrace();
  301.         }

  303.         return null;
  304.     }

  306.     @Override public org.drip.learning.rxtor1.EmpiricalPenaltySupremum supremumEmpiricalRisk (
  307.         final org.drip.measure.continuous.R1R1 distR1R1,
  308.         final org.drip.spaces.instance.GeneralizedValidatedVector gvviX,
  309.         final org.drip.spaces.instance.GeneralizedValidatedVector gvviY)
  310.     {
  311.         try {
  312.             return new org.drip.learning.rxtor1.EmpiricalPenaltySupremumEstimator
  313.                 (org.drip.learning.rxtor1.EmpiricalPenaltySupremumEstimator.SUPREMUM_PENALTY_EMPIRICAL_RISK,
  314.                     this, gvviY, distR1R1, null).supremum (gvviX);
  315.         } catch (java.lang.Exception e) {
  316.             e.printStackTrace();
  317.         }

  319.         return null;
  320.     }

  322.     @Override public org.drip.learning.rxtor1.EmpiricalPenaltySupremum supremumEmpiricalRisk (
  323.         final org.drip.measure.continuous.RdR1 distRdR1,
  324.         final org.drip.spaces.instance.GeneralizedValidatedVector gvviX,
  325.         final org.drip.spaces.instance.GeneralizedValidatedVector gvviY)
  326.     {
  327.         try {
  328.             return new org.drip.learning.rxtor1.EmpiricalPenaltySupremumEstimator
  329.                 (org.drip.learning.rxtor1.EmpiricalPenaltySupremumEstimator.SUPREMUM_PENALTY_EMPIRICAL_RISK,
  330.                     this, gvviY, null, distRdR1).supremum (gvviX);
  331.         } catch (java.lang.Exception e) {
  332.             e.printStackTrace();
  333.         }

  335.         return null;
  336.     }

  338.     @Override public double structuralRisk (
  339.         final org.drip.measure.continuous.R1R1 distR1R1,
  340.         final org.drip.function.definition.R1ToR1 funcLearnerR1ToR1,
  341.         final org.drip.spaces.instance.GeneralizedValidatedVector gvviX,
  342.         final org.drip.spaces.instance.GeneralizedValidatedVector gvviY)
  343.         throws java.lang.Exception
  344.     {
  345.         if (null == distR1R1 || null == gvviX || null == gvviY || !(gvviX instanceof
  346.             org.drip.spaces.instance.ValidatedR1) || !(gvviY instanceof
  347.                 org.drip.spaces.instance.ValidatedR1) && !(_funcClassRxToR1 instanceof
  348.                     org.drip.spaces.functionclass.NormedR1ToNormedR1Finite))
  349.             throw new java.lang.Exception ("GeneralizedLearner::structuralRisk => Invalid Inputs");

  351.         org.drip.function.definition.R1ToR1 funcRegularizerR1ToR1 = _regularizerFunc.r1Tor1();

  353.         if (null == funcRegularizerR1ToR1)
  354.             throw new java.lang.Exception ("GeneralizedLearner::structuralRisk => Invalid Inputs");

  356.         org.drip.spaces.functionclass.NormedR1ToNormedR1Finite finiteClassR1ToR1 =
  357.             (org.drip.spaces.functionclass.NormedR1ToNormedR1Finite) _funcClassRxToR1;

  359.         org.drip.spaces.metric.GeneralizedMetricVectorSpace gmvsInput =
  360.             finiteClassR1ToR1.inputMetricVectorSpace();

  362.         if (gmvsInput instanceof org.drip.spaces.metric.R1Normed)
  363.             throw new java.lang.Exception ("GeneralizedLearner::structuralRisk => Invalid Inputs");

  365.         org.drip.spaces.metric.GeneralizedMetricVectorSpace gmvsOutput =
  366.             finiteClassR1ToR1.outputMetricVectorSpace();

  368.         if (gmvsOutput instanceof org.drip.spaces.metric.R1Continuous)
  369.             throw new java.lang.Exception ("GeneralizedLearner::structuralRisk => Invalid Inputs");

  371.         org.drip.learning.regularization.RegularizerR1ToR1 regularizerR1ToR1 =
  372.             org.drip.learning.regularization.RegularizerBuilder.ToR1Continuous (funcRegularizerR1ToR1,
  373.                 (org.drip.spaces.metric.R1Normed) gmvsInput, (org.drip.spaces.metric.R1Continuous)
  374.                     gmvsOutput, _regularizerFunc.lambda());

  376.         if (null == regularizerR1ToR1)
  377.             throw new java.lang.Exception ("GeneralizedLearner::structuralRisk => Invalid Inputs");

  379.         return regularizerR1ToR1.structuralRisk (distR1R1, funcLearnerR1ToR1,
  380.             ((org.drip.spaces.instance.ValidatedR1) gvviX).instance(),
  381.                 ((org.drip.spaces.instance.ValidatedR1) gvviY).instance());
  382.     }

  384.     @Override public double structuralRisk (
  385.         final org.drip.measure.continuous.RdR1 distRdR1,
  386.         final org.drip.function.definition.RdToR1 funcLearnerRdToR1,
  387.         final org.drip.spaces.instance.GeneralizedValidatedVector gvviX,
  388.         final org.drip.spaces.instance.GeneralizedValidatedVector gvviY)
  389.         throws java.lang.Exception
  390.     {
  391.         if (null == distRdR1 || null == gvviX || null == gvviY || !(gvviX instanceof
  392.             org.drip.spaces.instance.ValidatedRd) || !(gvviY instanceof
  393.                 org.drip.spaces.instance.ValidatedR1) && !(_funcClassRxToR1 instanceof
  394.                     org.drip.spaces.functionclass.NormedR1ToNormedR1Finite))
  395.             throw new java.lang.Exception ("GeneralizedLearner::structuralRisk => Invalid Inputs");

  397.         org.drip.function.definition.RdToR1 funcRegularizerRdToR1 = _regularizerFunc.rdTor1();

  399.         if (null == funcRegularizerRdToR1)
  400.             throw new java.lang.Exception ("GeneralizedLearner::structuralRisk => Invalid Inputs");

  402.         org.drip.spaces.functionclass.NormedRdToNormedR1Finite finiteClassRdToR1 =
  403.             (org.drip.spaces.functionclass.NormedRdToNormedR1Finite) _funcClassRxToR1;

  405.         org.drip.spaces.metric.GeneralizedMetricVectorSpace gmvsInput =
  406.             finiteClassRdToR1.inputMetricVectorSpace();

  408.         if (gmvsInput instanceof org.drip.spaces.metric.RdNormed)
  409.             throw new java.lang.Exception ("GeneralizedLearner::structuralRisk => Invalid Inputs");

  411.         org.drip.spaces.metric.GeneralizedMetricVectorSpace gmvsOutput =
  412.             finiteClassRdToR1.outputMetricVectorSpace();

  414.         if (gmvsOutput instanceof org.drip.spaces.metric.R1Continuous)
  415.             throw new java.lang.Exception ("GeneralizedLearner::structuralRisk => Invalid Inputs");

  417.         org.drip.learning.regularization.RegularizerRdToR1 regularizerRdToR1 =
  418.             org.drip.learning.regularization.RegularizerBuilder.ToRdContinuous (funcRegularizerRdToR1,
  419.                 (org.drip.spaces.metric.RdNormed) gmvsInput, (org.drip.spaces.metric.R1Continuous)
  420.                     gmvsOutput, _regularizerFunc.lambda());

  422.         if (null == regularizerRdToR1)
  423.             throw new java.lang.Exception ("GeneralizedLearner::structuralRisk => Invalid Inputs");

  425.         return regularizerRdToR1.structuralRisk (distRdR1, funcLearnerRdToR1,
  426.             ((org.drip.spaces.instance.ValidatedRd) gvviX).instance(),
  427.                 ((org.drip.spaces.instance.ValidatedR1) gvviY).instance());
  428.     }

  430.     @Override public org.drip.learning.rxtor1.EmpiricalPenaltySupremum supremumStructuralRisk (
  431.         final org.drip.measure.continuous.R1R1 distR1R1,
  432.         final org.drip.spaces.instance.GeneralizedValidatedVector gvviX,
  433.         final org.drip.spaces.instance.GeneralizedValidatedVector gvviY)
  434.     {
  435.         try {
  436.             return new org.drip.learning.rxtor1.EmpiricalPenaltySupremumEstimator
  437.                 (org.drip.learning.rxtor1.EmpiricalPenaltySupremumEstimator.SUPREMUM_PENALTY_STRUCTURAL_RISK,
  438.                     this, gvviY, distR1R1, null).supremum (gvviX);
  439.         } catch (java.lang.Exception e) {
  440.             e.printStackTrace();
  441.         }

  443.         return null;
  444.     }

  446.     @Override public org.drip.learning.rxtor1.EmpiricalPenaltySupremum supremumStructuralRisk (
  447.         final org.drip.measure.continuous.RdR1 distRdR1,
  448.         final org.drip.spaces.instance.GeneralizedValidatedVector gvviX,
  449.         final org.drip.spaces.instance.GeneralizedValidatedVector gvviY)
  450.     {
  451.         try {
  452.             return new org.drip.learning.rxtor1.EmpiricalPenaltySupremumEstimator
  453.                 (org.drip.learning.rxtor1.EmpiricalPenaltySupremumEstimator.SUPREMUM_PENALTY_STRUCTURAL_RISK,
  454.                     this, gvviY, null, distRdR1).supremum (gvviX);
  455.         } catch (java.lang.Exception e) {
  456.             e.printStackTrace();
  457.         }

  459.         return null;
  460.     }

  462.     @Override public double regularizedRisk (
  463.         final org.drip.measure.continuous.R1R1 distR1R1,
  464.         final org.drip.function.definition.R1ToR1 funcLearnerR1ToR1,
  465.         final org.drip.spaces.instance.GeneralizedValidatedVector gvviX,
  466.         final org.drip.spaces.instance.GeneralizedValidatedVector gvviY)
  467.         throws java.lang.Exception
  468.     {
  469.         return empiricalRisk (distR1R1, funcLearnerR1ToR1, gvviX, gvviY) + structuralRisk (distR1R1,
  470.             funcLearnerR1ToR1, gvviX, gvviY);
  471.     }

  473.     @Override public double regularizedRisk (
  474.         final org.drip.measure.continuous.RdR1 distRdR1,
  475.         final org.drip.function.definition.RdToR1 funcLearnerRdToR1,
  476.         final org.drip.spaces.instance.GeneralizedValidatedVector gvviX,
  477.         final org.drip.spaces.instance.GeneralizedValidatedVector gvviY)
  478.         throws java.lang.Exception
  479.     {
  480.         return empiricalRisk (distRdR1, funcLearnerRdToR1, gvviX, gvviY) + structuralRisk (distRdR1,
  481.             funcLearnerRdToR1, gvviX, gvviY);
  482.     }

  484.     @Override public org.drip.learning.rxtor1.EmpiricalPenaltySupremum supremumRegularizedRisk (
  485.         final org.drip.measure.continuous.R1R1 distR1R1,
  486.         final org.drip.spaces.instance.GeneralizedValidatedVector gvviX,
  487.         final org.drip.spaces.instance.GeneralizedValidatedVector gvviY)
  488.     {
  489.         try {
  490.             return new org.drip.learning.rxtor1.EmpiricalPenaltySupremumEstimator
  491.                 (org.drip.learning.rxtor1.EmpiricalPenaltySupremumEstimator.SUPREMUM_PENALTY_REGULARIZED_RISK,
  492.                 this, gvviY, distR1R1, null).supremum (gvviX);
  493.         } catch (java.lang.Exception e) {
  494.             e.printStackTrace();
  495.         }

  497.         return null;
  498.     }

  500.     @Override public org.drip.learning.rxtor1.EmpiricalPenaltySupremum supremumRegularizedRisk (
  501.         final org.drip.measure.continuous.RdR1 distRdR1,
  502.         final org.drip.spaces.instance.GeneralizedValidatedVector gvviX,
  503.         final org.drip.spaces.instance.GeneralizedValidatedVector gvviY)
  504.     {
  505.         try {
  506.             return new org.drip.learning.rxtor1.EmpiricalPenaltySupremumEstimator
  507.                 (org.drip.learning.rxtor1.EmpiricalPenaltySupremumEstimator.SUPREMUM_PENALTY_REGULARIZED_RISK,
  508.                 this, gvviY, null, distRdR1).supremum (gvviX);
  509.         } catch (java.lang.Exception e) {
  510.             e.printStackTrace();
  511.         }

  513.         return null;
  514.     }

  516.     /**
  517.      * Retrieve the Covering Number based Deviation Upper Probability Bound Generator
  518.      * 
  519.      * @return The Covering Number based Deviation Upper Probability Bound Generator
  520.      */

  522.     public org.drip.learning.bound.CoveringNumberLossBound coveringLossBoundEvaluator()
  523.     {
  524.         return _funcClassCNLB;
  525.     }

  527.     /**
  528.      * Compute the Upper Bound of the Probability of the Absolute Deviation of the Empirical Mean from the
  529.      *  Population Mean using the Function Class Supremum Covering Number for General-Purpose Learning
  530.      * 
  531.      * @param iSampleSize The Sample Size
  532.      * @param dblEpsilon The Deviation of the Empirical Mean from the Population Mean
  533.      * @param bSupremum TRUE To Use the Supremum Metric in place of the Built-in Metric
  534.      * 
  535.      * @return The Upper Bound of the Probability of the Absolute Deviation of the Empirical Mean from the
  536.      *  Population Mean using the Function Class Supremum Covering Number for General-Purpose Learning
  537.      * 
  538.      * @throws java.lang.Exception Thrown if the Upper Probability Bound cannot be computed
  539.      */

  541.     public double genericCoveringProbabilityBound (
  542.         final int iSampleSize,
  543.         final double dblEpsilon,
  544.         final boolean bSupremum)
  545.         throws java.lang.Exception
  546.     {
  547.         return _funcClassCNLB.deviationProbabilityUpperBound (iSampleSize, dblEpsilon) * (bSupremum ?
  548.             _funcClassRxToR1.populationSupremumCoveringNumber (dblEpsilon) :
  549.                 _funcClassRxToR1.populationCoveringNumber (dblEpsilon));
  550.     }

  552.     /**
  553.      * Compute the Minimum Possible Sample Size needed to generate the required Upper Probability Bound for
  554.      *  the Specified Empirical Deviation using the Covering Number Convergence Bounds.
  555.      *  
  556.      * @param dblEpsilon The Deviation of the Empirical Mean from the Population Mean
  557.      * @param dblDeviationUpperProbabilityBound The Upper Bound of the Probability for the given Deviation
  558.      * @param bSupremum TRUE To Use the Supremum Metric in place of the Built-in Metric
  559.      * 
  560.      * @return The Minimum Possible Sample Size
  561.      * 
  562.      * @throws java.lang.Exception Thrown if the Minimum Sample Size cannot be computed
  563.      */

  565.     public double genericCoveringSampleSize (
  566.         final double dblEpsilon,
  567.         final double dblDeviationUpperProbabilityBound,
  568.         final boolean bSupremum)
  569.         throws java.lang.Exception
  570.     {
  571.         if (!org.drip.numerical.common.NumberUtil.IsValid (dblEpsilon) ||
  572.             !org.drip.numerical.common.NumberUtil.IsValid (dblDeviationUpperProbabilityBound))
  573.             throw new java.lang.Exception
  574.                 ("GeneralizedLearner::genericCoveringSampleSize => Invalid Inputs");

  576.         org.drip.function.definition.R1ToR1 funcDeviationUpperProbabilityBound = new
  577.             org.drip.function.definition.R1ToR1 (null) {
  578.             @Override public double evaluate (
  579.                 final double dblSampleSize)
  580.                 throws java.lang.Exception
  581.             {
  582.                 return genericCoveringProbabilityBound ((int) dblSampleSize, dblEpsilon, bSupremum);
  583.             }
  584.         };

  586.         org.drip.function.r1tor1solver.FixedPointFinderOutput fpfo = new
  587.             org.drip.function.r1tor1solver.FixedPointFinderZheng (dblDeviationUpperProbabilityBound,
  588.                 funcDeviationUpperProbabilityBound, false).findRoot();

  590.         if (null == fpfo || !fpfo.containsRoot())
  591.             throw new java.lang.Exception
  592.                 ("GeneralizedLearner::genericCoveringSampleSize => Cannot Estimate Minimal Sample Size");

  594.         return fpfo.getRoot();
  595.     }

  597.     /**
  598.      * Compute the Sample/Data Dependent Upper Bound of the Probability of the Absolute Deviation between
  599.      *  the Empirical and the Population Means using the Function Class Supremum Covering Number for
  600.      *  General-Purpose Learning
  601.      * 
  602.      * @param gvvi The Validated Instance Vector Sequence
  603.      * @param iSampleSize The Sample Size
  604.      * @param dblEpsilon The Deviation of the Empirical Mean from the Population Mean
  605.      * @param bSupremum TRUE To Use the Supremum Metric in place of the Built-in Metric
  606.      * 
  607.      * @return The Sample/Data Dependent Upper Bound of the Probability of the Absolute Deviation between
  608.      *  the Empirical and the Population Means using the Function Class Supremum Covering Number for
  609.      *  General-Purpose Learning
  610.      * 
  611.      * @throws java.lang.Exception Thrown if the Upper Probability Bound cannot be computed
  612.      */

  614.     public double genericCoveringProbabilityBound (
  615.         final org.drip.spaces.instance.GeneralizedValidatedVector gvvi,
  616.         final int iSampleSize,
  617.         final double dblEpsilon,
  618.         final boolean bSupremum)
  619.         throws java.lang.Exception
  620.     {
  621.         return _funcClassCNLB.deviationProbabilityUpperBound (iSampleSize, dblEpsilon) *
  622.             lossSampleCoveringNumber (gvvi, dblEpsilon, bSupremum);
  623.     }

  625.     /**
  626.      * Compute the Minimum Possible Sample Size needed to generate the required Upper Probability Bound for
  627.      *  the Specified Empirical Deviation using the Covering Number Convergence Bounds.
  628.      *  
  629.      * @param gvvi The Validated Instance Vector Sequence
  630.      * @param dblEpsilon The Deviation of the Empirical Mean from the Population Mean
  631.      * @param dblDeviationUpperProbabilityBound The Upper Bound of the Probability for the given Deviation
  632.      * @param bSupremum TRUE To Use the Supremum Metric in place of the Built-in Metric
  633.      * 
  634.      * @return The Minimum Possible Sample Size
  635.      * 
  636.      * @throws java.lang.Exception Thrown if the Minimum Sample Size cannot be computed
  637.      */

  639.     public double genericCoveringSampleSize (
  640.         final org.drip.spaces.instance.GeneralizedValidatedVector gvvi,
  641.         final double dblEpsilon,
  642.         final double dblDeviationUpperProbabilityBound,
  643.         final boolean bSupremum)
  644.         throws java.lang.Exception
  645.     {
  646.         if (null == gvvi || !org.drip.numerical.common.NumberUtil.IsValid (dblEpsilon) ||
  647.             !org.drip.numerical.common.NumberUtil.IsValid (dblDeviationUpperProbabilityBound))
  648.             throw new java.lang.Exception
  649.                 ("GeneralizedLearner::genericCoveringSampleSize => Invalid Inputs");

  651.         org.drip.function.definition.R1ToR1 funcDeviationUpperProbabilityBound = new
  652.             org.drip.function.definition.R1ToR1 (null) {
  653.             @Override public double evaluate (
  654.                 final double dblSampleSize)
  655.                 throws java.lang.Exception
  656.             {
  657.                 return genericCoveringProbabilityBound (gvvi, (int) dblSampleSize, dblEpsilon, bSupremum);
  658.             }
  659.         };

  661.         org.drip.function.r1tor1solver.FixedPointFinderOutput fpfo = new
  662.             org.drip.function.r1tor1solver.FixedPointFinderZheng (dblDeviationUpperProbabilityBound,
  663.                 funcDeviationUpperProbabilityBound, false).findRoot();

  665.         if (null == fpfo || !fpfo.containsRoot())
  666.             throw new java.lang.Exception
  667.                 ("GeneralizedLearner::genericCoveringSampleSize => Cannot Estimate Minimal Sample Size");

  669.         return fpfo.getRoot();
  670.     }

  672.     /**
  673.      * Compute the Upper Bound of the Probability of the Absolute Deviation between the Empirical and the
  674.      *  Population Means using the Function Class Supremum Covering Number for Regression Learning
  675.      * 
  676.      * @param iSampleSize The Sample Size
  677.      * @param dblEpsilon The Deviation of the Empirical Mean from the Population Mean
  678.      * @param bSupremum TRUE To Use the Supremum Metric in place of the Built-in Metric
  679.      * 
  680.      * @return The Upper Bound of the Probability of the Absolute Deviation between the Empirical and the
  681.      *  Population Means using the Function Class Supremum Covering Number for Regression Learning
  682.      * 
  683.      * @throws java.lang.Exception Thrown if the Upper Probability Bound cannot be computed
  684.      */

  686.     public double regressorCoveringProbabilityBound (
  687.         final int iSampleSize,
  688.         final double dblEpsilon,
  689.         final boolean bSupremum)
  690.         throws java.lang.Exception
  691.     {
  692.         if (!org.drip.numerical.common.NumberUtil.IsValid (dblEpsilon) || 0. >= dblEpsilon || iSampleSize < (2. /
  693.             (dblEpsilon * dblEpsilon)))
  694.             throw new java.lang.Exception
  695.                 ("GeneralizedLearner::regressorCoveringProbabilityBound => Invalid Inputs");

  697.         org.drip.function.definition.R1ToR1 funcSampleCoefficient = new
  698.             org.drip.function.definition.R1ToR1 (null) {
  699.             @Override public double evaluate (
  700.                 final double dblSampleSize)
  701.                 throws java.lang.Exception
  702.             {
  703.                 return 12. * dblSampleSize;
  704.             }
  705.         };

  707.         return (new org.drip.learning.bound.CoveringNumberLossBound (funcSampleCoefficient, 2.,
  708.             36.)).deviationProbabilityUpperBound (iSampleSize, dblEpsilon) * (bSupremum ?
  709.                 _funcClassRxToR1.populationSupremumCoveringNumber (dblEpsilon / 6.) :
  710.                     _funcClassRxToR1.populationCoveringNumber (dblEpsilon / 6.));
  711.     }

  713.     /**
  714.      * Compute the Minimum Possible Sample Size needed to generate the required Upper Probability Bound for
  715.      *  the Specified Empirical Deviation using the Covering Number Convergence Bounds for Regression
  716.      *  Learning.
  717.      *  
  718.      * @param dblEpsilon The Deviation of the Empirical Mean from the Population Mean
  719.      * @param dblDeviationUpperProbabilityBound The Upper Bound of the Probability for the given Deviation
  720.      * @param bSupremum TRUE To Use the Supremum Metric in place of the Built-in Metric
  721.      * 
  722.      * @return The Minimum Possible Sample Size
  723.      * 
  724.      * @throws java.lang.Exception Thrown if the Minimum Sample Size cannot be computed
  725.      */

  727.     public double regressorCoveringSampleSize (
  728.         final double dblEpsilon,
  729.         final double dblDeviationUpperProbabilityBound,
  730.         final boolean bSupremum)
  731.         throws java.lang.Exception
  732.     {
  733.         if (!org.drip.numerical.common.NumberUtil.IsValid (dblEpsilon) ||
  734.             !org.drip.numerical.common.NumberUtil.IsValid (dblDeviationUpperProbabilityBound))
  735.             throw new java.lang.Exception
  736.                 ("GeneralizedLearner::regressorCoveringSampleSize => Invalid Inputs");

  738.         org.drip.function.definition.R1ToR1 funcDeviationUpperProbabilityBound = new
  739.             org.drip.function.definition.R1ToR1 (null) {
  740.             @Override public double evaluate (
  741.                 final double dblSampleSize)
  742.                 throws java.lang.Exception
  743.             {
  744.                 return regressorCoveringProbabilityBound ((int) dblSampleSize, dblEpsilon, bSupremum);
  745.             }
  746.         };

  748.         org.drip.function.r1tor1solver.FixedPointFinderOutput fpfo = new
  749.             org.drip.function.r1tor1solver.FixedPointFinderZheng (dblDeviationUpperProbabilityBound,
  750.                 funcDeviationUpperProbabilityBound, false).findRoot();

  752.         if (null == fpfo || !fpfo.containsRoot())
  753.             throw new java.lang.Exception
  754.                 ("GeneralizedLearner::regressorCoveringSampleSize => Cannot Estimate Minimal Sample Size");

  756.         return fpfo.getRoot();
  757.     }

  759.     /**
  760.      * Compute the Sample/Data Dependent Upper Bound of the Probability of the Absolute Deviation between
  761.      *  the Empirical and the Population Means using the Function Class Supremum Covering Number for
  762.      *  Regression Learning
  763.      * 
  764.      * @param gvvi The Validated Instance Vector Sequence
  765.      * @param iSampleSize The Sample Size
  766.      * @param dblEpsilon The Deviation of the Empirical Mean from the Population Mean
  767.      * @param bSupremum TRUE To Use the Supremum Metric in place of the Built-in Metric
  768.      * 
  769.      * @return The Sample/Data Dependent Upper Bound of the Probability of the Absolute Deviation between
  770.      *  the Empirical and the Population Means using the Function Class Supremum Covering Number for
  771.      *  Regression Learning
  772.      * 
  773.      * @throws java.lang.Exception Thrown if the Upper Probability Bound cannot be computed
  774.      */

  776.     public double regressorCoveringProbabilityBound (
  777.         final org.drip.spaces.instance.GeneralizedValidatedVector gvvi,
  778.         final int iSampleSize,
  779.         final double dblEpsilon,
  780.         final boolean bSupremum)
  781.         throws java.lang.Exception
  782.     {
  783.         if (!org.drip.numerical.common.NumberUtil.IsValid (dblEpsilon) || 0. >= dblEpsilon || iSampleSize < (2. /
  784.             (dblEpsilon * dblEpsilon)))
  785.             throw new java.lang.Exception
  786.                 ("GeneralizedLearner::regressorCoveringProbabilityBound => Invalid Inputs");

  788.         org.drip.function.definition.R1ToR1 funcSampleCoefficient = new
  789.             org.drip.function.definition.R1ToR1 (null) {
  790.             @Override public double evaluate (
  791.                 final double dblSampleSize)
  792.                 throws java.lang.Exception
  793.             {
  794.                 return 12. * dblSampleSize;
  795.             }
  796.         };

  798.         return (new org.drip.learning.bound.CoveringNumberLossBound (funcSampleCoefficient, 2.,
  799.             36.)).deviationProbabilityUpperBound (iSampleSize, dblEpsilon) * lossSampleCoveringNumber (gvvi,
  800.                 dblEpsilon / 6., bSupremum);
  801.     }

  803.     /**
  804.      * Compute the Minimum Possible Sample Size needed to generate the required Upper Probability Bound for
  805.      *  the Specified Empirical Deviation using the Covering Number Convergence Bounds for Regression
  806.      *  Learning.
  807.      *  
  808.      * @param gvvi The Validated Instance Vector Sequence
  809.      * @param dblEpsilon The Deviation of the Empirical Mean from the Population Mean
  810.      * @param dblDeviationUpperProbabilityBound The Upper Bound of the Probability for the given Deviation
  811.      * @param bSupremum TRUE To Use the Supremum Metric in place of the Built-in Metric
  812.      * 
  813.      * @return The Minimum Possible Sample Size
  814.      * 
  815.      * @throws java.lang.Exception Thrown if the Minimum Sample Size cannot be computed
  816.      */

  818.     public double regressorCoveringSampleSize (
  819.         final org.drip.spaces.instance.GeneralizedValidatedVector gvvi,
  820.         final double dblEpsilon,
  821.         final double dblDeviationUpperProbabilityBound,
  822.         final boolean bSupremum)
  823.         throws java.lang.Exception
  824.     {
  825.         if (null == gvvi || !org.drip.numerical.common.NumberUtil.IsValid (dblEpsilon) ||
  826.             !org.drip.numerical.common.NumberUtil.IsValid (dblDeviationUpperProbabilityBound))
  827.             throw new java.lang.Exception
  828.                 ("GeneralizedLearner::regressorCoveringSampleSize => Invalid Inputs");

  830.         org.drip.function.definition.R1ToR1 funcDeviationUpperProbabilityBound = new
  831.             org.drip.function.definition.R1ToR1 (null) {
  832.             @Override public double evaluate (
  833.                 final double dblSampleSize)
  834.                 throws java.lang.Exception
  835.             {
  836.                 return regressorCoveringProbabilityBound (gvvi, (int) dblSampleSize, dblEpsilon, bSupremum);
  837.             }
  838.         };

  840.         org.drip.function.r1tor1solver.FixedPointFinderOutput fpfo = new
  841.             org.drip.function.r1tor1solver.FixedPointFinderZheng (dblDeviationUpperProbabilityBound,
  842.                 funcDeviationUpperProbabilityBound, false).findRoot();

  844.         if (null == fpfo || !fpfo.containsRoot())
  845.             throw new java.lang.Exception
  846.                 ("GeneralizedLearner::regressorCoveringSampleSize => Cannot Estimate Minimal Sample Size");

  848.         return fpfo.getRoot();
  849.     }
  850. }
Created with JaCoCo 0.7.9.201702052155