def test_min_max_indicator_inplace_false(self, data_frame):
""" Test that not setting inplace rules equates to more columns after the transformation"""
test_feature = MinMaxNormalizer(
columns=TestMinMaxNormalizer.price_columns, inplace=False)
test_feature.reset()
transformed = test_feature.transform(data_frame)
assert transformed is not None
assert len(data_frame.columns) != len(transformed.columns)
def test_min_max_indicator(self, data_frame, reference_frame):
""" Check that the min-max indicator is to be expected. """
test_feature = MinMaxNormalizer(
columns=TestMinMaxNormalizer.price_columns)
test_feature.reset()
roundable = 4
transformed = test_feature.transform(data_frame)
assert transformed is not None
transformed = transformed.round(roundable)
reference_frame = reference_frame.round(roundable)
close_1 = transformed.Close.values
close_2 = reference_frame.Close.values
is_valid = (close_1 == close_2).all()
assert is_valid
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 test_full_ta_min_max_pipeline(self, data_frame, reference_frame):
ta_indicator = TAlibIndicator(
indicators=["BBAND", "RSI", "EMA", "SMA"])
min_max = MinMaxNormalizer()
feature_pipeline = FeaturePipeline([ta_indicator, min_max])
columns = reference_frame.columns
col_1 = columns[0]
reference_frame = reference_frame.drop(columns=[col_1])
transformed_frame = feature_pipeline.transform(data_frame)
transformed_frame = transformed_frame.dropna()
reference_frame = reference_frame.dropna()
# We round to 4 significant digits
significance = 10
transformed_frame = transformed_frame.round(significance)
reference_frame = reference_frame.round(significance)
bb_middle1 = reference_frame.bb_middle.values
bb_middle2 = transformed_frame.bb_middle.values
is_valid = (bb_middle1 == bb_middle2).all()
assert is_valid
def handle(self, *args, **kwargs):
print(
'Start Time is : ',
datetime.datetime.now(pytz.timezone('Asia/Tehran')).strftime(
"%d %b %Y %H:%M:%S Tehran"))
# print('Start Time is : ', strftime("%Y-%m-%d %H:%M:%S", localtime()))
start_time = int(time.time())
train = True
train = False
iteration = 1
n_step_multiply = 100
window_size = 5
n_step = 128
gamma = 0.995
learning_rate = 2.5E-4
lam = 0.9
ent_coef = 0.1
leverage = 25
initial_balance = 100
max_allowed_amount = 5000
stop_loss_percent = 60
n_splitt = 5
end_candle = 300
render_mode = 'chart2'
# df = pd.read_csv('./tensortrade/data/Coinbase_BTCUSD_d.csv')[0:end_candle]
# candles = BitmxMinCandle.objects.all().order_by('id')[99:end_candle] #100000
# candles = MinCandle.objects.all().order_by('id')[99:end_candle] #134000
# candles = Min3Candle.objects.all().order_by('id')[99:end_candle] #48000
candles = Min5Candle.objects.all().order_by('id')[99:
end_candle] #28800
# candles = HourlyCandle.objects.all().order_by('id')[0:end_candle] #22500
df = pd.DataFrame(list(candles.values()))
df = df.drop(['id', 'coin_marketcap', 'marketcap', 'symbol', 'date'],
axis=1)
df['open'] = df['open'].astype('float64')
df['close'] = df['close'].astype('float64')
df['low'] = df['low'].astype('float64')
df['high'] = df['high'].astype('float64')
df['volume'] = df['volume'].astype('float64')
price_columns = ["close"]
volume_column = ["volume"]
normalized_price = MinMaxNormalizer(columns=price_columns,
feature_min=1E-6,
feature_max=1,
input_min=1E-6,
input_max=1E6)
normalized_volume = MinMaxNormalizer(columns=volume_column,
feature_min=1E-9,
feature_max=1,
input_min=1E-9,
input_max=1E9)
# difference_all = FractionalDifference(difference_order=0.6)
# ema = TAlibIndicator(indicators=[['EMA', {'args':['close'], 'params':{'timeperiod':14}}]])
# sma50 = TAlibIndicator(indicators=[['SMA', {'args':['close'], 'params':{'timeperiod':50}}]])
# sma100 = TAlibIndicator(indicators=[['SMA', {'args':['close'], 'params':{'timeperiod':100}}]])
# sma200 = TAlibIndicator(indicators=[['SMA', {'args':['close'], 'params':{'timeperiod':200}}]])
rsi = TAlibIndicator(indicators=[[
'RSI', {
'args': ['close'],
'params': {
'timeperiod': 14
}
}
]])
macd = TAlibIndicator(indicators=[[
'MACD', {
'args': ['close'],
'params': {
'fastperiod': 5,
'slowperiod': 20,
'signalperiod': 30
}
}
]])
stochastic = TAlibIndicator(indicators=[[
'STOCH', {
'args': ['high', 'low', 'close'],
'params': {
'fastk_period': 5,
'slowk_period': 3,
'slowd_period': 2
}
}
]])
cci = TAlibIndicator(indicators=[[
'CCI', {
'args': ['high', 'low', 'close'],
'params': {
'timeperiod': 20
}
}
]])
feature_pipeline = FeaturePipeline(
steps=[normalized_volume, normalized_price])
exchange = BitmexExchange3(data_frame=df,
base_instrument='USDT',
window_size=window_size,
initial_balance=initial_balance,
commission_percent=0.60,
leverage=leverage,
stop_loss_percent=stop_loss_percent)
action_scheme = DiscreteActionsPlus(
n_actions=4,
instrument='BTC/USDT',
max_allowed_amount=max_allowed_amount)
# action_scheme = CustomeDiscreteActions(n_splitt=n_splitt, instrument='BTC/USDT', max_allowed_amount=max_allowed_amount)
reward_scheme = BitmexProfit()
# reward_scheme = AdvancedProfit()
environment = BitmexEnvironment(exchange=exchange,
action_scheme=action_scheme,
reward_scheme=reward_scheme,
feature_pipeline=feature_pipeline)
model_kwargs = {
'learning_rate': learning_rate,
'nminibatches': 1,
'gamma': gamma,
'lam': lam
}
# net_arch = [1024, 'lstm', dict(vf=[256, 64], pi=[64])]
# net_arch = [1024, 'lstm', 512, 128]
net_arch = [128, 'lstm', 512, 64]
# net_arch = [1024, 256]
policy_kwargs = {
'net_arch': net_arch,
# 'feature_extraction': 'mlp',
'act_fun': tf.nn.relu,
# 'n_env': 32,
}
strategy = BitmexTradingStrategySBL(environment=environment,
model=DQN,
policy='MlpPolicy')
# custom_objects = {'learning_rate': learning_rate, 'nminibatches': 1, 'gamma': gamma, 'lam': lam, 'n_steps': n_step, 'ent_coef': ent_coef}
custom_objects = {}
if train:
for i in range(iteration):
print('*-------------- iteration =', i + 1, ' --------------*')
try:
strategy.restore_agent(path="./tensortrade/agents/train_4",
custom_objects=custom_objects)
print(
'Agent Loaded ',
datetime.datetime.now(
pytz.timezone('Asia/Tehran')).strftime("%H:%M:%S"))
# time.sleep(3)
except:
print('Loading Failed: Agent is not exist')
print(
'New Agent created ',
datetime.datetime.now(
pytz.timezone('Asia/Tehran')).strftime("%H:%M:%S"))
# time.sleep(3)
print('Training ...')
strategy.train(steps=round(len(df) * n_step_multiply))
strategy.save_agent(path="./tensortrade/agents/train_4")
print(
'Agent Saved ',
datetime.datetime.now(
pytz.timezone('Asia/Tehran')).strftime("%H:%M:%S"))
print('Elapsed Time is : ',
round((int(time.time()) - start_time) / 60, 2),
'Minutes')
else:
strategy.restore_agent(path="./tensortrade/agents/train_4")
performance = strategy.test(steps=round(len(df) - window_size - 2),
render_mode=render_mode)
performance.balance.plot(label='Balance', color='green')
print(performance)
plt.xlabel('Steps (' + str(round(len(df) - window_size)) + ')')
plt.ylabel('Balance (XBT)')
plt.legend()
plt.show()
print('Elapsed Time is : ',
round((int(time.time()) - start_time) / 60, 2), 'Minutes')
def handle(self, *args, **kwargs):
print('Start Time is : ', datetime.datetime.now(pytz.timezone('Asia/Tehran')).strftime("%d %b %Y %H:%M:%S Tehran"))
# print('Start Time is : ', strftime("%Y-%m-%d %H:%M:%S", localtime()))
start_time = int(time.time())
train = True
train = False
iteration = 500
n_step_multiply = 2
window_size = 50
n_step = 16
gamma = 0.995
learning_rate = 2.5E-4
lam = 0.9
ent_coef = 0.1
leverage = 10
initial_balance = 100
max_allowed_amount = 5000
stop_loss_percent = 60
n_splitt = 5
end_candle = 7200
render_mode = 'chart2'
# df = pd.read_csv('./tensortrade/data/Coinbase_BTCUSD_d.csv')[0:end_candle]
# candles = BitmxMinCandle.objects.all().order_by('id')[99:end_candle] #100000
# candles = MinCandle.objects.all().order_by('id')[99:end_candle] #134000
# candles = Min3Candle.objects.all().order_by('id')[99:end_candle] #48000
# candles = Min5Candle.objects.all().order_by('id')[99:end_candle] #28800
candles = HourlyCandle.objects.all().order_by('id')[0:end_candle] #22500
df = pd.DataFrame(list(candles.values()))
df = df.drop(['id', 'coin_marketcap', 'marketcap', 'symbol', 'date'], axis=1)
df['open'] = df['open'].astype('float64')
df['close'] = df['close'].astype('float64')
df['low'] = df['low'].astype('float64')
df['high'] = df['high'].astype('float64')
df['volume'] = df['volume'].astype('float64')
price_columns = ["open", "high", "low", "close"]
volume_column = ["volume"]
normalized_price = MinMaxNormalizer(columns=price_columns, feature_min=1E-6, feature_max=1, input_min=1E-6, input_max=1E6)
normalized_volume = MinMaxNormalizer(columns=volume_column, feature_min=1E-9, feature_max=1, input_min=1E-9, input_max=1E9)
# difference_all = FractionalDifference(difference_order=0.6)
# ema = TAlibIndicator(indicators=[['EMA', {'args':['close'], 'params':{'timeperiod':14}}]])
# sma50 = TAlibIndicator(indicators=[['SMA', {'args':['close'], 'params':{'timeperiod':50}}]])
# sma100 = TAlibIndicator(indicators=[['SMA', {'args':['close'], 'params':{'timeperiod':100}}]])
# sma200 = TAlibIndicator(indicators=[['SMA', {'args':['close'], 'params':{'timeperiod':200}}]])
rsi = TAlibIndicator(indicators=[['RSI', {'args':['close'], 'params':{'timeperiod':14}}]])
macd = TAlibIndicator(indicators=[['MACD', {'args':['close'], 'params':{'fastperiod':5,'slowperiod':20,'signalperiod':30}}]])
stochastic = TAlibIndicator(indicators=[['STOCH', {'args':['high', 'low', 'close'], 'params':{'fastk_period':5,'slowk_period':3,'slowd_period':2}}]])
cci = TAlibIndicator(indicators=[['CCI', {'args':['high', 'low', 'close'], 'params':{'timeperiod':20}}]])
feature_pipeline = FeaturePipeline(steps=[normalized_volume, macd, stochastic, cci, rsi])
exchange = BitmexExchange2(data_frame=df, base_instrument='USDT', window_size=window_size, initial_balance=initial_balance, commission_percent=0.60, leverage=leverage, stop_loss_percent=stop_loss_percent)
# action_scheme = DiscreteActions(n_actions=3, instrument='BTC/USDT', max_allowed_amount=max_allowed_amount)
action_scheme = CustomeDiscreteActions(n_splitt=n_splitt, instrument='BTC/USDT', max_allowed_amount=max_allowed_amount)
reward_scheme = BitmexProfit()
# reward_scheme = AdvancedProfit()
environment = BitmexEnvironment(exchange=exchange, action_scheme=action_scheme, reward_scheme=reward_scheme, feature_pipeline=feature_pipeline)
model_kwargs = {'learning_rate': learning_rate, 'nminibatches': 1, 'gamma': gamma, 'lam': lam, 'noptepochs': 4, 'n_steps': n_step, 'ent_coef': ent_coef,
# 'cliprange_vf': -1,
# 'tensorboard_log': "./tensortrade/logs/"
}
# net_arch = [1024, 'lstm', dict(vf=[256, 64], pi=[64])]
# net_arch = [1024, 'lstm', 512, 128]
net_arch = [256, 'lstm', 512, 64]
# net_arch = [1024, 256]
policy_kwargs = {'net_arch': net_arch,
# 'feature_extraction': 'mlp',
'act_fun': tf.nn.relu,
# 'n_env': 32,
}
strategy = BitmexTradingStrategySBL(environment=environment, model=PPO2, policy='MlpLstmPolicy', model_kwargs=model_kwargs, policy_kwargs=policy_kwargs)
custom_objects = {'learning_rate': learning_rate, 'nminibatches': 1, 'gamma': gamma, 'lam': lam, 'n_steps': n_step, 'ent_coef': ent_coef}
# custom_objects = {}
if train:
for i in range(iteration):
print('*-------------- iteration =', i+1, ' --------------*')
try:
strategy.restore_agent(path="./tensortrade/agents/train_2", custom_objects=custom_objects)
print('Agent Loaded ', datetime.datetime.now(pytz.timezone('Asia/Tehran')).strftime("%H:%M:%S"))
# time.sleep(3)
except:
print('Loading Failed: Agent is not exist')
print('New Agent created ', datetime.datetime.now(pytz.timezone('Asia/Tehran')).strftime("%H:%M:%S"))
# time.sleep(3)
print('Training ...')
strategy.train(steps=round(len(df) * n_step_multiply))
strategy.save_agent(path="./tensortrade/agents/train_2")
print('Agent Saved ', datetime.datetime.now(pytz.timezone('Asia/Tehran')).strftime("%H:%M:%S"))
print('Elapsed Time is : ', round((int(time.time())-start_time)/60, 2), 'Minutes')
else:
strategy.restore_agent(path="./tensortrade/agents/train_2")
performance = strategy.test(steps=round(len(df) - window_size - 2), render_mode=render_mode)
performance.balance.plot(label='Balance', color='green')
print(performance)
plt.xlabel('Steps ('+str(round(len(df) - window_size))+')')
plt.ylabel('Balance (XBT)')
plt.legend()
plt.show()
print('Elapsed Time is : ', round((int(time.time())-start_time)/60, 2), 'Minutes')
# tensorboard --logdir /home/coinstealer/www/binanceweb/tensortrade/logs/
# performances = []
# iteration = 10
# for i in range(iteration):
# print('-------------- iteration >', i, ' ', datetime.datetime.now(pytz.timezone('Asia/Tehran')).strftime("%d %b %Y %H:%M:%S Tehran"), ' --------------')
#
# # performances.append(strategy.run(steps=round(len(df)*0.96), render_mode='chart2'))# steps=100 episodes=1 'render.modes': ['log', 'chart']
# performances.append(
# strategy.run(steps=round(len(df) * 0.96))) # steps=100 episodes=1 'render.modes': ['log', 'chart']
# if i == 0:
# performances[i].balance.plot(label=i, color='blue')
# elif i == max(range(iteration)):
# performances[i].balance.plot(label=i, color='green')
# elif i % int(iteration / 10) == 0:
# performances[i].balance.plot(label=i, color=(0.9, 0.3, 0.5, i / iteration))
# print(performances[0])
# agent = model(policy, environment, model_kwargs=params)
# layer1 = Dense(name='layer1', size=100, input_spec={'shape': (6,), 'type': 'float'})
# layer2 = Dense(name='layer2', size=100, input_spec={'shape': (100,), 'type': 'float'})
# network_spec = LayeredNetwork(name='net1', layers=[layer1, layer2], inputs_spec={'shape': (7,), 'type': 'float'})
# agent_spec = {"type": "ppo", "discount": 0.995, "likelihood_ratio_clipping": 0.2, 'network': network_spec}
# agent_spec = {
# "policy": {
# "network": {
# "type": "layered",
# "inputs_spec": {'shape': (7,), 'type': 'float'},
# "layers": [
# {"type": 'dense', "size": 32, 'input_spec': {'shape': (6,), 'type': 'float'}},
# {"type": 'dense', "size": 32, 'input_spec': {'shape': (6,), 'type': 'float'}},
# # {"type": 'softmax'},
# ],
# }
# },
# "update": 64,
# "memory": {"type": Replay, "capacity": 10},
# "objective": "policy_gradient",
# "reward_estimation": {
# "horizon": 20
# }
# }
# agent_spec = {
# "policy": {
# "network": {
# "type": "auto",
# "size": 256,
# "depth": 2,
# # "internal_rnn": True,
# }
# },
# "update": 64,
# "memory": {"type": Replay, "capacity": 200},
# "objective": "policy_gradient",
# "reward_estimation": {
# "horizon": 20
# }
# }
numpy.seterr(divide='ignore')
import tensorflow
assert tensorflow.__version__ == '1.13.1'
from tensortrade.strategies import TensorforceTradingStrategy
from tensortrade.rewards import DirectProfitStrategy
from tensortrade.actions import FutureActionStrategy
reward_strategy = DirectProfitStrategy()
action_strategy = FutureActionStrategy()
#%% Feature Pipeline
from tensortrade.features.stationarity import FractionalDifference
from tensortrade.features.scalers import MinMaxNormalizer
from tensortrade.features import FeaturePipeline
normalize = MinMaxNormalizer(inplace=True)
difference = FractionalDifference(difference_order=0.6, inplace=True)
feature_pipeline = FeaturePipeline(steps=[])
#%% Data Input
from tensortrade.exchanges.simulated.future_exchange import FutureExchange
data = pd.read_csv('TA.csv', index_col=0)
data = data[data.index % 30 == 0]
data = data.reset_index(drop=True)
exchange = FutureExchange(data,
base_instrument='RMB',
exclude_close=True,
initial_balance=10000,
should_pretransform_obs=False)
def create_unity_environment(worker_id: int):
window_size = 10
leverage = 25
initial_balance = 100
max_allowed_amount = 5000
stop_loss_percent = 60
n_splitt = 5
env_seed = seed
if not env_seed:
env_seed = seed_pool[worker_id % len(seed_pool)]
start_candle = 99
end_candle = start_candle + n_steps + 1
# df = pd.read_csv('./tensortrade/data/Coinbase_BTCUSD_d.csv')[start_candle:end_candle]
# candles = BitmxMinCandle.objects.all().order_by('id')[start_candle:end_candle] #221000 (100K-150K Deleted)
candles = MinCandle.objects.all().order_by('id')[start_candle:
end_candle] # 204000
# candles = Min3Candle.objects.all().order_by('id')[start_candle:end_candle] #68000
# candles = Min5Candle.objects.all().order_by('id')[start_candle:end_candle] #41000
# candles = HourlyCandle.objects.all().order_by('id')[start_candle:end_candle] #23900
df = pd.DataFrame(list(candles.values()))
df = df.drop(['id', 'coin_marketcap', 'marketcap', 'symbol', 'date'],
axis=1)
df['open'] = df['open'].astype('float64')
df['close'] = df['close'].astype('float64')
df['low'] = df['low'].astype('float64')
df['high'] = df['high'].astype('float64')
df['volume'] = df['volume'].astype('float64')
price_columns = ["open", "high", "low", "close"]
volume_column = ["volume"]
normalized_price = MinMaxNormalizer(columns=price_columns,
feature_min=1E-6,
feature_max=1,
input_min=1E-6,
input_max=1E6)
normalized_volume = MinMaxNormalizer(columns=volume_column,
feature_min=1E-9,
feature_max=1,
input_min=1E-9,
input_max=1E9)
# difference_all = FractionalDifference(difference_order=0.6)
ema = TAlibIndicator(indicators=[[
'EMA', {
'args': ['close'],
'params': {
'timeperiod': 14
}
}
]])
# sma50 = TAlibIndicator(indicators=[['SMA', {'args':['close'], 'params':{'timeperiod':50}}]])
sma100 = TAlibIndicator(indicators=[[
'SMA', {
'args': ['close'],
'params': {
'timeperiod': 100
}
}
]])
# sma200 = TAlibIndicator(indicators=[['SMA', {'args':['close'], 'params':{'timeperiod':200}}]])
rsi = TAlibIndicator(indicators=[[
'RSI', {
'args': ['close'],
'params': {
'timeperiod': 14
}
}
]])
macd = TAlibIndicator(indicators=[[
'MACD', {
'args': ['close'],
'params': {
'fastperiod': 5,
'slowperiod': 20,
'signalperiod': 30
}
}
]])
stochastic = TAlibIndicator(indicators=[[
'STOCH', {
'args': ['high', 'low', 'close'],
'params': {
'fastk_period': 5,
'slowk_period': 3,
'slowd_period': 2
}
}
]])
cci = TAlibIndicator(indicators=[[
'CCI', {
'args': ['high', 'low', 'close'],
'params': {
'timeperiod': 20
}
}
]])
feature_pipeline = FeaturePipeline(
steps=[normalized_price, normalized_volume, macd, stochastic])
exchange = BitmexExchange(data_frame=df,
base_instrument='USDT',
window_size=window_size,
initial_balance=initial_balance,
commission_percent=0.60,
leverage=leverage,
stop_loss_percent=stop_loss_percent)
# action_scheme = DiscreteActions(n_actions=3, instrument='BTC/USDT', max_allowed_amount=max_allowed_amount)
action_scheme = DiscreteActionsPlus(
n_actions=4,
instrument='BTC/USDT',
max_allowed_amount=max_allowed_amount)
# action_scheme = CustomeDiscreteActions(n_splitt=n_splitt, instrument='BTC/USDT', max_allowed_amount=max_allowed_amount)
reward_scheme = BitmexProfit()
# reward_scheme = AdvancedProfit()
environment = BitmexEnvironment(exchange=exchange,
action_scheme=action_scheme,
reward_scheme=reward_scheme,
feature_pipeline=feature_pipeline)
return environment
from tensortrade.exchanges.simulated import SimulatedExchange
df = pd.read_csv('./data/btc_ohclv_1h.csv')
exchange = SimulatedExchange(data_frame=df, base_instrument='USD')
# Feature Pipelines
from tensortrade.features import FeaturePipeline
from tensortrade.features.scalers import MinMaxNormalizer
from tensortrade.features.stationarity import FractionalDifference
from tensortrade.features.indicators import SimpleMovingAverage
price_columns = ['open', 'high', 'low', 'close']
normalize_price = MinMaxNormalizer(price_columns)
moving_averages = SimpleMovingAverage(price_columns)
difference_all = FractionalDifference(difference_order=0.6)
feature_pipeline = FeaturePipeline(
steps=[normalize_price, moving_averages, difference_all])
exchange.feature_pipeline = feature_pipeline
# Action Strategies
from tensortrade.actions import DiscreteActionStrategy
action_strategy = DiscreteActionStrategy(n_actions=20, instrument_symbol='BTC')
# Reward Strategies
from tensortrade.exchanges.simulated import FBMExchange
from tensortrade.features.scalers import MinMaxNormalizer
from tensortrade.features.stationarity import FractionalDifference
from tensortrade.features import FeaturePipeline
from tensortrade.rewards import SimpleProfitStrategy
from tensortrade.actions import DiscreteActionStrategy
from tensortrade.environments import TradingEnvironment
# creating an environment
normalize_price = MinMaxNormalizer(['open', 'high', 'low', 'close'])
difference = FractionalDifference(difference_order=0.6)
feature_pipeline = FeaturePipeline(steps=[normalize_price, difference])
exchange = FBMExchange(timeframe='1h',
base_instrument='BTC',
feature_pipeline=feature_pipeline)
reward_strategy = SimpleProfitStrategy()
action_strategy = DiscreteActionStrategy(n_actions=20,
instrument_symbol='ETH/BTC')
environment = TradingEnvironment(exchange=exchange,
action_strategy=action_strategy,
reward_strategy=reward_strategy,
feature_pipeline=feature_pipeline)
# defining the agent
from stable_baselines.common.policies import MlpLnLstmPolicy
import pandas as pd
import tensortrade.slippage as slippage
import copy
from tensortrade import TradingContext
from tensortrade.trades import Trade
from tensortrade.exchanges.simulated import StochasticExchange
from tensortrade.trades import TradeType, Trade
from tensortrade.features import FeaturePipeline
from tensortrade.features.indicators import TAlibIndicator
from tensortrade.features.scalers import MinMaxNormalizer
ta_indicator = TAlibIndicator(indicators=["BBAND", "RSI", "EMA", "SMA"])
min_max = MinMaxNormalizer()
feature_pipeline = FeaturePipeline([ta_indicator, min_max])
config = {
'base_instrument': 'EURO',
'instruments': 'ETH',
'exchanges': {
'credentials': {
'api_key': '48hg34wydghi7ef',
'api_secret_key': '0984hgoe8d7htg'
}
},
"feature_pipeline": feature_pipeline
}
from stable_baselines import PPO2
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
candles = BitmxMinCandle.objects.all().order_by('id')[:1000]
df = pd.DataFrame(list(candles.values()))
# df = pd.read_csv('./data/Coinbase_BTCUSD_1h.csv')
exchange = SimulatedExchange(data_frame=df,
base_instrument='USD',
window_size=5,
should_pretransform_obs=True)
# -------------------------- Feature Pipelines ------------------------#
price_columns = ["open", "high", "low", "close"]
volume_column = ["volume"]
normalized_price = MinMaxNormalizer(price_columns)
normalized_volume = MinMaxNormalizer(volume_column)
sma = SimpleMovingAverage(columns=price_columns, window_size=50)
indicators = TAlibIndicator(
indicators=["EMA", "RSI", "CCI", "Stochastic", "MACD"],
lows=[30, -100, 20],
highs=[70, 100, 80])
difference_all = FractionalDifference(difference_order=0.6)
feature_pipeline = FeaturePipeline(steps=[
normalized_price, sma, difference_all, normalized_volume, indicators
])
exchange.feature_pipeline = feature_pipeline
# -------------------------- Action Schemes ------------------------#
action_scheme = DiscreteActions(n_actions=20, instrument='BTC/USD')
# -------------------------- Reward Schemes ------------------------#
reward_scheme = SimpleProfit()
# -*- coding: utf-8 -*-
"""
Created on Sun Apr 12 12:53:14 2020
@author: avales
"""
from tensortrade.features.scalers import MinMaxNormalizer
from tensortrade.features.stationarity import FractionalDifference
from tensortrade.features import FeaturePipeline
from tensortrade.rewards import SimpleProfit
from tensortrade.actions import DiscreteActions
from tensortrade.environments import TradingEnvironment
normalize_price = MinMaxNormalizer(["open", "high", "low", "close"])
difference = FractionalDifference(difference_order=0.6)
feature_pipeline = FeaturePipeline(steps=[normalize_price, difference])
from tensortrade.exchanges.simulated import FBMExchange
exchange = FBMExchange(timeframe='1h',
base_instrument='BTC',
feature_pipeline=feature_pipeline)
reward_scheme = SimpleProfit()
action_scheme = DiscreteActions(n_actions=20, instrument_symbol='ETH/BTC')
environment = TradingEnvironment(exchange=exchange,
action_scheme=action_scheme,
reward_scheme=reward_scheme,
feature_pipeline=feature_pipeline)
from stable_baselines.common.policies import MlpLnLstmPolicy