[research/lotterysim] miscel changes

script/research/lotterysim/.ipynb_checkpoints/playground-checkpoint.ipynb

@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "id": "c0e2a42d",
    "metadata": {},
    "outputs": [],
@@ -218,6 +218,70 @@
     "draw()"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "3aa2e8fc",
+   "metadata": {},
+   "source": [
+    "# randomize token in stake"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "01b062b3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def vesting_instance(kp, ki, kd, initial_distribution):\n",
+    "    os.system(\"rm f.hist; rm leads.hist\")\n",
+    "    RUNNING_TIME = len(next(iter(vesting.values())))*28800\n",
+    "\n",
+    "    if __name__ == \"__main__\":\n",
+    "        darkies = []\n",
+    "        id = 0\n",
+    "        for name, distrib in vesting.items():\n",
+    "            darkies += [Darkie(initial_distribution[id], vesting=distrib)]\n",
+    "            id+=1\n",
+    "        airdrop = ERC20DRK\n",
+    "        for darkie in darkies:\n",
+    "            airdrop+=darkie.stake\n",
+    "        print(\"network airdrop: {} on {} nodes\".format(airdrop, len(darkies)))\n",
+    "        dt = DarkfiTable(airdrop, RUNNING_TIME)\n",
+    "        for darkie in darkies:\n",
+    "            dt.add_darkie(darkie)\n",
+    "        dt.background(rand_running_time=False)\n",
+    "        dt.write()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "0de9a2ce",
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'NODES' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[0;32m/tmp/ipykernel_96111/1021349709.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mki\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m0.005999999985257798\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mkd\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0.01299999999999478\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mgenesis_distribution\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mrandom\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandom\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mNODES\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0m_\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mNODES\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      5\u001b[0m \u001b[0mvesting_instance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mki\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkd\u001b[0m\u001b[0;34m,\u001b[0m  \u001b[0mgenesis_distribution\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;31mNameError\u001b[0m: name 'NODES' is not defined"
+     ]
+    }
+   ],
+   "source": [
+    "kp=-0.03999999999998902\n",
+    "ki=-0.005999999985257798\n",
+    "kd=0.01299999999999478\n",
+    "NODES=1000\n",
+    "genesis_distribution = [random.random*NODES for _ in range(NODES)]\n",
+    "vesting_instance(kp, ki, kd,  genesis_distribution)\n",
+    "draw()"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "571219cb",
@@ -243,7 +307,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.9"
+   "version": "3.10.6"
   }
  },
  "nbformat": 4,

script/research/lotterysim/auto_crawler.py

@@ -40,8 +40,8 @@ randomize_nodes = args.randomize_nodes
 rand_running_time = args.rand_running_time
 debug = args.debug
 
-def experiment(accs=[], controller_type=CONTROLLER_TYPE_DISCRETE, kp=0, ki=0, kd=0, distribution=[], hp=False):
-    dt = DarkfiTable(sum(distribution), RUNNING_TIME, controller_type, kp=kp, ki=ki, kd=kd)
+def experiment(accs=[], controller_type=CONTROLLER_TYPE_DISCRETE, kp=0, ki=0, kd=0, distribution=[], hp=True):
+    dt = DarkfiTable(ERC20DRK, RUNNING_TIME, controller_type, kp=kp, ki=ki, kd=kd)
     RND_NODES = random.randint(5, NODES) if randomize_nodes else NODES
     for idx in range(0,RND_NODES):
         darkie = Darkie(distribution[idx])
@@ -50,7 +50,7 @@ def experiment(accs=[], controller_type=CONTROLLER_TYPE_DISCRETE, kp=0, ki=0, kd
     accs+=[acc]
     return acc
 
-def multi_trial_exp(kp, ki, kd, distribution = [], hp=False):
+def multi_trial_exp(kp, ki, kd, distribution = [], hp=True):
     global highest_acc
     global highest_gain
     new_record=False
@@ -94,7 +94,7 @@ def crawler(crawl, range_multiplier, step=0.1):
     crawl_range = np.arange(range_start, range_end, step)
     np.random.shuffle(crawl_range)
     crawl_range = tqdm(crawl_range)
-    distribution = [random.random()*NODES for i in range(NODES)]
+    distribution = [random.gauss(ERC20DRK/NODES, ERC20DRK/NODES*0.1) for i in range(NODES)]
     for i in crawl_range:
         kp = i if crawl==KP else highest_gain[0]
         ki = i if crawl==KI else highest_gain[1]

script/research/lotterysim/auto_crawler_takahashi.py

@@ -46,7 +46,7 @@ debug = args.debug
 
 
 def experiment(accs=[], controller_type=CONTROLLER_TYPE_TAKAHASHI, kp=0, ki=0, kd=0, kc=0, ti=0, td=0, ts=0, distribution=[], hp=False):
-    dt = DarkfiTable(sum(distribution), RUNNING_TIME, controller_type, kp=kp, ki=ki, kd=kd, kc=kc, td=td, ti=ti, ts=ts)
+    dt = DarkfiTable(ERC20DRK, RUNNING_TIME, controller_type, kp=kp, ki=ki, kd=kd, kc=kc, td=td, ti=ti, ts=ts)
     RND_NODES = random.randint(5, NODES) if randomize_nodes else NODES
     for idx in range(0,RND_NODES):
         darkie = Darkie(distribution[idx])
@@ -101,7 +101,7 @@ def crawler(crawl, range_multiplier, step=0.1):
     crawl_range = np.arange(range_start, range_end, step)
     np.random.shuffle(crawl_range)
     crawl_range = tqdm(crawl_range)
-    distribution = [random.random()*NODES for i in range(NODES)]
+    distribution = [random.random()*ERC20DRK*0.0001 for i in range(NODES)]
     for i in crawl_range:
         kc = i if crawl==KC else highest_gain[0]
         ti = i if crawl==TI else highest_gain[1]

script/research/lotterysim/constants.py

@@ -5,8 +5,6 @@ CONTROLLER_TYPE_ANALOGUE=-1
 CONTROLLER_TYPE_DISCRETE=0
 CONTROLLER_TYPE_TAKAHASHI=1
 
-
-
 L = 28948022309329048855892746252171976963363056481941560715954676764349967630337.0
 N_TERM = 2
 REWARD = 1
@@ -15,10 +13,10 @@ F_MIN = 0.01
 F_MAX = 0.99
 EPSILON = 1
 
-
 L_HP = Num(28948022309329048855892746252171976963363056481941560715954676764349967630337.0)
 REWARD_HP = Num(1)
 BASE_L_HP = L_HP*Num(0.01)
 F_MIN_HP = Num(0.01)
 F_MAX_HP = Num(0.99)
 EPSILON_HP = Num(1)
+ERC20DRK=2.1*10**9

script/research/lotterysim/darkie.py

@@ -6,6 +6,7 @@ class Darkie(Thread):
         Thread.__init__(self)
         self.vesting = [0] + vesting
         self.stake = (Num(airdrop) if hp else airdrop)
+        self.initial_stake = self.stake # for debugging purpose
         self.finalized_stake = (Num(airdrop) if hp else airdrop) # after fork finalization
         self.Sigma = None
         self.feedback = None
@@ -14,11 +15,11 @@ class Darkie(Thread):
         self.commit = commit # commit to staked tokens
         self.epoch_len=epoch_len # epoch length during which the stake is static
         self.staked_tokens_ratio = 1 # ratio of staked tokens, if commit is true then it's 100%
-
+        self.slot = 0
     def clone(self):
         return Darkie(self.finalized_stake)
 
-    def set_sigma_feedback(self, sigma, feedback, f, count, hp=False):
+    def set_sigma_feedback(self, sigma, feedback, f, count, hp=True):
         self.Sigma = (Num(sigma) if hp else sigma)
         self.feedback = (Num(feedback) if hp else feedback)
         self.f = (Num(f) if hp else f)
@@ -31,13 +32,13 @@ class Darkie(Thread):
             self.staked_tokens_ratio = random.random()
         return self.staked_tokens_ratio*self.finalized_stake
 
-    def run(self, hp=False):
+    def run(self, hp=True):
         k=N_TERM
         def target(tune_parameter, stake):
             x = (Num(1) if hp else 1)  - (Num(tune_parameter) if hp else tune_parameter)
             c = (x.ln() if type(x)==Num else math.log(x))
             sigmas = [   c/((self.Sigma+EPSILON)**i) * ( ((L_HP if hp else L)/fact(i)) ) for i in range(1, k+1) ]
-            scaled_target = approx_target_in_zk(sigmas, stake) #+ (BASE_L_HP if hp else BASE_L)
+            scaled_target = approx_target_in_zk(sigmas, Num(stake)) #+ (BASE_L_HP if hp else BASE_L)
             return scaled_target
         T = target(self.f, self.randomized_finalized_stake())
         self.won = lottery(T, hp)
@@ -54,10 +55,17 @@ class Darkie(Thread):
         return vesting_value
 
     def update_stake(self):
-        self.stake+=REWARD
+        if self.won:
+            self.stake+=REWARD
 
     def finalize_stake(self):
         if self.won:
             self.finalized_stake = self.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

script/research/lotterysim/highest_gain.txt

@@ -1 +1 @@
-accuracy:0.6955837324770962, kp: -0.04079999999987706, ki:-0.0091999992923755, kd:0.021599999999995102
+accuracy:0.7414672554662889, kp: -0.03179999999987708, ki:-0.03319999929237562, kd:0.0015999999999950984

script/research/lotterysim/highest_gain_takahashi.txt

@@ -1 +1 @@
-accuracy:0.6057924410609251, kc: -0.9259999999999974, td:-0.05600000000011672, ti:0.2690000000000005, ts:-1.5620000000002774
+accuracy:0.16051150895140665, kc: -0.25199999999999356, td:-0.03199999999964992, ti:0.565800000000054, ts:1.285999999984064

script/research/lotterysim/instance.py

@@ -9,7 +9,7 @@ RUNNING_TIME = int(input("running time:"))
 if __name__ == "__main__":
     darkies = []
     #darkies += [ Darkie(abs(random.gauss(20,20))*50, commit=False) for id in range(1000) ]
-    darkies += [ Darkie(1, commit=False) for id in range(1000) ]
+    darkies += [ Darkie(ERC20DRK*random.random(), commit=False) for id in range(1000) ]
     airdrop = 0
     for darkie in darkies:
         airdrop+=darkie.stake

script/research/lotterysim/lottery.py

@@ -20,7 +20,7 @@ class DarkfiTable:
     def add_darkie(self, darkie):
         self.darkies+=[darkie]
 
-    def background(self, rand_running_time=True, debug=False, hp=False):
+    def background(self, rand_running_time=True, debug=False, hp=True):
         self.debug=debug
         self.start_time=time.time()
         feedback=0 # number leads in previous slot
@@ -40,10 +40,15 @@ class DarkfiTable:
                 self.darkies[i].set_sigma_feedback(self.Sigma, feedback, f, count, hp)
                 self.darkies[i].run(hp)
                 total_vesting_stake+=self.darkies[i].update_vesting()
-            self.Sigma+=total_vesting_stake
             for i in range(len(self.darkies)):
                 winners += self.darkies[i].won
+                self.darkies[i].update_stake()
             feedback = winners
+            if winners==1:
+            #if count >= ERC20DRK and winners==1:
+                self.Sigma += 1
+                for i in range(len(self.darkies)):
+                    self.darkies[i].finalize_stake()
             count+=1
         self.end_time=time.time()
         return self.pid.acc()

script/research/lotterysim/main.py

@@ -36,10 +36,10 @@ debug = True if debug_str.lower()=="y" else False
 
 
 def experiment(accs=[], controller_type=CONTROLLER_TYPE_DISCRETE, kp=0, ki=0, kd=0, airdrop=0, hp=False):
-    dt = DarkfiTable(0, RUNNING_TIME, controller_type, kp=kp, ki=ki, kd=kd)
+    dt = DarkfiTable(ERC20DRK, RUNNING_TIME, controller_type, kp=kp, ki=ki, kd=kd)
     RND_NODES = random.randint(5, NODES) if randomize_nodes else NODES
     for idx in range(0,RND_NODES):
-        darkie = Darkie(airdrop+idx)
+        darkie = Darkie(random.random()*ERC20DRK/(RND_NODES))
         dt.add_darkie(darkie)
     acc = dt.background(rand_running_time, hp)
     accs+=[acc]
@@ -48,6 +48,7 @@ def experiment(accs=[], controller_type=CONTROLLER_TYPE_DISCRETE, kp=0, ki=0, kd
 highest_acc = 0
 
 def multi_trial_exp(gains, kp, ki, kd, hp=False):
+    global highest_acc
     experiment_accs = []
     exp_threads = []
     for i in range(0, AVG_LEN):
@@ -68,6 +69,7 @@ def multi_trial_exp(gains, kp, ki, kd, hp=False):
                 f.write(buff)
 
 def single_trial_exp(gains, kp, ki, kd, hp=False):
+    global highest_acc
     acc = experiment(kp=kp, ki=ki, kd=kd, hp=hp)
     buff = 'accuracy:{}, kp: {}, ki:{}, kd:{}'.format(acc, kp, ki, kd)
     print(buff)

script/research/lotterysim/pid.py

@@ -37,7 +37,6 @@ class PID:
             #print("pid::k2: {}".format(k2))
             #print("pid::k3: {}".format(k3))
         ret = self.f_hist[-1] + k1 * err + k2 * self.error_hist[-1] + k3 * self.error_hist[-2]
-
         self.error_hist+=[err]
         self.feedback_hist+=[feedback]
         return ret

script/research/lotterysim/utils.py

@@ -24,7 +24,7 @@ def approx_target_in_zk(sigmas, stake):
     # this dictates that tuning need to be hardcoded,
     # secondly the reward, or at least the total stake in the network,
     # can't be anonymous, should be public.
-    T = [sigma*(stake+1)**(i+1) for i, sigma in enumerate(sigmas)]
+    T = [sigma*(stake)**(i+1) for i, sigma in enumerate(sigmas)]
     return -1*sum(T)
 
 def rnd(hp=False):