[research/lotterysim] another bug in apy_scaled_to_runningtime with time conversion

script/research/lotterysim/core/constants.py

@@ -15,14 +15,16 @@ REWARD_MIN = 0
 REWARD_MAX = 1000
 
 SLOT = 90
-ONE_YEAR = 365.25*24*60*60/SLOT
-TARGET_APY = Num(0.1)
+ONE_YEAR = Num(365.25*24*60*60/SLOT)
 
-PRIMARY_REWARD_TARGET = 0.7 # ratio of staked tokens
+TARGET_APY = Num(1)
+
+PRIMARY_REWARD_TARGET = 0.33 # ratio of staked tokens
 SECONDARY_LEAD_TARGET = 1 #number of lead per slot
 
 EPSILON = 1
-EPOCH_LENGTH = 10
+EPOCH_LENGTH = Num(10)
+
 L_HP = Num(L)
 F_MIN_HP = Num(F_MIN)
 F_MAX_HP = Num(F_MAX)

script/research/lotterysim/core/darkie.py

@@ -14,6 +14,7 @@ class Darkie():
         self.epoch_len=epoch_len # epoch length during which the stake is static
         self.strategy = strategy
         self.slot = 0
+        self.apys = []
 
     def clone(self):
         return Darkie(self.finalized_stake)
@@ -27,18 +28,19 @@ class Darkie():
     '''
 
     '''
-    @rewards: array of reward per epoch, with compound interest.
+    @rewards: array of reward per epoch
+    return apy during runnigntime with compound interest
     '''
-    def apy_scaled_to_epoch(self, rewards):
+    def apy_scaled_to_runningtime(self, rewards):
         avg_apy = 0
         for idx, reward in enumerate(rewards):
             #print('slot: {}, idx: {} of {}, staked tokens: {}, initial stake: {}'.format(self.slot, idx, len(rewards), len(self.strategy.staked_tokens_ratio), len(self.initial_stake)))
             current_epoch_staked_tokens = Num(self.strategy.staked_tokens_ratio[idx-1]) * Num(self.initial_stake[idx-1])
             avg_apy += (Num(reward) / current_epoch_staked_tokens) if current_epoch_staked_tokens!=0 else 0
-        return avg_apy
+        return avg_apy * Num(ONE_YEAR/(self.slot/EPOCH_LENGTH)) if self.slot >0 else 0
 
     def apr_scaled_to_runningtime(self):
-        return (self.stake - self.initial_stake[0]) / self.initial_stake[0]
+        return Num(self.stake - self.initial_stake[0]) / Num(self.initial_stake[0]) *  Num(ONE_YEAR/(self.slot/EPOCH_LENGTH))
 
     def staked_tokens(self):
         '''
@@ -51,8 +53,7 @@ class Darkie():
     def staked_tokens_ratio(self):
         staked_ratio = Num(sum(self.strategy.staked_tokens_ratio)/len(self.strategy.staked_tokens_ratio))
         #print('type: {}, ratio: {}'.format(self.strategy.type, staked_ratio))
-        #TODO (fix)
-        assert(staked_ratio <= 100 and staked_ratio >=0)
+        assert staked_ratio <= 1 and staked_ratio >=0, 'staked_ratio: {}'.format(staked_ratio)
         return staked_ratio
 
 
@@ -60,7 +61,6 @@ class Darkie():
         self.Sigma = (Num(sigma) if hp else sigma)
         self.feedback = (Num(feedback) if hp else feedback)
         self.f = (Num(f) if hp else f)
-        #self.initial_stake += [self.finalized_stake]
         self.slot = count
 
 
@@ -73,13 +73,16 @@ class Darkie():
             scaled_target = approx_target_in_zk(sigmas, Num(stake)) #+ (BASE_L_HP if hp else BASE_L)
             return scaled_target
 
-        if self.slot % EPOCH_LENGTH==0:
+        if self.slot % EPOCH_LENGTH ==0 and self.slot > 0:
+            apy = self.apy_scaled_to_runningtime(rewards)
+            self.apys+=[apy]
+            # staked ratio is added in strategy
+            self.strategy.set_ratio(self.slot, apy)
+            # epoch stake is added
             self.initial_stake +=[self.finalized_stake]
-        self.strategy.set_ratio(self.slot, self.apy_scaled_to_epoch(rewards))
         T = target(self.f, self.strategy.staked_value(self.finalized_stake))
         self.won = lottery(T, hp)
 
-
     def update_vesting(self):
         if self.slot >= len(self.vesting):
             return 0
@@ -94,15 +97,28 @@ class Darkie():
     def update_stake(self, reward):
         if self.won:
             self.stake+=reward
+            #print('updating stake, stake: {}, last: {}'.format(self.stake, self.initial_stake[-1]))
 
     def finalize_stake(self):
+        '''
+        finalize stake if there is single leader
+        '''
         if self.won:
+            #print('finalizing stake')
             self.finalized_stake = self.stake
-        else:
-            self.stake = self.finalized_stake
+        #else:
+            #self.stake = self.finalized_stake
 
     def log_state_gain(self):
         # darkie started with self.initial_stake, self.initial_stake/self.Sigma percent
         # over the course of self.slot
         # current stake is self.stake, self.stake/self.Sigma percent
         pass
+
+    def write(self, idx):
+        with open('log/darkie'+str(idx)+'.log', 'w+') as f:
+            buf = 'initial stake:'+','.join([str(i) for i in self.initial_stake])
+            buf += '\r\n'
+            buf += 'staked ratio:'+','.join([str(i) for i in self.strategy.staked_tokens_ratio])
+            buf += 'apys: '+','.join([str(i) for i in self.apys])
+            f.write(buf)

script/research/lotterysim/core/lottery.py

@@ -39,7 +39,7 @@ class DarkfiTable:
 
             if count%EPOCH_LENGTH == 0:
                 acc = self.secondary_pid.acc_percentage()
-                reward = self.primary_pid.pid_clipped(float(self.avg_stake_ratio()), debug)
+                reward = self.primary_pid.pid_clipped(acc, debug)
                 self.rewards += [reward]
 
             #note! thread overhead is 10X slower than sequential node execution!
@@ -55,7 +55,6 @@ class DarkfiTable:
                 self.darkies[i].update_stake(self.rewards[-1])
                 ###
 
-
             feedback = winners
             if winners==1:
                 if count >= ERC20DRK:
@@ -72,16 +71,21 @@ class DarkfiTable:
         return self.secondary_pid.acc(), avg_apy, avg_reward, stake_ratio, avg_apr
 
     def avg_apy(self):
-        return sum([darkie.apy_scaled_to_epoch(self.rewards) for darkie in self.darkies])/len(self.darkies) * Num(ONE_YEAR/self.running_time) * 100
+        return Num(sum([darkie.apy_scaled_to_runningtime(self.rewards) for darkie in self.darkies])/len(self.darkies))
 
     def avg_apr(self):
-        return sum([darkie.apr_scaled_to_runningtime() for darkie in self.darkies])/len(self.darkies) * (ONE_YEAR/self.running_time) * 100
+        return Num(sum([darkie.apr_scaled_to_runningtime() for darkie in self.darkies])/len(self.darkies))
 
     def avg_stake_ratio(self):
         return sum([darkie.staked_tokens_ratio() for darkie in self.darkies])/len(self.darkies)
 
     def write(self):
         elapsed=self.end_time-self.start_time
+        for id, darkie in enumerate(self.darkies):
+            darkie.write(id)
         if self.debug:
             print("total time: {}, slot time: {}".format(str(timedelta(seconds=elapsed)), str(timedelta(seconds=elapsed/self.running_time))))
         self.secondary_pid.write()
+        with open('log/rewards.log', 'w+') as f:
+            buff = ','.join([str(i) for i in self.rewards])
+            f.write(buff)

script/research/lotterysim/core/strategy.py

@@ -12,7 +12,6 @@ class Strategy(object):
         return
 
     def staked_value(self, stake):
-        #assert(self.staked_tokens_ratio[-1]>=0 and self.staked_tokens_ratio[-1]<=1)
         return Num(self.staked_tokens_ratio[-1])*Num(stake)
 
 class RandomStrategy(Strategy):
@@ -25,23 +24,21 @@ class RandomStrategy(Strategy):
             self.staked_tokens_ratio += [random.random()]
 
 class LinearStrategy(Strategy):
-    '''
-    linear staking strategy wrt apy.
-    assume optimal is 20% APY!
-    '''
     def __init__(self, epoch_len=0):
         super().__init__(epoch_len)
         self.type = 'linear'
 
     def set_ratio(self, slot, apy):
         if slot%self.epoch_len==0:
-            self.staked_tokens_ratio += [Num(apy)/Num(self.target_apy)]
+            sr = Num(apy)/Num(self.target_apy)
+            if sr>1:
+                sr = 0
+            elif sr<0:
+                sr = 0
+            self.staked_tokens_ratio += [sr]
+
 
 class LogarithmicStrategy(Strategy):
-    '''
-    logarithmic staking strategy wrt apy.
-    assume optimal is 20% APY!
-    '''
     def __init__(self, epoch_len=0):
         super().__init__(epoch_len)
         self.type = 'logarithmic'
@@ -50,15 +47,14 @@ class LogarithmicStrategy(Strategy):
         if slot%self.epoch_len==0:
             apy_ratio = math.fabs(apy/self.target_apy)
             fn = lambda x: (math.log(x, 10)+1)/2 * 0.95 + 0.05
-            print('apy_ratio: {}, output: {}'.format(apy_ratio, fn(apy_ratio)))
-            self.staked_tokens_ratio += [Num(fn(apy_ratio) if apy_ratio != 0 else 0)]
-
+            sr = Num(fn(apy_ratio) if apy_ratio != 0 else 0)
+            if sr>1:
+                sr = 0
+            elif sr<0:
+                sr = 0
+            self.staked_tokens_ratio += [sr]
 
 class SigmoidStrategy(Strategy):
-    '''
-    logarithmic staking strategy wrt apy.
-    assume optimal is 20% APY!
-    '''
     def __init__(self, epoch_len=0):
         super().__init__(epoch_len)
         self.type = 'sigmoid'
@@ -67,8 +63,12 @@ class SigmoidStrategy(Strategy):
         if slot%self.epoch_len==0:
             #TODO should be abs?
             apy_ratio = apy/self.target_apy
-            self.staked_tokens_ratio += [Num(2/(1+math.pow(math.e, -4*apy_ratio))-1)]
-
+            sr = Num(2/(1+math.pow(math.e, -4*apy_ratio))-1)
+            if sr>1:
+                sr = 0
+            elif sr<0:
+                sr = 0
+            self.staked_tokens_ratio += [sr]
 
 def random_strategy(epoch_length):
     rnd = random.random()

script/research/lotterysim/discrete_instance.py

@@ -23,7 +23,7 @@ if __name__ == "__main__":
     for darkie in darkies:
         effective_airdrop+=darkie.stake
     print("network airdrop: {}, staked token: {}/{}% on {} nodes".format(airdrop, effective_airdrop, effective_airdrop/airdrop*100, len(darkies)))
-    dt = DarkfiTable(airdrop, RUNNING_TIME, CONTROLLER_TYPE_DISCRETE, kp=-0.010399999999938556, ki=-0.0365999996461878, kd=0.03840000000000491,  r_kp=-0.42, r_ki=2.71, r_kd=-0.239)
+    dt = DarkfiTable(airdrop, RUNNING_TIME, CONTROLLER_TYPE_DISCRETE, kp=-0.010399999999938556, ki=-0.0365999996461878, kd=0.03840000000000491,  r_kp=-0.1345, r_ki=-0.5, r_kd=-0.5)
     for darkie in darkies:
         dt.add_darkie(darkie)
     acc, avg_apy, avg_reward, stake_ratio, avg_apr = dt.background_with_apy(rand_running_time=False)