KKMLL::FeatureEncoder Class Reference

#include <FeatureEncoder.h>

Public Member Functions
	FeatureEncoder ()
	FeatureEncoder (FileDescPtr _fileDesc, MLClassPtr _class1, MLClassPtr _class2, const FeatureNumList &_selectedFeatures, SVM_EncodingMethod _encodingMethod, double _c_Param)
	Constructs a Feature Encoder object. More...
	~FeatureEncoder ()
	Frees any memory allocated by, and owned by the FeatureEncoder. More...
MLClassPtr	Class1 () const
MLClassPtr	Class2 () const
kkint32	CodedNumOfFeatures () const
void	CompressExamples (FeatureVectorListPtr srcExamples, FeatureVectorListPtr compressedExamples, ClassAssignments &assignments)
	Left over from BitReduction days; removed all code except that which processed the NO bit reduction option. More...
FeatureVectorListPtr	CreateEncodedFeatureVector (FeatureVectorList &srcData)
FileDescPtr	CreateEncodedFileDesc (ostream *o)
XSpacePtr	EncodeAExample (FeatureVectorPtr example)
	Converts a single example into the svm_problem format. More...
void	EncodeAExample (FeatureVectorPtr example, svm_node *xSpace, kkint32 &xSpaceUsed)
	Converts a single example into the svm_problem format. More...
FeatureVectorPtr	EncodeAExample (FileDescPtr encodedFileDesc, FeatureVectorPtr src)
FeatureVectorListPtr	EncodeAllExamples (const FeatureVectorListPtr srcData)
void	EncodeIntoSparseMatrix (FeatureVectorListPtr src, ClassAssignments &assignments, XSpacePtr &xSpace, kkint32 &totalxSpaceUsed, struct svm_problem &prob, RunLog &log)
	Compresses 'src' examples, allocating new 'xSpace' data structure. More...
kkint32	MemoryConsumedEstimated () const
virtual void	ReadXML (XmlStream &s, XmlTagConstPtr tag, VolConstBool &cancelFlag, RunLog &log)
virtual void	WriteXML (const KKStr &varName, ostream &o) const
kkint32	XSpaceNeededPerExample ()

Detailed Description

Definition at line 44 of file FeatureEncoder.h.

Constructor & Destructor Documentation

FeatureEncoder::FeatureEncoder

(

)

Definition at line 31 of file FeatureEncoder.cpp.

References KKMLL::NoEncoding.

                               :
    cardinalityDest          (NULL),
    class1                   (NULL),
    class2                   (NULL),
    codedNumOfFeatures       (0),
    c_Param                  (1.0),
    destFeatureNums          (NULL),
    destFileDesc             (NULL),
    destWhatToDo             (NULL),
    encodingMethod           (SVM_EncodingMethod::NoEncoding),
    fileDesc                 (NULL),
    numEncodedFeatures       (0),
    numOfFeatures            (0),
    selectedFeatures         (),
    srcFeatureNums           (NULL),
    xSpaceNeededPerExample   (0)
{
}

FeatureEncoder::FeatureEncoder	(	FileDescPtr	_fileDesc,
		MLClassPtr	_class1,
		MLClassPtr	_class2,
		const FeatureNumList &	_selectedFeatures,
		SVM_EncodingMethod	_encodingMethod,
		double	_c_Param
	)

Constructs a Feature Encoder object.

Parameters

[in]	_fileDesc
[in]	_class1
[in]	_class2
[in]	_log	A log-file stream. All important events will be output to this stream

Definition at line 59 of file FeatureEncoder.cpp.

References KKMLL::Binary, KKMLL::Attribute::Cardinality(), KKB::KKStr::Concat(), KKMLL::FeAsIs, KKMLL::FeatureNumList::FeatureNumList(), KKMLL::FeBinary, KKMLL::FeScale, KKMLL::FileDesc::GetAAttribute(), KKMLL::Attribute::GetNominalValue(), KKMLL::Attribute::Name(), KKMLL::FileDesc::NewContinuousDataOnly(), KKMLL::NoEncoding, KKMLL::Nominal, KKMLL::FeatureNumList::NumOfFeatures(), KKB::KKStr::operator+(), KKMLL::FeatureNumList::operator[](), KKMLL::Scaled, KKMLL::Symbolic, and KKMLL::Attribute::Type().

Referenced by KKMLL::SVMModel::ReadXML().

                                :

    cardinalityDest          (NULL),
    class1                   (_class1),
    class2                   (_class2),
    codedNumOfFeatures       (0),
    c_Param                  (_c_Param),
    destFeatureNums          (NULL),
    destFileDesc             (NULL),
    destWhatToDo             (NULL),
    encodingMethod           (_encodingMethod),
    fileDesc                 (_fileDesc),
    numEncodedFeatures       (0),
    numOfFeatures            (0),
    selectedFeatures         (_selectedFeatures),
    srcFeatureNums           (NULL),
    xSpaceNeededPerExample   (0)
{
  numOfFeatures   = selectedFeatures.NumOfFeatures ();

  xSpaceNeededPerExample = 0;
  srcFeatureNums   = new kkint32[numOfFeatures];
  cardinalityDest  = new kkint32[numOfFeatures];
  destFeatureNums  = new kkint32[numOfFeatures];
  destWhatToDo     = new FeWhatToDo[numOfFeatures];

  VectorKKStr   destFieldNames;

  kkint32  x;

  for  (x = 0;  x < numOfFeatures;  x++)
  {
    kkint32  srcFeatureNum = selectedFeatures[x];
    srcFeatureNums  [x] = srcFeatureNum;
    destFeatureNums [x] = xSpaceNeededPerExample;
    cardinalityDest [x] = 1;
    destWhatToDo    [x] = FeWhatToDo::FeAsIs;

    const Attribute&  attribute = fileDesc->GetAAttribute (srcFeatureNum);
    AttributeType  attributeType = attribute.Type ();
    kkint32        cardinality   = attribute.Cardinality ();

    switch (encodingMethod)
    {
      case SVM_EncodingMethod::Binary:
        if  ((attributeType == AttributeType::Nominal)  ||  (attributeType == AttributeType::Symbolic))
        {
          destWhatToDo    [x] = FeWhatToDo::FeBinary;
          cardinalityDest [x] = cardinality;
          xSpaceNeededPerExample += cardinalityDest[x];
          numEncodedFeatures   += cardinalityDest[x];
          for  (kkint32 zed = 0;  zed < cardinalityDest[x];  zed++)
          {
            KKStr  fieldName = attribute.Name () + "_" + attribute.GetNominalValue (zed);
            destFieldNames.push_back (fieldName);
          }
        }
        else
        {
          xSpaceNeededPerExample++;
          numEncodedFeatures++;
          destWhatToDo [x] = FeWhatToDo::FeAsIs;
          destFieldNames.push_back (attribute.Name ());
        }
        break;


      case  SVM_EncodingMethod::Scaled:
        xSpaceNeededPerExample++;
        numEncodedFeatures++;
        if  ((attributeType == AttributeType::Nominal)  ||
             (attributeType == AttributeType::Symbolic)
            )
          destWhatToDo [x] = FeWhatToDo::FeScale;
        else
          destWhatToDo [x] = FeWhatToDo::FeAsIs;

        destFieldNames.push_back (attribute.Name ());
        break;


      case  SVM_EncodingMethod::NoEncoding:
      default:
        xSpaceNeededPerExample++;
        numEncodedFeatures++;
        destWhatToDo [x] = FeWhatToDo::FeAsIs;
        destFieldNames.push_back (attribute.Name ());
        break;
    }
  }

  codedNumOfFeatures = xSpaceNeededPerExample;

  destFileDesc = FileDesc::NewContinuousDataOnly (destFieldNames);

  xSpaceNeededPerExample++;  // Add one more for the terminating (-1)
}

FeatureEncoder::~FeatureEncoder

(

)

Frees any memory allocated by, and owned by the FeatureEncoder.

Definition at line 172 of file FeatureEncoder.cpp.

{
  delete  srcFeatureNums;
  delete  destFeatureNums;
  delete  cardinalityDest;
  delete  destWhatToDo;
}

Member Function Documentation

MLClassPtr KKMLL::FeatureEncoder::Class1 ( ) const

inline

Definition at line 64 of file FeatureEncoder.h.

Referenced by KKMLL::SVMModel::DistanceFromDecisionBoundary().

{return class1;}

MLClassPtr KKMLL::FeatureEncoder::Class2 ( ) const

inline

Definition at line 65 of file FeatureEncoder.h.

Referenced by KKMLL::SVMModel::DistanceFromDecisionBoundary().

{return class2;}

kkint32 KKMLL::FeatureEncoder::CodedNumOfFeatures ( ) const

inline

Definition at line 61 of file FeatureEncoder.h.

{return codedNumOfFeatures;}

void FeatureEncoder::CompressExamples	(	FeatureVectorListPtr	srcExamples,
		FeatureVectorListPtr	compressedExamples,
		ClassAssignments &	assignments
	)

Left over from BitReduction days; removed all code except that which processed the NO bit reduction option.

Parameters

[in]	examples_list	The list of examples you want to attempt to reduce
[out]	compressed_examples_list	The reduced list of examples

Definition at line 637 of file FeatureEncoder.cpp.

References KKMLL::FeatureVectorList::AddQueue(), and KKB::osGetSystemTimeUsed().

{
  double time_before, time_after;
  time_before = osGetSystemTimeUsed ();
  compressedExamples->AddQueue (*srcExamples);
  time_after = osGetSystemTimeUsed ();
  compressedExamples->Owner (false);
  return;
}  /* CompressExamples */

FeatureVectorListPtr FeatureEncoder::CreateEncodedFeatureVector

(

FeatureVectorList &

srcData

)

Definition at line 653 of file FeatureEncoder.cpp.

References KKMLL::FeatureVector::AddFeatureData(), KKMLL::FeatureVectorList::AllFieldsAreNumeric(), KKMLL::FeatureVectorList::DuplicateListAndContents(), EncodeAExample(), KKMLL::FeatureVector::FeatureVector(), KKMLL::FeatureVectorList::FeatureVectorList(), SVM233::svm_node::index, KKMLL::FeatureVector::MLClass(), KKMLL::FeatureVectorList::PushOnBack(), and SVM233::svm_node::value.

{
  if  (srcData.AllFieldsAreNumeric ())
    return  srcData.DuplicateListAndContents ();

  FeatureVectorListPtr  encodedFeatureVectorList = new FeatureVectorList (destFileDesc, true);

  FeatureVectorList::iterator  idx;
  for  (idx = srcData.begin ();   idx != srcData.end ();  idx++)
  {
    FeatureVectorPtr  srcExample = *idx;
    XSpacePtr  encodedData = EncodeAExample (srcExample);

    kkint32  zed = 0;
    FeatureVectorPtr  encodedFeatureVector = new FeatureVector (codedNumOfFeatures);
    while  (encodedData[zed].index != -1)
    {
      encodedFeatureVector->AddFeatureData (encodedData[zed].index, (float)encodedData[zed].value);
      zed++;
    }

    encodedFeatureVector->MLClass (srcExample->MLClass ());
    encodedFeatureVectorList->PushOnBack (encodedFeatureVector);

    delete  encodedData;
    encodedData = NULL;
  }

  return  encodedFeatureVectorList;
}  /* CreateEncodedFeatureVector */

FileDescPtr FeatureEncoder::CreateEncodedFileDesc

(

ostream *

o

)

Definition at line 201 of file FeatureEncoder.cpp.

References KKMLL::FileDesc::AddAAttribute(), KKB::KKStr::Concat(), KKMLL::FeAsIs, KKMLL::FeBinary, KKMLL::FeScale, KKMLL::FileDesc::FieldName(), KKMLL::FileDesc::FileDesc(), KKMLL::FileDesc::GetNominalValue(), KKB::KKException::KKException(), KKB::KKStr::KKStr(), KKMLL::Numeric, KKB::KKStr::operator+(), KKB::StrFormatInt(), and KKMLL::FileDesc::TypeStr().

Referenced by EncodeAllExamples().

{
  FileDescPtr  newFileDesc = new FileDesc ();

  if  (o)
  {
    *o << endl 
       << "Orig"     << "\t" << "Orig"      << "\t" << "Field" << "\t" << "Encoded"  << "\t" << "Encoded"   << endl;
    *o << "FieldNum" << "\t" << "FieldName" << "\t" << "Type"  << "\t" << "FieldNum" << "\t" << "FieldName" << endl;
  }

  kkint32  x;

  bool  alreadyExist;
  
  for  (x = 0;  x < numOfFeatures; x++)
  {
    kkint32  srcFeatureNum = srcFeatureNums[x];
    kkint32  y = destFeatureNums[x];

    if  (y >= numEncodedFeatures)
    {
      KKStr  errMsg (128);
      errMsg << "FeatureEncoder::CreateEncodedFileDesc  numEncodedFeatures [" << numEncodedFeatures << "]  exceeded.";
      cerr << endl
           << "FeatureEncoder::CreateEncodedFileDesc     *** ERROR ***"           << endl
           << "             " << errMsg << endl
           << endl;
      throw KKException (errMsg);
      exit (-1);
    }

    KKStr  origFieldDesc = StrFormatInt (srcFeatureNum, "zz0") + "\t" +
                            fileDesc->FieldName (srcFeatureNum) + "\t" +
                            fileDesc->TypeStr (srcFeatureNum);


    switch (destWhatToDo[x])
    {
    case  FeWhatToDo::FeAsIs:
      {
        newFileDesc->AddAAttribute (fileDesc->FieldName (x), AttributeType::Numeric, alreadyExist);
        if  (o)
        {
          *o << origFieldDesc          << "\t" 
             << y                      << "\t"
             << fileDesc->FieldName (x)
             << endl;
        }
      }
      break;

    case  FeWhatToDo::FeBinary:
      {
        for  (kkint32 z = 0;  z < cardinalityDest[x];  z++)
        {
          KKStr  nominalValue = fileDesc->GetNominalValue (srcFeatureNums[x], z);
          KKStr  encodedName  = fileDesc->FieldName (x) + "_" + nominalValue;
          newFileDesc->AddAAttribute (encodedName, AttributeType::Numeric, alreadyExist);
          if  (o)
          {
            *o << origFieldDesc << "\t" 
               << y             << "\t"
               << encodedName
               << endl;
          }

          y++;
        }
      }

      break;

    case  FeWhatToDo::FeScale:
      {
        newFileDesc->AddAAttribute (fileDesc->FieldName (x), AttributeType::Numeric, alreadyExist);
        if  (o)
        {
          *o << origFieldDesc           << "\t" 
             << y                       << "\t"
             << fileDesc->FieldName (x)
             << endl;
        }
      }
      break;
    }
  }

  return  newFileDesc;
}  /* CreateEncodedFileDesc */

XSpacePtr FeatureEncoder::EncodeAExample

(

FeatureVectorPtr

example

)

Converts a single example into the svm_problem format.

Parameters

[in]

example

That we're converting

Definition at line 301 of file FeatureEncoder.cpp.

References EncodeAExample().

Referenced by CreateEncodedFeatureVector(), and KKMLL::SVMModel::ProbabilitiesByClass().

{
  // XSpacePtr  xSpace  = (struct svm_node*)malloc (xSpaceNeededPerExample * sizeof (struct svm_node));
  XSpacePtr  xSpace  = new svm_node[xSpaceNeededPerExample];
  kkint32  xSpaceUsed = 0;
  EncodeAExample (example, xSpace, xSpaceUsed);
  return  xSpace;
}  /* EncodeAExample */

void FeatureEncoder::EncodeAExample	(	FeatureVectorPtr	example,
		svm_node *	xSpace,
		kkint32 &	xSpaceUsed
	)

Converts a single example into the svm_problem format.

Parameters

[in]	The	example That we're converting
[in]	The	row kkint32 he svm_problem structure that the converted data will be stored

Definition at line 392 of file FeatureEncoder.cpp.

References KKB::KKStr::Concat(), KKMLL::FeAsIs, KKMLL::FeatureVector::FeatureData(), KKMLL::FeBinary, KKMLL::FeScale, SVM233::svm_node::index, KKB::KKException::KKException(), KKB::KKStr::KKStr(), and SVM233::svm_node::value.

Referenced by KKMLL::SVMModel::DistanceFromDecisionBoundary(), EncodeAExample(), EncodeIntoSparseMatrix(), KKMLL::SVMModel::FindWorstSupportVectors(), and KKMLL::SVMModel::FindWorstSupportVectors2().

{
  const float*  featureData = example->FeatureData ();
  kkint32  x;

  xSpaceUsed = 0;

  for  (x = 0;  x < numOfFeatures; x++)
  {
    float  featureVal = featureData [srcFeatureNums[x]];
    kkint32  y = destFeatureNums[x];

    if  (y >= xSpaceNeededPerExample)
    {
      KKStr  errMsg (128);
      errMsg << "FeatureEncoder::EncodeAExample  ***ERROR***   xSpaceNeededPerExample[" << xSpaceNeededPerExample << "].";
      cerr << endl
           << "FeatureEncoder::EncodeAExample     *** ERROR ***"  << endl
           << "             " << errMsg                           << endl
           << endl;
      throw KKException (errMsg);
    }

    switch (destWhatToDo[x])
    {
    case  FeWhatToDo::FeAsIs:
      {
        if  (featureVal != 0.0)
        {
          xSpace[xSpaceUsed].index = y;
          xSpace[xSpaceUsed].value = featureVal;
          xSpaceUsed++;
        }
      }
      break;

    case  FeWhatToDo::FeBinary:
      {
        for  (kkint32 z = 0; z < cardinalityDest[x]; z++)
        {
          float  bVal = ((kkint32)featureVal == z);
          if  (bVal != 0.0)
          {
            xSpace[xSpaceUsed].index = y;
            xSpace[xSpaceUsed].value = bVal;
            xSpaceUsed++;
          }
          y++;
        }
      }

      break;

    case  FeWhatToDo::FeScale:
      {
        if  (featureVal != (float)0.0)
        {
          xSpace[xSpaceUsed].index = y;
          xSpace[xSpaceUsed].value = featureVal / (float)cardinalityDest[x];
          xSpaceUsed++;
        }
      }
      break;
    }
  }

  xSpace[xSpaceUsed].index = -1;
  xSpace[xSpaceUsed].value = -1;
  xSpaceUsed++;
}  /* EncodeAExample */

FeatureVectorPtr FeatureEncoder::EncodeAExample	(	FileDescPtr	encodedFileDesc,
		FeatureVectorPtr	src
	)

Definition at line 313 of file FeatureEncoder.cpp.

References KKMLL::FeatureVector::AddFeatureData(), KKMLL::FeAsIs, KKMLL::FeatureVector::FeatureData(), KKMLL::FeatureVector::FeatureVector(), KKMLL::FeBinary, KKMLL::FeScale, KKMLL::FeatureVector::MLClass(), KKMLL::FeatureVector::PredictedClass(), and KKMLL::FeatureVector::TrainWeight().

Referenced by EncodeAllExamples().

{
  FeatureVectorPtr  encodedExample = new FeatureVector (numEncodedFeatures);
  encodedExample->MLClass     (src->MLClass     ());
  encodedExample->PredictedClass (src->PredictedClass ());
  //encodedExample->Version        (src->Version        ());
  encodedExample->TrainWeight    (src->TrainWeight    ());

  const float*  featureData = src->FeatureData ();
  kkint32  x;

  for  (x = 0;  x < numOfFeatures; x++)
  {
    float  featureVal = featureData [srcFeatureNums[x]];
    kkint32  y = destFeatureNums[x];

    switch (destWhatToDo[x])
    {
    case  FeWhatToDo::FeAsIs:
      {
        encodedExample->AddFeatureData (y, featureVal);
      }
      break;

    case  FeWhatToDo::FeBinary:
      {
        for  (kkint32 z = 0; z < cardinalityDest[x]; z++)
        {
          float  bVal = ((kkint32)featureVal == z);
          encodedExample->AddFeatureData (y, bVal);
          y++;
        }
      }

      break;

    case  FeWhatToDo::FeScale:
      {
        encodedExample->AddFeatureData (y, (featureVal / (float)cardinalityDest[x]));
      }
      break;
    }
  }

  return  encodedExample;
}  /* EncodeAExample */

FeatureVectorListPtr FeatureEncoder::EncodeAllExamples

(

const FeatureVectorListPtr

srcData

)

Definition at line 366 of file FeatureEncoder.cpp.

References CreateEncodedFileDesc(), EncodeAExample(), KKMLL::FeatureVectorList::FeatureVectorList(), and KKMLL::FeatureVectorList::PushOnBack().

{
  FileDescPtr  encodedFileDesc = CreateEncodedFileDesc (NULL);

  FeatureVectorListPtr  encodedExamples = new FeatureVectorList (encodedFileDesc, true);

  FeatureVectorList::const_iterator  idx;

  for  (idx = srcData->begin ();  idx !=  srcData->end ();   idx++)
  {
    const FeatureVectorPtr srcExample = *idx;
    FeatureVectorPtr  encodedExample = EncodeAExample (encodedFileDesc, srcExample);
    encodedExamples->PushOnBack (encodedExample);
  }

  return  encodedExamples;
}  /* EncodeAllExamples */

void FeatureEncoder::EncodeIntoSparseMatrix	(	FeatureVectorListPtr	src,
		ClassAssignments &	assignments,
		XSpacePtr &	xSpace,
		kkint32 &	totalxSpaceUsed,
		struct svm_problem &	prob,
		RunLog &	log
	)

Compresses 'src' examples, allocating new 'xSpace' data structure.

Parameters

[in]	src	Examples that are to be compressed
[in]	assignments	Class Assignments
[in]	xSpace	will allocate enough xSpace nodes and place compressed results in this structure.
[out]	totalxSpaceUsed	number nodes used in xSpace

Parameters

[out]	prob	Data Structure that is used by SVMLib
[in]	log

Definition at line 514 of file FeatureEncoder.cpp.

References EncodeAExample(), KKMLL::ClassAssignments::GetNumForClass(), SVM233::svm_problem::index, SVM233::svm_problem::l, KKMLL::FeatureVector::MLClass(), KKMLL::FeatureVector::TrainWeight(), SVM233::svm_problem::W, SVM233::svm_problem::x, and SVM233::svm_problem::y.

{
  FeatureVectorListPtr  compressedExamples    = NULL;
  FeatureVectorListPtr  examplesToUseFoXSpace = NULL;
  kkint32               xSpaceUsed            = 0;

  totalxSpaceUsed = 0;

  examplesToUseFoXSpace = src;

  kkint32  numOfExamples = examplesToUseFoXSpace->QueueSize ();
  //kkint32  elements      = numOfExamples * xSpaceNeededPerExample;

  prob.l     = numOfExamples;
  prob.y     = (double*)malloc  (prob.l * sizeof (double));
  prob.x     = (struct svm_node **) malloc (prob.l * sizeof (struct svm_node*));
  prob.index = new kkint32[prob.l];
  prob.exampleNames.clear ();

  kkint32  numNeededXspaceNodes = DetermineNumberOfNeededXspaceNodes (examplesToUseFoXSpace);

  kkint32  totalBytesForxSpaceNeeded = (numNeededXspaceNodes + 10) * sizeof (struct svm_node);  // I added '10' to elements because I am paranoid

  xSpace = (struct svm_node*) malloc (totalBytesForxSpaceNeeded);
  if  (xSpace == NULL)
  {
    log.Level (-1) << endl << endl << endl
                   << " FeatureEncoder::Compress   *** Failed to allocates space for 'xSpace' ****" << endl
                   << endl
                   << "     Space needed          [" << totalBytesForxSpaceNeeded << "]" << endl
                   << "     Num of Examples       [" << numOfExamples             << "]" << endl
                   << "     Num XSpaceNodesNeeded [" << numNeededXspaceNodes      << "]" << endl
                   << endl;
    // we sill have to allocate space for each individual training example separately.
    //throw "FeatureEncoder::Compress     Allocation of memory for xSpace Failed.";
  }

  prob.W = NULL;

  kkint32 i = 0;
 
  FeatureVectorPtr  example      = NULL;
  MLClassPtr        lastMlClass  = NULL;
  kkint16           lastClassNum = -1;

  kkint32  bytesOfxSpacePerExample = xSpaceNeededPerExample * sizeof (struct svm_node);

  for (i = 0;  i < prob.l;  i++)
  {
    if  (totalxSpaceUsed > numNeededXspaceNodes)
    {
      log.Level (-1) << endl << endl
        << "FeatureEncoder::Compress   ***ERROR***   We have exceeded the number of XSpace nodes allocated." << endl
        << endl;
    }

    example = examplesToUseFoXSpace->IdxToPtr (i);

    if  (example->MLClass () != lastMlClass)
    {
      lastMlClass  = example->MLClass ();
      lastClassNum = assignments.GetNumForClass (lastMlClass);
    }

    prob.y[i]     = lastClassNum;
    prob.index[i] = i;
    prob.exampleNames.push_back (osGetRootName (example->ExampleFileName ()));

    if  (prob.W)
    {
      prob.W[i] = example->TrainWeight () * c_Param;
      if  (example->TrainWeight () <= 0.0f)
      {
        log.Level (-1) << endl 
                       << "FeatureEncoder::EncodeIntoSparseMatrix    ***ERROR***   Example[" << example->ExampleFileName () << "]" << endl
                       << "      has a TrainWeight value of 0 or less defaulting to 1.0" << endl
                       << endl;
        prob.W[i] = 1.0 * c_Param;
      }
    }

    if  (xSpace == NULL)
    {
      struct svm_node*  xSpaceThisExample = (struct svm_node*) malloc (bytesOfxSpacePerExample);
      prob.x[i] = xSpaceThisExample;
      EncodeAExample (example, prob.x[i], xSpaceUsed);
      if  (xSpaceUsed < xSpaceNeededPerExample)
      {
        kkint32  bytesNeededForThisExample = xSpaceUsed * sizeof (struct svm_node);
        struct svm_node*  smallerXSpaceThisExample = (struct svm_node*) malloc (bytesNeededForThisExample);
        memcpy (smallerXSpaceThisExample, xSpaceThisExample, bytesNeededForThisExample);
        free  (xSpaceThisExample);
        prob.x[i] = smallerXSpaceThisExample;
      }
    }
    else
    {
      prob.x[i] = &xSpace[totalxSpaceUsed];
      EncodeAExample (example, prob.x[i], xSpaceUsed);
    }
    totalxSpaceUsed += xSpaceUsed;
  }

  delete  compressedExamples;
  return;
}  /* Compress */

kkint32 FeatureEncoder::MemoryConsumedEstimated

(

)

const

Definition at line 182 of file FeatureEncoder.cpp.

References KKMLL::FeatureNumList::MemoryConsumedEstimated().

Referenced by KKMLL::SVMModel::MemoryConsumedEstimated().

{
  kkint32  memoryConsumedEstimated = sizeof (FeatureEncoder) 
    + selectedFeatures.MemoryConsumedEstimated ()
    + numOfFeatures * sizeof (kkint32);

  if  (cardinalityDest)
    memoryConsumedEstimated += 3 * sizeof (kkint32) * numOfFeatures;    // cardinalityDest + destFeatureNums + srcFeatureNums

  //  We do not own 'destFileDesc'  and  'fileDesc'
  if  (destWhatToDo)
    memoryConsumedEstimated += sizeof (FeWhatToDo) * numOfFeatures;

  return  memoryConsumedEstimated;
}  /* MemoryConsumedEstimated */

void FeatureEncoder::ReadXML ( XmlStream &  s, XmlTagConstPtr  tag, VolConstBool &  cancelFlag, RunLog &  log  )

virtual

Definition at line 737 of file FeatureEncoder.cpp.

References KKB::KKStr::Concat(), KKMLL::MLClass::CreateNewMLClass(), KKMLL::EncodingMethodFromStr(), KKB::KKStr::EqualIgnoreCase(), KKB::XmlStream::GetNextToken(), KKB::XmlElement::ToDouble(), KKB::XmlElement::ToInt32(), KKB::XmlToken::tokElement, KKB::XmlToken::TokenType(), KKB::XmlElement::ToKKStr(), KKMLL::XmlElementFileDesc::Value(), and KKB::XmlElement::VarName().

{
  XmlTokenPtr t = s.GetNextToken (cancelFlag,  log);
  while  (t  &&  (!cancelFlag))
  {
    if  (t->TokenType () == XmlToken::TokenTypes::tokElement)
    {
      XmlElementPtr e = dynamic_cast<XmlElementPtr> (t);
      if  (e)
      {
        KKStr varName = e->VarName ();

        if  (varName.EqualIgnoreCase ("CodedNumOfFeatures"))
          codedNumOfFeatures= e->ToInt32 ();

        else if  (varName.EqualIgnoreCase ("C_Param"))
          c_Param = e->ToDouble ();

        else if  (varName.EqualIgnoreCase ("NumEncodedFeatures"))
          numEncodedFeatures = e->ToInt32 ();

        else if  (varName.EqualIgnoreCase ("NumOfFeatures"))
          numOfFeatures = e->ToInt32 ();

        else if  (varName.EqualIgnoreCase ("xSpaceNeededPerExample"))
          xSpaceNeededPerExample = e->ToInt32 ();

        else if  (typeid (*e) == typeid (XmlElementArrayInt32))
        {
          XmlElementArrayInt32Ptr xmlArray = dynamic_cast<XmlElementArrayInt32Ptr> (e);
          kkuint32 count = xmlArray->Count ();
          if  (count != numOfFeatures)
          {
            log.Level (-1) << endl
              << "FeatureEncoder::ReadXML   ***ERROR***  Variable[" << varName << "]  Invalid Length[" << count << "]  Expected[" << numOfFeatures << "]" << endl
              << endl;
          }
          else
          {
            if  (varName.EqualIgnoreCase ("CardinalityDest"))
            {
              delete  cardinalityDest;
              cardinalityDest = xmlArray->TakeOwnership ();
            }

            else if  (varName.EqualIgnoreCase ("DestFeatureNums"))
            {
              delete  destFeatureNums;
              destFeatureNums = xmlArray->TakeOwnership ();
            }

            else if  (varName.EqualIgnoreCase ("SrcFeatureNums"))
            {
              delete  srcFeatureNums;
              srcFeatureNums = xmlArray->TakeOwnership ();
            }
          }
        }

        else if  (varName.EqualIgnoreCase ("Class1"))
          class1 = MLClass::CreateNewMLClass (e->ToKKStr (), -1);

        else if  (varName.EqualIgnoreCase ("Class2"))
          class2 = MLClass::CreateNewMLClass (e->ToKKStr (), -1);

        else if  (varName.EqualIgnoreCase ("FileDesc")  &&  (typeid (*e) == typeid (XmlElementFileDesc)))
          fileDesc = dynamic_cast<XmlElementFileDescPtr> (e)->Value ();

        else if  (varName.EqualIgnoreCase ("DestFileDesc")  &&  (typeid (*e) == typeid (XmlElementFileDesc)))
          destFileDesc = dynamic_cast<XmlElementFileDescPtr> (e)->Value ();

        else if  (varName.EqualIgnoreCase ("DestWhatToDo")  &&  (typeid (*e) == typeid (XmlElementVectorInt32)))
        {
          XmlElementVectorInt32Ptr  xmlVect = dynamic_cast<XmlElementVectorInt32Ptr> (e);
          if  (xmlVect  &&  xmlVect->Value ())
          {
            const VectorInt32&  v = *(xmlVect->Value ());
            if  (v.size () != numOfFeatures)
            {
              log.Level (-1) << endl
                << "FeatureEncoder::ReadXML   ***ERROR***   Variable[" << varName << "]  Invalid Size[" << v.size () << "]  Expected[" << numOfFeatures << "]." << endl
                << endl;
            }
            else
            {
              delete  destWhatToDo;
              destWhatToDo = new FeWhatToDo[v.size ()];
              for  (kkuint32 x = 0;  x < v.size ();  ++x)
                destWhatToDo[x] = (FeWhatToDo)v[x];
            }
          }
        }

        else if  (varName.EqualIgnoreCase ("EncodingMethod"))
          encodingMethod = EncodingMethodFromStr (e->ToKKStr ());

        else
        {
          log.Level (-1) << "XmlElementTrainingClassList   ***ERROR***   Un-expected Section Element[" << e->SectionName () << "]" << endl;
        }
      }
    }

    delete  t;
    t = s.GetNextToken (cancelFlag, log);
  }
  delete  t;
  t = NULL;
}  /* ReadXML */

void FeatureEncoder::WriteXML ( const KKStr &  varName, ostream &  o  ) const

virtual

Definition at line 687 of file FeatureEncoder.cpp.

References KKB::XmlTag::AddAtribute(), KKB::KKStr::Empty(), KKMLL::EncodingMethodToStr(), KKMLL::MLClass::Name(), KKB::XmlTag::tagEnd, KKB::XmlTag::tagStart, KKMLL::FeatureNumList::WriteXML(), KKB::XmlTag::WriteXML(), KKMLL::FileDesc::WriteXML(), KKB::KKStr::WriteXML(), and KKB::XmlTag::XmlTag().

{
  XmlTag  tagStart ("TrainingClassList", XmlTag::TagTypes::tagStart);
  if  (!varName.Empty ())
    tagStart.AddAtribute ("VarName", varName);

  tagStart.WriteXML (o);
  o << endl;

  XmlElementInt32::WriteXML  (codedNumOfFeatures,     "CodedNumOfFeatures",     o);
  XmlElementDouble::WriteXML (c_Param,                "c_Param",                o);
  XmlElementInt32::WriteXML  (numEncodedFeatures,     "NumEncodedFeatures",     o);
  XmlElementInt32::WriteXML  (numOfFeatures,          "NumOfFeatures",          o);
  XmlElementInt32::WriteXML  (xSpaceNeededPerExample, "xSpaceNeededPerExample", o);

  if  (cardinalityDest)
    XmlElementArrayInt32::WriteXML (numOfFeatures, cardinalityDest, "CardinalityDest", o);

  if  (class1)  class1->Name ().WriteXML ("Class1", o);
  if  (class2)  class2->Name ().WriteXML ("Class2", o);
  if  (destFeatureNums)
    XmlElementArrayInt32::WriteXML (numOfFeatures, destFeatureNums, "DestFeatureNums", o);

  if  (fileDesc)      fileDesc->WriteXML     ("FileDesc",     o);
  if  (destFileDesc)  destFileDesc->WriteXML ("DestFileDesc", o);

  if  (destWhatToDo)
  {
    VectorInt32  v;
    for  (kkint32 x = 0;  x < numOfFeatures;  ++x)
      v.push_back ((kkint32)(destWhatToDo[x]));
    XmlElementVectorInt32::WriteXML (v, "DestWhatToDo", o);
  }

  EncodingMethodToStr (encodingMethod).WriteXML ("EncodingMethod", o);

  selectedFeatures.WriteXML ("selectedFeatures", o);

  if  (srcFeatureNums)
    XmlElementArrayInt32::WriteXML (numOfFeatures, srcFeatureNums, "SrcFeatureNums", o);
 
  XmlTag  tagEnd ("TrainingClassList", XmlTag::TagTypes::tagEnd);
  tagEnd.WriteXML (o);
  o << endl;
}

kkint32 KKMLL::FeatureEncoder::XSpaceNeededPerExample ( )

inline

Definition at line 128 of file FeatureEncoder.h.

{return xSpaceNeededPerExample;}

---

The documentation for this class was generated from the following files:

• C:/Users/Kurt/GitHub/KSquareLibraries/KKMachineLearning/FeatureEncoder.h
• C:/Users/Kurt/GitHub/KSquareLibraries/KKMachineLearning/FeatureEncoder.cpp