Method BP_Single_Thread

LycorisNet/sources/individual.cpp:123–225

Single threaded version of back propagation.

    // Single threaded version of back propagation.
    void Individual::BP_Single_Thread() {
        this->fitness = 0;
        float output[outputNum];
        std::map<uint32_t, float> gradient; // Store the gradient of all nodes.
        for (uint32_t z = 0; z < args->batchSize; ++z) {
            this->forward(args->inputArray[z], output);

            gradient.clear();
            if (args->mode == "predict") { // Predict.
                for (uint32_t j = 0; j < nodeSlice->size(); ++j) {
                    auto index = (*nodeSlice)[nodeSlice->size() - 1 - j];
                    auto n = (*nodeMap)[index];

                    // The output nodes.
                    if (index >= inputNum && index < (inputNum + outputNum)) {
                        gradient[index] = n->value - args->desireArray[z][index - inputNum];
                    }

                    auto grad = gradient[index] * (n->value > 0 ? 1.0f : 0.2f);

                    for (auto iter = n->genomeMap->begin(); iter != n->genomeMap->end(); ++iter) {
                        auto p = gradient.find(iter->first.in);
                        if (p != gradient.end()) {
                            gradient[iter->first.in] += grad * iter->second.weight;
                        } else {
                            gradient[iter->first.in] = grad * iter->second.weight;
                        }

                        (*(n->genomeMap))[iter->first].delta_backup = ((*(n->genomeMap))[iter->first].delta_backup * z -
                                                                       args->lr * grad *
                                                                       (*nodeMap)[iter->first.in]->value) /
                                                                      float(z + 1);

                        if (z == args->batchSize - 1) {
                            (*(n->genomeMap))[iter->first].delta = (*(n->genomeMap))[iter->first].delta * 0.9f +
                                                                   (*(n->genomeMap))[iter->first].delta_backup * 0.1f;
                            (*(n->genomeMap))[iter->first].weight += (*(n->genomeMap))[iter->first].delta;
                        }
                    }

                    n->delta_backup = (n->delta_backup * z - args->lr * grad) / float(z + 1);
                    if (z == args->batchSize - 1) {
                        n->delta = n->delta * 0.9f + n->delta_backup * 0.1f;
                        n->bias += n->delta;
                    }
                }
            } else { // Classify.
                LycorisUtils::softmax(output, outputNum);

                for (uint32_t j = 0; j < nodeSlice->size(); ++j) {
                    auto index = (*nodeSlice)[nodeSlice->size() - 1 - j];
                    auto n = (*nodeMap)[index];

                    // The output nodes.
                    if (index >= inputNum && index < (inputNum + outputNum)) {
                        gradient[index] = output[index - inputNum] - args->desireArray[z][index - inputNum];
                    }