KKMLL::FeatureEncoder2 Class Reference

#include <FeatureEncoder2.h>

Classes
struct	FeatureVar2
class	FeatureVar2List

Public Types
typedef FeatureEncoder2 *	FeatureEncoder2Ptr
enum	FeWhatToDo { FeWhatToDo::FeAsIs, FeWhatToDo::FeBinary, FeWhatToDo::FeScale }
typedef FeWhatToDo *	FeWhatToDoPtr

Public Member Functions
	FeatureEncoder2 (const ModelParam &_param, FileDescPtr _fileDesc)
	Constructs a Feature Encoder object. More...
	FeatureEncoder2 (const FeatureEncoder2 &_encoder)
	~FeatureEncoder2 ()
	Frees any memory allocated by, and owned by the FeatureEncoder2. More...
kkint32	CodedNumOfFeatures () const
FileDescPtr	CreateEncodedFileDesc (ostream *o, RunLog &log) const
FeatureVectorPtr	EncodeAExample (FeatureVectorPtr src) const
FeatureVectorListPtr	EncodeAllExamples (const FeatureVectorListPtr srcData)
FeatureVectorListPtr	EncodedFeatureVectorList (const FeatureVectorList &srcData) const
kkint32	MemoryConsumedEstimated () const
kkint32	NumEncodedFeatures () const
void	ReadXML (istream &i)
void	WriteXML (istream &o)

Detailed Description

                     FeatureEncoder2                               *
                                                                   *
This will eventually replace "FeatureEncoder" when we shift over   *
to the new paradigm where all Machine Learning Algorithms will be  *
derived from 'Model'.                                              *

Definition at line 27 of file FeatureEncoder2.h.

Member Typedef Documentation

typedef FeatureEncoder2* KKMLL::FeatureEncoder2::FeatureEncoder2Ptr

Definition at line 30 of file FeatureEncoder2.h.

typedef FeWhatToDo* KKMLL::FeatureEncoder2::FeWhatToDoPtr

Definition at line 33 of file FeatureEncoder2.h.

Member Enumeration Documentation

enum KKMLL::FeatureEncoder2::FeWhatToDo

strong

Enumerator
FeAsIs
FeBinary
FeScale

Definition at line 32 of file FeatureEncoder2.h.

{FeAsIs, FeBinary, FeScale};

Constructor & Destructor Documentation

FeatureEncoder2::FeatureEncoder2	(	const ModelParam &	_param,
		FileDescPtr	_fileDesc
	)

Constructs a Feature Encoder object.

Parameters

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

Definition at line 33 of file FeatureEncoder2.cpp.

References KKMLL::FileDesc::AttributeVector(), KKMLL::FileDesc::CardinalityVector(), KKMLL::ModelParam::EncodingMethod(), FeAsIs, KKMLL::FileDesc::NewContinuousDataOnly(), KKMLL::ModelParam::NoEncoding, KKMLL::FeatureNumList::NumOfFeatures(), KKMLL::FeatureNumList::operator[](), KKMLL::ModelParam::Scaled, and KKMLL::ModelParam::SelectedFeatures().

Referenced by KKMLL::Model::TrainModel().

                                   :
    attributeVector     (_fileDesc->AttributeVector ()),
    cardinalityDest     (NULL),
    cardinalityVector   (_fileDesc->CardinalityVector ()),
    codedNumOfFeatures  (0),
    destFeatureNums     (NULL),
    destWhatToDo        (NULL),
    encodedFileDesc     (NULL),
    encodingMethod      (ModelParam::EncodingMethodType::NoEncoding),
    fileDesc            (_fileDesc),
    numOfFeatures       (0),
    srcFeatureNums      (NULL),
    param               (_param)
    
{
  FeatureNumListConstPtr  selectedFeatures = param.SelectedFeatures ();
  numOfFeatures = param.SelectedFeatures ()->NumOfFeatures ();

  encodingMethod   = param.EncodingMethod ();

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

  VectorKKStr   destFieldNames;

  kkint32  x;

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

    Attribute  srcAttribute = (fileDesc->Attributes ())[srcFeatureNum];

    switch (encodingMethod)
    {
      case  ModelParam::EncodingMethodType::Binary:
        if  ((attributeVector[srcFeatureNum] == AttributeType::Nominal)  ||
             (attributeVector[srcFeatureNum] == AttributeType::Symbolic)
            )
        {
          destWhatToDo    [x] = FeWhatToDo::FeBinary;
          cardinalityDest [x] = cardinalityVector[srcFeatureNums [x]];
          codedNumOfFeatures   += cardinalityDest[x];
          for  (kkint32 zed = 0;  zed < cardinalityDest[x];  zed++)
          {
            KKStr  fieldName = srcAttribute.Name () + "_" + srcAttribute.GetNominalValue (zed);
            destFieldNames.push_back (fieldName);
          }
        }
        else
        {
          codedNumOfFeatures++;
          destWhatToDo [x] = FeWhatToDo::FeAsIs;
          destFieldNames.push_back (srcAttribute.Name ());
        }
        break;


      case  ModelParam::EncodingMethodType::Scaled:
        codedNumOfFeatures++;
        if  ((attributeVector[srcFeatureNums[x]] == AttributeType::Nominal)  ||
             (attributeVector[srcFeatureNums[x]] == AttributeType::Symbolic)
            )
          destWhatToDo [x] = FeWhatToDo::FeScale;
        else
          destWhatToDo [x] = FeWhatToDo::FeAsIs;

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


      case    ModelParam::EncodingMethodType::NoEncoding:
      default:
        codedNumOfFeatures++;
        destWhatToDo [x] = FeWhatToDo::FeAsIs;
        destFieldNames.push_back (srcAttribute.Name ());
        break;
    }
  }

  encodedFileDesc = FileDesc::NewContinuousDataOnly (destFieldNames);
}

FeatureEncoder2::FeatureEncoder2

(

const FeatureEncoder2 &

_encoder

)

Definition at line 127 of file FeatureEncoder2.cpp.

Referenced by KKMLL::Model::Model().

                                                                 :
    attributeVector    (_encoder.attributeVector),
    cardinalityDest    (NULL),
    cardinalityVector  (_encoder.cardinalityVector),
    codedNumOfFeatures (_encoder.codedNumOfFeatures),
    destFeatureNums    (NULL),
    destWhatToDo       (NULL),
    encodedFileDesc    (_encoder.encodedFileDesc),
    encodingMethod     (_encoder.encodingMethod),
    fileDesc           (_encoder.fileDesc),
    numOfFeatures      (_encoder.numOfFeatures),
    srcFeatureNums     (NULL),
    param              (_encoder.param)
{
  cardinalityDest  = new kkint32[numOfFeatures];
  destFeatureNums  = new kkint32[numOfFeatures];
  destWhatToDo     = new FeWhatToDo[numOfFeatures];
  srcFeatureNums   = new kkuint16[numOfFeatures];

  kkint32  x;
  for  (x = 0;  x < numOfFeatures;  x++)
  {
    srcFeatureNums   [x] = _encoder.srcFeatureNums [x];
    destFeatureNums  [x] = _encoder.destFeatureNums[x];
    cardinalityDest  [x] = _encoder.cardinalityDest[x];
    destWhatToDo     [x] = _encoder.destWhatToDo   [x];
    srcFeatureNums   [x] = _encoder.srcFeatureNums [x];
  }
}

FeatureEncoder2::~FeatureEncoder2

(

)

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

Definition at line 162 of file FeatureEncoder2.cpp.

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

Member Function Documentation

kkint32 KKMLL::FeatureEncoder2::CodedNumOfFeatures ( ) const

inline

Definition at line 55 of file FeatureEncoder2.h.

{return codedNumOfFeatures;}

FileDescPtr FeatureEncoder2::CreateEncodedFileDesc	(	ostream *	o,
		RunLog &	log
	)		const

If 'o' is not NULL will write out a table showing assignments from old to new.

Definition at line 195 of file FeatureEncoder2.cpp.

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

{
  log.Level (40) << "FeatureEncoder2::CreateEncodedFileDesc" << endl;
  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++)
  {
    kkuint16  srcFeatureNum = srcFeatureNums[x];
    kkint32  y = destFeatureNums[x];

    if  (y >= codedNumOfFeatures)
    {
      log.Level(-1) 
            << endl
            << "FeatureEncoder2::CreateEncodedFileDesc     ***ERROR***"                                   << endl
            << "             overriding number of encoded features. This should never be able to happen." << endl
            << "             Something is wrong with object."                                             << endl
            << endl;
      osWaitForEnter ();
      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;
    }
  }

  newFileDesc = FileDesc::GetExistingFileDesc (newFileDesc);

  return  newFileDesc;
}  /* CreateEncodedFileDesc */

FeatureVectorPtr FeatureEncoder2::EncodeAExample

(

FeatureVectorPtr

src

)

const

Definition at line 294 of file FeatureEncoder2.cpp.

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

Referenced by EncodeAllExamples(), EncodedFeatureVectorList(), and KKMLL::Model::PrepExampleForPrediction().

{
  FeatureVectorPtr  encodedImage = new FeatureVector (codedNumOfFeatures);
  encodedImage->MLClass     (src->MLClass     ());
  encodedImage->PredictedClass (src->PredictedClass ());
  encodedImage->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:
      {
        encodedImage->AddFeatureData (y, featureVal);
      }
      break;

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

      break;

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

  return  encodedImage;
}  /* EncodeAExample */

FeatureVectorListPtr FeatureEncoder2::EncodeAllExamples

(

const FeatureVectorListPtr

srcData

)

Definition at line 344 of file FeatureEncoder2.cpp.

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

Referenced by KKMLL::Model::TrainModel().

{
  FeatureVectorListPtr  encodedExamples = new FeatureVectorList (encodedFileDesc, 
                                                                  true                  // Will own the contents 
                                                                );

  FeatureVectorList::const_iterator  idx;

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

  return  encodedExamples;
}  /* EncodeAllImages */

FeatureVectorListPtr FeatureEncoder2::EncodedFeatureVectorList

(

const FeatureVectorList &

srcData

)

const

Definition at line 365 of file FeatureEncoder2.cpp.

References KKMLL::FeatureVectorList::AllFieldsAreNumeric(), KKMLL::FeatureVectorList::DuplicateListAndContents(), EncodeAExample(), KKMLL::FeatureVectorList::FeatureVectorList(), KKMLL::FeatureVector::MLClass(), and KKMLL::FeatureVectorList::PushOnBack().

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

  FeatureVectorListPtr  encodedFeatureVectorList = new FeatureVectorList (encodedFileDesc, true);

  FeatureVectorList::const_iterator  idx;
  for  (idx = srcData.begin ();   idx != srcData.end ();  idx++)
  {
    FeatureVectorPtr  srcExample = *idx;
    FeatureVectorPtr  encodedFeatureVector = EncodeAExample (srcExample);
    encodedFeatureVector->MLClass (srcExample->MLClass ());
    encodedFeatureVectorList->PushOnBack (encodedFeatureVector);
  }

  return  encodedFeatureVectorList;
}  /* EncodedFeatureVectorList */

kkint32 FeatureEncoder2::MemoryConsumedEstimated

(

)

const

Definition at line 171 of file FeatureEncoder2.cpp.

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

{
  kkint32  memoryConsumedEstimated = sizeof (FeatureEncoder2)
    +  attributeVector.size ()   * sizeof (AttributeType)
    +  cardinalityVector.size () * sizeof (kkint32);

  if  (cardinalityDest)   memoryConsumedEstimated += 2 * numOfFeatures * sizeof (kkint32);  // For 'cardinalityDest', 'destFeatureNums'
  if  (destFeatureNums)   memoryConsumedEstimated += numOfFeatures * sizeof (kkint32);
  if  (destWhatToDo)      memoryConsumedEstimated += numOfFeatures * sizeof (FeWhatToDo);
  if  (srcFeatureNums)    memoryConsumedEstimated += numOfFeatures * sizeof (kkuint16);
  
  return  memoryConsumedEstimated;
}

kkint32 FeatureEncoder2::NumEncodedFeatures

(

)

const

Definition at line 187 of file FeatureEncoder2.cpp.

References KKMLL::FileDesc::NumOfFields().

{
  return  encodedFileDesc->NumOfFields ();
}

void KKMLL::FeatureEncoder2::ReadXML

(

istream &

i

)

void KKMLL::FeatureEncoder2::WriteXML

(

istream &

o

)

---

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

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