PLearn 0.1
Public Member Functions | Static Public Member Functions | Public Attributes | Static Public Attributes | Static Protected Member Functions | Protected Attributes | Private Types | Private Member Functions
PLearn::ClassifierFromConditionalPDistribution Class Reference

Classifier that takes a ConditionalPDistribution and classifies with it, by finding the target class y that maximizes p(y|x), where x is the input. More...

#include <ClassifierFromConditionalPDistribution.h>

Inheritance diagram for PLearn::ClassifierFromConditionalPDistribution:
Inheritance graph
[legend]
Collaboration diagram for PLearn::ClassifierFromConditionalPDistribution:
Collaboration graph
[legend]

List of all members.

Public Member Functions

 ClassifierFromConditionalPDistribution ()
 Default constructor.
virtual void build ()
 Simply calls inherited::build() then build_()
virtual void makeDeepCopyFromShallowCopy (CopiesMap &copies)
 Transforms a shallow copy into a deep copy.
virtual string classname () const
virtual OptionListgetOptionList () const
virtual OptionMapgetOptionMap () const
virtual RemoteMethodMapgetRemoteMethodMap () const
virtual
ClassifierFromConditionalPDistribution
deepCopy (CopiesMap &copies) const
virtual int outputsize () const
 returns the size of this learner's output, (which typically may depend on its inputsize(), targetsize() and set options)
virtual void forget ()
 (Re-)initializes the PLearner in its fresh state (that state may depend on the 'seed' option) And sets 'stage' back to 0 (this is the stage of a fresh learner!)
virtual void train ()
 The role of the train method is to bring the learner up to stage==nstages, updating the train_stats collector with training costs measured on-line in the process.
virtual void computeOutput (const Vec &input, Vec &output) const
 Computes the output from the input.
virtual void computeCostsFromOutputs (const Vec &input, const Vec &output, const Vec &target, Vec &costs) const
 Computes the costs from already computed output.
virtual TVec< string > getTestCostNames () const
 Returns the names of the costs computed by computeCostsFromOutpus (and thus the test method)
virtual TVec< string > getTrainCostNames () const
 Returns the names of the objective costs that the train method computes and for which it updates the VecStatsCollector train_stats.

Static Public Member Functions

static string _classname_ ()
static OptionList_getOptionList_ ()
static RemoteMethodMap_getRemoteMethodMap_ ()
static Object_new_instance_for_typemap_ ()
static bool _isa_ (const Object *o)
static void _static_initialize_ ()
static const PPathdeclaringFile ()

Public Attributes

int nclasses
 Number of classes (doesn't need to be specified if train_set has a Dictionary for the target column.
PP< PDistributionpcd
 ConditionalPDistribution, that will be trained if this learner is trained.
string output_type
 Output type (choose among: "predicted_class", "class_probabilities" or "class_log-probabilities")

Static Public Attributes

static StaticInitializer _static_initializer_

Static Protected Member Functions

static void declareOptions (OptionList &ol)
 Declares this class' options.

Protected Attributes

Vec target_values
Vec pcd_input
Vec pcd_output

Private Types

typedef PLearner inherited

Private Member Functions

void build_ ()
 This does the actual building.

Detailed Description

Classifier that takes a ConditionalPDistribution and classifies with it, by finding the target class y that maximizes p(y|x), where x is the input.

Definition at line 52 of file ClassifierFromConditionalPDistribution.h.


Member Typedef Documentation

Reimplemented from PLearn::PLearner.

Definition at line 57 of file ClassifierFromConditionalPDistribution.h.


Constructor & Destructor Documentation

PLearn::ClassifierFromConditionalPDistribution::ClassifierFromConditionalPDistribution ( )

Default constructor.

Definition at line 47 of file ClassifierFromConditionalPDistribution.cc.

    : nclasses(-1),
      output_type("predicted_class")
{}

Member Function Documentation

string PLearn::ClassifierFromConditionalPDistribution::_classname_ ( ) [static]

Reimplemented from PLearn::PLearner.

Definition at line 56 of file ClassifierFromConditionalPDistribution.cc.

OptionList & PLearn::ClassifierFromConditionalPDistribution::_getOptionList_ ( ) [static]

Reimplemented from PLearn::PLearner.

Definition at line 56 of file ClassifierFromConditionalPDistribution.cc.

RemoteMethodMap & PLearn::ClassifierFromConditionalPDistribution::_getRemoteMethodMap_ ( ) [static]

Reimplemented from PLearn::PLearner.

Definition at line 56 of file ClassifierFromConditionalPDistribution.cc.

bool PLearn::ClassifierFromConditionalPDistribution::_isa_ ( const Object o) [static]

Reimplemented from PLearn::PLearner.

Definition at line 56 of file ClassifierFromConditionalPDistribution.cc.

Object * PLearn::ClassifierFromConditionalPDistribution::_new_instance_for_typemap_ ( ) [static]

Reimplemented from PLearn::Object.

Definition at line 56 of file ClassifierFromConditionalPDistribution.cc.

StaticInitializer ClassifierFromConditionalPDistribution::_static_initializer_ & PLearn::ClassifierFromConditionalPDistribution::_static_initialize_ ( ) [static]

Reimplemented from PLearn::PLearner.

Definition at line 56 of file ClassifierFromConditionalPDistribution.cc.

void PLearn::ClassifierFromConditionalPDistribution::build ( ) [virtual]

Simply calls inherited::build() then build_()

Reimplemented from PLearn::PLearner.

Definition at line 86 of file ClassifierFromConditionalPDistribution.cc.

References PLearn::PLearner::build(), and build_().

Here is the call graph for this function:

void PLearn::ClassifierFromConditionalPDistribution::build_ ( ) [private]

This does the actual building.

Reimplemented from PLearn::PLearner.

Definition at line 95 of file ClassifierFromConditionalPDistribution.cc.

References PLearn::PLearner::inputsize(), nclasses, output_type, pcd, pcd_input, pcd_output, PLERROR, PLearn::TVec< T >::resize(), and PLearn::PLearner::train_set.

Referenced by build().

{
    if(pcd && train_set)
    {
        PP<Dictionary> target_dict = train_set->getDictionary(inputsize());
        if(!target_dict && nclasses <= 0) PLERROR("In ClassifierFromConditionalPDistribution::build_(): There is not way to know what are the possible targets (nclasses <= 0 and no Dictionary for target field)");
        if(target_dict) nclasses = -1;
        if(output_type == "predicted_class" || output_type == "class_log-probabilities") pcd->outputs_def = "l";
        else if (output_type == "class_probabilities") pcd->outputs_def = "d";
        else PLERROR("ClassifierFromConditionalPDistribution::build_(): output_type %s is not supported", output_type.c_str());

        pcd_input.resize(train_set->inputsize() + train_set->targetsize());
        pcd_output.resize(1);
    }

}

Here is the call graph for this function:

Here is the caller graph for this function:

string PLearn::ClassifierFromConditionalPDistribution::classname ( ) const [virtual]

Reimplemented from PLearn::Object.

Definition at line 56 of file ClassifierFromConditionalPDistribution.cc.

void PLearn::ClassifierFromConditionalPDistribution::computeCostsFromOutputs ( const Vec input,
const Vec output,
const Vec target,
Vec costs 
) const [virtual]

Computes the costs from already computed output.

Implements PLearn::PLearner.

Definition at line 216 of file ClassifierFromConditionalPDistribution.cc.

References PLearn::argmax(), c, PLearn::TVec< T >::find(), PLearn::PLearner::inputsize(), nclasses, output_type, PLearn::safeflog(), target_values, and PLearn::PLearner::train_set.

{
    if(output_type == "predicted_class")
    {
        costs[0] = (int) (target[0] != output[0]);
    }
    else
    {
        int c;
        if(nclasses <= 0)
        {
            train_set->getValues(input,inputsize(),target_values);
            c = target_values.find(target[0]);           
        }
        else
            c = (int)target[0];
        costs[0] = (int) (argmax(output) != c);
        if(output_type == "class_probabilities") costs[1] = safeflog(output[c]);
        else costs[1] = output[c];
    }
}                                

Here is the call graph for this function:

void PLearn::ClassifierFromConditionalPDistribution::computeOutput ( const Vec input,
Vec output 
) const [virtual]

Computes the output from the input.

Reimplemented from PLearn::PLearner.

Definition at line 178 of file ClassifierFromConditionalPDistribution.cc.

References PLearn::argmax(), c, i, PLearn::PLearner::inputsize(), PLearn::TVec< T >::length(), nclasses, output_type, pcd, pcd_input, pcd_output, PLearn::TVec< T >::resize(), PLearn::TVec< T >::subVec(), target_values, and PLearn::PLearner::train_set.

{    
    pcd_input.subVec(0,inputsize()) << input;
    if(nclasses <= 0)
    {   
        train_set->getValues(input, inputsize(),target_values);
        output.resize(target_values.length());
        for(int i=0; i<target_values.length(); i++)
        {
            pcd_input[inputsize()] = target_values[i];            
            pcd->computeOutput(pcd_input, pcd_output);
            output[i] = pcd_output[0];
        }
    }
    else
    {
        output.resize(nclasses);
        for(int c=0; c<nclasses; c++)
        {
            pcd_input[inputsize()] = c;
            pcd->computeOutput(pcd_input, pcd_output);
            output[c] = pcd_output[0];
        }     
    }

    if(output_type == "predicted_class") 
    {
        if(nclasses <= 0)
            output[0] = (int)target_values[argmax(output)];
        else
            output[0] = argmax(output);
        output.resize(1);
    }
}

Here is the call graph for this function:

void PLearn::ClassifierFromConditionalPDistribution::declareOptions ( OptionList ol) [static, protected]

Declares this class' options.

Reimplemented from PLearn::PLearner.

Definition at line 61 of file ClassifierFromConditionalPDistribution.cc.

References PLearn::OptionBase::buildoption, PLearn::declareOption(), PLearn::PLearner::declareOptions(), nclasses, output_type, and pcd.

{

    // Build options.

    declareOption(ol, "nclasses", &ClassifierFromConditionalPDistribution::nclasses, OptionBase::buildoption,
                  "The number of classes");

    declareOption(ol, "conditional_distribution", &ClassifierFromConditionalPDistribution::pcd, OptionBase::buildoption,
                  "ConditionalPDistribution that computes p(y|x) for all possible classes y.");

    declareOption(ol, "output_type", &ClassifierFromConditionalPDistribution::output_type, OptionBase::buildoption,
                  "Output type. Choose among: \n"
                  "- \"predicted_class\"\n"
                  "- \"class_probabilities\"\n"
                  "- \"class_log-probabilities\")\n"
                  "Note that this may change the value of output_defs of the conditional_distribution.");
 
    // Now call the parent class' declareOptions
    inherited::declareOptions(ol);
}

Here is the call graph for this function:

static const PPath& PLearn::ClassifierFromConditionalPDistribution::declaringFile ( ) [inline, static]

Reimplemented from PLearn::PLearner.

Definition at line 115 of file ClassifierFromConditionalPDistribution.h.

ClassifierFromConditionalPDistribution * PLearn::ClassifierFromConditionalPDistribution::deepCopy ( CopiesMap copies) const [virtual]

Reimplemented from PLearn::PLearner.

Definition at line 56 of file ClassifierFromConditionalPDistribution.cc.

void PLearn::ClassifierFromConditionalPDistribution::forget ( ) [virtual]

(Re-)initializes the PLearner in its fresh state (that state may depend on the 'seed' option) And sets 'stage' back to 0 (this is the stage of a fresh learner!)

Reimplemented from PLearn::PLearner.

Definition at line 139 of file ClassifierFromConditionalPDistribution.cc.

References pcd, and PLearn::PLearner::stage.

Referenced by train().

{
    stage=0;
    pcd->forget();
}

Here is the caller graph for this function:

OptionList & PLearn::ClassifierFromConditionalPDistribution::getOptionList ( ) const [virtual]

Reimplemented from PLearn::Object.

Definition at line 56 of file ClassifierFromConditionalPDistribution.cc.

OptionMap & PLearn::ClassifierFromConditionalPDistribution::getOptionMap ( ) const [virtual]

Reimplemented from PLearn::Object.

Definition at line 56 of file ClassifierFromConditionalPDistribution.cc.

RemoteMethodMap & PLearn::ClassifierFromConditionalPDistribution::getRemoteMethodMap ( ) const [virtual]

Reimplemented from PLearn::Object.

Definition at line 56 of file ClassifierFromConditionalPDistribution.cc.

TVec< string > PLearn::ClassifierFromConditionalPDistribution::getTestCostNames ( ) const [virtual]

Returns the names of the costs computed by computeCostsFromOutpus (and thus the test method)

Implements PLearn::PLearner.

Definition at line 242 of file ClassifierFromConditionalPDistribution.cc.

References output_type, and PLearn::TVec< T >::resize().

{
    TVec<string> cnames;    
    if(output_type == "predicted_class")
    {
        cnames.resize(1);
        cnames[0] = "class_error";
    }
    else
    {
        cnames.resize(2);
        cnames[0] = "class_error";
        cnames[1] = "NLL";
    }
    return cnames;
}

Here is the call graph for this function:

TVec< string > PLearn::ClassifierFromConditionalPDistribution::getTrainCostNames ( ) const [virtual]

Returns the names of the objective costs that the train method computes and for which it updates the VecStatsCollector train_stats.

Implements PLearn::PLearner.

Definition at line 262 of file ClassifierFromConditionalPDistribution.cc.

{
    return TVec<string>();
}
void PLearn::ClassifierFromConditionalPDistribution::makeDeepCopyFromShallowCopy ( CopiesMap copies) [virtual]

Transforms a shallow copy into a deep copy.

Reimplemented from PLearn::PLearner.

Definition at line 115 of file ClassifierFromConditionalPDistribution.cc.

References PLearn::deepCopyField(), PLearn::PLearner::makeDeepCopyFromShallowCopy(), pcd, pcd_input, and target_values.

Here is the call graph for this function:

int PLearn::ClassifierFromConditionalPDistribution::outputsize ( ) const [virtual]

returns the size of this learner's output, (which typically may depend on its inputsize(), targetsize() and set options)

Implements PLearn::PLearner.

Definition at line 126 of file ClassifierFromConditionalPDistribution.cc.

References PLearn::PLearner::inputsize(), PLearn::TVec< T >::length(), nclasses, target_values, and PLearn::PLearner::train_set.

{
    if(nclasses > 0) return nclasses;
    else
    {
        train_set->getValues(0,inputsize(),target_values);
        return target_values.length();
    }
}

Here is the call graph for this function:

void PLearn::ClassifierFromConditionalPDistribution::train ( ) [virtual]

The role of the train method is to bring the learner up to stage==nstages, updating the train_stats collector with training costs measured on-line in the process.

Implements PLearn::PLearner.

Definition at line 148 of file ClassifierFromConditionalPDistribution.cc.

References PLearn::endl(), forget(), PLearn::PLearner::getExperimentDirectory(), PLearn::PLearner::inputsize(), PLearn::PLearner::nstages, pcd, PLERROR, PLearn::pout, PLearn::PLearner::stage, PLearn::PLearner::targetsize(), PLearn::PLearner::train_set, PLearn::PLearner::train_stats, PLearn::PLearner::verbosity, and PLearn::PLearner::weightsize().

{
    if(targetsize()!=1)
        PLERROR("In ClassifierFromConditionalPDistribution::train - Expecting a targetsize of 1, not %d !!",targetsize());

    if(nstages<stage) // asking to revert to a previous stage!
        forget();  // reset the learner to stage=0

    if(stage==0)
    {
        pcd->setExperimentDirectory(getExperimentDirectory() / "PCD");
        train_set->defineSizes(inputsize()+1,targetsize()-1,weightsize());
        pcd->setTrainingSet(train_set);
        PP<VecStatsCollector> train_stats = new VecStatsCollector();
        train_stats->setFieldNames(pcd->getTrainCostNames());
        pcd->setTrainStatsCollector(train_stats);
        pcd->nstages = nstages;
        if (verbosity >= 2)
        pout << ">>> Training ConditionalPDistribution" << endl;    
        pcd->train();
        if (verbosity >= 2)
        pout << ">>> Training is over" << endl;    
        train_set->defineSizes(inputsize(),targetsize(),weightsize());
    }
    stage = nstages; // trained!
}

Here is the call graph for this function:


Member Data Documentation

Reimplemented from PLearn::PLearner.

Definition at line 115 of file ClassifierFromConditionalPDistribution.h.

Number of classes (doesn't need to be specified if train_set has a Dictionary for the target column.

Definition at line 73 of file ClassifierFromConditionalPDistribution.h.

Referenced by build_(), computeCostsFromOutputs(), computeOutput(), declareOptions(), and outputsize().

Output type (choose among: "predicted_class", "class_probabilities" or "class_log-probabilities")

Definition at line 77 of file ClassifierFromConditionalPDistribution.h.

Referenced by build_(), computeCostsFromOutputs(), computeOutput(), declareOptions(), and getTestCostNames().

ConditionalPDistribution, that will be trained if this learner is trained.

Definition at line 75 of file ClassifierFromConditionalPDistribution.h.

Referenced by build_(), computeOutput(), declareOptions(), forget(), makeDeepCopyFromShallowCopy(), and train().

Definition at line 63 of file ClassifierFromConditionalPDistribution.h.

Referenced by build_(), and computeOutput().


The documentation for this class was generated from the following files:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines