def reset(self, market=None):
""" Resets the environment with a market or creates a new one. Also resets the render app if needed.
Parameters
----------
market : Market
If to use a specific market instead of a newly created one.
Returns
-------
observation : tuple
"""
if market is not None:
self.market = market
else:
self.market = get_market(self._market_type, **self._market_setup)
obs = self.get_obs()
self.capital = self.initial_funds
self.possession = 0
self.funds = self.initial_funds
if self.render_app:
self.render_app.use_reloader = False
self.render_app.__setattr__('ask', deque(maxlen=self.price_n))
self.render_app.__setattr__('bid', deque(maxlen=self.price_n))
self.render_app.__setattr__('time', deque(maxlen=self.price_n))
self.render_app.__setattr__('sellbook', {})
self.render_app.__setattr__('buybook', {})
self.render_app.__setattr__('trades_', [])
return obs, self.get_private_variables()
def reset(self, market=None):
""" Resets the environment.
Also resets the render app with zero portfolio.
"""
obs = ExternalMarketEnv.reset(self, market)
self.funds = self.initial_funds
self.possession = 0
bid = self.quotes[Q_BID] / self.market.multiplier
self.capital = self.funds + self.possession * bid
ask = self.quotes[Q_ASK] / self.market.multiplier
self.prev_buying_power = self.capital / ask
if not self.init_bp:
self.init_buying_power = self.prev_buying_power
self.init_bp = True
if self.render_app:
self.render_app.possession = deque(maxlen=self.price_n)
self.render_app.funds = deque(maxlen=self.price_n)
self.render_app.capital_change = deque(maxlen=self.price_n)
self.opt_funds = self.funds
self.opt_poss = self.possession
self.opt_capital = self.capital
self.memory_ask = ask
self.memory_bid = bid
return obs, self.get_private_variables()
def render(self, mode=None):
""" Renders the environment in a dash app.
"""
if self.first_render:
self.render_app.use_reloader = False
self.render_app.__setattr__('ask', deque(maxlen=self.price_n))
self.render_app.__setattr__('bid', deque(maxlen=self.price_n))
self.render_app.__setattr__('time', deque(maxlen=self.price_n))
self.render_app.__setattr__('sellbook', {})
self.render_app.__setattr__('buybook', {})
self.render_app.__setattr__('trades_', [])
self.app_thread = threading.Thread(
target=self.render_app.run_server)
self.app_thread.start()
if not self.open_tab:
self.open_tab = webbrowser.open_new('http://127.0.0.1:8050')
self.first_render = False
time_ = pd.to_datetime(self.market.time)
ask, ask_vol, bid, bid_vol = self.quotes
self.render_app.ask.append(ask)
self.render_app.bid.append(bid)
self.render_app.time.append(time_)
self.render_app.trades_ = self.trades_list[-40:]
ask, ask_vol, bid, bid_vol = self.quotes
n = 50
buy_book = {}
for i in range(n):
p = bid - i
try:
size = self.market.ob.price_levels.get_level(BUY, p).size
except (KeyError, IndexError) as e:
pass
buy_book[p] = size
n = 50
sell_book = {}
for i in range(n):
p = ask + i
try:
size = self.market.ob.price_levels.get_level(SELL, p).size
except (KeyError, IndexError) as e:
pass
sell_book[p] = size
self.render_app.buybook = buy_book
self.render_app.sellbook = sell_book
def reset(self, **kwargs):
true_state = super().reset(**kwargs)
self.history = deque(maxlen=self.history_length)
observation = self._image_observation()
self.history.append(observation)
history = self._get_history().flatten()
full_obs = self._get_obs(history, true_state)
return full_obs
def render(self, mode=None):
""" Renders a dash app with the portfolio of the agent.
"""
if self.first_render:
self.render_app = get_portfolio_app()
self.render_app.__setattr__('possession',
deque(maxlen=self.price_n))
self.render_app.__setattr__('funds', deque(maxlen=self.price_n))
self.render_app.__setattr__('capital_change',
deque(maxlen=self.price_n))
MarketEnv.render(self)
self.render_app.possession.append(self.possession)
self.render_app.funds.append(self.funds)
self.render_app.capital_change.append(self.capital /
self.initial_funds)
time.sleep(0.005) # TODO investigate why a halt is n
def levelorderTravel(self):
nodelist: deque[Node] = deque()
current = self.root
if self.root is None:
print("There is no data in tree!!!!!!")
else:
while current != None:
print(current.key, " : ", current.name)
if current.left != None:
nodelist.append(current.left)
if current.right != None:
nodelist.append(current.right)
try:
current = nodelist.popleft()
except:
current = None
def __init__( self, batch_size=environment.DB_QUEUE_SIZE ):
# number of times save is called
self._queryCount = 0
# number of items actually saved
self._saveCount = 0
# number of items attempted to save
self._saveAttemptCount = 0
# number invalid tweets
self._invalidCount = 0
# number of updated tweets
self._updatedCount = 0
# number of users whose data has been updated from tweets
self._usersUpdatedCount = 0
self.batch_size = batch_size
self.store = deque()
def __init__(self,
x,
y,
direction,
color_head=ObjectColor.own_head,
color_body=ObjectColor.own_body):
self.alive = True
self._color_head = color_head
self._color_body = color_body
self._deque = deque()
self._set = set()
self._direction = direction
p = (x, y)
self._deque.append(p)
self._set.add(p)
def __init__(self,
batch_size=environment.DB_QUEUE_SIZE,
file_path=environment.MASTER_DB):
self._queryCount = 0
self.batch_size = batch_size
self.store = deque()
self.file_path = file_path
self.user_query = """
INSERT INTO word_map
(word, sentence_index, word_index, user_id)
VALUES (?, ?, ?, ?)
"""
self.tweet_query = """
INSERT INTO word_map
(word, sentence_index, word_index, tweet_id)
VALUES (?, ?, ?, ?)
"""
# use the environent to set which word_map_table_creation_query we use
self.query = self.tweet_query if environment.ITEM_TYPE == 'tweet' else self.user_query
def __init__(
self,
wrapped_env,
imsize=32,
keep_prev=0,
init_camera=None,
camera_name=None,
transpose=False,
grayscale=False,
normalize=False,
):
import mujoco_py
super().__init__(wrapped_env)
self.imsize = imsize
if grayscale:
self.image_length = self.imsize * self.imsize
else:
self.image_length = 3 * self.imsize * self.imsize
# This is torch format rather than PIL image
self.image_shape = (self.imsize, self.imsize)
# Flattened past image queue
self.history_length = keep_prev + 1
self.history = deque(maxlen=self.history_length)
# init camera
if init_camera is not None:
sim = self._wrapped_env.sim
viewer = mujoco_py.MjRenderContextOffscreen(sim, device_id=-1)
init_camera(viewer.cam)
sim.add_render_context(viewer)
self.camera_name = camera_name # None means default camera
self.transpose = transpose
self.grayscale = grayscale
self.normalize = normalize
self._render_local = False
self.observation_space = Box(low=0.0,
high=1.0,
shape=(self.image_length *
self.history_length, ))
def __init__(self,
population_size,
training_type,
env,
network,
make_sess=tf_util.make_session,
seed=None,
nsteps=2048,
gamma=0.99,
lam=0.95,
ent_coef=0.0,
vf_coef=0.5,
max_grad_norm=0.5,
nminibatches=4,
load_paths=None,
model_fn=None,
**network_kwargs):
runner = functools.partial(PPOMultiRunner, gamma=gamma, lam=lam)
super().__init__(population_size, training_type, runner, env)
set_global_seeds(seed)
# Get state_space and action_space
ob_space = env.observation_space.spaces[0]
ac_space = env.action_space.spaces[0]
for ob_sp, ac_sp in zip(env.observation_space.spaces,
env.action_space.spaces):
assert ob_sp == ob_space
assert ac_sp == ac_space
# Calculate the batch_size
self.nsteps = nsteps
self.nminibatches = nminibatches
self.nbatch = self.nenv * self.nsteps
self.nbatch_train = self.nbatch // nminibatches
self.graphs = [tf.Graph() for _ in range(population_size)]
self.sess = [make_sess(graph=graph) for graph in self.graphs]
fake_env = FakeSingleSpacesVec(env)
for i in range(population_size):
policy = build_policy(fake_env, network, **network_kwargs)
# Instantiate the model object (that creates act_model and train_model)
if model_fn is None:
from baselines.ppo2.model import Model
model_fn = Model
# SOMEDAY: construct everything in one graph & session?
# This might give performance improvements, e.g. evaluate actions
# for each agent in one pass. (Although since they're independent,
# possibly not -- depends how clever TF is at optimizing.)
# However, it breaks PPO's Model, which uses
# tf.trainable_variables('ppo2_model') and so does not support
# multiple variables scopes.
with self.sess[i].as_default():
with self.graphs[i].as_default():
# Both of these are needed -- making a session default
# does not change the default graph.
model = model_fn(policy=policy,
ob_space=ob_space,
ac_space=ac_space,
nbatch_act=self.nenv,
nbatch_train=self.nbatch_train,
nsteps=nsteps,
ent_coef=ent_coef,
vf_coef=vf_coef,
max_grad_norm=max_grad_norm)
if load_paths is not None:
model.load(load_paths[i])
self.models[i] = model
self.epinfobufs = [deque(maxlen=1000) for _ in range(population_size)]
def __init__(self, size, batch_size):
self.batch_size = batch_size
self.states = deque(maxlen=size)
self.signals = deque(maxlen=size)
self.action = None
def __init__(self):
PriceLevel.__init__(self)
self.orders = deque()
def __init__(self, size):
self.buffer = deque(maxlen=size)
