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)