freESAsymmetricMutation.txx

Go to the documentation of this file.

/*=========================================================================

  Program:   F.R.E.E. - flexible registration evaluation engine
  Version:   v.1.0.0
  Date:      $Date: 2006/09/01 12:00:00 $
  Module:    $RCSfile: freESAsymmetricMutation.h,v $
  Language:  C++



  Copyright (c) 2007 Ralf o Floca (Department of Medical Informatics,
  Institute for Medical Biometry and Informatics, University of Heidelberg,
  Germany). All rights reserved.
  See FREECopyright.txt or http://www.mi.med.uni-hd.de/free/copyright.htm
  for details.

     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#ifndef _freESAsymmetricMutation_txx
#define _freESAsymmetricMutation_txx

#include "freESAsymmetricMutation.h"

#include "vnl/vnl_sample.h"

namespace FREE
{
namespace ES
{

template <class TIndividual>
AsymmetricMutation<TIndividual>
::AsymmetricMutation()
{
  m_Gamma = 2.0;

  m_TauGlobal = 1/sqrt(2.0);
  m_Tau = 1/sqrt(2.0);
  m_TauGlobal_Skewness = 1/sqrt(2.0);
  m_Tau_Skewness = 1/sqrt(2.0);

  m_MutateValueVariance = 1.0;
  m_MutateValueSkewness = 0.0;

  m_RandomGenerator = VariateGeneratorType::New();
}

template <class TIndividual>
void
AsymmetricMutation<TIndividual>
::RegisterStrategicIndividualParameters(IndividualType& individual) const
{
  for (unsigned long index = 0; index<individual.ObjectiveParameters().size(); index++)
  {
    typename IndividualType::StrategicParameterPointer parameter = IndividualType::StrategicParameterType::New();
    parameter->SetValue(1.0);
    parameter->SetHandling(IndividualType::StrategicParameterType::HDynamic);
    parameter->SetOrigin(this->GetNameOfClass());
    individual.StrategicParameters().push_back(parameter);

    parameter = IndividualType::StrategicParameterType::New();
    parameter->SetValue(0.0);
    parameter->SetHandling(IndividualType::StrategicParameterType::HDynamic);
    parameter->SetOrigin(this->GetNameOfClass());
    individual.StrategicParameters().push_back(parameter);
  }
};

template <class TIndividual>
void
AsymmetricMutation<TIndividual>
::RegisterStrategicPopulationParameters(PopulationType& population) const
{
  //ID of the generation tauGlobal and tauGlobal_skewness are belonging too
  typename IndividualType::StrategicParameterPointer parameter = IndividualType::StrategicParameterType::New();
  parameter->SetValue(-1.0);
  parameter->SetHandling(IndividualType::StrategicParameterType::HStatic);
  parameter->SetOrigin(this->GetNameOfClass());
  population.StrategicParameters().push_back(parameter);

  //Last calculated population variate for variance mutation
  parameter = IndividualType::StrategicParameterType::New();
  parameter->SetValue(0.0);
  parameter->SetHandling(IndividualType::StrategicParameterType::HStatic);
  parameter->SetOrigin(this->GetNameOfClass());
  population.StrategicParameters().push_back(parameter);

  //Last calculated population variate for skewness mutation
  parameter = IndividualType::StrategicParameterType::New();
  parameter->SetValue(0.0);
  parameter->SetHandling(IndividualType::StrategicParameterType::HStatic);
  parameter->SetOrigin(this->GetNameOfClass());
  population.StrategicParameters().push_back(parameter);
};

template <class TIndividual>
void
AsymmetricMutation<TIndividual>
::MutateStrategicIndividualParameters(IndividualType& individual, PopulationType& population) const
{
  typename PopulationType::StrategicParametersType::SelectedParametersType popParameters =
    population.StrategicParameters().GetStrategicParameters(this->GetNameOfClass());

  if (popParameters.size()<2) itkExceptionMacro(<<"Error. Invalid count of strategic population parameters belongig to "<<this->GetNameOfClass()<<". Ensure that parameters have been registered correctly.");

  //get population mutation parameters
  double z = popParameters[0]->GetValue(); 
  double z_skew = popParameters[1]->GetValue();

  //get all strategic individual parameters of the mutation
  typename IndividualType::StrategicParametersType::SelectedParametersType parameters =
    individual.StrategicParameters().GetStrategicParameters(this->GetNameOfClass());

  for (unsigned long index = 0; index<parameters.size(); index = index+2)
  {
    //calculate individual mutation parameters
    double z_i = exp(vnl_sample_normal(0,m_Tau));
    double z_i_skew = vnl_sample_normal(0,m_Tau_Skewness);

    typename IndividualType::StrategicParameterValueType variance = (parameters[index])->GetValue();
    //mutate variance
    variance = variance * z * z_i;
    //set new value;
    (parameters[index])->SetValue(variance);

    typename IndividualType::StrategicParameterValueType skewness = (parameters[index+1])->GetValue();
    //mutate skewness
    skewness = skewness + z_skew + z_i_skew;
    //set new value;
    (parameters[index+1])->SetValue(skewness);
  }
};

template <class TIndividual>
void
AsymmetricMutation<TIndividual>
::MutateStrategicPopulationParameters(PopulationType& population) const
{
  typename PopulationType::StrategicParametersType::SelectedParametersType popParameters =
    population.StrategicParameters().GetStrategicParameters(this->GetNameOfClass());

  if (popParameters.size()<2) itkExceptionMacro(<<"Error. Invalid count of strategic population parameters belongig to "<<this->GetNameOfClass()<<". Ensure that parameters have been registered correctly.");

  //the variates are outdated, so get some new
  double z = exp(vnl_sample_normal(0,m_TauGlobal));
  double z_skew = vnl_sample_normal(0,m_TauGlobal_Skewness);

  popParameters[0]->SetValue(z);
  popParameters[1]->SetValue(z_skew);
};

template <class TIndividual>
double
AsymmetricMutation<TIndividual>
::MutateValue(const double& value)
{
    double mutatedValue = value;
    m_RandomGenerator->SetGamma(m_Gamma);
    m_RandomGenerator->SetVariance(m_MutateValueVariance);
    m_RandomGenerator->SetSkewness(m_MutateValueSkewness);

    mutatedValue += m_RandomGenerator->GetVariate()/this->m_MutateValueScale;
    return mutatedValue;
};

template <class TIndividual>
void
AsymmetricMutation<TIndividual>
::MutateObjectivParameters(IndividualType* pIndividual, PopulationType* pPopulation) const
{
  if (!pIndividual) itkExceptionMacro(<<"Error. Passed individual is Null.");
  if (!pPopulation) itkExceptionMacro(<<"Error. Passed population is Null.");

  //get the strategic parameters
  typename IndividualType::StrategicParametersType::SelectedParametersType parameters =
    pIndividual->StrategicParameters().GetStrategicParameters(this->GetNameOfClass());

  if (parameters.size()!=(pIndividual->ObjectiveParameters().size())*2) throwExceptionMacro("Error. Invalid number of strategic parameters (two strategic parameters needed per objective parameter). Ensure that strategic parameters are properly registered. Objective count:" << pIndividual->ObjectiveParameters().size() <<"; strategic count: "<< parameters.size());
  if (pIndividual->ObjectiveParameters().size()!=this->m_GeneralObjectiveScales.size()) throwExceptionMacro("Error. Number of objective parameters and global scales are not equal. Ensure that scales have been set properly. Objective count:" << pIndividual->ObjectiveParameters().size() <<"; objective scales count: "<< this->m_GeneralObjectiveScales.size());

  for (unsigned long index = 0; index<pIndividual->ObjectiveParameters().size(); index++)
  {
    typename IndividualType::StrategicParameterValueType variance = (parameters[index*2])->GetValue();
    typename IndividualType::StrategicParameterValueType skewness = (parameters[(index*2)+1])->GetValue();
    typename IndividualType::ObjectiveParameterType mutatedParameter = (pIndividual->ObjectiveParameters())[index];

    //mutate parameter
    m_RandomGenerator->SetGamma(m_Gamma);
    m_RandomGenerator->SetVariance(m_MutateValueVariance);
    m_RandomGenerator->SetSkewness(m_MutateValueSkewness);

    mutatedParameter += m_RandomGenerator->GetVariate()/this->m_GeneralObjectiveScales[index];
    
    //set new value;
    (pIndividual->ObjectiveParameters())[index] = mutatedParameter;
  }
};


} // end of namespace ES
} // end of namespace FREE

#endif

---