Defines.h

Go to the documentation of this file.

/************************************************************************
* Verve                                                                 *
* Copyright (C) 2004-2006                                               *
* Tyler Streeter  tylerstreeter@gmail.com                               *
* All rights reserved.                                                  *
* Web: http://verve-agents.sourceforge.net                              *
*                                                                       *
* This library is free software; you can redistribute it and/or         *
* modify it under the terms of EITHER:                                  *
*   (1) The GNU Lesser General Public License as published by the Free  *
*       Software Foundation; either version 2.1 of the License, or (at  *
*       your option) any later version. The text of the GNU Lesser      *
*       General Public License is included with this library in the     *
*       file license-LGPL.txt.                                          *
*   (2) The BSD-style license that is included with this library in     *
*       the file license-BSD.txt.                                       *
*                                                                       *
* This library 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 files    *
* license-LGPL.txt and license-BSD.txt for more details.                *
************************************************************************/

#ifndef VERVE_DEFINES_H
#define VERVE_DEFINES_H

#include <iostream>
#include <vector>
#include <assert.h>
#include <math.h>

#include "Platform.h"
#include "Logger.h"

namespace verve
{
        #ifdef VERVE_USE_DOUBLE
                typedef double real;
        #else
                typedef float real;
        #endif

        const real VERVE_E = (real)2.71828182845904523536;

        enum AgentArchitecture
        {
                RL,

                MODEL_RL,

                CURIOUS_MODEL_RL
        };

        namespace defaults
        {
                const real stepSize = (real)0.1;

                // --------------------------------------------------------
                // TIME CONSTANT NOTES
                // 
                // These notes discuss the basics of time constants used in all 
                // kinds of dynamic systems.  The time constant is the amount of 
                // time it takes for the output to decay to 37% of its initial value.
                // 
                // Here, let 'T' represent a time constant.
                // 
                // System response with zero input:
                // x(t) = e^(-t/T) * x(0)
                // The discrete time equation is:
                // x(t + dt) = e^(-dt/T) * x(t)
                // 
                // System response with a constant input:
                // x(t) = e^(-t/T) * x(0) + (1 - e^(-t/T)) * h
                // where h is the resting level/equilibrium point/constant input 
                // value.  The discrete time equation is: 
                // x(t + dt) = e^(-dt/T) * x(t) + (1 - e^(-dt/T) * h 
                // --------------------------------------------------------

                // OLD...
                // Learning rates should be much slower than Neuron firing rate 
                // decays (i.e. membrane time constants) to ensure a 
                // steady state condition.  See Porr and Worgotter, "Isotropic 
                // Sequence Order Learning."  Also, the average reinforcement 
                // rate should change much slower than the learning rate.  See 
                // Nathaniel Daw's PhD dissertation.  So the relative rate of 
                // change 
                // of these parameters is:
                // (slowest)
                // average reinforcement rate
                // learning rate
                // change in membrane potential
                // (fastest)

                // The membrane time constant is a measure of how fast a Neuron's 
                // membrane potential can change.  It ranges from 1-100 ms 
                // (0.001-0.1 s) in animals, according to Koch, 1998, "Biophysics 
                // of Computation."  Firing rates change at roughly the same rate 
                // as membrane potentials.

                const real eTraceTimeConstant = (real)0.1;

                const real TDDiscountTimeConstant = (real)1.0;

                const real valueFunctionLearningTimeConstant = (real)0.1;

                const real policyLearningMultiplier = 5;

                const real modelLearningTimeConstant = (real)0.001;

                const real activeETraceThreshold = (real)0.01;

                const real minActionSelectionProb = (real)0.0;

                const AgentArchitecture agentArchitecture = RL;

                const unsigned int maxNumPlanningSteps = 10;

                const real planningUncertaintyThreshold = (real)0.1;
        }
}

#endif

---