plqcom.PLQLoss
==============

.. py:module:: plqcom.PLQLoss

.. autoapi-nested-parse::

   PLQLoss: Piecewise Linear Quadratic Loss function, with Decomposition to ReLU-ReHU Composition Loss functions 

   ..
       !! processed by numpydoc !!


Classes
-------

.. autoapisummary::

   plqcom.PLQLoss.PLQLoss


Functions
---------

.. autoapisummary::

   plqcom.PLQLoss.max_to_plq
   plqcom.PLQLoss.points_to_plq
   plqcom.PLQLoss.merge_successive_intervals


Module Contents
---------------

.. py:class:: PLQLoss(quad_coef=None, form='plq', cutpoints=np.empty(shape=(0, )), points=np.empty(shape=(0, 2)))

   Bases: :py:obj:`object`


   
   PLQLoss is a class represents a continuous convex piecewise quandratic loss function, which adopts three types of
   input forms: 'plq', 'max' and 'points'.


   :Parameters:

       **quad_coef** : {dict-like} of {'a': [], 'b': [], 'c': []}
           The quandratic coefficients in pieces of the PLQLoss.
           The i-th piece Q is: a[i]* x**2 + b[i] * x + c[i]

       **form** : str, optional, default: 'plq'
           The form of the input PLQ function.
           
           'plq' for the PLQ form
               In this form, cutpoints must be given explicitly.
           
           'max' for the max form
               The max form is a special form of the PLQ function, which is the pointwise maximum of several linear or
               quadratic functions.
               The cutpoints are not necessary in this form, since they will be automatically calculated.
           
           'points' for the piecewise linear form based on given points
               The piecewise linear form is a special form of the PLQ function, which is the piecewise linear function.
               The function will connect the given points to form a piecewise linear loss.
               For the first piece and the last piece related to infinity, they will be the same as their adjacent piece.

       **cutpoints** : {array-like} of float, optional, default: None
           cutpoints of the PLQLoss, except -np.inf and np.inf
           
           if the form is 'max' or 'points', the cutpoints is not necessary
           
           if the form is 'plq', the cutpoints is necessary

       **points** : {array-like} of (x,y) pairs [(x1, y1), (x2, y2), ... (xn, yn)]
               or {dict-like} of {'x': [x1, x2, ..., xn], 'y': [y1, y2, ... yn]}
               or {2d-array-like} of [[x1, x2, ..., xn], [y1, y2, ... yn]]
               optional, default: None
           
           Points coordinates of the piecewise linear form of the PLQLoss. The PLQLoss will be constructed by straight
           lines between each two adjcent points according to their x coordinates. Two points with the same x coordinates
           will be rejected.
           
           if the form is 'points', the points is necessary
           
           if the form is 'max' or 'plq', the points is not necessary













   .. rubric:: Examples

   >>> import numpy as np
   >>> from plqcom import PLQLoss
   >>> cutpoints = [0., 1.]
   >>> quad_coef = {'a': np.array([0., .5, 0.]), 'b': np.array([-1, 0., 1]), 'c': np.array([0., 0., -.5])}
   >>> random_loss = PLQLoss(quad_coef, cutpoints=cutpoints)
   >>> x = np.arange(-2,2,.05)
   >>> random_loss(x)

   ..
       !! processed by numpydoc !!

   .. py:attribute:: cutpoints


   .. py:attribute:: min_val


   .. py:attribute:: min_knot


   .. py:method:: __call__(x)

      
      Evaluation of PLQLoss function.


      :Parameters:

          **x** : {array-like} of shape {n_samples}
              ..

          **Training vector, where `n_samples` is the number of samples.**
              ..



      :Returns:

          **y** : {array-like} of shape {n_samples}
              The values of the PLQLoss function on each x
              y[j] = quad_coef['a'][i]*x[j]**2 + quad_coef['b'][i]*x[j] + quad_coef['c'][i],
              if cutpoints[i] < x[j] < cutpoints[i+1]











      ..
          !! processed by numpydoc !!


.. py:function:: max_to_plq(quad_coef)

.. py:function:: points_to_plq(points)

.. py:function:: merge_successive_intervals(quad_coef, cutpoints)