MAWeakModel.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 "MAWeakModel.hpp"

#include "core/MACoreTypes.hpp"

#include <MCContainers.hpp>
#include <MCLog.hpp>

MAWeakModel::MAWeakModel(MAModel& classifier)
{
  AddClassifier(classifier);
}


MAWeakModel::~MAWeakModel()
{
}


unsigned int MAWeakModel::GetFeatureCount() const
{
  unsigned int Size = 0;

  for (unsigned int i = 0; i < Classifiers.size(); ++i)
  {
    Size += Classifiers[i]->GetFeatureCount();
  }
  return Size;
}


MC::FloatList& MAWeakModel::GetModelLabels()
{
  return Classifiers[0]->GetModelLabels();
}


void MAWeakModel::AddClassifier(MAModel& classifier)
{
  Classifiers.push_back(MA::ModelSPtr(&classifier));
}


MC::FloatList MAWeakModel::Predict(const MC::FloatTable& input_vectors, MC::FloatList& confidences)
{
  if (input_vectors.empty())
  {
    MC_WARNING("No data in the input table for classifier prediction.");
    return MC::FloatList();
  }
  // Check if the table is appropriate for training
  int RowSize = input_vectors[0].size();

  if (RowSize == 0)
  {
    MC_WARNING("No data in the input table for classifier prediction.");
    return MC::FloatList();
  }
  for (unsigned int i = 1; i < input_vectors.size(); ++i)
  {
    if ((int)input_vectors[i].size() != RowSize)
    {
      MC_WARNING("Row counts are inconsistent in the input table for classifier prediction.");
      return MC::FloatList();
    }
  }
  if (RowSize != (int)GetFeatureCount())
  {
    MC_WARNING("Feature count does not match with the expected (%d != %d).", GetFeatureCount(), RowSize);
    return MC::FloatList();
  }
  MC::FloatList Labels;

  for (unsigned int i = 0; i < input_vectors.size(); ++i)
  {
    Labels.push_back(Predict(input_vectors[i], confidences));
  }
  return Labels;
}


float MAWeakModel::Predict(const MC::FloatList& input_vector, MC::FloatList& confidence)
{
  if (input_vector.empty())
  {
    MC_WARNING("No data in the input vector for classifier prediction.");
    return MCFloatInfinity();
  }
  if (input_vector.size() != GetFeatureCount())
  {
    MC_WARNING("Feature count does not match with the expected test vector (%d != %d).",
               GetFeatureCount(), input_vector.size());
    return MCFloatInfinity();
  }
  int StartIndex = 0;
  MA::FloatFloatSortedMap LabelCounts;

  for (unsigned int i = 0; i < Classifiers.size(); ++i)
  {
    int FeatureCount = Classifiers[i]->GetFeatureCount();
    MC::FloatList VectorPart(input_vector.begin()+StartIndex, input_vector.begin()+StartIndex+FeatureCount);
    MC::FloatList Confidence;
    float Label = Classifiers[i]->Predict(VectorPart, Confidence);

    if (Confidence.empty())
    {
      LabelCounts[Label]++;
    } else {
      LabelCounts[Label] += Confidence[0];
    }
    StartIndex += FeatureCount;
  }
  float MaxAmount = 0;
  float MaxLabel = LabelCounts.begin()->first;
  float MaxValue = LabelCounts.begin()->second;

  for (auto& value : LabelCounts)
  {
    MaxAmount += value.second;
    if (MaxValue < value.second)
    {
      MaxLabel = value.first;
      MaxValue = value.second;
    }
  }
  confidence.push_back(MaxValue / MaxAmount);
  return MaxLabel;
}


MC::FloatTable MAWeakModel::Predict(const MC::FloatTable& input_vectors)
{
  if (input_vectors.empty())
  {
    MC_WARNING("No data in the input table for classifier prediction.");
    return MC::FloatTable();
  }
  // Check if the table is appropriate for training
  int RowSize = input_vectors[0].size();

  if (RowSize == 0)
  {
    MC_WARNING("No data in the input table for classifier prediction.");
    return MC::FloatTable();
  }
  for (unsigned int i = 1; i < input_vectors.size(); ++i)
  {
    if ((int)input_vectors[i].size() != RowSize)
    {
      MC_WARNING("Row counts are inconsistent in the input table for classifier prediction.");
      return MC::FloatTable();
    }
  }
  if (RowSize != (int)GetFeatureCount())
  {
    MC_WARNING("Feature count does not match with the expected (%d != %d).", GetFeatureCount(), RowSize);
    return MC::FloatTable();
  }
  MC::FloatTable LabelTable;

  for (unsigned int i = 0; i < input_vectors.size(); ++i)
  {
    LabelTable.push_back(Predict(input_vectors[i]));
  }
  return LabelTable;
}


MC::FloatList MAWeakModel::Predict(const MC::FloatList& input_vector)
{
  if (input_vector.empty())
  {
    MC_WARNING("No data in the input vector for classifier prediction.");
    return MC::FloatList();
  }
  if (input_vector.size() != GetFeatureCount())
  {
    MC_WARNING("Feature count does not match with the expected test vector (%d != %d).",
               GetFeatureCount(), input_vector.size());
    return MC::FloatList();
  }
  MC::FloatList Labels;
  int StartIndex = 0;
  MC::FloatList Confidence;

  for (unsigned int i = 0; i < Classifiers.size(); ++i)
  {
    int FeatureCount = Classifiers[i]->GetFeatureCount();
    MC::FloatList VectorPart(input_vector.begin()+StartIndex, input_vector.begin()+StartIndex+FeatureCount);

    Labels.push_back(Classifiers[i]->Predict(VectorPart, Confidence));
    StartIndex += FeatureCount;
  }
  return Labels;
}


MCBinaryData* MAWeakModel::Encode() const
{
  MCBinaryData* FileData = nullptr;
  MA::BinaryDataSPtrList DataList;
  int FileSize = (int)Classifiers.size()*4;

  for (unsigned int i = 0; i < Classifiers.size(); ++i)
  {
    DataList.push_back(MC::BinaryDataSPtr(Classifiers[i]->Encode()));
    FileSize += DataList[i]->GetSize();
  }
  FileData = new MCBinaryData(FileSize);
  for (unsigned int i = 0; i < Classifiers.size(); ++i)
  {
    FileData->AddInt32(DataList[i]->GetSize());
    DataList[i]->ResetPosition();
    DataList[i]->WriteData(*FileData, DataList[i]->GetSize());
  }
  return FileData;
}


MAWeakModel* MAWeakModel::Decode(const MCBinaryData& data)
{
  MCBinaryData& Data = const_cast<MCBinaryData&>(data);
  MC::BinaryDataSPtr ReadData(new MCBinaryData);
  int OldPosition = Data.GetPosition();
  MAWeakModel* WeakModel = nullptr;

  Data.SetPosition(0);
  while (!Data.IsPositionAtEnd())
  {
    MAModel* Model = nullptr;

    ReadData->Allocate(Data.GetInt32());
    Data.WriteData(*ReadData, ReadData->GetSize());
    Model = MAModel::Decode(*ReadData);
    if (Model)
    {
      if (!WeakModel)
      {
        WeakModel = new MAWeakModel(*Model);
        continue;
      }
      WeakModel->AddClassifier(*Model);
    }
  }
  Data.SetPosition(OldPosition);
  if (WeakModel && WeakModel->Classifiers.empty())
  {
    delete WeakModel;
    WeakModel = nullptr;
  }
  return WeakModel;
}