summaryrefslogtreecommitdiff
path: root/model
diff options
context:
space:
mode:
authorJan Huwald <jh@sotun.de>2012-05-07 20:01:51 (GMT)
committerJan Huwald <jh@sotun.de>2012-05-07 20:01:51 (GMT)
commit420d2ef464d4a741028e132e662d5626806a41f5 (patch)
tree1aca6eb512e4ed0fb5f3c10c528cb998b6ffd695 /model
Initial commitHEADmaster
Diffstat (limited to 'model')
-rw-r--r--model/LongerET.model183
-rw-r--r--model/Rand.model187
-rw-r--r--model/TauV.model187
-rw-r--r--model/WinAdv.model187
-rw-r--r--model/default.model187
5 files changed, 931 insertions, 0 deletions
diff --git a/model/LongerET.model b/model/LongerET.model
new file mode 100644
index 0000000..c1af44a
--- /dev/null
+++ b/model/LongerET.model
@@ -0,0 +1,183 @@
+const const {
+ double FireThreshold = 0.015; // [V], fasimu
+ double Tau_Voltage = 0.05; // [s], fasimu
+ double RefractoryPeriod = 0.001; // [s], fasimu
+ double Tau_Dopamine = 0.005; // [s], fasimu
+ double TauEligibility = 0.5; // [s], fasimu
+ double Tau_LTP = 0.014; // [s], fasimu
+ double Tau_LTD = 0.034; // [s], fasimu
+ double Delta_LTP = 1; // [V]
+ double Delta_LTD = 1; // [V]
+ double DeltaET_LTP = 0.000103; // christina 2008 (poster)
+ double DeltaET_LTD = 0.000055; // christina 2008 (poster)
+
+ double Tau_MomEst = 0.01; // [s]
+ double Tau_SlowMomEst = 20; // [s]
+
+ double TargetFreq = 10; // [Hz]
+
+ double RandomFreq = 3.15; // [Hz] (per neuron); is the break even
+ // point (rand freq = neuron freq) w/o IP
+ double RandomSpikeWeight = 0.01; // [V]
+
+ double MaxWeight = 0.004; // [V]
+
+ int TrainerNumSymbols = 2;
+ double TrainerInput = 0.008; // [V]
+ double TrainerInputWindow = 0.05; // [ms]
+ double TrainerInputFreq = 40; // [Hz]
+ double TrainerReward = 50; // reduced to half as Tau_ET will be increased
+ double TrainerPunish = 0;
+ double TrainerReadoutDelay = 0.5;
+ double TrainerReadoutWindow = 0.05;
+ double TrainerReadoutFreq = 40; // [Hz]
+ double TrainerInterTrialDelay = 1;
+ double TrainerInitialDelay = 50;
+
+ int FanIn = 100;
+ int FanOut = 100;
+ int NumExcitatory = 800;
+
+ double LambdaIP1 = 0.00005; // achieves steady state after ~50s
+}
+
+discrete GlobalMsg {
+ TrainerT NextTrainer;
+}
+
+continuous Global {
+ double Dopamine = 0.0;
+ TrainerT Trainer = TrainerT();
+ double Performance = 1.0 / TrainerNumSymbols;
+ uint16_t LastInput = 2;
+ uint16_t LastOutput = 2;
+ bool ResetSpikeCounter = true;
+
+ Dopamine' = Dopamine * exp(-dt / Tau_Dopamine);
+
+ on GlobalMsg {
+ Trainer' = NextTrainer;
+ Performance' = NextTrainer.performance;
+ LastInput' = NextTrainer.input;
+ LastOutput' = NextTrainer.output;
+ ResetSpikeCounter' = NextTrainer.resetCounter;
+ }
+
+ emit GlobalMsg {
+ default true;
+ after Trainer'.delay;
+
+ Dopamine' = Dopamine + Trainer.reward;
+ NextTrainer' = Trainer.update(pc, indices, queues, t);
+ }
+}
+
+continuous Neuron {
+ double Voltage = 0.0;
+ double LTDTrace = 0.0;
+ double RefractoryLeft = 0.0;
+ double SpikeRate = 0.0;
+ double Moment1 = TargetFreq;
+ double SlowMoment1 = TargetFreq;
+ double IPCoeff1 = 0.0;
+ double SumWeight = 0.0; // set by convert_topology
+ double TargetSumWeight = 0.0; // set by convert_topology
+ Time LastSpike = 0.0;
+ uint16_t SpikeCounter = 0;
+ RNG::seed_t RandomSeed = 0; // initialized seperately during bootstrap
+ bool RandomEnabled = false; // an incoming randspike turns this to true,
+ // on outgoing to false again -> only
+ // incoming randspikes generate new ones
+
+ Voltage' = Voltage * exp(-dt / Tau_Voltage);
+ LTDTrace' = LTDTrace * exp(-dt / Tau_LTD);
+ RefractoryLeft' = fmax(0.0, RefractoryLeft - dt);
+ Moment1' = Moment1 * exp(-dt / Tau_MomEst);
+ SpikeCounter' = ResetSpikeCounter ? 0 : SpikeCounter;
+
+ on SpikeArrival {
+ SumWeight' = SumWeight + DeltaWeight;
+ Voltage' = Voltage + Weight;
+ }
+
+ on RandomSpike {
+ Voltage' = Voltage + RandomSpikeWeight + FireThreshold
+ * (context.template getptr<Neuron>()() > NumExcitatory);
+ RandomEnabled' = context.template getptr<Neuron>()() < NumExcitatory;
+ }
+
+ emit Spike {
+ default true;
+ if Voltage' > FireThreshold + _CP(IPCoeff1);
+ if RefractoryLeft' == 0.0;
+
+ LTDTrace' = Delta_LTD;
+ RefractoryLeft' = RefractoryPeriod * (context.template getptr<Neuron>()() < NumExcitatory);
+ Voltage' = 0;
+ LastSpike' = t;
+ SpikeRate' = 1 / (t() - LastSpike());
+
+ Moment1' = Moment1 + SpikeRate' * (1 - exp(- (t() - LastSpike()) / Tau_MomEst));
+ SlowMoment1' = SlowMoment1 * exp(- (t() - LastSpike()) / Tau_SlowMomEst)
+ + SpikeRate' * (1 - exp(- (t() - LastSpike()) / Tau_SlowMomEst));
+ IPCoeff1' = (context.template getptr<Neuron>()() < NumExcitatory)
+ ? fmax(-FireThreshold, IPCoeff1 - (t() - LastSpike()) * LambdaIP1 * (TargetFreq - SpikeRate'))
+ : IPCoeff1;
+
+ SpikeCounter' = ResetSpikeCounter ? 0 : SpikeCounter + 1;
+
+ }
+
+ emit RandomSpike {
+ default false;
+ if RandomEnabled' == true;
+ after RNG::expo(RandomSeed, 1.0 / RandomFreq);
+
+ RandomEnabled' = false;
+ RandomSeed' = RNG::next(RandomSeed);
+ }
+}
+
+continuous Synapse {
+ double Weight = 0.0; // set by convert_topology
+ double DeltaWeight = 0;
+ double TmpDeltaWeight = 0;
+ double EligibilityTrace = 0.0;
+ double LTPTrace = 0.0;
+
+ TmpDeltaWeight' = (Weight >= 0 && Weight <= MaxWeight
+ && (context.template getptr<Neuron>()() < NumExcitatory))
+ ? TmpDeltaWeight
+ + EligibilityTrace * Dopamine
+ * Tau_Dopamine * TauEligibility
+ / (Tau_Dopamine + TauEligibility)
+ * (1.0 - exp( (-(Tau_Dopamine + TauEligibility))
+ / (Tau_Dopamine * TauEligibility)
+ * dt))
+ : 0;
+ // HACK: we compare begin of time interval to evolve with time of the last
+ // outgoing spike; if equal, this is the first time that synapse if
+ // evolved since that spike and we can add LTDTrace
+ EligibilityTrace' = EligibilityTrace * exp(-dt / TauEligibility)
+ + (LastSpike == t) * DeltaET_LTP * LTPTrace';
+ LTPTrace' = LTPTrace * exp(-dt / Tau_LTP);
+
+ on Spike {
+ LTPTrace' = LTPTrace + Delta_LTP;
+ EligibilityTrace' = EligibilityTrace - DeltaET_LTD * LTDTrace;
+ }
+
+ emit SpikeArrival {
+ default true; // unconditionally emit SA event (it is more like
+ // a pseudo event)
+ Weight' = (Weight >= 0 && Weight <= MaxWeight
+ && (context.template getptr<Neuron>()() < NumExcitatory))
+ ? fmin(MaxWeight, fmax(0,
+ (Weight + TmpDeltaWeight)
+ / (SumWeight + TmpDeltaWeight)
+ * TargetSumWeight))
+ : Weight;
+ DeltaWeight' = Weight' - Weight;
+ TmpDeltaWeight' = 0;
+ }
+}
diff --git a/model/Rand.model b/model/Rand.model
new file mode 100644
index 0000000..54c3dd6
--- /dev/null
+++ b/model/Rand.model
@@ -0,0 +1,187 @@
+const const {
+ double FireThreshold = 0.015; // [V], fasimu
+ double Tau_Voltage = 0.05; // [s], fasimu
+ double RefractoryPeriod = 0.001; // [s], fasimu
+ double Tau_Dopamine = 0.005; // [s], fasimu
+ double TauEligibility = 0.2; // [s], fasimu
+ double Tau_LTP = 0.014; // [s], fasimu
+ double Tau_LTD = 0.034; // [s], fasimu
+ double Delta_LTP = 1; // [V]
+ double Delta_LTD = 1; // [V]
+ double DeltaET_LTP = 0.000103; // christina 2008 (poster)
+ double DeltaET_LTD = 0.000055; // christina 2008 (poster)
+
+ double Tau_MomEst = 0.01; // [s]
+ double Tau_SlowMomEst = 20; // [s]
+
+ double TargetFreq = 10; // [Hz]
+
+ double RandomFreq = 3.15; // [Hz] (per neuron); is the break even
+ // point (rand freq = neuron freq) w/o IP
+ double RandomSpikeWeight = 0.01; // [V]
+
+ double MaxWeight = 0.004; // [V]
+
+ int TrainerNumSymbols = 2;
+ double TrainerInput = 0.008; // [V]
+ double TrainerInputWindow = 0.05; // [ms]
+ double TrainerInputFreq = 40; // [Hz]
+ double TrainerWinAdv = 0;
+ double TrainerReward = 50; // reduced to half as Tau_ET will be increased
+ double TrainerPunish = 0;
+ double TrainerReadoutDelay = 0.25;
+ double TrainerReadoutRandDelay = 0.05;
+ double TrainerReadoutWindow = 0.05;
+ double TrainerReadoutFreq = 40; // [Hz]
+ double TrainerInterTrialDelay = 0.75;
+ double TrainerInterTrialRandDelay = 0.5;
+
+ double TrainerInitialDelay = 50;
+
+ int FanIn = 100;
+ int FanOut = 100;
+ int NumExcitatory = 800;
+
+ double LambdaIP1 = 0.00005; // achieves steady state after ~50s
+}
+
+discrete GlobalMsg {
+ TrainerT NextTrainer;
+}
+
+continuous Global {
+ double Dopamine = 0.0;
+ TrainerT Trainer = TrainerT();
+ double Performance = 1.0 / TrainerNumSymbols;
+ uint16_t LastInput = 2;
+ uint16_t LastOutput = 2;
+ bool ResetSpikeCounter = true;
+
+ Dopamine' = Dopamine * exp(-dt / Tau_Dopamine);
+
+ on GlobalMsg {
+ Trainer' = NextTrainer;
+ Performance' = NextTrainer.performance;
+ LastInput' = NextTrainer.input;
+ LastOutput' = NextTrainer.output;
+ ResetSpikeCounter' = NextTrainer.resetCounter;
+ }
+
+ emit GlobalMsg {
+ default true;
+ after Trainer'.delay;
+
+ Dopamine' = Dopamine + Trainer.reward;
+ NextTrainer' = Trainer.update(pc, indices, queues, t);
+ }
+}
+
+continuous Neuron {
+ double Voltage = 0.0;
+ double LTDTrace = 0.0;
+ double RefractoryLeft = 0.0;
+ double SpikeRate = 0.0;
+ double Moment1 = TargetFreq;
+ double SlowMoment1 = TargetFreq;
+ double IPCoeff1 = 0.0;
+ double SumWeight = 0.0; // set by convert_topology
+ double TargetSumWeight = 0.0; // set by convert_topology
+ Time LastSpike = 0.0;
+ uint16_t SpikeCounter = 0;
+ RNG::seed_t RandomSeed = 0; // initialized seperately during bootstrap
+ bool RandomEnabled = false; // an incoming randspike turns this to true,
+ // on outgoing to false again -> only
+ // incoming randspikes generate new ones
+
+ Voltage' = Voltage * exp(-dt / Tau_Voltage);
+ LTDTrace' = LTDTrace * exp(-dt / Tau_LTD);
+ RefractoryLeft' = fmax(0.0, RefractoryLeft - dt);
+ Moment1' = Moment1 * exp(-dt / Tau_MomEst);
+ SpikeCounter' = ResetSpikeCounter ? 0 : SpikeCounter;
+
+ on SpikeArrival {
+ SumWeight' = SumWeight + DeltaWeight;
+ Voltage' = Voltage + Weight;
+ }
+
+ on RandomSpike {
+ Voltage' = Voltage + RandomSpikeWeight + FireThreshold
+ * (context.template getptr<Neuron>()() > NumExcitatory);
+ RandomEnabled' = context.template getptr<Neuron>()() < NumExcitatory;
+ }
+
+ emit Spike {
+ default true;
+ if Voltage' > FireThreshold + _CP(IPCoeff1);
+ if RefractoryLeft' == 0.0;
+
+ LTDTrace' = Delta_LTD;
+ RefractoryLeft' = RefractoryPeriod * (context.template getptr<Neuron>()() < NumExcitatory);
+ Voltage' = 0;
+ LastSpike' = t;
+ SpikeRate' = 1 / (t() - LastSpike());
+
+ Moment1' = Moment1 + SpikeRate' * (1 - exp(- (t() - LastSpike()) / Tau_MomEst));
+ SlowMoment1' = SlowMoment1 * exp(- (t() - LastSpike()) / Tau_SlowMomEst)
+ + SpikeRate' * (1 - exp(- (t() - LastSpike()) / Tau_SlowMomEst));
+ IPCoeff1' = (context.template getptr<Neuron>()() < NumExcitatory)
+ ? fmax(-FireThreshold, IPCoeff1 - (t() - LastSpike()) * LambdaIP1 * (TargetFreq - SpikeRate'))
+ : IPCoeff1;
+
+ SpikeCounter' = ResetSpikeCounter ? 0 : SpikeCounter + 1;
+
+ }
+
+ emit RandomSpike {
+ default false;
+ if RandomEnabled' == true;
+ after RNG::expo(RandomSeed, 1.0 / RandomFreq);
+
+ RandomEnabled' = false;
+ RandomSeed' = RNG::next(RandomSeed);
+ }
+}
+
+continuous Synapse {
+ double Weight = 0.0; // set by convert_topology
+ double DeltaWeight = 0;
+ double TmpDeltaWeight = 0;
+ double EligibilityTrace = 0.0;
+ double LTPTrace = 0.0;
+
+ TmpDeltaWeight' = (Weight >= 0 && Weight <= MaxWeight
+ && (context.template getptr<Neuron>()() < NumExcitatory))
+ ? TmpDeltaWeight
+ + EligibilityTrace * Dopamine
+ * Tau_Dopamine * TauEligibility
+ / (Tau_Dopamine + TauEligibility)
+ * (1.0 - exp( (-(Tau_Dopamine + TauEligibility))
+ / (Tau_Dopamine * TauEligibility)
+ * dt))
+ : 0;
+ // HACK: we compare begin of time interval to evolve with time of the last
+ // outgoing spike; if equal, this is the first time that synapse if
+ // evolved since that spike and we can add LTDTrace
+ EligibilityTrace' = EligibilityTrace * exp(-dt / TauEligibility)
+ + (LastSpike == t) * DeltaET_LTP * LTPTrace';
+ LTPTrace' = LTPTrace * exp(-dt / Tau_LTP);
+
+ on Spike {
+ LTPTrace' = LTPTrace + Delta_LTP;
+ EligibilityTrace' = EligibilityTrace - DeltaET_LTD * LTDTrace;
+ }
+
+ emit SpikeArrival {
+ default true; // unconditionally emit SA event (it is more like
+ // a pseudo event)
+ Weight' = (Weight >= 0 && Weight <= MaxWeight
+ && (context.template getptr<Neuron>()() < NumExcitatory))
+ ? fmin(MaxWeight, fmax(0,
+ (Weight + TmpDeltaWeight)
+ / (SumWeight + TmpDeltaWeight)
+ * TargetSumWeight))
+ : Weight;
+ DeltaWeight' = Weight' - Weight;
+ TmpDeltaWeight' = 0;
+ }
+}
diff --git a/model/TauV.model b/model/TauV.model
new file mode 100644
index 0000000..f1cd795
--- /dev/null
+++ b/model/TauV.model
@@ -0,0 +1,187 @@
+const const {
+ double FireThreshold = 0.015; // [V], fasimu
+ double TauVoltage = 0.05; // [s], fasimu
+ double RefractoryPeriod = 0.001; // [s], fasimu
+ double Tau_Dopamine = 0.005; // [s], fasimu
+ double TauEligibility = 0.1; // [s], fasimu
+ double Tau_LTP = 0.014; // [s], fasimu
+ double Tau_LTD = 0.034; // [s], fasimu
+ double Delta_LTP = 1; // [V]
+ double Delta_LTD = 1; // [V]
+ double DeltaET_LTP = 0.000103; // christina 2008 (poster)
+ double DeltaET_LTD = 0.000055; // christina 2008 (poster)
+
+ double Tau_MomEst = 0.01; // [s]
+ double Tau_SlowMomEst = 20; // [s]
+
+ double TargetFreq = 10; // [Hz]
+
+ double RandomFreq = 3.15; // [Hz] (per neuron); is the break even
+ // point (rand freq = neuron freq) w/o IP
+ double RandomSpikeWeight = 0.01; // [V]
+
+ double MaxWeight = 0.004; // [V]
+
+ int TrainerNumSymbols = 2;
+ double TrainerInput = 0.008; // [V]
+ double TrainerInputWindow = 0.05; // [ms]
+ double TrainerInputFreq = 40; // [Hz]
+ double TrainerReward = 50; // reduced to half as Tau_ET will be increased
+ double TrainerPunish = 0;
+ double TrainerWinAdv = 0;
+ double TrainerReadoutDelay = 0.25;
+ double TrainerReadoutRandDelay = 0.05;
+ double TrainerReadoutWindow = 0.05;
+ double TrainerReadoutFreq = 40; // [Hz]
+ double TrainerInterTrialDelay = 0.75;
+ double TrainerInterTrialRandDelay = 0.5;
+
+ double TrainerInitialDelay = 50;
+
+ int FanIn = 100;
+ int FanOut = 100;
+ int NumExcitatory = 800;
+
+ double LambdaIP1 = 0.00005; // achieves steady state after ~50s
+}
+
+discrete GlobalMsg {
+ TrainerT NextTrainer;
+}
+
+continuous Global {
+ double Dopamine = 0.0;
+ TrainerT Trainer = TrainerT();
+ double Performance = 1.0 / TrainerNumSymbols;
+ uint16_t LastInput = 2;
+ uint16_t LastOutput = 2;
+ bool ResetSpikeCounter = true;
+
+ Dopamine' = Dopamine * exp(-dt / Tau_Dopamine);
+
+ on GlobalMsg {
+ Trainer' = NextTrainer;
+ Performance' = NextTrainer.performance;
+ LastInput' = NextTrainer.input;
+ LastOutput' = NextTrainer.output;
+ ResetSpikeCounter' = NextTrainer.resetCounter;
+ }
+
+ emit GlobalMsg {
+ default true;
+ after Trainer'.delay;
+
+ Dopamine' = Dopamine + Trainer.reward;
+ NextTrainer' = Trainer.update(pc, indices, queues, t);
+ }
+}
+
+continuous Neuron {
+ double Voltage = 0.0;
+ double LTDTrace = 0.0;
+ double RefractoryLeft = 0.0;
+ double SpikeRate = 0.0;
+ double Moment1 = TargetFreq;
+ double SlowMoment1 = TargetFreq;
+ double IPCoeff1 = 0.0;
+ double SumWeight = 0.0; // set by convert_topology
+ double TargetSumWeight = 0.0; // set by convert_topology
+ Time LastSpike = 0.0;
+ uint16_t SpikeCounter = 0;
+ RNG::seed_t RandomSeed = 0; // initialized seperately during bootstrap
+ bool RandomEnabled = false; // an incoming randspike turns this to true,
+ // on outgoing to false again -> only
+ // incoming randspikes generate new ones
+
+ Voltage' = Voltage * exp(-dt / TauVoltage);
+ LTDTrace' = LTDTrace * exp(-dt / Tau_LTD);
+ RefractoryLeft' = fmax(0.0, RefractoryLeft - dt);
+ Moment1' = Moment1 * exp(-dt / Tau_MomEst);
+ SpikeCounter' = ResetSpikeCounter ? 0 : SpikeCounter;
+
+ on SpikeArrival {
+ SumWeight' = SumWeight + DeltaWeight;
+ Voltage' = Voltage + Weight;
+ }
+
+ on RandomSpike {
+ Voltage' = Voltage + RandomSpikeWeight + FireThreshold
+ * (context.template getptr<Neuron>()() > NumExcitatory);
+ RandomEnabled' = context.template getptr<Neuron>()() < NumExcitatory;
+ }
+
+ emit Spike {
+ default true;
+ if Voltage' > FireThreshold + _CP(IPCoeff1);
+ if RefractoryLeft' == 0.0;
+
+ LTDTrace' = Delta_LTD;
+ RefractoryLeft' = RefractoryPeriod * (context.template getptr<Neuron>()() < NumExcitatory);
+ Voltage' = 0;
+ LastSpike' = t;
+ SpikeRate' = 1 / (t() - LastSpike());
+
+ Moment1' = Moment1 + SpikeRate' * (1 - exp(- (t() - LastSpike()) / Tau_MomEst));
+ SlowMoment1' = SlowMoment1 * exp(- (t() - LastSpike()) / Tau_SlowMomEst)
+ + SpikeRate' * (1 - exp(- (t() - LastSpike()) / Tau_SlowMomEst));
+ IPCoeff1' = (context.template getptr<Neuron>()() < NumExcitatory)
+ ? fmax(-FireThreshold, IPCoeff1 - (t() - LastSpike()) * LambdaIP1 * (TargetFreq - SpikeRate'))
+ : IPCoeff1;
+
+ SpikeCounter' = ResetSpikeCounter ? 0 : SpikeCounter + 1;
+
+ }
+
+ emit RandomSpike {
+ default false;
+ if RandomEnabled' == true;
+ after RNG::expo(RandomSeed, 1.0 / RandomFreq);
+
+ RandomEnabled' = false;
+ RandomSeed' = RNG::next(RandomSeed);
+ }
+}
+
+continuous Synapse {
+ double Weight = 0.0; // set by convert_topology
+ double DeltaWeight = 0;
+ double TmpDeltaWeight = 0;
+ double EligibilityTrace = 0.0;
+ double LTPTrace = 0.0;
+
+ TmpDeltaWeight' = (Weight >= 0 && Weight <= MaxWeight
+ && (context.template getptr<Neuron>()() < NumExcitatory))
+ ? TmpDeltaWeight
+ + EligibilityTrace * Dopamine
+ * Tau_Dopamine * TauEligibility
+ / (Tau_Dopamine + TauEligibility)
+ * (1.0 - exp( (-(Tau_Dopamine + TauEligibility))
+ / (Tau_Dopamine * TauEligibility)
+ * dt))
+ : 0;
+ // HACK: we compare begin of time interval to evolve with time of the last
+ // outgoing spike; if equal, this is the first time that synapse if
+ // evolved since that spike and we can add LTDTrace
+ EligibilityTrace' = EligibilityTrace * exp(-dt / TauEligibility)
+ + (LastSpike == t) * DeltaET_LTP * LTPTrace';
+ LTPTrace' = LTPTrace * exp(-dt / Tau_LTP);
+
+ on Spike {
+ LTPTrace' = LTPTrace + Delta_LTP;
+ EligibilityTrace' = EligibilityTrace - DeltaET_LTD * LTDTrace;
+ }
+
+ emit SpikeArrival {
+ default true; // unconditionally emit SA event (it is more like
+ // a pseudo event)
+ Weight' = (Weight >= 0 && Weight <= MaxWeight
+ && (context.template getptr<Neuron>()() < NumExcitatory))
+ ? fmin(MaxWeight, fmax(0,
+ (Weight + TmpDeltaWeight)
+ / (SumWeight + TmpDeltaWeight)
+ * TargetSumWeight))
+ : Weight;
+ DeltaWeight' = Weight' - Weight;
+ TmpDeltaWeight' = 0;
+ }
+}
diff --git a/model/WinAdv.model b/model/WinAdv.model
new file mode 100644
index 0000000..2b62234
--- /dev/null
+++ b/model/WinAdv.model
@@ -0,0 +1,187 @@
+const const {
+ double FireThreshold = 0.015; // [V], fasimu
+ double Tau_Voltage = 0.05; // [s], fasimu
+ double RefractoryPeriod = 0.001; // [s], fasimu
+ double Tau_Dopamine = 0.005; // [s], fasimu
+ double TauEligibility = 0.2; // [s], fasimu
+ double Tau_LTP = 0.014; // [s], fasimu
+ double Tau_LTD = 0.034; // [s], fasimu
+ double Delta_LTP = 1; // [V]
+ double Delta_LTD = 1; // [V]
+ double DeltaET_LTP = 0.000103; // christina 2008 (poster)
+ double DeltaET_LTD = 0.000055; // christina 2008 (poster)
+
+ double Tau_MomEst = 0.01; // [s]
+ double Tau_SlowMomEst = 20; // [s]
+
+ double TargetFreq = 10; // [Hz]
+
+ double RandomFreq = 3.15; // [Hz] (per neuron); is the break even
+ // point (rand freq = neuron freq) w/o IP
+ double RandomSpikeWeight = 0.01; // [V]
+
+ double MaxWeight = 0.004; // [V]
+
+ int TrainerNumSymbols = 2;
+ double TrainerInput = 0.008; // [V]
+ double TrainerInputWindow = 0.05; // [ms]
+ double TrainerInputFreq = 40; // [Hz]
+ double TrainerWinAdv = 0.1;
+ double TrainerReward = 50; // reduced to half as Tau_ET will be increased
+ double TrainerPunish = 0;
+ double TrainerReadoutDelay = 0.25;
+ double TrainerReadoutRandDelay = 0.05;
+ double TrainerReadoutWindow = 0.05;
+ double TrainerReadoutFreq = 40; // [Hz]
+ double TrainerInterTrialDelay = 0.75;
+ double TrainerInterTrialRandDelay = 0.5;
+
+ double TrainerInitialDelay = 50;
+
+ int FanIn = 100;
+ int FanOut = 100;
+ int NumExcitatory = 800;
+
+ double LambdaIP1 = 0.00005; // achieves steady state after ~50s
+}
+
+discrete GlobalMsg {
+ TrainerT NextTrainer;
+}
+
+continuous Global {
+ double Dopamine = 0.0;
+ TrainerT Trainer = TrainerT();
+ double Performance = 1.0 / TrainerNumSymbols;
+ uint16_t LastInput = 2;
+ uint16_t LastOutput = 2;
+ bool ResetSpikeCounter = true;
+
+ Dopamine' = Dopamine * exp(-dt / Tau_Dopamine);
+
+ on GlobalMsg {
+ Trainer' = NextTrainer;
+ Performance' = NextTrainer.performance;
+ LastInput' = NextTrainer.input;
+ LastOutput' = NextTrainer.output;
+ ResetSpikeCounter' = NextTrainer.resetCounter;
+ }
+
+ emit GlobalMsg {
+ default true;
+ after Trainer'.delay;
+
+ Dopamine' = Dopamine + Trainer.reward;
+ NextTrainer' = Trainer.update(pc, indices, queues, t);
+ }
+}
+
+continuous Neuron {
+ double Voltage = 0.0;
+ double LTDTrace = 0.0;
+ double RefractoryLeft = 0.0;
+ double SpikeRate = 0.0;
+ double Moment1 = TargetFreq;
+ double SlowMoment1 = TargetFreq;
+ double IPCoeff1 = 0.0;
+ double SumWeight = 0.0; // set by convert_topology
+ double TargetSumWeight = 0.0; // set by convert_topology
+ Time LastSpike = 0.0;
+ uint16_t SpikeCounter = 0;
+ RNG::seed_t RandomSeed = 0; // initialized seperately during bootstrap
+ bool RandomEnabled = false; // an incoming randspike turns this to true,
+ // on outgoing to false again -> only
+ // incoming randspikes generate new ones
+
+ Voltage' = Voltage * exp(-dt / Tau_Voltage);
+ LTDTrace' = LTDTrace * exp(-dt / Tau_LTD);
+ RefractoryLeft' = fmax(0.0, RefractoryLeft - dt);
+ Moment1' = Moment1 * exp(-dt / Tau_MomEst);
+ SpikeCounter' = ResetSpikeCounter ? 0 : SpikeCounter;
+
+ on SpikeArrival {
+ SumWeight' = SumWeight + DeltaWeight;
+ Voltage' = Voltage + Weight;
+ }
+
+ on RandomSpike {
+ Voltage' = Voltage + RandomSpikeWeight + FireThreshold
+ * (context.template getptr<Neuron>()() > NumExcitatory);
+ RandomEnabled' = context.template getptr<Neuron>()() < NumExcitatory;
+ }
+
+ emit Spike {
+ default true;
+ if Voltage' > FireThreshold + _CP(IPCoeff1);
+ if RefractoryLeft' == 0.0;
+
+ LTDTrace' = Delta_LTD;
+ RefractoryLeft' = RefractoryPeriod * (context.template getptr<Neuron>()() < NumExcitatory);
+ Voltage' = 0;
+ LastSpike' = t;
+ SpikeRate' = 1 / (t() - LastSpike());
+
+ Moment1' = Moment1 + SpikeRate' * (1 - exp(- (t() - LastSpike()) / Tau_MomEst));
+ SlowMoment1' = SlowMoment1 * exp(- (t() - LastSpike()) / Tau_SlowMomEst)
+ + SpikeRate' * (1 - exp(- (t() - LastSpike()) / Tau_SlowMomEst));
+ IPCoeff1' = (context.template getptr<Neuron>()() < NumExcitatory)
+ ? fmax(-FireThreshold, IPCoeff1 - (t() - LastSpike()) * LambdaIP1 * (TargetFreq - SpikeRate'))
+ : IPCoeff1;
+
+ SpikeCounter' = ResetSpikeCounter ? 0 : SpikeCounter + 1;
+
+ }
+
+ emit RandomSpike {
+ default false;
+ if RandomEnabled' == true;
+ after RNG::expo(RandomSeed, 1.0 / RandomFreq);
+
+ RandomEnabled' = false;
+ RandomSeed' = RNG::next(RandomSeed);
+ }
+}
+
+continuous Synapse {
+ double Weight = 0.0; // set by convert_topology
+ double DeltaWeight = 0;
+ double TmpDeltaWeight = 0;
+ double EligibilityTrace = 0.0;
+ double LTPTrace = 0.0;
+
+ TmpDeltaWeight' = (Weight >= 0 && Weight <= MaxWeight
+ && (context.template getptr<Neuron>()() < NumExcitatory))
+ ? TmpDeltaWeight
+ + EligibilityTrace * Dopamine
+ * Tau_Dopamine * TauEligibility
+ / (Tau_Dopamine + TauEligibility)
+ * (1.0 - exp( (-(Tau_Dopamine + TauEligibility))
+ / (Tau_Dopamine * TauEligibility)
+ * dt))
+ : 0;
+ // HACK: we compare begin of time interval to evolve with time of the last
+ // outgoing spike; if equal, this is the first time that synapse if
+ // evolved since that spike and we can add LTDTrace
+ EligibilityTrace' = EligibilityTrace * exp(-dt / TauEligibility)
+ + (LastSpike == t) * DeltaET_LTP * LTPTrace';
+ LTPTrace' = LTPTrace * exp(-dt / Tau_LTP);
+
+ on Spike {
+ LTPTrace' = LTPTrace + Delta_LTP;
+ EligibilityTrace' = EligibilityTrace - DeltaET_LTD * LTDTrace;
+ }
+
+ emit SpikeArrival {
+ default true; // unconditionally emit SA event (it is more like
+ // a pseudo event)
+ Weight' = (Weight >= 0 && Weight <= MaxWeight
+ && (context.template getptr<Neuron>()() < NumExcitatory))
+ ? fmin(MaxWeight, fmax(0,
+ (Weight + TmpDeltaWeight)
+ / (SumWeight + TmpDeltaWeight)
+ * TargetSumWeight))
+ : Weight;
+ DeltaWeight' = Weight' - Weight;
+ TmpDeltaWeight' = 0;
+ }
+}
diff --git a/model/default.model b/model/default.model
new file mode 100644
index 0000000..46c4c05
--- /dev/null
+++ b/model/default.model
@@ -0,0 +1,187 @@
+const const {
+ double FireThreshold = 0.015; // [V], fasimu
+ double Tau_Voltage = 0.05; // [s], fasimu
+ double RefractoryPeriod = 0.001; // [s], fasimu
+ double Tau_Dopamine = 0.005; // [s], fasimu
+ double TauEligibility = 0.1; // [s], fasimu
+ double Tau_LTP = 0.014; // [s], fasimu
+ double Tau_LTD = 0.034; // [s], fasimu
+ double Delta_LTP = 1; // [V]
+ double Delta_LTD = 1; // [V]
+ double DeltaET_LTP = 0.000103; // christina 2008 (poster)
+ double DeltaET_LTD = 0.000055; // christina 2008 (poster)
+
+ double Tau_MomEst = 0.01; // [s]
+ double Tau_SlowMomEst = 20; // [s]
+
+ double TargetFreq = 10; // [Hz]
+
+ double RandomFreq = 3.15; // [Hz] (per neuron); is the break even
+ // point (rand freq = neuron freq) w/o IP
+ double RandomSpikeWeight = 0.01; // [V]
+
+ double MaxWeight = 0.004; // [V]
+
+ int TrainerNumSymbols = 2;
+ double TrainerInput = 0.008; // [V]
+ double TrainerInputWindow = 0.05; // [ms]
+ double TrainerInputFreq = 40; // [Hz]
+ double TrainerReward = 50; // reduced to half as Tau_ET will be increased
+ double TrainerPunish = 0;
+ double TrainerWinAdv = 0;
+ double TrainerReadoutDelay = 0.25;
+ double TrainerReadoutRandDelay = 0.05;
+ double TrainerReadoutWindow = 0.05;
+ double TrainerReadoutFreq = 40; // [Hz]
+ double TrainerInterTrialDelay = 0.75;
+ double TrainerInterTrialRandDelay = 0.5;
+
+ double TrainerInitialDelay = 50;
+
+ int FanIn = 100;
+ int FanOut = 100;
+ int NumExcitatory = 800;
+
+ double LambdaIP1 = 0.00005; // achieves steady state after ~50s
+}
+
+discrete GlobalMsg {
+ TrainerT NextTrainer;
+}
+
+continuous Global {
+ double Dopamine = 0.0;
+ TrainerT Trainer = TrainerT();
+ double Performance = 1.0 / TrainerNumSymbols;
+ uint16_t LastInput = 2;
+ uint16_t LastOutput = 2;
+ bool ResetSpikeCounter = true;
+
+ Dopamine' = Dopamine * exp(-dt / Tau_Dopamine);
+
+ on GlobalMsg {
+ Trainer' = NextTrainer;
+ Performance' = NextTrainer.performance;
+ LastInput' = NextTrainer.input;
+ LastOutput' = NextTrainer.output;
+ ResetSpikeCounter' = NextTrainer.resetCounter;
+ }
+
+ emit GlobalMsg {
+ default true;
+ after Trainer'.delay;
+
+ Dopamine' = Dopamine + Trainer.reward;
+ NextTrainer' = Trainer.update(pc, indices, queues, t);
+ }
+}
+
+continuous Neuron {
+ double Voltage = 0.0;
+ double LTDTrace = 0.0;
+ double RefractoryLeft = 0.0;
+ double SpikeRate = 0.0;
+ double Moment1 = TargetFreq;
+ double SlowMoment1 = TargetFreq;
+ double IPCoeff1 = 0.0;
+ double SumWeight = 0.0; // set by convert_topology
+ double TargetSumWeight = 0.0; // set by convert_topology
+ Time LastSpike = 0.0;
+ uint16_t SpikeCounter = 0;
+ RNG::seed_t RandomSeed = 0; // initialized seperately during bootstrap
+ bool RandomEnabled = false; // an incoming randspike turns this to true,
+ // on outgoing to false again -> only
+ // incoming randspikes generate new ones
+
+ Voltage' = Voltage * exp(-dt / Tau_Voltage);
+ LTDTrace' = LTDTrace * exp(-dt / Tau_LTD);
+ RefractoryLeft' = fmax(0.0, RefractoryLeft - dt);
+ Moment1' = Moment1 * exp(-dt / Tau_MomEst);
+ SpikeCounter' = ResetSpikeCounter ? 0 : SpikeCounter;
+
+ on SpikeArrival {
+ SumWeight' = SumWeight + DeltaWeight;
+ Voltage' = Voltage + Weight;
+ }
+
+ on RandomSpike {
+ Voltage' = Voltage + RandomSpikeWeight + FireThreshold
+ * (context.template getptr<Neuron>()() > NumExcitatory);
+ RandomEnabled' = context.template getptr<Neuron>()() < NumExcitatory;
+ }
+
+ emit Spike {
+ default true;
+ if Voltage' > FireThreshold + _CP(IPCoeff1);
+ if RefractoryLeft' == 0.0;
+
+ LTDTrace' = Delta_LTD;
+ RefractoryLeft' = RefractoryPeriod * (context.template getptr<Neuron>()() < NumExcitatory);
+ Voltage' = 0;
+ LastSpike' = t;
+ SpikeRate' = 1 / (t() - LastSpike());
+
+ Moment1' = Moment1 + SpikeRate' * (1 - exp(- (t() - LastSpike()) / Tau_MomEst));
+ SlowMoment1' = SlowMoment1 * exp(- (t() - LastSpike()) / Tau_SlowMomEst)
+ + SpikeRate' * (1 - exp(- (t() - LastSpike()) / Tau_SlowMomEst));
+ IPCoeff1' = (context.template getptr<Neuron>()() < NumExcitatory)
+ ? fmax(-FireThreshold, IPCoeff1 - (t() - LastSpike()) * LambdaIP1 * (TargetFreq - SpikeRate'))
+ : IPCoeff1;
+
+ SpikeCounter' = ResetSpikeCounter ? 0 : SpikeCounter + 1;
+
+ }
+
+ emit RandomSpike {
+ default false;
+ if RandomEnabled' == true;
+ after RNG::expo(RandomSeed, 1.0 / RandomFreq);
+
+ RandomEnabled' = false;
+ RandomSeed' = RNG::next(RandomSeed);
+ }
+}
+
+continuous Synapse {
+ double Weight = 0.0; // set by convert_topology
+ double DeltaWeight = 0;
+ double TmpDeltaWeight = 0;
+ double EligibilityTrace = 0.0;
+ double LTPTrace = 0.0;
+
+ TmpDeltaWeight' = (Weight >= 0 && Weight <= MaxWeight
+ && (context.template getptr<Neuron>()() < NumExcitatory))
+ ? TmpDeltaWeight
+ + EligibilityTrace * Dopamine
+ * Tau_Dopamine * TauEligibility
+ / (Tau_Dopamine + TauEligibility)
+ * (1.0 - exp( (-(Tau_Dopamine + TauEligibility))
+ / (Tau_Dopamine * TauEligibility)
+ * dt))
+ : 0;
+ // HACK: we compare begin of time interval to evolve with time of the last
+ // outgoing spike; if equal, this is the first time that synapse if
+ // evolved since that spike and we can add LTDTrace
+ EligibilityTrace' = EligibilityTrace * exp(-dt / TauEligibility)
+ + (LastSpike == t) * DeltaET_LTP * LTPTrace';
+ LTPTrace' = LTPTrace * exp(-dt / Tau_LTP);
+
+ on Spike {
+ LTPTrace' = LTPTrace + Delta_LTP;
+ EligibilityTrace' = EligibilityTrace - DeltaET_LTD * LTDTrace;
+ }
+
+ emit SpikeArrival {
+ default true; // unconditionally emit SA event (it is more like
+ // a pseudo event)
+ Weight' = (Weight >= 0 && Weight <= MaxWeight
+ && (context.template getptr<Neuron>()() < NumExcitatory))
+ ? fmin(MaxWeight, fmax(0,
+ (Weight + TmpDeltaWeight)
+ / (SumWeight + TmpDeltaWeight)
+ * TargetSumWeight))
+ : Weight;
+ DeltaWeight' = Weight' - Weight;
+ TmpDeltaWeight' = 0;
+ }
+}
contact: Jan Huwald // Impressum