def _create_wallet_source(wallet: 'Wallet', include_worth: bool = True) -> 'List[Stream[float]]':
"""Creates a list of streams to describe a `Wallet`.
Parameters
----------
wallet : `Wallet`
The wallet to make streams for.
include_worth : bool, default True
Whether or
Returns
-------
`List[Stream[float]]`
A list of streams to describe the `wallet`.
"""
exchange_name = wallet.exchange.name
symbol = wallet.instrument.symbol
streams = []
with NameSpace(exchange_name + ":/" + symbol):
free_balance = Stream.sensor(wallet, lambda w: w.balance.as_float(), dtype="float").rename("free")
locked_balance = Stream.sensor(wallet, lambda w: w.locked_balance.as_float(), dtype="float").rename("locked")
total_balance = Stream.sensor(wallet, lambda w: w.total_balance.as_float(), dtype="float").rename("total")
streams += [free_balance, locked_balance, total_balance]
if include_worth:
price = Stream.select(wallet.exchange.streams(), lambda node: node.name.endswith(symbol))
worth = price.mul(total_balance).rename('worth')
streams += [worth]
return streams
def create_env(envs_config=None):
features = []
for c in data.columns[5:]:
s = Stream.source(list(data[c][-100:]),
dtype="float").rename(data[c].name)
features += [s]
cp = Stream.select(features, lambda s: s.name == "close")
features = [cp.log().diff().fillna(0).rename("lr")] + features[1:]
feed = DataFeed(features)
feed.compile()
bitstamp = Exchange("bitstamp", service=execute_order)(Stream.source(
list(data["close"]), dtype="float").rename("USD-BTC"))
portfolio = Portfolio(
USD, [Wallet(bitstamp, 10000 * USD),
Wallet(bitstamp, 10 * BTC)])
renderer_feed = DataFeed([
Stream.source(list(data["date"])).rename("date"),
Stream.source(list(data["open"]), dtype="float").rename("open"),
Stream.source(list(data["high"]), dtype="float").rename("high"),
Stream.source(list(data["low"]), dtype="float").rename("low"),
Stream.source(list(data["close"]), dtype="float").rename("close"),
Stream.source(list(data["volume"]), dtype="float").rename("volume")
])
# reward_scheme = RiskAdjustedReturns(
# return_algorithm='sortino',
# risk_free_rate=0.025,
# target_returns=0.1,
# window_size=200
# )
reward_scheme = SimpleProfit(window_size=200) #PBR(price=cp)
# action_scheme = BSH(
# cash=portfolio.wallets[0],
# asset=portfolio.wallets[1]
# ).attach(reward_scheme)
env = default.create(
portfolio=portfolio,
action_scheme="managed-risk",
reward_scheme=reward_scheme, #"risk-adjusted",
feed=feed,
renderer_feed=renderer_feed,
renderer=default.renderers.PlotlyTradingChart(display=False,
save_format='html',
path='./agents/charts/'),
window_size=40)
return env
def _setup_stream(self):
"""
Sets up data stream with indicators and close
:return: tensortrade.feed.core.DataFeed
"""
features = []
for c in self._data.columns[1:]:
s = Stream.source(list(self._data[c]), dtype="float").rename(self._data[c].name)
features += [s]
cp = Stream.select(features, lambda s: s.name == "close")
features = [
cp.log().diff().rename("lr"),
rsi(cp, period=20).rename("rsi"),
macd(cp, fast=10, slow=50, signal=5).rename("macd")
]
feed = DataFeed(features)
feed.compile()
return feed
def macd(price: Stream[float], fast: float, slow: float,
signal: float) -> Stream[float]:
fm = price.ewm(span=fast, adjust=False).mean()
sm = price.ewm(span=slow, adjust=False).mean()
md = fm - sm
signal = md - md.ewm(span=signal, adjust=False).mean()
return signal
features = []
for c in data.columns[1:]:
s = Stream.source(list(data[c]), dtype="float").rename(data[c].name)
features += [s]
cp = Stream.select(features, lambda s: s.name == "close")
op = Stream.select(features, lambda s: s.name == 'open')
hp = Stream.select(features, lambda s: s.name == 'high')
lp = Stream.select(features, lambda s: s.name == 'low')
v = Stream.select(features, lambda s: s.name == 'volume')
features = [
cp.log().diff().rename("lr"),
op.log().diff().rename("op"),
hp.log().diff().rename("hp"),
lp.log().diff().rename("lp"),
v.log().diff().rename("v"),
rsi(cp, period=20).rename("rsi"),
macd(cp, fast=10, slow=50, signal=5).rename("macd"),
]
def build_env(config):
worker_index = 1
if hasattr(config, 'worker_index'):
worker_index = config.worker_index
raw_data = pd.read_csv(btc_usd_file, sep=';')
raw_data['date'] = pd.to_datetime(raw_data['time'], unit='ms')
data = compute_features(raw_data)
features = []
for c in data.columns:
if c not in raw_data.columns:
s = Stream.source(list(data[c]),
dtype="float").rename(data[c].name)
features += [s]
comm = 0.00001
coinbase = Exchange("coinbase",
service=execute_order,
options=ExchangeOptions(commission=comm))(
Stream.source(list(data["close"]),
dtype="float").rename("USD-BTC"))
cash = Wallet(coinbase, 10000 * USD)
asset = Wallet(coinbase, 0 * BTC)
portfolio = Portfolio(USD, [cash, asset])
renderer_feed = DataFeed([
Stream.source(list(data["date"])).rename("date"),
Stream.source(list(data["open"]), dtype="float").rename("open"),
Stream.source(list(data["high"]), dtype="float").rename("high"),
Stream.source(list(data["low"]), dtype="float").rename("low"),
Stream.source(list(data["close"]), dtype="float").rename("close"),
Stream.source(list(data["volume"]), dtype="float").rename("volume")
])
# reward_scheme = rewards.SimpleProfit()
rsi = Stream.select(features, lambda x: x.name == "rsi")
reward_scheme = SparseReward(rsi=rsi, window_size=10)
action_scheme = BuySellHoldActionSchemes(cash, asset)
action_scheme.attach(reward_scheme)
plotly = PlotlyTradingChart(display=True, height=700, save_format="html")
class EpisodeStopper(Stopper):
def stop(self, env: 'TradingEnv') -> bool:
return env.clock.num_steps > 1000
open_position = Stream.sensor(asset,
lambda a: asset.total_balance.as_float() > 0)
# open_position = Stream.sensor(
# action_scheme, lambda action_scheme: action_scheme.has_asset
# )
features.append(open_position)
feed = DataFeed(features)
feed.compile()
env = default.create(
portfolio=portfolio,
action_scheme=action_scheme,
reward_scheme=reward_scheme,
feed=feed,
renderer_feed=renderer_feed,
renderer=plotly,
window_size=20,
max_allowed_loss=0.5,
stopper=EpisodeStopper(),
callback=(LoggingCallback('http://165.227.193.153:8050', plotly)
if worker_index == 1 else None))
import logging
import os
LOGGER = logging.getLogger(__name__)
logging.basicConfig(
level=logging.INFO,
format=
'%(asctime)s - %(name)s [%(threadName)s] - %(levelname)s - %(message)s',
)
LOGGER.info('env created logger')
LOGGER.info(f'env: {os.environ}')
print(f'env: {os.environ}')
print('env created')
return env
def create_env(data, config):
features = []
for c in data.columns[1:]:
s = Stream.source(list(data[c]), dtype="float").rename(data[c].name)
features += [s]
cp = Stream.select(features, lambda s: s.name == "close")
high_price = data['high']
low_price = data['low']
close_price = data['close']
# print(data['volume'])
try:
data['date']
except KeyError:
data['date'] = data.index
features = [
cp.rename('USD/BTC'),
cp.log().diff().rename("lr"),
rsi(cp, period=14).rename("rsi"),
macd(cp, fast=10, slow=50, signal=5).rename("macd"),
Stream.source(ta.cci(high_price, low_price, close_price)).rename('cci')
# cp.rolling(window=10).mean().rename("fast"),
# cp.rolling(window=50).mean().rename("medium"),
# cp.rolling(window=100).mean().rename("slow")
]
feed = DataFeed(features)
feed.compile()
# for i in range(5):
# print(feed.next())
coinbase = Exchange("coinbase", service=execute_order)(cp)
cash = Wallet(coinbase, 100000 * USD)
asset = Wallet(coinbase, 10 * BTC)
portfolio = Portfolio(USD, [cash, asset])
# reward_scheme = PBR(price=cp)
reward_scheme = RiskAdjustedReturns()
# action_scheme = BSH(cash=cash, asset=asset).attach(reward_scheme)
action_scheme = ManagedRiskOrders()
renderer_feed = DataFeed([
Stream.source(list(data["date"])).rename("date"),
Stream.source(list(data["open"]), dtype="float").rename("open"),
Stream.source(list(data["high"]), dtype="float").rename("high"),
Stream.source(list(data["low"]), dtype="float").rename("low"),
Stream.source(list(data["close"]), dtype="float").rename("close"),
Stream.source(list(data["volume"]), dtype="float").rename("volume"),
#Stream.sensor(action_scheme, lambda s: s.action, dtype="float").rename("action")
])
renderer = PlotlyTradingChart()
environment = default.create(
feed=feed,
portfolio=portfolio,
action_scheme=action_scheme, # The DQN example uses action_scheme="managed-risk"
reward_scheme=reward_scheme, # The DQN uses reward_scheme="risk-adjusted"
renderer_feed=renderer_feed,
renderer=renderer,
window_size=config["window_size"],
max_allowed_loss=0.6
)
return environment
