Compare commits

...
15 Commits
Author SHA1 Message Date
manuel eec9c82a83 This is getting better and better 2023-07-12 15:15:25 +02:00
manuel 8d5ad7c62d it just look good 2023-07-12 12:33:58 +02:00
manuel 010d1b6d3c simulator 2023-07-05 17:42:45 +02:00
manuel da598c4475 its starting to be more stable 2023-07-05 16:34:06 +02:00
manuel 7554071405 mem 2023-07-04 16:02:53 +02:00
manuel 7d506625bd this shit is it 2023-07-04 09:08:25 +02:00
manuel 1ca6b3d036 wow .. sieht gut aus 2023-07-03 12:53:37 +02:00
manuel 9ed01abea4 ich glaube ich habe es langsam gefixet 2023-06-30 16:04:52 +02:00
manuel 4d4d609cea HA looks good 2023-06-29 09:48:11 +02:00
manuel 4bfe5245a9 something something i broke it meh 2023-06-29 08:02:20 +02:00
manuel 509c59bb88 fuck man major readjustment but it is running again... 2023-06-28 19:40:42 +02:00
manuel b7dc7b99d1 ok dokey, performance ist ein wenig besser 2023-06-27 09:17:14 +02:00
manuel 5514f3f1d9 its starting to get stable 2023-06-26 17:03:15 +02:00
manuel 4cec35935f seams to start working 2023-06-26 13:30:34 +02:00
manuel f60dca6367 a lot of fixes 2023-06-26 11:31:47 +02:00
47 changed files with 1062 additions and 229 deletions
+24
View File
@@ -0,0 +1,24 @@
{
// Use IntelliSense to learn about possible attributes.
// Hover to view descriptions of existing attributes.
// For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
"version": "0.2.0",
"configurations": [{
"name": "Python: Current File with profiler",
"type": "python",
"request": "launch",
"module": "cProfile",
"args": [
"-o", "tmp.prof", "${file}"
]
},
{
"name": "Python: Current File",
"type": "python",
"request": "launch",
"program": "${file}",
"console": "integratedTerminal",
"justMyCode": true
}
]
}
+7
View File
@@ -0,0 +1,7 @@
{
"ansible.python.interpreterPath": "c:\\Users\\handg\\miniconda3\\python.exe",
"[python]": {
"editor.defaultFormatter": "ms-python.autopep8"
},
"python.formatting.provider": "none"
}
+16
View File
@@ -0,0 +1,16 @@
kind: commodity
spec:
- name: "Gem"
max_world_price: 100
- name: "Food"
max_world_price: 5
- name: "Grain"
max_world_price: 5
- name: "Fruit"
max_world_price: 1
+5
View File
@@ -0,0 +1,5 @@
kind: demand
spec:
- name: basic
res:
- 'Food': 1
+17
View File
@@ -0,0 +1,17 @@
kind: production
spec:
- name: Food
amount: 100
prod:
- "Grain": 1
- "Fruit": 1
- name: Grain
amount: 1000
prod:
- Raw_Agriculture_Plot: 1
- name: Fruit
amount: 100
prod:
- Raw_Agriculture_Plot: 1
+15
View File
@@ -0,0 +1,15 @@
kind: world
spec:
- name: gems
res:
- 'Raw_Gem': 15
- name: grass
res:
- 'Raw_Agriculture_Plot': 0.3
- name: forrest
res:
- 'Raw_Agriculture_Plot': 1
File diff suppressed because one or more lines are too long
+6 -5
View File
@@ -4,13 +4,14 @@ spec:
max_world_price: 100
- name: "Food"
max_world_price: 5
max_world_price: 30
- name: "Grain"
max_world_price: 1
max_world_price: 5
- name: "Fruit"
- name: "Fuel"
max_world_price: 1
- name: "Fruit"
max_world_price: 5
+1
View File
@@ -3,3 +3,4 @@ spec:
- name: basic
res:
- 'Food': 1
# - 'Fruit': 0.1
+24 -11
View File
@@ -1,17 +1,30 @@
kind: production
spec:
- name: Food
amount: 100
prod:
- "Grain": 1
- "Fruit": 1
- name: Grain
amount: 1
amount: 20
prod:
- Raw_Agriculture_Plot: 1
Raw_Agriculture_Plot: 1
- name: Fruit
amount: 1
amount: 20
prod:
- Raw_Agriculture_Plot: 1
Raw_Agriculture_Plot: 1
# - name: Wood
# amount: 1000
# prod:
# Raw_Forrest: 1
# - name: Fuel
# amount: 10
# prod:
# Wood: 1
- name: Food
amount: 5
prod:
# Fuel: 1
Fruit: 1
Grain: 2
+4 -2
View File
@@ -6,10 +6,12 @@ spec:
- name: grass
res:
- 'Raw_Agriculture_Plot': 0.3
- 'Raw_Agriculture_Plot': 0.5
- 'Raw_Forrest': 0.5
- name: forrest
res:
- 'Raw_Agriculture_Plot': 1
- 'Raw_Agriculture_Plot': 0.5
- 'Raw_Forrest': 0.5
+27
View File
@@ -0,0 +1,27 @@
version: '3'
services:
database:
image: 'postgres:14'
ports:
- 15432:5432
environment:
POSTGRES_PASSWORD: econ
POSTGRES_USER: admin
POSTGRES_DB: econ
networks:
- postgres-network
pgadmin:
image: dpage/pgadmin4
environment:
PGADMIN_DEFAULT_EMAIL: admin@pgadmin.com
PGADMIN_DEFAULT_PASSWORD: password
PGADMIN_LISTEN_PORT: 80
ports:
- 15433:80
depends_on:
- database
networks:
postgres-network:
driver: bridge
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
+39 -15
View File
@@ -5,7 +5,7 @@ class AutoProductionAgent(BaseAgent):
"""
def __init__(self,sim,business,worker=1,employment_rate=0) -> None:
def __init__(self,sim,business,worker=-1,employment_rate=0) -> None:
super().__init__(sim)
self.business=business
self.prod=business.production
@@ -13,32 +13,56 @@ class AutoProductionAgent(BaseAgent):
self.employment_rate=employment_rate
self.employment_index=worker
self.target=0
self.prod_counter=0
def set_worker(self,workers):
if workers>1:
self.worker=workers
elif workers==-1:
self.worker=-1
else:
self.worker=1
def set_target(self,qty):
self.target=qty
def can_produce(self):
# If can produce item
for com in self.prod["prod"]:
for k,v in com.items():
if v > self.business.inventory[k]:
return False
# how much can we produce
minprod=[]
for k,v in self.prod["prod"].items():
minprod.append(self.business.inventory[k]/v)
possibleProds=int(min(minprod))
return possibleProds*self.prod["amount"]
def should_produce(self):
# check if we should produce
if self.business.resource_in_possesion()>self.target:
return False
return True
if self.business.resource_in_possesion()>=self.target:
return 0
return self.can_produce()
def tick(self,step,epi):
for i in range(self.worker):
if not self.can_produce():
continue
can=self.should_produce()
if can==0:
return
run=True
i=self.worker
while run:
if self.should_produce()==0:
return
if i==0:
return
# remove cost from inventory
for com in self.prod["prod"]:
for k,cost in com.items():
self.business.inventory[k]-=cost
for k,cost in self.prod["prod"].items():
self.business.inventory[k]-=cost
# add commodity
self.business.inventory[self.prod['name']]+=self.prod["amount"]
self.prod_counter+=1
i-=1
def reset_qty(self):
self.prod_counter=0
def qty(self):
return self.prod_counter
+13 -1
View File
@@ -23,4 +23,16 @@ class BaseAgent(ABC):
Resets agent to new episode.
"""
assert "No reset method has been provided"
pass
pass
def unregister(self):
"""
Disables agent by removing it from the simulation
"""
self.simulation.unregister_agent(self.id)
def register(self):
"""
Enables agent by adding it to the simulation:
"""
self.simulation.register_agent(self.id,self.tick,self.reset)
+38 -5
View File
@@ -9,7 +9,7 @@ class Base_Aquire_Agent(BaseAgent,ABC):
Agent for aquire of resources.
business: Business to aquire resources for.
resource: Resource to aquire.
exchanges: list of exchanges to aquire resources from
exchanges: list of exchanges to acquire resources from
"""
self.business=business
self.resource=resource
@@ -17,6 +17,11 @@ class Base_Aquire_Agent(BaseAgent,ABC):
self.orders={i: {} for i in range(len(self.exchanges))}
self.target=0
self.trades=[]
self.tqty=0
self.qty_offset=0
self.texpense=0
self.expense_offset=0
self.max_price=-1
super().__init__(simulation)
@@ -34,7 +39,7 @@ class Base_Aquire_Agent(BaseAgent,ABC):
If err < 0 then agent needs to aquire resources
"""
err=self.business.inventory[self.resource]-self.target
return err
return int(err)
def set_price_max(self,price: int):
"""
@@ -58,9 +63,10 @@ class Base_Aquire_Agent(BaseAgent,ABC):
self.business.balance-=total_price
cx.add_to_account(self.id,"balance",total_price) # prepaid charge account for cx
cx.register_account(self.id,self.business.id)
order=cx.submit_order(self.id,self.resource,amount,price_per,Side.BUY)
if order==None: # Order failed
return False
return None
self.orders[cx_id][order.order_id]=order
self.update_trades()
return order
@@ -73,6 +79,7 @@ class Base_Aquire_Agent(BaseAgent,ABC):
amount=cx.get_account_resource_amount(self.id,"balance")
cx.remove_from_account(self.id,"balance",amount)
self.business.balance+=amount
def collect_resource_from_cxs(self,resource):
"""
@@ -88,13 +95,39 @@ class Base_Aquire_Agent(BaseAgent,ABC):
Returns a list of all trades performed by this agent
"""
trades=[]
self.tqty=0
self.texpense=0
for cx_id in range(len(self.exchanges)):
cx=self.exchanges[cx_id]
orders=self.orders[cx_id]
if len(orders)>0:
for k,o in orders.items():
if k in cx.order_trades_map:
trades.append(cx.order_trades_map[k])
trades.extend(cx.order_trades_map[k])
self.trades=trades
for t in trades:
self.tqty+=t.trade_qty
self.texpense+=round(t.trade_qty*t.trade_price,2)
return trades
# Confirm a purchase of x amount to reduce qty and expense counter
def confirm_purchase(self,confirmed_qty):
expensePer=self.expense/self.qty
confirmedExpense=expensePer*confirmed_qty
self.expense_offset-=confirmedExpense
self.qty_offset-=confirmed_qty
@property
def qty(self):
return self.tqty+self.qty_offset
@property
def expense(self):
return self.texpense+self.expense_offset
def reset(self, episode):
#self.tqty=0
self.qty_offset=0
self.expense_offset=0
self.trades=[]
return super().reset(episode)
+49 -5
View File
@@ -2,6 +2,7 @@ from .base_agent import BaseAgent
from ..exchange import Exchange
from lightmatchingengine.lightmatchingengine import Order,Side
from abc import ABC
from decimal import *
class Base_Distribution_Agent(BaseAgent,ABC):
def __init__(self,simulation,business,resource,exchanges: list) -> None:
@@ -17,12 +18,20 @@ class Base_Distribution_Agent(BaseAgent,ABC):
self.orders={i: {} for i in range(len(self.exchanges))}
self.target=0
self.min_price=-1
self.max_batch_qty=10
self.tincome=0
self.tqty=0
self.income_offset=0
self.qty_offset=0
self.trade_curser=0
super().__init__(simulation)
def set_target(self,target: int):
"""
Sets the amount of resources the agent should keep in business inventory
"""
if target<0:
target=0
self.target=target
@@ -40,7 +49,7 @@ class Base_Distribution_Agent(BaseAgent,ABC):
If err < 0 then agent needs to distribute resources
"""
err=self.business.inventory[self.resource]-self.target
return err
return int(err)
def distribute_resource(self,price_per,amount,cx_id):
@@ -51,12 +60,16 @@ class Base_Distribution_Agent(BaseAgent,ABC):
# Get exchange
cx=self.exchanges[cx_id]
#if amount>=self.max_batch_qty:
# amount=self.max_batch_qty
if not self.business.inventory[self.resource]>=amount:
return False # we dont have enough balance
self.business.inventory[self.resource]-=amount
cx.add_to_account(self.id,self.resource,amount) # prepaid charge account for cx
cx.register_account(self.id,self.business.id)
order=cx.submit_order(self.id,self.resource,amount,price_per,Side.SELL)
if order==None: # Order failed
return False
@@ -71,6 +84,7 @@ class Base_Distribution_Agent(BaseAgent,ABC):
amount=cx.get_account_resource_amount(self.id,"balance")
cx.remove_from_account(self.id,"balance",amount)
self.business.balance+=amount
def collect_resource_from_cxs(self,resource):
"""
@@ -86,12 +100,42 @@ class Base_Distribution_Agent(BaseAgent,ABC):
Returns a list of all trades performed by this agent
"""
trades=[]
self.tqty=0
self.tincome=0
for cx_id in range(len(self.exchanges)):
cx=self.exchanges[cx_id]
orders=self.orders[cx_id]
if len(orders)>0:
for o in orders:
trades.append(cx.order_trades_map[o.order_id])
for k,o in orders.items():
if k in cx.order_trades_map:
trades.extend(cx.order_trades_map[k])
self.trades=trades
for t in trades:
self.tqty+=t.trade_qty
self.tincome+=t.trade_qty*t.trade_price
self.tincome=round(self.tincome,2)
return trades
@property
def qty(self):
return self.tqty+self.qty_offset
@property
def income(self):
return self.tincome+self.income_offset
def confirm_distribution(self,dis_qty,step):
income_per=self.income/self.qty
income_to_confirm=income_per*dis_qty
income_to_confirm=round(income_to_confirm,2)
self.income_offset-=income_to_confirm
self.qty_offset-=dis_qty
self.income_offset=round(self.income_offset,2)
self.trade_curser=len(self.trades)-1
def reset(self, episode):
self.qty_offset=0
self.tqty=0
self.income_offset=0
self.tincome=0
self.trade_curser=0
self.trades=[]
return super().reset(episode)
+94 -51
View File
@@ -1,104 +1,147 @@
from .base_aquire_agent import Base_Aquire_Agent
import random
class Price_Believe_Aquire_Agent(Base_Aquire_Agent):
"""
Aquire agent with internal price believe system.
"""
def __init__(self, simulation, business, resource, exchanges: list, lr, max_price_adj_rate) -> None:
super().__init__(simulation, business, resource, exchanges)
self.lr=lr
self.max_price_adj_rate=max_price_adj_rate
self.price_believe={i: 0 for i in range(len(self.exchanges))}
self.open_orders={i: [] for i in range(len(self.exchanges))}
self.open_qty=0
self.lr = lr
self.max_price_adj_rate = max_price_adj_rate
self.price_believe = {i: 1 for i in range(len(self.exchanges))}
self.open_orders = {i: [] for i in range(len(self.exchanges))}
self.open_qty = 0
self.hp_threshold=0.70
self.lp_threshold=0.99
def tick(self,tick,episode):
def tick(self, tick, episode):
order_error=self.open_qty+self.target_error()
if order_error<0:
# aquire based on current price belive
cx_id=self.select_best_cx()
order=self.order_resource(self.price_believe[cx_id],order_error*-1,cx_id)
if not order==None:
self.register_order(cx_id,order)
order_error = self.open_qty+self.target_error()
if order_error < 0:
# aquire based on current price believe
cx_id = self.select_best_cx()
order = self.order_resource(
self.price_believe[cx_id], order_error*-1, cx_id)
if not order == None:
self.register_order(cx_id, order)
else:
# order failed due to missing balance.. we need to adjust our price believe
self.collect_balance_from_cxs()
self.collect_resource_from_cxs(self.resource)
self.update_believe(cx_id,-1)
self.tick_open_orders()
self.update_believe(cx_id, -1)
self.tick_open_orders()
def select_best_cx(self):
best_id=-1
best=0
best_id = -1
best = 999999999
for cx_id in range(len(self.exchanges)):
cx=self.exchanges[cx_id]
potential=cx.get_total_supply(self.resource)*self.price_believe[cx_id]
if potential<best:
best=potential
best_id=cx_id
if best_id==-1:
best_id=random.randint(0,len(self.exchanges)-1)
cx = self.exchanges[cx_id]
available = (cx.get_total_supply(self.resource) > 0)
if available:
potential = 1*self.price_believe[cx_id]
else:
continue
if potential < best:
best = potential
best_id = cx_id
if best_id == -1:
best_id = random.randint(0, len(self.exchanges)-1)
return best_id
def register_order(self,cx_id,order):
def register_order(self, cx_id, order):
half=self.max_price_adj_rate/2
ran=random.randrange(-half,half)
self.open_orders[cx_id].append({
'id': order.order_id,
'lifetime': self.max_price_adj_rate,
'lifetime': self.max_price_adj_rate+ran,
'leaves': order.leaves_qty
})
if order.leaves_qty != order.qty:
self.update_trades()
def tick_open_orders(self) -> int:
"""
Removes 1 from pending orders timeout timer and cancels timeed out orders.
Returns ids of orders that timeed out.
"""
self.open_qty=0
self.open_qty = 0
for cx_id in range(len(self.exchanges)):
cx=self.exchanges[cx_id]
cx_orders=self.open_orders[cx_id]
cx = self.exchanges[cx_id]
cx_orders = self.open_orders[cx_id]
for i in cx_orders:
# Check for each order if it is fullfiled or if it is timed
o=self.orders[cx_id][i["id"]]
if o.leaves_qty==0:
#order is done
self.open_orders[cx_id].remove(i) # remove order from open
self.update_believe(cx_id,-1) # update price believe
# Check for each order if it is fullfiled or if it is timed
o = self.orders[cx_id][i["id"]]
leaves = o.leaves_qty
if o.leaves_qty == 0:
# order is done
self.open_orders[cx_id].remove(i) # remove order from open
self.update_believe(cx_id, -1) # update price believe
self.collect_balance_from_cxs()
self.collect_resource_from_cxs(self.resource)
continue
if i["lifetime"]>0:
self.open_qty+=o.leaves_qty
i["lifetime"]-=1 # subtract lifetime
if not (i["leaves"] == leaves):
# update in order
i["leaves"] = leaves
self.update_trades()
# reset lifetime
i["lifetime"] = self.max_price_adj_rate
if i["lifetime"] > 0:
self.open_qty += o.leaves_qty
i["lifetime"] -= 1 # subtract lifetime
else:
# timeout
self.update_trades()
modifier =0
success=self.calc_order_success(cx,o)
if success>=self.lp_threshold:
modifier=-1
elif success<=self.hp_threshold:
modifier=1
cx.cancel_order(i["id"])
self.collect_balance_from_cxs()
self.collect_resource_from_cxs(self.resource)
self.update_believe(cx_id,1)
self.update_believe(cx_id, modifier)
self.open_orders[cx_id].remove(i)
def update_believe(self,cx_id,modifier):
def calc_order_success(self, cx, o):
"""
Calculate how we should adjust the price belive
"""
buy = o.qty-o.leaves_qty
buyperc = buy/o.qty
dem = cx.total_supply[self.resource]+buy
if dem == 0:
dem = 1
coverage = buy/dem
base_success = max([coverage, buyperc])
return base_success
def update_believe(self, cx_id, modifier):
"""
Updates the believe based on the modifier.
If positive will add lr to believe
If negative will sub lr to believe
"""
self.price_believe[cx_id]+=modifier*self.lr
if self.price_believe[cx_id]<0:
self.price_believe[cx_id]=0
self.price_believe[cx_id] += modifier*self.lr
if self.price_believe[cx_id] < 0:
self.price_believe[cx_id] = 0
def reset(self,episode):
def reset(self, episode):
# Clean shop for today
for cx_id in range(len(self.exchanges)):
cx=self.exchanges[cx_id]
cx_orders=self.open_orders[cx_id]
cx = self.exchanges[cx_id]
cx_orders = self.open_orders[cx_id]
for i in cx_orders:
cx.cancel_order(i["id"])
self.collect_balance_from_cxs()
self.collect_resource_from_cxs(self.resource)
# book keeping
self.update_trades()
return super().reset(episode)
self.open_orders = {i: [] for i in range(len(self.exchanges))}
self.orders = {i: {} for i in range(len(self.exchanges))}
return super().reset(episode)
+116 -55
View File
@@ -1,101 +1,162 @@
from .base_distribution_agent import Base_Distribution_Agent
import random
class Price_Believe_Distribiute_Agent(Base_Distribution_Agent):
"""
Aquire agent with internal price believe system.
"""
def __init__(self, simulation, business, resource, exchanges: list, lr, max_price_adj_rate) -> None:
super().__init__(simulation, business, resource, exchanges)
self.lr=lr
self.max_price_adj_rate=max_price_adj_rate
self.price_believe={i: 0 for i in range(len(self.exchanges))}
self.open_orders={i: [] for i in range(len(self.exchanges))}
self.open_qty=0
def tick(self,step,episode):
order_error=self.target_error()
if order_error>0:
def __init__(self, simulation, business, resource, exchanges: list, lr,at_sales, max_price_adj_rate) -> None:
super().__init__(simulation, business, resource, exchanges)
self.lr = lr
self.lr_at_sales=at_sales
self.max_price_adj_rate = max_price_adj_rate
self.price_believe = {i: 1 for i in range(len(self.exchanges))}
self.lr_moment={i: 0 for i in range(len(self.exchanges))}
self.open_orders = {i: [] for i in range(len(self.exchanges))}
self.open_qty = 0
self.beta=0.8
self.lp_threshold=0.05
self.hp_threshold=0.80
def tick(self, step, episode):
order_error = self.target_error()
if (order_error > 0) & (self.open_qty==0):
# aquire based on current price belive
cx_id=self.select_best_cx()
order=self.distribute_resource(self.price_believe[cx_id],order_error,cx_id)
self.register_order(cx_id,order)
self.tick_open_orders()
cx_id = self.select_best_cx()
price = round(self.price_believe[cx_id],2)
if price==30.0:
print("Ple")
if price < self.min_price:
price = self.min_price
order = self.distribute_resource(
price, order_error, cx_id)
self.register_order(cx_id, order)
self.tick_open_orders()
def select_best_cx(self):
best_id=-1
best=0
best_id = -1
best = -1
for cx_id in range(len(self.exchanges)):
cx=self.exchanges[cx_id]
potential=cx.get_total_supply(self.resource)*self.price_believe[cx_id]
if potential>best:
best=potential
best_id=cx_id
if best_id==-1:
best_id=random.randint(0,len(self.exchanges)-1)
cx = self.exchanges[cx_id]
available = (cx.get_total_demand(self.resource) > 0)
if available:
potential = 1*self.price_believe[cx_id]
else:
continue
if potential > best:
best = potential
best_id = cx_id
if best_id == -1:
best_id = random.randint(0, len(self.exchanges)-1)
return best_id
def register_order(self,cx_id,order):
def register_order(self, cx_id, order):
half=self.max_price_adj_rate/2
ran=random.randrange(-half,half)
self.open_orders[cx_id].append({
'id': order.order_id,
'lifetime': self.max_price_adj_rate,
'lifetime': self.max_price_adj_rate+ran,
'leaves': order.leaves_qty
})
if order.leaves_qty != order.qty:
self.update_trades()
def tick_open_orders(self) -> int:
"""
Removes 1 from pending orders timeout timer and cancels timeed out orders.
Returns ids of orders that timeed out.
"""
self.open_qty=0
self.open_qty = 0
for cx_id in range(len(self.exchanges)):
cx=self.exchanges[cx_id]
cx_orders=self.open_orders[cx_id]
cx = self.exchanges[cx_id]
cx_orders = self.open_orders[cx_id]
for i in cx_orders:
# Check for each order if it is fullfiled or if it is timed
o=self.orders[cx_id][i["id"]]
if o.leaves_qty==0:
#order is done
# Check for each order if it is fullfiled or if it is timed
o = self.orders[cx_id][i["id"]]
leaves = o.leaves_qty
if o.leaves_qty == 0:
# order is done
self.open_orders[cx_id].remove(i) # remove order from open
self.update_believe(cx_id,1) # update price believe
self.update_trades()
succsess=self.calc_order_success(cx,o)
modifier=0
if succsess>=self.hp_threshold:
modifier=1
elif succsess<=self.lp_threshold:
modifier=-1
self.update_believe(cx_id,o.price, succsess,o.qty) # update price believe
self.collect_balance_from_cxs()
self.collect_resource_from_cxs(self.resource)
continue
if i["lifetime"]>0:
self.open_qty+=o.leaves_qty
i["lifetime"]-=1 # subtract lifetime
if not (i["leaves"] == leaves):
# update in order
i["leaves"] = leaves
self.update_trades()
# reset lifetime
i["lifetime"] = self.max_price_adj_rate
if i["lifetime"] > 0:
self.open_qty += o.leaves_qty
i["lifetime"] -= 1 # subtract lifetime
else:
# timeout
self.update_trades()
succsess=self.calc_order_success(cx,o)
cx.cancel_order(i["id"])
self.collect_balance_from_cxs()
self.collect_resource_from_cxs(self.resource)
self.update_believe(cx_id,-1)
self.update_believe(cx_id,o.price, succsess,o.qty)
self.open_orders[cx_id].remove(i)
def calc_order_success(self,cx, o):
"""
Calculate how we should adjust the price belive
"""
sold = o.qty-o.leaves_qty
nsold=min(o.leaves_qty,cx.total_demand[self.resource])
dem = cx.total_demand[self.resource]+sold
if dem == 0:
dem = 1
score=sold-nsold
return score
def update_believe(self,cx_id,modifier):
def update_believe(self, cx_id, used_price, modifier,qty):
"""
Updates the believe based on the modifier.
If positive will add lr to believe
If negative will sub lr to believe
"""
self.price_believe[cx_id]+=modifier*self.lr
if self.price_believe[cx_id]<0:
self.price_believe[cx_id]=0
def reset(self,episode):
clipMod=max(-qty,min(modifier,qty))
moment=clipMod/qty
#clip mod so that price believe more smooth
self.lr_moment[cx_id]=self.lr_moment[cx_id]*self.beta + (1-self.beta)*moment
update=self.lr_moment[cx_id]*self.lr
self.price_believe[cx_id]+=update
self.price_believe[cx_id] = round(self.price_believe[cx_id], 2)
if self.price_believe[cx_id] < 1:
self.price_believe[cx_id] = 1
def reset(self, episode):
# Clean shop for today
self.update_trades()
for cx_id in range(len(self.exchanges)):
cx=self.exchanges[cx_id]
cx_orders=self.open_orders[cx_id]
cx = self.exchanges[cx_id]
cx_orders = self.open_orders[cx_id]
for i in cx_orders:
cx.cancel_order(i["id"])
self.collect_balance_from_cxs()
self.collect_resource_from_cxs(self.resource)
# book keeping
self.update_trades()
return super().reset(episode)
self.open_orders = {i: [] for i in range(len(self.exchanges))}
self.orders = {i: {} for i in range(len(self.exchanges))}
return super().reset(episode)
+141 -23
View File
@@ -2,30 +2,148 @@ from .base_business import Business
from ..agents.price_believe_aquire import Price_Believe_Aquire_Agent
from ..agents.price_believe_distribute import Price_Believe_Distribiute_Agent
from ..agents.autoproduction import AutoProductionAgent
class Price_Believe_Business(Business):
def __init__(self, id, production, balance,exchange,simulation) -> None:
super().__init__(id, production, balance)
self.distribute=Price_Believe_Distribiute_Agent(simulation,self,production["name"],exchange,0.5,10)
self.craft=AutoProductionAgent(simulation,self)
self.aquire={}
for l in production["prod"]:
for k,v in l.items():
a=Price_Believe_Aquire_Agent(simulation,self,k,exchange,1,10)
a.set_target(v*2)
a.set_price_max(10)
self.aquire[k]=a
self.distribute.set_price_min(10)
self.distribute.set_target(0)
import log
def tick_business_decisions(self,step):
for comp in self.production["prod"]:
for k,v in comp.items():
modifier=self.craft.worker+1
self.aquire[k].set_target(v*modifier)
max_amount=self.production["amount"]*5
self.craft.set_target(max_amount)
class Price_Believe_Business(Business):
def __init__(self, id, production, balance, exchange, simulation, location) -> None:
super().__init__(id, production, balance, location)
self.max_storage = 10
self.expense_per_unit = -1
self.expense_per_prod=-1
self.income_per_unit = -1
self.distribute = Price_Believe_Distribiute_Agent(
simulation, self, production["name"], exchange, 0.08,production["amount"]*2, 6)
self.craft = AutoProductionAgent(simulation, self)
self.aquire = {}
for k, v in production["prod"].items():
a = Price_Believe_Aquire_Agent(
simulation, self, k, exchange, 0.02, 6)
a.set_target(v*2)
a.set_price_max(10)
self.aquire[k] = a
self.distribute.set_price_min(0)
self.distribute.max_batch_qty=production["amount"]
self.distribute.set_target(0)
def tick_business_decisions(self, step):
amount= self.production["amount"]
if step == 0:
max_amount = self.production["amount"]*5
self.craft.set_target(max_amount)
# Update bookkeeping
self.update_ex_per_unit()
self.update_income_per_unit(step)
# calc descision
orderForNewProds = self.max_storage
if self.income_per_unit<=0 or self.expense_per_unit<=0:
# dont have data
retain=0
else:
ie = (self.income_per_unit/self.expense_per_unit)-1
ie=max(0,min(ie,1))
retain=((self.max_storage-ie*self.max_storage)*amount)-amount
#retain=0
# set target for aquire
prod = self.production["prod"]
for k, v in prod.items():
self.aquire[k].set_target(v*orderForNewProds)
# update production
targetUnit = self.production["amount"]*orderForNewProds
self.craft.set_target(targetUnit)
# set min distribute
self.distribute.set_price_min(self.expense_per_unit)
self.distribute.set_target(retain)
def tick_business_episode(self, episode_count):
start_balance = self.balance_history[-1]
diff = self.balance-start_balance
def resource_in_possesion(self):
return self.distribute.open_qty+self.inventory[self.production["name"]]
return self.distribute.open_qty+self.inventory[self.production["name"]]
def update_ex_per_unit(self):
experunit = 0
prod = self.production["prod"]
amount = self.production["amount"]
qtyNewProds = -1
for key, agent in self.aquire.items():
agent.update_trades()
if agent.qty == 0:
return
if agent.qty < 0:
print("pla")
req = prod[key]
covers = agent.qty/req
if qtyNewProds == -1:
qtyNewProds = covers
if qtyNewProds > covers:
qtyNewProds = covers
ExPerProd = agent.expense/covers
experunit += ExPerProd/amount
if qtyNewProds > 0:
# confirm new units
for key, agent in self.aquire.items():
qtyToConfirm = prod[key]*qtyNewProds
agent.confirm_purchase(qtyToConfirm)
a = 1+2
qtyNewUnits = qtyNewProds*amount
# if we havent set the expense_per_unit
if self.expense_per_unit == -1:
self.expense_per_unit = experunit
return
# update expense per unit
prev_ex_total = self.expense_per_unit*self.resource_in_possesion()
new_ex_total = qtyNewUnits*experunit
ex_total = prev_ex_total+new_ex_total
estimatedQTYUnits = qtyNewUnits+self.resource_in_possesion()
new_ex = ex_total/estimatedQTYUnits
self.expense_per_unit = new_ex
self.expense_per_prod=self.expense_per_unit*amount
def update_income_per_unit(self, step):
qty_sold = self.distribute.qty
income = self.distribute.income
if income == 0:
return
self.income_per_unit = qty_sold/income
self.distribute.confirm_distribution(qty_sold, step)
a=self.distribute.trade_curser
def close_business(self):
for k, a in self.aquire.items():
a.unregister()
self.distribute.unregister()
self.craft.unregister()
def log(self, episode, episode_length, step):
data = {}
data["id"] = self.id
data["episode"] = episode
data["step"] = step
data["tstep"] = step+episode*episode_length
data["production"] = self.production["name"]
data["expense"] = self.expense_per_unit
data["expense_prod"]=self.expense_per_prod
data["income"] = self.income_per_unit
data["inventory"] = self.inventory[self.production["name"]]
data["retain"] = self.distribute.target
data["balance"] = self.balance
data["location"] = self.location
log.BUSINESSData.append(data)
+14 -5
View File
@@ -1,6 +1,7 @@
from abc import ABC
import log
class Business(ABC):
def __init__(self,id,production,balance) -> None:
def __init__(self,id,production,balance,location) -> None:
"""production (dict): {
name: 'Gem',
amount: 4,
@@ -12,14 +13,17 @@ class Business(ABC):
balance (int): Starting Balance
"""
self.id=id
self.location=location
self.production=production
self.balance_history=[balance]
self.balance=balance
self.expense=0
self.income=0
#Setup Inventory
self.inventory={production["name"]: 0}
for l in production["prod"]:
for k,v in l.items():
self.inventory[k]=0
for k,v in production["prod"].items():
self.inventory[k]=0
pass
def tick(self,step):
@@ -33,8 +37,10 @@ class Business(ABC):
"""
Call for resetting for the next episode
"""
self.balance_history.append(self.balance)
self.tick_business_episode(episode_count)
self.balance_history.append(self.balance)
def tick_business_episode(self,episode_count):
@@ -43,3 +49,6 @@ class Business(ABC):
"""
assert "no business episode tick method has been created"
def close_business(self):
assert "close_business has not been provided"
Binary file not shown.
Binary file not shown.
+3 -2
View File
@@ -24,7 +24,7 @@ class Cell:
exchange: None
def __init__(self,name,x,y,area,pop,demand,world) -> None:
pop=pop*1000
pop=pop*10
self.name=name
self.loc_x=x
self.loc_y=y
@@ -63,13 +63,14 @@ class Cell:
qty=value/episode_length
comm=cm.commoditys[demand_key]
max_price=comm["max_world_price"]*qty
self.exchange.register_account(self.name,self.name)
self.exchange.add_to_account(self.name,"balance",max_price)
self.exchange.submit_order(self.name,demand_key,qty,comm["max_world_price"],Side.BUY)
def setup_supply_for_episode(self):
self.exchange.reset()
for supply_key,value in self.world.items():
self.exchange.add_to_account(self.name,supply_key,value)
self.exchange.submit_order(self.name,supply_key,value,0,Side.SELL)
self.exchange.submit_order(self.name,supply_key,value,1,Side.SELL)
+5 -5
View File
@@ -40,10 +40,10 @@ def search_yaml_files(directory = "db"):
productions[comm['name']]=[]
productions[comm['name']].append(comm)
productions_id_map[comm["id"]]=comm
for comp in comm["prod"]:
k=list(comp.keys())[0]
if k not in productions_uses:
productions_uses[k]=[]
productions_uses[k].append(comm)
k=comm["prod"].keys()
for component in k:
if component not in productions_uses:
productions_uses[component]=[]
productions_uses[component].append(comm)
+149 -16
View File
@@ -1,5 +1,18 @@
_bal="balance"
from lightmatchingengine.lightmatchingengine import LightMatchingEngine,Side,Trade,Order,OrderBook
import log
from influxdb_client.client.write_api import SYNCHRONOUS
from influxdb_client import InfluxDBClient, Point
import time
import pandas as pd
import uuid
import threading
software_start=int(time.time())
class Exchange():
"""
Basic Commodity exchange.
@@ -17,20 +30,30 @@ class Exchange():
self.order_account_map={}
self.orders={}
self.executed_trades=[]
self.trade_curser=0
self.account_business={}
self.order_trades_map={}
self.market_rate={}
self.best_ask={}
self.best_bid={}
self.total_demand={}
self.demand={}
#self.demand={}
self.total_supply={}
self.supply={}
#self.supply={}
self.traded_commoditys={}
self.lock=threading.Lock()
def register_account(self,account,business):
self.account_business[account]=business
def add_to_account(self,account_id,resource,amount):
"""
Adds resources to account escrow
"""
#check if account exists
self.lock.acquire()
if account_id not in self.account:
self.account[account_id]={_bal: 0}
#check if ressource exists
@@ -38,12 +61,14 @@ class Exchange():
self.account[account_id][resource]=0
self.account[account_id][resource]+=amount
self.lock.release()
def remove_from_account(self,account_id,resource,amount) -> int:
"""
Remove resources from account. Returns amount retrieved
"""
#check if account exists
self.lock.acquire()
if account_id not in self.account:
self.account[account_id]={_bal: 0}
#check if ressource exists
@@ -56,6 +81,7 @@ class Exchange():
self.account[account_id][resource]=0
else:
self.account[account_id][resource]-=amount
self.lock.release()
return ret
def _move_to_escrow(self,account_id,resource,amount):
@@ -110,7 +136,13 @@ class Exchange():
Returns an order if the order is active. Returns None if submit has failed.
"""
# calculate price for complete order fullfilment
full_price=price*amount
prev=amount
amount=int(amount)
price=round(price)
if amount<1:
# invalid order
return None
full_price=round(price*amount)
# Move resources into escrow
@@ -123,13 +155,14 @@ class Exchange():
# no sufficient resources
return None
# create order and execude any trades
self.lock.acquire()
order,trades=self.lme.add_order(resource,price,amount,side)
self.orders[order.order_id]=order
self.order_account_map[order.order_id]=account_id
self._execute_trades(trades)
self.calculate_resource_metrics(resource)
self.lock.release()
return order
def cancel_order(self,order_id):
@@ -142,6 +175,7 @@ class Exchange():
order=self.orders[order_id]
if self._is_order_complete(order):
return False
self.lock.acquire()
order=self.lme.cancel_order(order_id,order.instmt)
if order_id in self.order_trades_map: # has order any kind of trades
@@ -161,6 +195,7 @@ class Exchange():
qty_traded+=trade.trade_qty
qty_diff=qty_submitted-qty_traded
self._move_to_account(self.order_account_map[order_id],order.instmt,qty_diff)
self.lock.release()
return True
@@ -212,26 +247,35 @@ class Exchange():
def calculate_resource_metrics(self, resource):
order_book = self.lme.order_books.setdefault(resource, OrderBook())
best_bid = max(order_book.bids.keys()) if len(order_book.bids) > 0 else None
best_ask = max(order_book.asks.keys()) if len(order_book.asks) > 0 else None
best_bid = None
best_ask = None
self.total_demand[resource]=0
self.demand[resource]={}
#self.demand[resource]={}
for k,v in order_book.bids.items():
self.demand[resource][k]=0
# self.demand[resource][k]=0
if best_bid==None:
best_bid=k
if best_bid<=k:
best_bid=k
for o in v:
self.demand[resource][k]+=o.qty
self.total_demand[resource]+=o.qty
self.supply[resource]={}
# self.demand[resource][k]+=o.leaves_qty
self.total_demand[resource]+=o.leaves_qty
#self.supply[resource]={}
self.total_supply[resource]=0
for k,v in order_book.asks.items():
self.supply[resource][k]=0
# self.supply[resource][k]=0
if best_ask==None:
best_ask=k
if best_ask<=k:
best_ask=k
for o in v:
self.supply[resource][k]+=o.qty
self.total_supply[resource]+=o.qty
# self.supply[resource][k]+=o.leaves_qty
self.total_supply[resource]+=o.leaves_qty
self.best_ask[resource]=best_ask
self.best_bid[resource]=best_bid
self.traded_commoditys[resource]=True
def get_account_resource_amount(self,account_id,resource):
"""
@@ -249,4 +293,93 @@ class Exchange():
def get_total_supply(self,resource):
if resource in self.total_supply:
return self.total_supply[resource]
return 0
return 0
def log_step(self,name,episode,episode_length,step,autolog=True):
timepoint=episode*episode_length+step
localStepDB={}
for instrm,order in self.traded_commoditys.items():
data={}
data["cxid"]=name
data["episode"]=episode
#data["step"]=step
data["tstep"]=timepoint
data["instrm"]=instrm
data["best_ask"]=None
data["best_bid"]=None
data["total_demand"]=None
data["total_supply"]=None
data["market_rate"]=None
localStepDB[instrm]=data
## add best ask/best bid
for item , value in self.best_ask.items():
if value!=None:
localStepDB[item]["best_ask"]=int(value)
for item , value in self.best_bid.items():
if value!=None:
localStepDB[item]["best_bid"]=int(value)
#demand supply
for item , value in self.total_demand.items():
if value!=None:
localStepDB[item]["total_demand"]=int(value)
for item , value in self.total_supply.items():
if value!=None:
localStepDB[item]["total_supply"]=int(value)
#last market rate
for item , value in self.market_rate.items():
if value!=None:
localStepDB[item]["market_rate"]=int(value)
#Trade
new_trades=self.executed_trades[self.trade_curser:]
self.trade_curser=len(self.executed_trades)-1
for t in new_trades:
if t.trade_side==1:
# will get logged twice so only log one side
#
account_id=self.order_account_map[t.order_id]
data={}
data["cxid"]=name
data["tstep"]=timepoint
data["episode"]=int(episode)
data["account"]=account_id
data["business"]=self.account_business[account_id]
data["order_id"]=t.order_id
data["instmt"]=t.instmt
data["price"]=int(t.trade_price)
data["qty"]=int(t.trade_qty)
log.EXTradeDataDetail.append(data)
if autolog:
for id,item in localStepDB.items():
log.EXBooksData.append(item)
return localStepDB
def log_episode(self,name,episode):
transformed={}
for t in self.executed_trades:
if t.trade_side==1:
# will get logged twice so only log one side
if t.instmt not in transformed:
transformed[t.instmt]={}
if t.trade_price not in transformed[t.instmt]:
transformed[t.instmt][t.trade_price]=0
transformed[t.instmt][t.trade_price]+=t.trade_qty
for inst,stats in transformed.items():
for price,qty in stats.items():
data={}
#data["id"]=uuid.uuid4()
data["cxid"]=name
data["episode"]=int(episode)
#data["order_id"]=t.order_id
data["instmt"]=t.instmt
data["price"]=int(price)
data["qty"]=int(qty)
#data["side"]=int(t.trade_side)
log.EXTradeData.append(data)
+151 -18
View File
@@ -3,18 +3,28 @@ from .commoditys import commoditys as cm
from .exchange import Exchange
from .business import Price_Believe_Business
import uuid
import time
import logging
from concurrent.futures import ThreadPoolExecutor
import log
class Simulation():
"""
Class for controlling the different calculation steps of the Simulation.
"""
def __init__(self) -> None:
self.timings={}
self.tick_funcs={}
self.reset_funcs={}
self.tick_count=0
self.episode_count=0
self.episode_count=-1
self.cells={}
self.populated_cells={}
self.businesses=[]
self.production_util={}
self.episode_tax=1
self.taskpool=ThreadPoolExecutor()
self.setup_timing(["dss","dsa","dab","dbl","dt"])
for k in cm.productions.items():
l=k[1]
for i in l:
@@ -25,6 +35,7 @@ class Simulation():
def set_cells(self,cells):
for c in cells:
self.cells[c.name]=c
self.populated_cells[c.name]=0
def set_businesses(self,bus):
self.businesses=bus
@@ -37,6 +48,14 @@ class Simulation():
self.tick_funcs[id]=tickfunc
self.reset_funcs[id]=resetfunc
def unregister_agent(self,id):
"""
Unregisters agent
"""
self.tick_funcs.pop(id,None)
self.reset_funcs.pop(id,None)
def tick_agents_random_order(self):
"""
@@ -44,31 +63,79 @@ class Simulation():
"""
keys=list(self.tick_funcs.keys())
random.shuffle(keys)
tasks=[]
for k in keys:
fun=self.tick_funcs[k]
#row=[fun,self.tick_count,self.episode_count]
#tasks.append(row)
#self.taskpool.submit(self._execute_tick,row)
fun(self.tick_count,self.episode_count)
#self.taskpool.map(self._execute_tick,tasks)
def _execute_tick(self,args):
fun=args[0]
fun(args[1],args[2])
return True
def tick(self,episode_length):
"""
Executes a tick of the simulation
"""
start=time.time()
self.tick_agents_random_order()
agentstep=time.time()
for cell_id,c in self.cells.items():
c.setup_demand_for_step(episode_length)
setup=time.time()
for b in self.businesses:
b.tick(self.tick_count)
busstep=time.time()
self.tick_count+=1
self.log_cxs_tick(episode_length)
#self.log_business_tick(episode_length)
logstep=time.time()
self.timings["dss"]+=setup-start
self.timings["dsa"]+=agentstep-setup
self.timings["dsap"]=self.timings["dsa"]/(len(self.tick_funcs)+1)
self.timings["dab"]+=(busstep-agentstep)/(len(self.businesses)+1)
self.timings["dbl"]+=logstep-busstep
self.timings["dt"]+=logstep-start
def reset(self):
"""
Resets all agents to new Episode
"""
self.log_cxs_episode()
self.log_business_episode()
for k,v in self.reset_funcs.items():
v(self.episode_count)
for cell_id,cell in self.cells.items():
cell.setup_supply_for_episode()
toclose=[]
for b in self.businesses:
#tax business
b.balance-=self.episode_tax
b.tick_episode(self.episode_count)
if b.balance<=0:
toclose.append(b.id)
for close in toclose:
self.remove_business(close)
self.timings["numBus"]=len(self.businesses)
self.timings["tickfuncs"]=len(self.tick_funcs)
self.timings["episode"]=self.episode_count
log.PerformanceData.append(self.timings.copy())
self.setup_timing(["dss","dsa","dsap","dab","dbl","dt"])
self.tick_count=0
self.episode_count+=1
@@ -82,14 +149,15 @@ class Simulation():
under.append(k)
return under
def create_bussiness(self):
def create_bussiness(self,min_available_per_prod):
"""
Create a new business based on given econemy state.
Return Business
"""
selected_prod=None
# Create a business for every production rule out there
under_prods=self.get_underutelized_prods(1)
under_prods=self.get_underutelized_prods(min_available_per_prod)
if len(under_prods)>0:
# we need to create more businesses
selected_prod=random.choice(under_prods)
@@ -103,24 +171,46 @@ class Simulation():
cell_id=random.choice(cells)
cell=self.cells[cell_id]
cxs=[cell.exchange,self.cx]
business=Price_Believe_Business.Price_Believe_Business(uuid.uuid4(),prod,1000,cxs,self)
business=Price_Believe_Business.Price_Believe_Business(uuid.UUID(int=random.getrandbits(128)),prod,1000,cxs,self,cell_id)
self.businesses.append(business)
self.production_util[selected_prod]+=1
self.populated_cells[cell_id]+=1
return business
def remove_business(self,id):
bus=None
for busl in self.businesses:
if busl.id==id:
bus=busl
break
bus.close_business()
self.businesses.remove(bus)
self.production_util[bus.production["id"]]-=1
self.populated_cells[bus.location]-=1
def get_max_profit_prod(self):
"""
Returns the prod with the highest profit in last episode
"""
profit=self.businesses[0].balance-self.businesses[0].balance_history[-1]
prod=self.businesses[0].production
profit={}
for b in self.businesses:
diff=b.balance-b.balance_history[-1]
if diff>profit:
profit=diff
prod=b.production
return prod
id=b.production["id"]
if len(b.balance_history)<2:
continue
diff=b.balance-b.balance_history[-2]
if id not in profit:
profit[id]=0
profit[id]+=diff
best=None
bestv=-1000000000000
for k,v in profit.items():
if bestv<v:
bestv=v
best=k
return best
@@ -135,15 +225,58 @@ class Simulation():
cx=cell.exchange
# Best prod resource availability
# Using the exchange in that cell, lookup supply or demand of resources. Supply +1 / Demand -1
for prod_item in prod["prod"]:
key=list(prod_item.keys())[0]
val=prod_item[key]
for key,val in prod["prod"].items():
a=cx.get_total_supply(key)
cell_score[cell.name]+=(cx.get_total_supply(key)/val)
cell_score[cell.name]-=(cx.get_total_demand(key)/val)
# If demand for prod item in cell then score +1/ score -1 if supply is already there
a=cx.get_total_demand(prod["name"])
cell_score[cell.name]+=cx.get_total_demand(prod["name"])
cell_score[cell.name]-=cx.get_total_supply(prod["name"])
b=cx.get_total_supply(prod["name"])
cell_score[cell.name]+=a
cell_score[cell.name]-=b
max_keys = [key for key, value in cell_score.items() if value == max(cell_score.values())]
return max_keys
return max_keys
def log_cxs_tick(self,epi_length):
items=[]
for id,_ in self.populated_cells.items():
cell=self.cells[id]
lcx=cell.exchange
name="lcx_{}".format(id)
items.append([lcx,name,self.episode_count,epi_length,self.tick_count])
results=map(self.launch_cxs_log,items)
for result in results:
for id,item in result.items():
log.EXBooksData.append(item)
self.cx.log_step("cx",self.episode_count,epi_length,self.tick_count)
def launch_cxs_log(self,args):
"""
Runs in a conncurrent map
"""
cx=args[0]
name=args[1]
epi=args[2]
epilen=args[3]
tick=args[4]
return cx.log_step(name,epi,epilen,tick,False)
def log_cxs_episode(self):
for id,v in self.populated_cells.items():
if v>0:
cell=self.cells[id]
lcx=cell.exchange
name="lcx_{}".format(id)
lcx.log_episode(name,self.episode_count)
self.cx.log_episode("cx",self.episode_count)
def log_business_tick(self,episode_length):
for bus in self.businesses:
bus.log(self.episode_count,episode_length,self.tick_count)
def log_business_episode(self):
for bus in self.businesses:
bus.log(self.episode_count,1,0)
def setup_timing(self,metrics):
for met in metrics:
self.timings[met]=0
+3
View File
@@ -0,0 +1,3 @@
admin
adminadmin
ywMlW7zpVYFcGr1krHa83R_J_HSrd2wEq8MgtB7YX7Nc6QoTZSD6H-iiKlXYZUZaZY2MbNrL3XxfioaSGe9_bA==
Binary file not shown.
+63
View File
@@ -0,0 +1,63 @@
import influxdb_client, os, time
from influxdb_client import InfluxDBClient, Point, WritePrecision
from influxdb_client.client.write_api import SYNCHRONOUS
from sqlalchemy import create_engine
import pandas as pd
token = "AcU0_L5vtfH-9ycHnk0txF3jgHIcWRcMOElzAVtIrAGXC0oNSjwZUzPBsWCBZHNbaJmr-9x34E1Hycow59MnQg=="
org = "econ"
url = "http://localhost:8086"
bucket="econ"
posturl='postgresql://admin:econ@localhost:15432/econ'
write_client = None
EXInit=False
EXBooksData=[]
EXTradeData=[]
EXTradeDataDetail=[]
BUSINESSData=[]
PerformanceData=[]
def get_client():
global write_client
if write_client==None:
write_client=influxdb_client.InfluxDBClient(url=url, token=token, org=org)
return write_client
def writeEXData():
db = create_engine(posturl)
df=pd.DataFrame(EXBooksData)
types=df.dtypes
start=time.time()
df.to_sql('cx_books', con=db, if_exists='replace',
index=False,chunksize=200000)
t1=time.time()
print(f"cx_books completed: {t1-start}/{df.size}")
df=pd.DataFrame(EXTradeData)
df.to_sql("cx_trades",con=db, if_exists='replace',
index=False,chunksize=10000)
t2=time.time()
print(f"cx_trades completed: {t2-t1}/{df.size}")
df=pd.DataFrame(EXTradeDataDetail)
df.to_sql("cx_trades_detailed",con=db, if_exists='replace',
index=False,chunksize=10000)
t3=time.time()
print(f"cx_trades_detailed completed: {t3-t2}/{df.size}")
def writeBusinessData():
db = create_engine(posturl)
df=pd.DataFrame(BUSINESSData)
df.to_sql('business', con=db, if_exists='replace',
index=False,chunksize=10000)
print(f"business completed: {df.size}")
def writePerformanceData():
db = create_engine(posturl)
df=pd.DataFrame(PerformanceData)
df.to_sql('performance', con=db, if_exists='replace',
index=False,chunksize=10000)
print(f"performance completed: {df.size}")
def clearlog():
EXBooksData=[]
EXTradeData=[]
BUSINESSData=[]
Binary file not shown.
+31 -9
View File
@@ -4,7 +4,9 @@ from econ.simulation import Simulation
from econ.business.Price_Believe_Business import Price_Believe_Business
from econ.commoditys import commoditys
from econ.cells import db, cell
import log
from tqdm import tqdm
import uuid
db.load_world("db/world.json")
commoditys.search_yaml_files()
@@ -24,17 +26,37 @@ cxs=[cx]
# Init World
# Create Demand
cx.submit_order(w,"Wood",0,1000,Side.BUY)
cx.submit_order(2,"Gem",1,10,Side.SELL)
#cx.submit_order(w,"Wood",0,1000,Side.BUY)
#cx.submit_order(2,"Gem",1,10,Side.SELL)
EPISODE_LEN=20
NUM_EPISODES=20
NUM_SEED_BUS=10
sim=Simulation()
sim.seed(43)
sim.set_cells(cells)
sim.reset()
sim.tick(1)
# create info
while len(sim.get_underutelized_prods(1))>0:
sim.create_bussiness()
for i in range(EPISODE_LEN):
sim.tick(EPISODE_LEN)
sim.reset()
for i in range(1000):
sim.tick(1000)
# create info
while len(sim.get_underutelized_prods(2))>0:
sim.create_bussiness(2)
#sim.reset()
for a in tqdm(range(NUM_EPISODES)):
for i in range(EPISODE_LEN):
sim.tick(EPISODE_LEN)
print(f"|Stats| Num of Businesses: {len(sim.businesses)} Num Tickfunk: {len(sim.tick_funcs)} Time Agent Tick: {sim.timings['dsa']} Time Logging {sim.timings['dbl']}")
sim.reset()
for i in range(NUM_SEED_BUS):
sim.create_bussiness(1)
log.writeEXData()
log.writeBusinessData()
log.writePerformanceData()
print("help")
+6 -1
View File
@@ -1 +1,6 @@
lightmatchingengine
lightmatchingengine
pyyaml
influxdb-client
pandas
sqlalchemy
tensorflow
BIN
View File
Binary file not shown.