MAClassifierSamples.cpp

/*
 *  This file is part of the AiBO+ project
 *
 *  Copyright (C) 2005-2016 Csaba Kertész (csaba.kertesz@gmail.com)
 *
 *  AiBO+ is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  AiBO+ is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Street #330, Boston, MA 02111-1307, USA.
 *
 */

#include <ml/MAClassifierSamples.hpp>

#include <MCBinaryData.hpp>
#include <MCDataContainer.hpp>
#include <MCDataStorage.hpp>
#include <MCLog.hpp>

MAClassifierSamples::MAClassifierSamples()
{
}


const MC::FloatTable& MAClassifierSamples::GetFeatureVectors() const
{
  return FeatureVectors;
}


const MC::FloatList& MAClassifierSamples::GetLabels() const
{
  return Labels;
}


void MAClassifierSamples::AddSample(const MC::FloatList& feature_vector, const float label)
{
  if (feature_vector.empty())
  {
    MC_WARNING("Empty feature vector.");
    return;
  }
  if (FeatureVectors.size() > 0 && feature_vector.size() != FeatureVectors[0].size())
  {
    MC_WARNING("Feature count does not match with the stored vectors (%d != %d).",
               feature_vector.size(), FeatureVectors[0].size());
    return;
  }
  FeatureVectors.push_back(feature_vector);
  Labels.push_back(label);
}


void MAClassifierSamples::AddSamples(const MC::FloatTable& feature_vectors, const MC::FloatList& labels)
{
  if (feature_vectors.empty())
  {
    MC_WARNING("No feature vectors.");
    return;
  }
  if (!MCIsConsistentTable(feature_vectors))
  {
    MC_WARNING("Feature vectors are not consistent.");
    return;
  }
  if (feature_vectors.size() != labels.size())
  {
    MC_WARNING("Feature vector count does not match with the label count (%d != %d).",
               feature_vectors.size(), labels.size());
    return;
  }
  for (unsigned int i = 0; i < feature_vectors.size(); ++i)
    AddSample(feature_vectors[i], labels[i]);
}


void MAClassifierSamples::RemoveSample(unsigned int index)
{
  if (index >= FeatureVectors.size())
  {
    MC_WARNING("Invalid index to remove a sample (%d >= %d)", index, FeatureVectors.size());
    return;
  }
  FeatureVectors.erase(FeatureVectors.begin()+index);
  Labels.erase(Labels.begin()+index);
}


MCBinaryData* MAClassifierSamples::Encode() const
{
  MC::DataStorageSPtr DataStorage(new MCDataStorage("FeatureVectors", true));
  MC::DataContainerSPtr DataContainer(DataStorage->CreateContainer("FeatureVectors"));

  // Add the feature vectors to the storage
  for (unsigned int i = 0; i < FeatureVectors.size(); ++i)
  {
    MCDataItemBase* FeatureVectorsItem = DataContainer->GetData(MCToStr((int)Labels[i]));

    if (!FeatureVectorsItem)
    {
      FeatureVectorsItem = new MCDataItem<MC::FloatTable>(MC::FloatTable(), MCToStr((int)Labels[i]));
      DataContainer->AddData(*FeatureVectorsItem);
    }
    reinterpret_cast<MC::FloatTable*>(FeatureVectorsItem->DataPtr)->push_back(FeatureVectors[i]);
  }
  return DataStorage->Encode();
}


MAClassifierSamples* MAClassifierSamples::Decode(const MCBinaryData& data)
{
  MC::DataStorageSPtr DataStorage(MCDataStorage::Decode(data, true));
  MC::DataContainerSPtr DataContainer;

  if (!DataStorage.get())
    return nullptr;

  DataContainer = DataStorage->GetContainer("FeatureVectors");
  if (!DataContainer.get())
    return nullptr;

  const MC::DataItemBasePtrList& Items = DataContainer->GetAllData();
  MAClassifierSamples* ClassifierSamples = new MAClassifierSamples;

  for (auto& item : Items)
  {
    MC::FloatTable* FeatureVectors = reinterpret_cast<MC::FloatTable*>(item->DataPtr);

    MCMergeContainers(ClassifierSamples->FeatureVectors, *FeatureVectors);
    for (unsigned int i = 0; i < FeatureVectors->size(); ++i)
      ClassifierSamples->Labels.push_back(MCStrConvert<float>(item->DataName));
  }
  return ClassifierSamples;
}


MAClassifierSamples* MAClassifierSamples::LoadFromFile(const std::string& file_name)
{
  MC::BinaryDataSPtr BinaryData(new MCBinaryData);

  if (BinaryData->LoadFromFile(file_name))
  {
    return Decode(*BinaryData);
  }
  return nullptr;
}


bool MAClassifierSamples::SaveToFile(const std::string& file_name) const
{
  MC::BinaryDataSPtr BinaryData(Encode());

  if (BinaryData->SaveToFile(file_name))
  {
    return true;
  }
  return false;
}