[research/lotterysim] update vesting, fix vesting apr, enhance logging

script/research/lotterysim/core/constants.py

@@ -16,6 +16,8 @@ REWARD_MAX = 1000
 
 SLOT = 90
 ONE_YEAR = Num(365.25*24*60*60/SLOT)
+ONE_MONTH = int(30*24*60*60/SLOT)
+VESTING_PERIOD = ONE_MONTH
 
 TARGET_APR = Num(0.12)
 
@@ -31,3 +33,4 @@ F_MAX_HP = Num(F_MAX)
 EPSILON_HP = Num(EPSILON)
 REWARD_MIN_HP = Num(REWARD_MIN)
 REWARD_MAX_HP = Num(REWARD_MAX)
+VESTING_FILE='vested_distribution.csv'

script/research/lotterysim/core/darkie.py

@@ -3,9 +3,9 @@ from core.strategy import *
 
 class Darkie():
     def __init__(self, airdrop, initial_stake=None, vesting=[], hp=False, commit=True, epoch_len=EPOCH_LENGTH, strategy=random_strategy(EPOCH_LENGTH)):
-        self.vesting = [0] + vesting
+        self.vesting = vesting
         self.stake = (Num(airdrop) if hp else airdrop)
-        self.initial_stake = [self.stake] # for debugging purpose
+        self.initial_stake = [self.stake]
         self.Sigma = None
         self.feedback = None
         self.f = None
@@ -24,9 +24,16 @@ class Darkie():
             avg_apy += (Num(reward) / current_epoch_staked_tokens) if current_epoch_staked_tokens!=0 else 0
         return avg_apy * Num(ONE_YEAR/(self.slot/EPOCH_LENGTH)) if self.slot  and self.initial_stake[0]>0 >0 else 0
 
+    def vesting_wrapped_initial_stake(self):
+        #print('initial stake: {}, corresponding vesting: {}'.format(self.initial_stake[0], self.vesting[int((self.slot)/VESTING_PERIOD)]))
+        # note index is previous slot since update_vesting is called after background execution.
+        return self.current_vesting() if self.slot>0 else self.initial_stake[0]
 
     def apr_scaled_to_runningtime(self):
-        return Num(self.stake - self.initial_stake[0]) / Num(self.initial_stake[0]) *  Num(ONE_YEAR/(self.slot/EPOCH_LENGTH)) if self.slot> 0 and self.initial_stake[0]>0 else 0
+        initial_stake = self.vesting_wrapped_initial_stake()
+        #print('stake: {}, initial_stake: {}'.format(self.stake, initial_stake))
+        assert self.stake >= initial_stake, 'stake: {}, initial_stake: {}, slot: {}, current: {}, previous: {} vesting'.format(self.stake, initial_stake, self.slot, self.current_vesting(), self.prev_vesting())
+        return Num(self.stake - initial_stake) / Num(initial_stake) *  Num(ONE_YEAR/(self.slot/EPOCH_LENGTH)) if self.slot> 0 and self.initial_stake[0]>0 else 0
 
     def staked_tokens(self):
         '''
@@ -70,14 +77,22 @@ class Darkie():
         self.won_hist += [won]
 
     def update_vesting(self):
-        if self.slot >= len(self.vesting):
-            return 0
-        slot2vest_index = int(self.slot/28800.0) #slot to month conversion
-        slot2vest_prev_index = int((self.slot-1)/28800.0)
-        slot2vest_index_shifted = slot2vest_index - 1 # by end of month
-        slot2vest_prev_index_shifted = slot2vest_prev_index - 1 # by end of month
-        vesting_value = float(self.vesting[slot2vest_index_shifted]) - self.vesting[slot2vest_prev_index_shifted]
-        self.stake+= vesting_value
+        self.stake+= self.vesting_differential()
+
+    def current_vesting(self):
+        '''
+        current corresponding slot vesting
+        '''
+        return self.vesting[int(self.slot/VESTING_PERIOD)]
+
+    def prev_vesting(self):
+        '''
+        previous corresponding slot vesting
+        '''
+        return self.vesting[int((self.slot-1)/VESTING_PERIOD)] if self.slot>0 else self.current_vesting()
+
+    def vesting_differential(self):
+        vesting_value =  self.current_vesting() - self.prev_vesting()
         return vesting_value
 
     def update_stake(self, reward):

script/research/lotterysim/core/lottery.py

@@ -4,6 +4,7 @@ import time
 from datetime import timedelta
 from core.darkie import *
 from pid.cascade import *
+from tqdm import tqdm
 
 class DarkfiTable:
     def __init__(self, airdrop, running_time, controller_type=CONTROLLER_TYPE_DISCRETE, kp=0, ki=0, kd=0, dt=1, kc=0, ti=0, td=0, ts=0, debug=False, r_kp=0, r_ki=0, r_kd=0):
@@ -13,7 +14,9 @@ class DarkfiTable:
         self.start_time=None
         self.end_time=None
         self.secondary_pid = SecondaryDiscretePID(kp=kp, ki=ki, kd=kd) if controller_type==CONTROLLER_TYPE_DISCRETE else SecondaryTakahashiPID(kc=kc, ti=ti, td=td, ts=ts)
+        print('secondary min/max : {}/{}'.format(self.secondary_pid.clip_min, self.secondary_pid.clip_max))
         self.primary_pid = PrimaryDiscretePID(kp=r_kp, ki=r_ki, kd=r_kd) if controller_type==CONTROLLER_TYPE_DISCRETE else PrimaryTakahashiPID(kc=kc, ti=ti, td=td, ts=ts)
+        print('primary min/max : {}/{}'.format(self.primary_pid.clip_min, self.primary_pid.clip_max))
         self.debug=debug
         self.rewards = []
         self.winners = []
@@ -33,9 +36,10 @@ class DarkfiTable:
             #print("random running time: {}".format(self.running_time))
             #print('running time: {}'.format(self.running_time))
 
-        while count < self.running_time:
+        rt_range = tqdm(np.arange(0,self.running_time, 1))
+        for count in rt_range:
+        #while count < self.running_time:
             winners=0
-            total_vesting_stake = 0
             f = self.secondary_pid.pid_clipped(float(feedback), debug)
 
             if count%EPOCH_LENGTH == 0:
@@ -44,13 +48,13 @@ class DarkfiTable:
                 reward = self.primary_pid.pid_clipped(acc, debug)
                 self.rewards += [reward]
 
+            rt_range.set_description('issuance {} DRK'.format(sum(self.rewards)))
             #note! thread overhead is 10X slower than sequential node execution!
             for i in range(len(self.darkies)):
                 self.darkies[i].set_sigma_feedback(self.Sigma, feedback, f, count, hp)
-                total_vesting_stake+=self.darkies[i].update_vesting()
+                self.darkies[i].update_vesting()
                 self.darkies[i].run(hp)
 
-
             #print('reward: {}'.format(rewards[-1]))
             for i in range(len(self.darkies)):
                 winners += self.darkies[i].won_hist[-1]

script/research/lotterysim/core/strategy.py

@@ -74,7 +74,7 @@ class SigmoidStrategy(Strategy):
             self.staked_tokens_ratio += [sr]
             self.annual_return += [apr]
 
-def random_strategy(epoch_length):
+def random_strategy(epoch_length=EPOCH_LENGTH):
     rnd = random.random()
     if rnd < 0.25:
         return Hodler(epoch_length)

script/research/lotterysim/discrete_instance.py

@@ -5,6 +5,7 @@ from core.lottery import *
 import matplotlib.pyplot as plt
 import scipy.stats as stats
 import math
+from draw import draw
 
 os.system("rm log/*_feedback.hist; rm log/*_output.hist")
 
@@ -16,7 +17,7 @@ if __name__ == "__main__":
     darkies = []
 
     for id in range(int(NODES)):
-        darkie = Darkie(random.gauss(egalitarian, egalitarian*0.1), strategy=random_strategy(EPOCH_LENGTH))
+        darkie = Darkie(random.gauss(egalitarian, egalitarian*0.1), strategy=random_strategy())
         darkies += [darkie]
 
     #TODO try rpid with 0mint
@@ -53,3 +54,4 @@ if __name__ == "__main__":
 
     variance = sum(shifted_aprs)/(len(aprs)-1)
     print('mu: {}, variance: {}'.format(str(mu), str(variance)))
+    draw()

script/research/lotterysim/draw.py

@@ -11,25 +11,26 @@ F_PROCESSED_IMG = 'img'+os.sep+"output_history_processed.png"
 SEP = ","
 NODES = 1000 # number of nodes logged
 
-with open(LEAD_FILE) as f:
-    buf = f.read()
-    nodes = buf.split(SEP)[:-1]
-    node_log = []
-    for i in range(0, len(nodes)):
-        node_log+=[int(float(nodes[i]))]
-    freq_single_lead = sum(np.array(node_log)==1)/float(len(node_log))
-    print("single leader frequency: {}".format(freq_single_lead))
-    plt.plot(node_log)
-    plt.legend(['#leads'])
-    plt.savefig(LEAD_PROCESSED_IMG)
+def draw():
+    with open(LEAD_FILE) as f:
+        buf = f.read()
+        nodes = buf.split(SEP)[:-1]
+        node_log = []
+        for i in range(0, len(nodes)):
+            node_log+=[int(float(nodes[i]))]
+        freq_single_lead = sum(np.array(node_log)==1)/float(len(node_log))
+        print("single leader frequency: {}".format(freq_single_lead))
+        plt.plot(node_log)
+        plt.legend(['#leads'])
+        plt.savefig(LEAD_PROCESSED_IMG)
 
 
-with open(F_FILE) as f:
-    buf = f.read()
-    nodes = buf.split(SEP)[:-1]
-    node_log = []
-    for i in range(0, len(nodes)):
-        node_log+=[float(nodes[i])]
-    plt.plot(node_log)
-    plt.legend(['#leads', 'f'])
-    plt.savefig(F_PROCESSED_IMG)
+    with open(F_FILE) as f:
+        buf = f.read()
+        nodes = buf.split(SEP)[:-1]
+        node_log = []
+        for i in range(0, len(nodes)):
+            node_log+=[float(nodes[i])]
+        plt.plot(node_log)
+        plt.legend(['#leads', 'f'])
+        plt.savefig(F_PROCESSED_IMG)