def test_smoke(): cdd = CryptoDataDownload() coinbase_btc = cdd.fetch("Coinbase", "USD", "BTC", "1h") coinbase_eth = cdd.fetch("Coinbase", "USD", "ETH", "1h") bitstamp_btc = cdd.fetch("Bitstamp", "USD", "BTC", "1h") bitstamp_eth = cdd.fetch("Bitstamp", "USD", "ETH", "1h") bitstamp_ltc = cdd.fetch("Bitstamp", "USD", "LTC", "1h") steps = len(coinbase_btc) coinbase = Exchange("coinbase", service=execute_order)( Stream("USD-BTC", list(coinbase_btc['close'][-steps:])), Stream("USD-ETH", list(coinbase_eth['close'][-steps:]))) bitstamp = Exchange("bitstamp", service=execute_order)( Stream("USD-BTC", list(bitstamp_btc['close'][-steps:])), Stream("USD-ETH", list(bitstamp_eth['close'][-steps:])), Stream("USD-LTC", list(bitstamp_ltc['close'][-steps:]))) portfolio = Portfolio(USD, [ Wallet(coinbase, 200000 * USD), Wallet(coinbase, 0 * BTC), Wallet(bitstamp, 10000 * USD), Wallet(bitstamp, 2 * BTC), Wallet(bitstamp, 20 * ETH), Wallet(bitstamp, 30 * LTC) ]) action_scheme = ManagedRiskOrders( durations=[4, 6, 8, 10], stop_loss_percentages=[0.01, 0.003, 0.3], take_profit_percentages=[0.01, 0.003, 0.3], trade_sizes=[0.99999999999999]) env = TradingEnvironment(action_scheme=action_scheme, reward_scheme="simple", portfolio=portfolio) done = False n_steps = 0 while not done: action = env.action_space.sample() obs, reward, done, info = env.step(action) n_steps += 1 portfolio.ledger.as_frame().sort_values(["step", "poid"]).to_clipboard(index=False) df = portfolio.ledger.as_frame() frames = [] for poid in df.poid.unique(): frames += [df.loc[df.poid == poid, :]] pd.concat(frames, ignore_index=True, axis=0).to_clipboard(index=False) pytest.fail("Failed.")
def test_runs_with__external_feed_only(portfolio): df = pd.read_csv("tests/data/input/coinbase_(BTC,ETH)USD_d.csv").tail(100) df = df.rename({"Unnamed: 0": "date"}, axis=1) df = df.set_index("date") coinbase_btc = df.loc[:, [name.startswith("BTC") for name in df.columns]] coinbase_eth = df.loc[:, [name.startswith("ETH") for name in df.columns]] ta.add_all_ta_features( coinbase_btc, colprefix="BTC:", **{k: "BTC:" + k for k in ['open', 'high', 'low', 'close', 'volume']} ) ta.add_all_ta_features( coinbase_eth, colprefix="ETH:", **{k: "ETH:" + k for k in ['open', 'high', 'low', 'close', 'volume']} ) nodes = [] with Module("coinbase") as coinbase: for name in coinbase_btc.columns: nodes += [Stream(name, list(coinbase_btc[name]))] for name in coinbase_eth.columns: nodes += [Stream(name, list(coinbase_eth[name]))] feed = DataFeed()(coinbase) action_scheme = ManagedRiskOrders() reward_scheme = SimpleProfit() env = TradingEnvironment( portfolio=portfolio, action_scheme=action_scheme, reward_scheme=reward_scheme, feed=feed, window_size=50, use_internal=False, enable_logger=False ) done = False obs = env.reset() while not done: action = env.action_space.sample() obs, reward, done, info = env.step(action) n_features = coinbase_btc.shape[1] + coinbase_eth.shape[1] assert obs.shape == (50, n_features)
def make_env(exchange: str, action: str, reward: str): portfolio = mock.Mock() feed = mock.Mock() return TradingEnvironment(portfolio=portfolio, action_scheme=action, reward_scheme=reward, feed=feed)
def test_init_multiple_exchanges(portfolio): action_scheme = ManagedRiskOrders() reward_scheme = SimpleProfit() env = TradingEnvironment(portfolio=portfolio, action_scheme=action_scheme, reward_scheme=reward_scheme, window_size=50, enable_logger=False) obs = env.reset() assert obs.shape == (50, 32) assert env.observation_space.shape == (50, 32)
def test_runs_with_only_internal_data_feed(portfolio): action_scheme = ManagedRiskOrders() reward_scheme = SimpleProfit() env = TradingEnvironment(portfolio=portfolio, action_scheme=action_scheme, reward_scheme=reward_scheme, window_size=50, enable_logger=False) done = False obs = env.reset() while not done: action = env.action_space.sample() obs, reward, done, info = env.step(action) assert obs.shape == (50, 32)
def create_env(): def fetch_data(exchange_name, symbol, timeframe): url = "https://www.cryptodatadownload.com/cdd/" filename = "{}_{}USD_{}.csv".format(exchange_name, symbol, timeframe) volume_column = "Volume {}".format(symbol) new_volume_column = "Volume_{}".format(symbol) df = pd.read_csv(url + filename, skiprows=1) df = df[::-1] df = df.drop(["Symbol"], axis=1) df = df.rename( { "Volume USD": "volume", volume_column: new_volume_column }, axis=1) df = df.set_index("Date") df.columns = [symbol + ":" + name.lower() for name in df.columns] return df ssl._create_default_https_context = ssl._create_unverified_context # Only used if pandas gives a SSLError coinbase_data = pd.concat([ fetch_data("Coinbase", "BTC", "1h"), fetch_data("Coinbase", "ETH", "1h") ], axis=1) coinbase = Exchange("coinbase", service=execute_order)( Stream("USD-BTC", list(coinbase_data['BTC:close'])), Stream("USD-ETH", list(coinbase_data['ETH:close']))) with Module("coinbase") as coinbase_ns: nodes = [ Stream(name, list(coinbase_data[name])) for name in coinbase_data.columns ] feed = DataFeed([coinbase_ns]) portfolio = Portfolio(USD, [ Wallet(coinbase, 10000 * USD), Wallet(coinbase, 10 * BTC), Wallet(coinbase, 5 * ETH), ]) env = TradingEnvironment(feed=feed, portfolio=portfolio, action_scheme='managed-risk', reward_scheme='risk-adjusted', window_size=20) return env
def trading(agent_path, n_step = len(test),): from tensortrade.exchanges import Exchange from tensortrade.exchanges.services.execution.simulated import execute_order from tensortrade.data import Stream, DataFeed, Module from tensortrade.instruments import USD, BTC from tensortrade.wallets import Wallet, Portfolio coinbase = Exchange("coinbase", service=execute_order)( Stream("USD-BTC", price_history['close'].tolist()) ) portfolio = Portfolio(USD, [ Wallet(coinbase, 10000 * USD), Wallet(coinbase, 10 * BTC), ]) with Module("coinbase") as coinbase_ns: nodes = [Stream(name, test[name].tolist()) for name in test.columns] feed = DataFeed([coinbase_ns]) from tensortrade.environments import TradingEnvironment env = TradingEnvironment( feed=feed, portfolio=portfolio, action_scheme='managed-risk', reward_scheme='risk-adjusted', window_size=20 ) agent = DQNAgent(env) agent.restore() action = agent.env.action_space.sample() state, reward, done, info = agent.env.step(action) action = agent.get_action(state) action = agent.env.action_space.sample() step = 0 while not done and (step < n_steps): state, reward, done, info = agent.env.step(action) action = agent.get_action(state) print('step:', step, '-- action:', action) step += 1 env.portfolio.performance.plot(figsize=(16, 10)) env.portfolio.performance.net_worth.plot(figsize=(16, 10))
def main(): trading_pair = TradingPair(USD, BTC) action = DynamicOrders(trading_pair) exchange = CCXTExchange('bitmex', observation_pairs=[trading_pair], timeframe='1m') wallet = Wallet(exchange, .01 * BTC) portfolio = Portfolio(USD, wallets=[wallet]) env = TradingEnvironment(portfolio, exchange, action, 'simple') while True: env.step(0) env.render('human') time.sleep(.02)
def env(): context = { "base_instrument": USD, "actions": { "pairs": [USD / BTC], "stop_loss_percentages": [0.02, 0.04, 0.06], "take_profit_percentages": [0.01, 0.02, 0.03], "trade_sizes": 10, "trade_side": TradeSide.BUY, "trade_type": TradeType.MARKET, "order_listener": None }, "rewards": { "return_algorithm": "sharpe", "risk_free_rate": 0, "target_returns": 0 }, "exchanges": { "model_type": "FBM", "hurst": 0.61, "timeframe": "1d", "base_price": 7500, "base_volume": 12000 } } with TradingContext(**context): action_scheme = ManagedRiskOrders() reward_scheme = RiskAdjustedReturns() exchange = Exchange() portfolio = Portfolio(USD, [ Wallet(exchange, 100000 * USD), Wallet(exchange, 0 * BTC) ]) env = TradingEnvironment( portfolio=portfolio, action_scheme=action_scheme, reward_scheme=reward_scheme, window_size=14, enable_logger=False ) return env
def test_injects_trading_strategy_with_context(): with TradingContext(**config): env = TradingEnvironment(exchange='simulated', action_scheme='discrete', reward_scheme='simple') strategy = ConcreteTradingStrategy(environment=env) assert hasattr(strategy.environment.exchange.context, 'credentials') assert strategy.environment.exchange.context.credentials == config[ 'exchanges']['credentials'] assert hasattr(strategy.environment.action_scheme.context, 'n_actions') assert strategy.environment.action_scheme.context.n_actions == 24 print(strategy.environment.reward_scheme.context.data) assert hasattr(strategy.environment.reward_scheme.context, 'amount') assert strategy.environment.reward_scheme.context.amount == 100
def get_env(file_path): df = load_data(file_path) normalize = MinMaxNormalizer(inplace=True) difference = FractionalDifference(difference_order=0.6, inplace=True) feature_pipeline = FeaturePipeline(steps=[normalize, difference]) reward_strategy = SimpleProfitStrategy() action_strategy = DiscreteActionStrategy(n_actions=20, instrument_symbol='BTC/USDT') exchange = SimulatedExchange(base_instrument='USDT', should_pretransform_obs=True, feature_pipeline=feature_pipeline ) exchange.data_frame = df[:STEP] environment = TradingEnvironment(exchange=exchange, action_strategy=action_strategy, reward_strategy=reward_strategy, feature_pipeline=feature_pipeline) return environment
def main(): df = load_dataframe() exchange = SimulatedExchange(df) wallet_usd = Wallet(exchange, 0 * USD) wallet_btc = Wallet(exchange, .01 * BTC) portfolio = Portfolio(BTC, wallets=[wallet_usd, wallet_btc]) trading_pair = TradingPair(USD, BTC) action = DynamicOrders(trading_pair) env = TradingEnvironment(portfolio, exchange, action, 'simple', window_size=20) times = [] for _ in range(300): action = 0 if random.random() > .9: action = int(random.uniform(1, 20)) env.step(action) t1 = time.time() env.render('human') times.append(time.time() - t1) if len(times) > 120: times.pop(0) print(f'FPS: {1 / np.mean(times):.1f}', end='\r')
def make_env(exchange: str, action: str, reward: str): return TradingEnvironment(exchange=exchange, action_strategy=action, reward_strategy=reward)
] agent_spec = { "type": "ppo", "learning_rate": 0.0003, "discount": 1.0, "likelihood_ratio_clipping": 0.2, "estimate_terminal": False, "max_episode_timesteps": 200000, "network": network_spec, "batch_size": 10, "update_frequency": 10 } environment = TradingEnvironment(exchange=exchange, action_strategy=action_strategy, reward_strategy=reward_strategy, feature_pipeline=feature_pipeline) strategy = TensorforceTradingStrategy(environment=environment, agent_spec=agent_spec, save_best_agent=False) #%%Start Over performance = strategy.run(episodes=1000, evaluation=False) #manually store agent #strategy.save_agent(directory = 'test/', filename = '01') #%% Restore and Continue ''' strategy.restore_agent(directory = 'a/', filename = 'best-model') performance = strategy.run(episodes=(strategy._runner.agent.episodes + 20), evaluation=False)
portfolio = Portfolio(USD, [ Wallet(coinbase, 10000 * USD), Wallet(coinbase, 10 * BTC), ]) with Module("coinbase") as coinbase_ns: nodes = [Stream(name, data[name].tolist()) for name in data.columns] feed = DataFeed([coinbase_ns]) # Initialize the trading environment from tensortrade.environments import TradingEnvironment env_1 = TradingEnvironment( feed=feed, portfolio=portfolio, action_scheme='managed-risk', reward_scheme='risk-adjusted', window_size=4 ) # Load the agent from the external (pre-trained) files # Training parameters: window_size=4, n_episodes=7, n_steps=2000 from tensortrade.agents import A2CAgent agent = A2CAgent(env_1) agent.restore(path=path, actor_filename=r'C:\Users\ketap\Downloads\drive-download-20200322T222027Z-001\A2C_actor_7.hdf5', critic_filename=r'C:\Users\ketap\Downloads\drive-download-20200322T222027Z-001\A2C_critic_7.hdf5') # Make agent take a set of actions action = agent.env.action_space.sample()
reward_scheme = SimpleProfit() # -------------------------- Live Exchange ------------------------# # import ccxt # from tensortrade.exchanges.live import CCXTExchange # coinbase = ccxt.coinbasepro() # exchange = CCXTExchange(exchange=coinbase, base_instrument='USD') # -------------------------- Simulated Exchange ------------------------# # df = pd.read_csv('./data/Coinbase_BTCUSD_1h.csv') # exchange = SimulatedExchange(data_frame=df, base_instrument='USD',feature_pipeline=feature_pipeline) # from tensortrade.exchanges.simulated import FBMExchange # exchange = FBMExchange(base_instrument='BTC', timeframe='1h', feature_pipeline=feature_pipeline) # #################### Creating an Environment ###################### environment = TradingEnvironment(exchange=exchange, action_scheme=action_scheme, reward_scheme=reward_scheme, feature_pipeline=feature_pipeline) # #################### Learning Agents ###################### params = {"learning_rate": 1e-5, 'nminibatches': 1} # agent = model(policy, environment, model_kwargs=params) # #################### Training a Strategy ###################### strategy = StableBaselinesTradingStrategy(environment=environment, model=PPO2, policy='MlpLnLstmPolicy', model_kwargs=params) # 'render.modes': ['human', 'rgb_array'] # episodes=1 # steps=100 performance = strategy.run(episodes=5, render_mode='human') print(performance[:]) # performance.balance.plot()
warnings.warn = warn warnings.simplefilter(action='ignore', category=FutureWarning) sys.path.append(os.path.dirname(os.path.abspath(''))) from tensortrade.environments import TradingEnvironment from tensortrade.exchanges.simulated import FBMExchange from tensortrade.actions import DiscreteActionStrategy from tensortrade.rewards import SimpleProfitStrategy exchange = FBMExchange() action_strategy = DiscreteActionStrategy() reward_strategy = SimpleProfitStrategy() env = TradingEnvironment(exchange=exchange, action_strategy=action_strategy, reward_strategy=reward_strategy) obs = env.reset() sell_price = 1e9 stop_price = -1 print('Initial portfolio: ', exchange.portfolio) for i in range(1000): action = 0 if obs['close'] < sell_price else 18 action = 19 if obs['close'] < stop_price else action if i == 0 or portfolio['BTC'] == 0: action = 16 sell_price = obs['close'] + (obs['close'] / 50)