void ScaledSigmoidFunction::save(ConfigurationParameters& params, QString prefix)
{
params.startObjectParameters(prefix, "ScaledSigmoidFunction", this);
params.createParameter(prefix, "lambda", QString::number(lambda));
params.createParameter(prefix, "min", QString::number(min));
params.createParameter(prefix, "max", QString::number(max));
}
void StepFunction::save(ConfigurationParameters& params, QString prefix)
{
params.startObjectParameters(prefix, "StepFunction", this);
params.createParameter(prefix, "min", QString::number(min));
params.createParameter(prefix, "max", QString::number(max));
params.createParameter(prefix, "threshold", QString::number(threshold));
}
void Pattern::configure(ConfigurationParameters& params, QString prefix) {
//--- get all parameters with the prefix 'cluster:'
QStringList clusterList = params.getParametersWithPrefixList( prefix, "cluster:" );
foreach( QString cluster, clusterList ) {
QString id = cluster.split(':')[1];
if ( id.isNull() || id.isEmpty() ) continue;
//--- now, it check if there is a inputs and outputs parameter and load it
QString str = params.getValue( prefix + "inputs:" + id );
DoubleVector inputs;
if (!str.isNull()) {
QStringList list = str.split(QRegExp("\\s+"), QString::SkipEmptyParts);
for( int i=0; i<list.size(); i++) {
inputs.append( list[i].toDouble() );
}
}
str = params.getValue( prefix + "outputs:" + id );
DoubleVector outputs;
if (!str.isNull()) {
QStringList list = str.split(QRegExp("\\s+"), QString::SkipEmptyParts);
for( int i=0; i<list.size(); i++) {
outputs.append( list[i].toDouble() );
}
}
if ( inputs.size() == 0 && outputs.size() == 0 ) continue;
Cluster* cl = params.getObjectFromParameter<Cluster>( prefix+cluster, false, true );
if ( inputs.size() > 0 ) {
setInputsOf( cl, inputs );
}
if ( outputs.size() > 0 ) {
setOutputsOf( cl, outputs );
}
}
void LinearComboFunction::configure(ConfigurationParameters& params, QString prefix)
{
// We don't need configured component functions here (and they will be
// configured after exiting from this function)
first.reset(params.getObjectFromParameter<OutputFunction>(prefix + "first", false, false));
w1 = 0.0;
QString str = params.getValue(prefix + "w1");
if (!str.isNull()) {
bool ok;
w1 = str.toDouble(&ok);
if (!ok) {
w1 = 0.0;
}
}
second.reset(params.getObjectFromParameter<OutputFunction>(prefix + "second", false, false));
w2 = 0.0;
str = params.getValue(prefix + "w2");
if (!str.isNull()) {
bool ok;
w2 = str.toDouble(&ok);
if (!ok) {
w2 = 0.0;
}
}
// We don't need to reload a reference to the cluster as he calls our setCluster
// function after our creation
}
void ScaledSigmoidFunction::configure(ConfigurationParameters& params, QString prefix)
{
lambda = 1.0;
QString str = params.getValue(prefix + "lambda");
if (!str.isNull()) {
bool ok;
lambda = str.toDouble(&ok);
if (!ok) {
lambda = 1.0;
}
}
min = -1.0;
str = params.getValue(prefix + "min");
if (!str.isNull()) {
bool ok;
min = str.toDouble(&ok);
if (!ok) {
min = -1.0;
}
}
max = 1.0;
str = params.getValue(prefix + "max");
if (!str.isNull()) {
bool ok;
max = str.toDouble(&ok);
if (!ok) {
max = 1.0;
}
}
}
void Linker::save(ConfigurationParameters& params, QString prefix)
{
Updatable::save( params, prefix );
params.startObjectParameters(prefix, "Linker", this);
params.createParameter(prefix, "from", fromc );
params.createParameter(prefix, "to", toc );
}
void StepFunction::configure(ConfigurationParameters& params, QString prefix)
{
min = 0.0;
QString str = params.getValue(prefix + "min");
if (!str.isNull()) {
bool ok;
min = str.toDouble(&ok);
if (!ok) {
min = 0.0;
}
}
max = 1.0;
str = params.getValue(prefix + "max");
if (!str.isNull()) {
bool ok;
max = str.toDouble(&ok);
if (!ok) {
max = 1.0;
}
}
threshold = 0.0;
str = params.getValue(prefix + "threshold");
if (!str.isNull()) {
bool ok;
threshold = str.toDouble(&ok);
if (!ok) {
threshold = 0.0;
}
}
}
void LeakyIntegratorFunction::configure(ConfigurationParameters& params, QString prefix)
{
// Delta is a vector, that is a list of space-separated values
QString str = params.getValue(prefix + "delta");
if (!str.isNull()) {
QStringList list = str.split(QRegExp("\\s+"), QString::SkipEmptyParts);
delta.resize(list.size());
for( int i = 0; i < list.size(); i++) {
bool ok;
delta[i] = list[i].toDouble(&ok);
if (!ok) {
delta[i] = 0.0;
}
}
}
// Also reloading outprev (resizing it to match delta length)
str = params.getValue(prefix + "outprev");
if (!str.isNull()) {
QStringList list = str.split(QRegExp("\\s+"), QString::SkipEmptyParts);
outprev.resize(list.size());
for( int i = 0; i < list.size(); i++) {
bool ok;
outprev[i] = list[i].toDouble(&ok);
if (!ok) {
outprev[i] = 0.0;
}
}
}
outprev.resize(delta.size());
}
void RampFunction::save(ConfigurationParameters& params, QString prefix)
{
params.startObjectParameters(prefix, "RampFunction", this);
params.createParameter(prefix, "minX", QString::number(min_x));
params.createParameter(prefix, "maxX", QString::number(max_x));
params.createParameter(prefix, "minY", QString::number(min_y));
params.createParameter(prefix, "maxY", QString::number(max_y));
}
void CompositeFunction::save(ConfigurationParameters& params, QString prefix)
{
params.startObjectParameters(prefix, "CompositeFunction", this);
params.createParameter(prefix, "first", first.get());
params.createParameter(prefix, "second", second.get());
// We don't need to save the reference to the cluster as he calls our setCluster
// function after our creation
}
void MatrixLinker::save(ConfigurationParameters& params, QString prefix) {
Linker::save( params, prefix );
params.startObjectParameters( prefix, "MatrixLinker", this );
// First creating a string list, then transforming to a single string
QStringList list;
for( unsigned int r=0; r<rows(); r++ ) {
for( unsigned int c=0; c<cols(); c++ ) {
list.push_back(QString::number(w[r][c]));
}
}
params.createParameter(prefix, "weights", list.join(" "));
}
MatrixLinker::MatrixLinker( ConfigurationParameters& params, QString prefix )
: Linker( params, prefix ), nrows(from()->numNeurons()), ncols(to()->numNeurons()), w(nrows, ncols, true) {
// the weights are read from a single vector of data supposing they are row-major arranged
QString str = params.getValue(prefix + "weights");
if (!str.isNull()) {
QStringList list = str.split(QRegExp("\\s+"), QString::SkipEmptyParts);
int cycleLength = nrows*ncols;
if (list.size() != cycleLength) {
#ifdef NNFW_DEBUG
qWarning() << "The number of elements of the weights in configuration file (" << list.size()
<< ") is different from the total number of weights (" << cycleLength << ").";
#endif
cycleLength = std::min(list.size(), cycleLength);
}
for( int i=0; i<cycleLength; i++) {
bool ok;
unsigned int r = i/ncols; //--- division may be expensive
unsigned int c = i%ncols; //--- module may be expensive
w[r][c] = list[i].toDouble(&ok);
if (!ok) {
w[r][c] = 0.0;
}
}
}
}
void CopyLinker::save(ConfigurationParameters& params, QString prefix) {
Linker::save( params, prefix );
params.startObjectParameters( prefix, "CopyLinker", this );
switch( mode ) {
case In2In:
params.createParameter( prefix, "mode", "In2In" );
break;
case In2Out:
params.createParameter( prefix, "mode", "In2Out" );
break;
case Out2In:
params.createParameter( prefix, "mode", "Out2In" );
break;
case Out2Out:
params.createParameter( prefix, "mode", "Out2Out" );
break;
}
}
void LeakyIntegratorFunction::save(ConfigurationParameters& params, QString prefix)
{
params.startObjectParameters(prefix, "LeakyIntegratorFunction", this);
// First creating a string list, then transforming to a single string
QStringList list;
for (unsigned int i = 0; i < delta.size(); i++) {
list.push_back(QString::number(delta[i]));
}
params.createParameter(prefix, "delta", list.join(" "));
// Saving in the same way also outprev
list.clear();
for (unsigned int i = 0; i < delta.size(); i++) {
list.push_back(QString::number(outprev[i]));
}
params.createParameter(prefix, "outprev", list.join(" "));
}
void RampFunction::configure(ConfigurationParameters& params, QString prefix)
{
min_x = 0.0;
QString str = params.getValue(prefix + "minX");
if (!str.isNull()) {
bool ok;
min_x = str.toDouble(&ok);
if (!ok) {
min_x = 0.0;
}
}
max_x = 0.0;
str = params.getValue(prefix + "maxX");
if (!str.isNull()) {
bool ok;
max_x = str.toDouble(&ok);
if (!ok) {
max_x = 0.0;
}
}
min_y = 0.0;
str = params.getValue(prefix + "minY");
if (!str.isNull()) {
bool ok;
min_y = str.toDouble(&ok);
if (!ok) {
min_y = 0.0;
}
}
max_y = 0.0;
str = params.getValue(prefix + "maxY");
if (!str.isNull()) {
bool ok;
max_y = str.toDouble(&ok);
if (!ok) {
max_y = 0.0;
}
}
}
void GainFunction::configure(ConfigurationParameters& params, QString prefix)
{
gainv = 1.0;
QString str = params.getValue(prefix + "gain");
if (!str.isNull()) {
bool ok;
gainv = str.toDouble(&ok);
if (!ok) {
gainv = 1.0;
}
}
}
void ScaleFunction::configure(ConfigurationParameters& params, QString prefix)
{
rate = 1.0;
QString str = params.getValue(prefix + "rate");
if (!str.isNull()) {
bool ok;
rate = str.toDouble(&ok);
if (!ok) {
rate = 1.0;
}
}
}
void FakeSigmoidFunction::configure(ConfigurationParameters& params, QString prefix)
{
lambda = 1.0;
QString str = params.getValue(prefix + "lambda");
if (!str.isNull()) {
bool ok;
lambda = str.toDouble(&ok);
if (!ok) {
lambda = 1.0;
}
}
}
void LogLikeFunction::configure(ConfigurationParameters& params, QString prefix)
{
A = 1.0;
QString str = params.getValue(prefix + "A");
if (!str.isNull()) {
bool ok;
A = str.toDouble(&ok);
if (!ok) {
A = 1.0;
}
}
B = 5.0;
str = params.getValue(prefix + "B");
if (!str.isNull()) {
bool ok;
B = str.toDouble(&ok);
if (!ok) {
B = 5.0;
}
}
}
void LinearFunction::configure(ConfigurationParameters& params, QString prefix)
{
m = 0.0;
QString str = params.getValue(prefix + "m");
if (!str.isNull()) {
bool ok;
m = str.toDouble(&ok);
if (!ok) {
m = 0.0;
}
}
b = 0.0;
str = params.getValue(prefix + "b");
if (!str.isNull()) {
bool ok;
b = str.toDouble(&ok);
if (!ok) {
b = 0.0;
}
}
}
void Genotype::configure( ConfigurationParameters& params, QString prefix ) {
int newsize = params.getValue( prefix + QString( "bitsize" ) ).toInt();
Q_ASSERT_X( newsize > 0,
"Genotype::configure",
"The bitsize must be present in the config file and its value must be greater than zero" );
resize( newsize );
QString zipdata = params.getValue( prefix + QString( "data" ) );
if ( !zipdata.isNull() ) {
fromCompressedString( zipdata );
}
QStringList valuesList = params.getValue( prefix + QString( "fitness" ) )
.split( QRegExp("\\s+"), QString::SkipEmptyParts );
if ( valuesList.size() > 0 ) {
// read the values of fitness
fitnessv.resize(0);
foreach( QString avalue, valuesList ) {
fitnessv << avalue.toDouble();
}
// safe check
if ( fitnessv.size() == 0 ) {
fitnessv.append( 0 );
}
}
CopyLinker::CopyLinker( ConfigurationParameters& params, QString prefix )
: Linker( params, prefix ), dataFrom(), dataTo() {
dimData = qMin( to()->numNeurons(), from()->numNeurons() );
this->mode = (CopyMode)-1;
//--- default initialisation, in the case the user forget to set the parameter
setMode( Out2In );
QString str = params.getValue(prefix + "mode");
if ( !str.isNull() ) {
str = str.toLower();
if ( str == "in2in" ) {
setMode( In2In );
} else if ( str == "in2ou" ) {
setMode( In2Out );
} else if ( str == "out2in" ) {
setMode( Out2In );
} else if ( str == "out2out" ) {
setMode( Out2Out );
}
}
}
void LinearFunction::save(ConfigurationParameters& params, QString prefix)
{
params.startObjectParameters(prefix, "LinearFunction", this);
params.createParameter(prefix, "m", QString::number(m));
params.createParameter(prefix, "b", QString::number(b));
}
void LogLikeFunction::save(ConfigurationParameters& params, QString prefix)
{
params.startObjectParameters(prefix, "LogLikeFunction", this);
params.createParameter(prefix, "A", QString::number(A));
params.createParameter(prefix, "B", QString::number(B));
}
void GainFunction::save(ConfigurationParameters& params, QString prefix)
{
params.startObjectParameters(prefix, "GainFunction", this);
params.createParameter(prefix, "gain", QString::number(gainv));
}
void DeterministicRank::save( ConfigurationParameters& params, QString prefix ) {
params.createParameter( prefix, QString("type"), "DeterministicRank" );
params.createParameter( prefix, QString("nTruncation"), QString("%1").arg( nTruncation ) );
}
void DeterministicRank::configure( ConfigurationParameters& params, QString prefix ) {
nTruncation = params.getValue( prefix + QString( "nTruncation" ) ).toInt();
}
void FakeSigmoidFunction::save(ConfigurationParameters& params, QString prefix)
{
params.startObjectParameters(prefix, "FakeSigmoidFunction", this);
params.createParameter(prefix, "lambda", QString::number(lambda));
}
void ScaleFunction::save(ConfigurationParameters& params, QString prefix)
{
params.startObjectParameters(prefix, "ScaleFunction", this);
params.createParameter(prefix, "rate", QString::number(rate));
}
void IdentityFunction::save(ConfigurationParameters& params, QString prefix)
{
// Just telling our type to ConfigurationParameters
params.startObjectParameters(prefix, "IdentityFunction", this);
}
