|
PLearn 0.1
|
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>


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 OptionList & | getOptionList () const |
| virtual OptionMap & | getOptionMap () const |
| virtual RemoteMethodMap & | getRemoteMethodMap () 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 PPath & | declaringFile () |
Public Attributes | |
| int | nclasses |
| Number of classes (doesn't need to be specified if train_set has a Dictionary for the target column. | |
| PP< PDistribution > | pcd |
| 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. | |
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.
typedef PLearner PLearn::ClassifierFromConditionalPDistribution::inherited [private] |
Reimplemented from PLearn::PLearner.
Definition at line 57 of file ClassifierFromConditionalPDistribution.h.
| PLearn::ClassifierFromConditionalPDistribution::ClassifierFromConditionalPDistribution | ( | ) |
Default constructor.
Definition at line 47 of file ClassifierFromConditionalPDistribution.cc.
: nclasses(-1), output_type("predicted_class") {}
| 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.
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_().
{
inherited::build();
build_();
}

| 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);
}
}


| 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];
}
}

| 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);
}
}

| 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);
}

| 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().

| 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;
}

| 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.
{
inherited::makeDeepCopyFromShallowCopy(copies);
deepCopyField(pcd, copies);
deepCopyField(target_values, copies);
deepCopyField(pcd_input, copies);
}

| 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();
}
}

| 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!
}

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().
Vec PLearn::ClassifierFromConditionalPDistribution::pcd_input [mutable, protected] |
Definition at line 62 of file ClassifierFromConditionalPDistribution.h.
Referenced by build_(), computeOutput(), and makeDeepCopyFromShallowCopy().
Vec PLearn::ClassifierFromConditionalPDistribution::pcd_output [mutable, protected] |
Definition at line 63 of file ClassifierFromConditionalPDistribution.h.
Referenced by build_(), and computeOutput().
Vec PLearn::ClassifierFromConditionalPDistribution::target_values [mutable, protected] |
Definition at line 61 of file ClassifierFromConditionalPDistribution.h.
Referenced by computeCostsFromOutputs(), computeOutput(), makeDeepCopyFromShallowCopy(), and outputsize().
1.7.4