bool TextFileReaderInternal::readArray(NumericalArray<double> *array) throw()
{
ugen_assert(array != 0);
if(isEof()) return false;
Text text = readLine();
if(text != "NumericalArray<double>:v1") return false; // should reset the file position before read
text = readLine(); // should be size info;
int size;
sscanf(text.getArray(), "size:%d", &size);
NumericalArray<double> newArray = NumericalArray<double>::withSize(size);
double *newArrayPtr = newArray.getArray();
for(int i = 0; i < size; i++)
{
text = readLine();
int index;
double value;
sscanf(text.getArray(), "[%d]=%lg", &index, &value);
if(index != i) return false;
newArrayPtr[i] = value;
}
*array = newArray;
return true;
}
void NeuralNodeSimpleInternal::backProp(NumericalArray<float> const& inputVector,
const float error, const float actFuncOffset, const float learnRate,
NumericalArray<float>& adjustVector) throw()
{
float output = this->output;
float adjust = error * (actFuncOffset + (output * (one-output)));
float learn = adjust * learnRate;
float* weightVectorPtr = weightVector.getArray();
float* adjustVectorPtr = adjustVector.getArray();
const float* inputVectorPtr = inputVector.getArray();
const int size = weightVector.size();
for(int i = 0; i < size; i++)
{
weightVectorPtr[i] += inputVectorPtr[i] * learn;
adjustVectorPtr[i] += weightVectorPtr[i] * adjust;
}
threshold += learn;
}
void NeuralNetworkSimpleInternal::backProp(NumericalArray<float> const& inputVector, NumericalArray<float> const& targetVector) throw()
{
NumericalArray<float> outputVector = propogate(inputVector);
float* errorVectorPtr = errorVector.getArray();
const float* targetVectorPtr = targetVector.getArray();
const float* outputVectorPtr = outputVector.getArray();
const int size = errorVector.size();
for(int i = 0; i < size; i++)
{
errorVectorPtr[i] = targetVectorPtr[i] - outputVectorPtr[i];
}
NumericalArray<float> vector = errorVector;
NeuralLayer *layersPtr = layers.getArray();
for(int i = getNumLayersExcludingInput()-1; i >= 0; i--)
{
vector = layersPtr[i].backProp(vector, actFuncOffset, learnRate);
}
}
float NeuralNodeSimpleInternal::propogate(NumericalArray<float> const& inputVector) throw()
{
float input = zero;
const float* inputVectorPtr = inputVector.getArray();
const float* weightVectorPtr = weightVector.getArray();
const int size = weightVector.size();
for(int i = 0; i < size; i++)
{
input += inputVectorPtr[i] * weightVectorPtr[i];
}
float act = input + threshold;
output = one / (one + (float)ugen::pow(ne1, -act));
return output;
}
