alphaneuron.cpp

amygdata的神经网络算法源代码

            converged = 0;
            iterate = 0;

            // set the scheduled spike time to zero to keep
            // the neuron from spiking when an inhibitory input
            // spike has canceled a previously scheduled spike.
            schedSpikeTime = 0;
        }
        else if (currState > 1.0) {
            converged = 1;
            iterate = 0;
        }
        else {
            stateDelta = fabs(1.0 - currState);
            threshCrs = (stateDelta / currDeriv) + lstThreshCrs;
            LOGGER(6, "stateDelta: " << stateDelta << "\nthreshCrs: " << threshCrs << "\nlstThreshCrs: " << lstThreshCrs)
            if ((threshCrs - lstThreshCrs) < convergeRes) {
                if (stateDelta < 1.0) {
                    converged = 1;
                    iterate = 0;
                    LOGGER(6, "threshCrs - lstThreshCrs < convergeRes -- Converged")
                }
                else {
                    converged = 0;
                    calcTime = int(threshCrs);
                    lstThreshCrs = threshCrs;

                    // set the scheduled spike time to zero to keep
                    // the neuron from spiking when an inhibitory input
                    // spike has canceled a previously scheduled spike.
                    schedSpikeTime = 0;
                }
            }
            else {
                converged = 0;
                if ((threshCrs-lstThreshCrs) > maxThreshCrs) {
                //if (threshCrs > maxThreshCrs) {
                    iterate = 0;
                }
                calcTime = int(threshCrs);
                lstThreshCrs = threshCrs;

                // set the scheduled spike time to zero to keep
                // the neuron from spiking when an inhibitory input
                // spike has canceled a previously scheduled spike.
                schedSpikeTime = 0;
            }
        }
    }
    if (converged) {

        // Make sure we wait at least one cycle before spiking
        if (calcTime == inTime) {
            calcTime += simStepSize;
        }
        schedSpikeTime = calcTime;

        LOGGER(5, "Neuron " << nId << " Scheduling spike at " << schedSpikeTime)
        
		Network::GetNetworkRef()->ScheduleSpike( schedSpikeTime, this );
    }
}

float AlphaNeuron::GetMembranePtnl() const
{
    float currState=0.0, currDeriv=0.0;
    unsigned int histSize = inputHist.size();
    unsigned int hbi = histBeginIdx;
    //AmTimeInt calcTime = Node::SimTime();
    AmTimeInt calcTime = Network::GetNetworkRef()->SimTime();

    Utilities::RoundTime(calcTime, pspStepSize);

    for (unsigned int i=hbi; i<histSize; i++) {
        InputHist tmpInput = inputHist[i];
        AmTimeInt funcTime = calcTime - tmpInput.time;
        float funcWeight = tmpInput.weight;

        unsigned int tblIndex = (funcTime / pspStepSize);
        if (tblIndex < pspLSize) {
            if ( funcWeight > 0.0 ) {
                currState = currState + (funcWeight * (epspLookup[tblIndex]));
                currDeriv = currDeriv + (funcWeight * (edPspLookup[tblIndex]));
            }
            else {
                currState = currState + (funcWeight * (ipspLookup[tblIndex]));
                currDeriv = currDeriv + (funcWeight * (idPspLookup[tblIndex]));
            }
        }
        else {
            ++hbi;
        }
    }
    return currState;
}

void AlphaNeuron::ScaleFunctionLookups()
{
    unsigned int i;
    float lastPtnl=0.0;
    float maxPtnl=0.0;

    for (i=0; i<pspLSize; ++i) {
        maxPtnl = epspLookup[i];
        //maxDPtnl = edPspLookup[i];

        if (maxPtnl < lastPtnl) {
            maxPtnl = lastPtnl;
            break;
        }
        else {
            lastPtnl = maxPtnl;
        }

        /*if (maxDPtnl < lastDPtnl) {
            maxDPtnl = lastDPtnl;
            break;
        }
        else {
            lastDPtnl = maxDPtnl;
        } */
    }

    if (maxPtnl == 0.0)
        return;

    // Normalize the function -- a small number is added to the
    // peak to make sure that a weight of 1 will cross the threshold
    float scaleFactor = 1.0/maxPtnl + 0.000001;
    //float dscaleFactor = 1.0/maxDPtnl;
    for (i=0; i<pspLSize; i++) {
        epspLookup[i] = scaleFactor*epspLookup[i];
        edPspLookup[i] = scaleFactor*edPspLookup[i];
    }

    // maxScaledWeight is increased a little bit beyond its
    // true value to make sure that a weight of 1.0 will always
    // exceed the threshold at the peak of the psp curve.
//    maxScaledWeight = ( thresholdPtnl / maxPtnl ) + 0.000001;

    // Scale the inhibitory psp to match the amplitude of the epsp.
    // This will ensure consistent behavior for all time constants
    // (the maximum of the ipsp gets lower with increasing synaptic
    // time constants).
    float imaxPtnl = 0.0;
    lastPtnl = 0.0;
    for (i=0; i<pspLSize; i++) {
        imaxPtnl = ipspLookup[i];
        //imaxDPtnl = idPspLookup[i];

        if (imaxPtnl < lastPtnl) {
            imaxPtnl = lastPtnl;
            break;
        }
        else {
            lastPtnl = imaxPtnl;
        }

        /*if (imaxDPtnl < lastDPtnl) {
            imaxDPtnl = lastDPtnl;
            break;
        }
        else {
            lastDPtnl = imaxDPtnl;
        }*/
    }

    //scaleFactor = 1.0*maxPtnl/imaxPtnl;
    scaleFactor = 1.0/imaxPtnl;
    //dscaleFactor = 0.9*maxDPtnl/imaxDPtnl;
    for (i=0; i<pspLSize; i++) {
        ipspLookup[i] = scaleFactor*ipspLookup[i];
        idPspLookup[i] = scaleFactor*idPspLookup[i];
    }
}

void AlphaNeuron::PrintLookupTables()
{
    cout << "\n\nPrinting excitatory tables:\nepspLookup:\n\n";
    for (unsigned int i=0; i<pspLSize; ++i) {
        cout << i << "\t" << epspLookup[i] << endl;
    }

    /*cout << "\n\nedPspLookup:\n\n";
    for (unsigned int i=0; i<pspLSize; ++i) {
        cout << i << "\t" << edPspLookup[i] << endl;
    }*/

    cout << "\n\nPrinting inhibitory tables:\nipspLookup:\n\n";
    for (unsigned int i=0; i<pspLSize; ++i) {
        cout << i << "\t" << ipspLookup[i] << endl;
    }

    /*cout << "\n\nidPspLookup:\n\n";
    for (unsigned int i=0; i<pspLSize; ++i) {
        cout << i << "\t" << idPspLookup[i] << endl;
    }*/
}

void AlphaNeuron::InitLookup()
{
	FunctionLookup* fl = Network::GetNetworkRef()->GetFunctionLookup();

	try {
		TableProperties t0 = GetTableProps(0);
		TableProperties t1 = GetTableProps(1);
		TableProperties t2 = GetTableProps(2);
		TableProperties t3 = GetTableProps(3);
		epspLookup = fl->GetTableData(t0);
		edPspLookup = fl->GetTableData(t1);
		ipspLookup = fl->GetTableData(t2);
		idPspLookup = fl->GetTableData(t3);
	}
	catch (TableNotFoundException& e) {
		//pspLookup = fl->MakeLookupTable(props);
		MakeLookupTables();
		//PrintLookupTables();
	}
}

TableProperties AlphaNeuron::GetTableProps(unsigned int index)
{
	TableProperties props;
	props.SetClassName("AlphaNeuron");
	props.SetTableSize(pspLSize);
	AlphaNeuronProperties* anProps = dynamic_cast<AlphaNeuronProperties*>(neuronProps);
	float membraneConst = anProps->GetMembraneConst();
	float eSynConst = anProps->GetExcitatorySynapseConst();
	float iSynConst = anProps->GetInhibitorySynapseConst();
	props.AddParam((AmTimeInt)index);
	props.AddParam(membraneConst);
	props.AddParam(eSynConst);
	props.AddParam(iSynConst);
	return props;
}

void AlphaNeuron::MakeLookupTables()
{
	FunctionLookup* fl = Network::GetNetworkRef()->GetFunctionLookup();
	
	TableProperties t0 = GetTableProps(0);
	TableProperties t1 = GetTableProps(1);
	TableProperties t2 = GetTableProps(2);
	TableProperties t3 = GetTableProps(3);
	LOGGER(6, "Making lookup tables")
    epspLookup = fl->MakeLookupTable(t0);
    edPspLookup = fl->MakeLookupTable(t1);
    ipspLookup = fl->MakeLookupTable(t2);
    idPspLookup = fl->MakeLookupTable(t3);
    LOGGER(6, "Lookups made")
    
	AlphaNeuronProperties* anProps = dynamic_cast<AlphaNeuronProperties*>(neuronProps);
	float membraneConst = anProps->GetMembraneConst();
	float eSynConst = anProps->GetExcitatorySynapseConst();
	float iSynConst = anProps->GetInhibitorySynapseConst();

	// TODO: Need to add in code for iSynConst here and in Euler
	Euler* eul = new Euler(1, 0, 100000, eSynConst, iSynConst, membraneConst);

	LOGGER(6, "Filling lookup tables")
    eul->GenExcitatoryTable(pspStepSize, epspLookup, edPspLookup);
    eul->GenInhibitoryTable(pspStepSize, ipspLookup, idPspLookup);
    
    delete eul;
    ScaleFunctionLookups();
}