distribution.h

Go to the documentation of this file.

/*

Copyright (c) 2003, Cornell University
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

   - Redistributions of source code must retain the above copyright notice,
       this list of conditions and the following disclaimer.
   - Redistributions in binary form must reproduce the above copyright
       notice, this list of conditions and the following disclaimer in the
       documentation and/or other materials provided with the distribution.
   - Neither the name of Cornell University nor the names of its
       contributors may be used to endorse or promote products derived from
       this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
THE POSSIBILITY OF SUCH DAMAGE.

*/

// -*- C++ -*-

#if !defined _CLUS_DISTRIBUTION_H_
#define _CLUS_DISTRIBUTION_H_

#include <string>
#include <iostream>
#include <math.h>

// The maximum dimentionality of the space
#define MAX_IN_DIM 1000

class Regressor;

namespace CLUS
{

/** Base class for all the continuous distributions that have sufficient statistics.
*/
class Distribution
{
protected:
    /// The dimentionality of the input space.
    int inDim;
    
    /// Used for optimization purpses. Is the last parameter passed to Infer or Learn
    
    const double* dataCache;
    
    /// Cached values for the last probabilities of belonging to the cluster
    double probabilityInfer, probabilityLearn;
    
    /// The weight in the sum of distributions
    double weight;

public:
    Distribution(int InDim=0):
            inDim(InDim), dataCache(NULL), probabilityInfer(0.0),
            probabilityLearn(0.0), weight(1.0)
    {}

    /// Creates a class that can do the regression for this distribution if given the input
    Regressor* CreateRegressor(void)
    {
        return 0;
    }

    /// Returns true if weitht=0. In this case the distribution should not be used
    bool HasZeroWeight(void)
    {
        return (weight==0.0);
    }

    /// Initializes the parameters of the distribution randomly
    void RandomCluster(void)
    {}

    /// Perform distribution dependent transformations on the data
    void NormalizeData(const double* DataCache, double* X)
    {
        // Just copy the content of DataCache into X
        for (int i=0; i<inDim; i++)
            X[i]=DataCache[i];
    }

    /// Reverse the normalization transformation in original space
    void DenormalizeParameters(Distribution* pD)
    {/* do nothing */
    }
    
    /// Probability that a point belongs to this distribution at inference, unnormalized
    double InferProbability(const double* DataCache)
    {
        return 0.0;
    }
    
    /// Probability that a point belongs to this distribution at learning, unnormalized
    double LearnProbability(const double* DataCache)
    {
        return 0.0;
    }
    
    /// Probability that a point belongs to this distribution (unnormalized). Same as learn probability
    double Probability(const double* DataCache)
    {
        return LearnProbability(DataCache);
    }
    
    /// Returns the last Inference probability
    double LastInferProbability(void)
    {
        return probabilityInfer;
    }
    
    /// Returns the last Learning probability
    double LastLearnProbability(void)
    {
        return probabilityLearn;
    }

    double LastProbability(void)
    {
        return probabilityLearn;
    }
    
    /// Normalizes the probability of belonging to this cluster, normalizing over the mixture
    /// Coef is sum alpha*P(x|distribution)
    double NormalizeInferProbability(double Coef, int nrClus=1)
    {
        if (Coef==0.0)
            return 1.0/nrClus;
        probabilityInfer/=Coef;
        return probabilityInfer;
    }
    
    /// Normalizes the probability of belonging to this cluster, normalizing over the mixture
    /// Coef is sum alpha*P(x|distribution)
    double NormalizeLearnProbability(double Coef, int nrClus=1)
    {
        if (Coef==0.0)
            return probabilityLearn = 1.0/nrClus; // this is used when the point is far from any of the clusters
        if (isinf(Coef))
            return probabilityLearn = 0.0;
        probabilityLearn/=Coef;
        return probabilityLearn;
    }
    
    /// Makes the simple normalization of the probability not more sophisticated version that can be later added
    double NormalizeProbability(double Coef, int nrClus=1)
    {
        return NormalizeLearnProbability(Coef,nrClus);
    }

    /// Prepares the distribution for learning
    void InitializeStatistics(void)
    { }
    
    /// Updates the sufficient statistics
    void UpdateStatistics(double prob)
    { }

    /// Computes the values of the new parameters from sufficient statistics
    double UpdateParameters(void)
    {
        return 0.0;
    }
    
    static string TypeName(void)
    {
        return string("Distribution");
    }
    
    bool SetOptionDbl(char* optName,double value)
    {
        if ( strcmp(optName,"weight") )
        {
            weight=value;
            return true;
        }
        return false;
    }
    
    /// Computes the output value for the distribution*probab
    void AdjustYwithYoverD(double& y)
    {}
    
    /// Random initialization of a distribution
    void RandomDistribution(int NrClusters)
    {}
    
    /// Saves the state of the Distribution in a stream
    void SaveToStream(ostream& out)
    {}
    
    /// Loads the state of the Distribution in a stream
    void LoadFromStream(istream& in)
    {}    

#ifdef CLUS_USE_XML
    /// Prints the distribution in XML in a stream
    void PrintToXmlStream(ostream& output)
    {
        output << "<Distribution";
        PrintAttribute(output, "weight", weight);
        output << "/>" << endl;
    }
#endif

};
}



#endif // _CLUS_DISTRIBUTION_H

---