cparameters.cpp

强化学习算法（R-Learning）难得的珍贵资料

	for (;it != parameterObjects->end(); it ++)
	{
		string prefix = (*it).second;

		if (prefix == paramName.substr(0, prefix.length()))
		{
			paramName = paramName.substr(prefix.length());
			if ((*it).first->getParameterIndex(paramName) >= 0)
			{
				(*it).first->addAdaptiveParameter(paramName, paramCalc);
			}
		}
	}

    addParameters(paramCalc, name);
}

void CParameterObject::removeAdaptiveParameter(string paramName)
{
	std::map<string, CAdaptiveParameterCalculator *>::iterator it = adaptiveParameters->find(paramName);

	if (it != adaptiveParameters->end())
	{
		adaptiveParameters->erase(it);
	}
}

bool CParameterObject::operator == (CParameters &parameterObject)
{
	std::map<string, rlt_real>::iterator it = parameters->begin();

	if (parameterObject.getNumParameters() != getNumParameters())
	{
		return false;
	}

	for (int i = 0 ;it != parameters->end(); it++, i++)
	{
		if (parameterObject.getParameterIndex((*it).first) >= 0)
		{
			if (adaptiveParameters->find((*it).first) == adaptiveParameters->end() && fabs((*it).second - parameterObject.getParameter((*it).first)) > 0.00001)
			{
				//printf("Different Param Values for Parameter %s, %f %f\n", (*it).first.c_str(), (*it).second, parameterObject.getParameter((*it).first));
				return false;
			}
		}
		else
		{
			return false;
		}
	}
	return true;
}


void CParameterObject::setParameter(string name, rlt_real value)
{
	CParameters::setParameter(name, value);
	parametersChanged();
}

void CParameterObject::setParameters(CParameters *parameters)
{
	CParameters::setParameters(parameters);
	parametersChanged();
}

void CParameterObject::parametersChanged()
{
	std::list<paramPair>::iterator it = parameterObjects->begin();

	for (;it != parameterObjects->end(); it ++)
	{
		string prefix = (*it).second;
		for (int i = 0; i < getNumParameters(); i++)
		{
			string paramName = getParameterName(i);
			rlt_real value = getParameter(paramName);

			if (prefix == paramName.substr(0, prefix.length()))
			{
				paramName = paramName.substr(prefix.length());
				if ((*it).first->getParameterIndex(paramName) >= 0 && fabs((*it).first->getParameter(paramName) - value) > 0.00001)
				{
					(*it).first->setParameter(paramName, value);
				}
			}
		}
	}
	onParametersChanged();
}

void CParameterObject::addParameters(CParameterObject *lparameters, string prefix)
{
	std::map<string, rlt_real>::iterator it = parameters->begin();

	for (int i = 0; i < lparameters->getNumParameters(); i ++)
	{
		string name = prefix + lparameters->getParameterName(i);
		it = parameters->find(name);

		if (it == parameters->end()) 
		{
			(*parameters)[name] = lparameters->getParameterFromIndex(i);
		}
	} 
	parameterObjects->push_back(paramPair(lparameters, prefix));
}

rlt_real CParameterObject::getParameter(string name)
{
	std::map<string, CAdaptiveParameterCalculator *>::iterator it = adaptiveParameters->find(name);

	if (it != adaptiveParameters->end())
	{
		return (*it).second->getParameterValue();
	}
	else
	{
		return CParameters::getParameter(name);
	}
}

void CParameterObject::resetParameterCalculators()
{
	std::map<string, CAdaptiveParameterCalculator *>::iterator it = adaptiveParameters->begin();

	for (; it != adaptiveParameters->end(); it ++)
	{
		(*it).second->resetCalculator();
	}

	std::list<paramPair>::iterator it2 = parameterObjects->begin();

	for (;it2 != parameterObjects->end(); it2 ++)
	{
		(*it2).first->resetParameterCalculators();
	}

}




CAdaptiveParameterCalculator::CAdaptiveParameterCalculator(int functionKind)
{
	this->functionKind = functionKind;

	addParameter("APFunction", (rlt_real) functionKind);

	targetValue = 0.0;
}

CAdaptiveParameterCalculator::~CAdaptiveParameterCalculator()
{
}

void CAdaptiveParameterCalculator::onParametersChanged()
{
	CParameterObject::onParametersChanged();
	functionKind = my_round(getParameter("APFunction"));

}




CAdaptiveParameterBoundedValuesCalculator::CAdaptiveParameterBoundedValuesCalculator(int functionKind, rlt_real paramOffset, rlt_real paramScale, rlt_real targetMin, rlt_real targetMax) : CAdaptiveParameterCalculator(functionKind)
{
	this->targetMin = targetMin;
	this->targetMax = targetMax;
	this->paramOffset = paramOffset;
	this->paramScale = paramScale;

	addParameter("APTargetMin", targetMin);
	addParameter("APTargetMax", targetMax);
	addParameter("APParamOffset", paramOffset);
	addParameter("APParamScale", paramScale);
	addParameter("APInvertTargetFunction", 0.0);
	addParameter("APTargetScale", 1.0);

	invertTarget = false;
	targetScale = 1.0;

	targetValue = targetMin;

}

CAdaptiveParameterBoundedValuesCalculator::~CAdaptiveParameterBoundedValuesCalculator()
{
}

void CAdaptiveParameterBoundedValuesCalculator::onParametersChanged()
{
	CAdaptiveParameterCalculator::onParametersChanged();

	targetMin = getParameter("APTargetMin");
	targetMax = getParameter("APTargetMax");
	targetScale = getParameter("APTargetScale");
	paramScale = getParameter("APParamScale");
	paramOffset = getParameter("APParamOffset");
	invertTarget = getParameter("APInvertTargetFunction") > 0.5;
}


rlt_real CAdaptiveParameterBoundedValuesCalculator::getParameterValue()
{
	rlt_real functionValue = 0.0;
	rlt_real functionArgument = (targetValue - targetMin) / (targetMax - targetMin);

	if (functionArgument < 0)
	{
		functionArgument = 0;
	}
	else
	{
		if (functionArgument > 1.0)
		{
			functionArgument = 1.0;
		}
	}


	switch (functionKind)
	{
	case LINEAR:
		{
			functionValue = functionArgument;
			break;
		}
	case SQUARE:
		{
			functionValue = pow(functionArgument, 2);
			break;
		}
	case LOG:
		{
			assert(functionArgument >= 0);
			functionValue = log(functionArgument * targetScale + 1.0) / log(1.0 + targetScale);
			break;
		}
	case FRACT:
		{
			assert(functionArgument > 0);
			functionValue = (1.0 / (functionArgument * targetScale + 1.0) - 1.0 / (targetScale + 1.0)) * (1.0 + targetScale) /targetScale;
		}
	case FRACTSQUARE:
		{
			assert(functionArgument > 0);
			rlt_real powScale = pow(targetScale, (rlt_real) 2.0);
			functionValue = (1.0 / (pow(functionArgument, 2) * powScale + 1.0) - 1.0 / (powScale + 1.0)) * (1.0 + powScale) /powScale;
			break;
		}
	case FRACTLOG :
		{
			assert(functionArgument >= 0);
			rlt_real offset = 1.0 / (1.0 + log(1.0 + targetScale));
			functionValue = (1.0 / (1.0 + log(functionArgument * targetScale + 1.0)) - offset) / (1 - offset);
			break;
		}
	default:
		{
			functionValue = functionArgument;
			printf("Unknown Adaptive Parameter Function Value %d, linear used instead\n", functionKind);
		}
	}
	if (invertTarget)
	{
		functionValue = 1 - functionValue;
	}

	return paramOffset + paramScale * functionValue;
}

void CAdaptiveParameterBoundedValuesCalculator::resetCalculator()
{
	targetValue = getParameter("APTargetMin");
}

CAdaptiveParameterUnBoundedValuesCalculator::CAdaptiveParameterUnBoundedValuesCalculator(int functionKind, rlt_real param0, rlt_real paramScale, rlt_real target0, rlt_real targetScale) : CAdaptiveParameterCalculator(functionKind)
{
	addParameter("APTargetOffset", target0);
	addParameter("APTargetScale", targetScale);
	addParameter("APParamOffset", param0);
	addParameter("APParamScale", paramScale);

	addParameter("ApParamLimit", 0.0);

	targetValue = 0.0;

	paramLimit = 0.0;
	targetOffset = target0;
	this->targetScale = targetScale;
}

CAdaptiveParameterUnBoundedValuesCalculator::~CAdaptiveParameterUnBoundedValuesCalculator()
{
}

void CAdaptiveParameterUnBoundedValuesCalculator::onParametersChanged()
{
	CAdaptiveParameterCalculator::onParametersChanged();

	targetOffset = getParameter("APTargetOffset");
	targetScale = getParameter("APTargetScale");
	paramOffset = getParameter("APParamOffset");
	paramScale = getParameter("APParamScale");
}


rlt_real CAdaptiveParameterUnBoundedValuesCalculator::getParameterValue()
{
	rlt_real functionValue = 0.0;
	rlt_real functionArgument = targetOffset + targetValue / targetScale;


	switch (functionKind)
	{
	case LINEAR:
		{
			functionValue = functionArgument;
			break;
		}
	case SQUARE:
		{
			functionValue = pow(functionArgument, 2);
			break;
		}
	case LOG:
		{
			assert(functionArgument >= 0);
			functionValue = log(functionArgument + 1.0);
			break;
		}
	case FRACT:
		{
			assert(functionArgument > 0);
			functionValue = (1.0 / (functionArgument + 1.0));
			break;
		}
	case FRACTSQUARE:
		{
			assert(functionArgument > 0);
			functionValue = 1.0 / (pow(functionArgument, 2) + 1.0);
			break;
		}
	case FRACTLOG :
		{
			assert(functionArgument >= 0);

			functionValue = 1.0 / (1.0 + log(functionArgument + 1.0));
			break;
		}
	default:
		{
			functionValue = functionArgument;
			printf("Unknown Adaptive Parameter Function Value %d, linear used instead\n", functionKind);
		}
	}

	rlt_real paramValue = paramOffset + paramScale * functionValue;
	
	if (paramScale < 0)
	{
		if (paramValue < paramLimit)
		{
			paramValue = paramLimit;
		}
	}
	else
	{
		if (paramValue > paramLimit)
		{
			paramValue = paramLimit;
		}
	}

	return paramValue;
}