def test_simple(self):
prices = data.load_relative("../data/YNDX_160101_161231.csv")
env = environ.StocksEnv({"YNDX": prices})
s = env.reset()
obs, reward, done, info = env.step(0)
# print(obs)
# print(reward)
# print(done)
# print(info)
self.assertAlmostEqual(reward, 0.0, 6)
def test(self):
"""Test trained agent for a single episode. Return the episode reward"""
# instantiate env
STOCKS = 'stock_prices__min_test_NVDA.csv'
stock_data = {"NVDA": data.load_relative(STOCKS)}
env = environ.StocksEnv(stock_data,
bars_count=30,
reset_on_close=False,
commission=0.00,
state_1d=False,
random_ofs_on_reset=False,
reward_on_close=True,
volumes=False)
episode_reward = 0
total_steps = 0
rewards = []
obs = env.reset()
while True:
action = self.agent.compute_action(obs)
obs, reward, done, _ = env.step(action)
print("done", done)
episode_reward += reward
total_steps += 1
rewards.append(episode_reward)
print("{}: reward={} action={}".format(total_steps, episode_reward,
action))
if done:
break
rewards_data = pd.DataFrame(rewards)
print("Sharpe", rewards_data.apply(self.sharpe, freq=125, rfr=0))
print("Max Drawdown", rewards_data.apply(self.max_drawdown))
# plot rewards
plt.clf()
plt.plot(rewards)
plt.title("Total reward, data=NVDA")
plt.ylabel("Reward, %")
plt.savefig("curiousity_model_test_NVDA_30.png")
Prices = collections.namedtuple('Prices', field_names=['open', 'high', 'low', 'close', 'volume'])
torch, nn = try_import_torch()
def env_creator(env_name):
if env_name == "StocksEnv-v0":
from lib.environ import StocksEnv as env
else:
raise NotImplementedError
return env
# register the env
BARS_COUNT = 30
STOCKS = '/Users/user/Desktop/Market_Research/stock_data/stock_prices__min_train_NET.csv'
stock_data = {"NIO": data.load_relative(STOCKS)}
env = env_creator("StocksEnv-v0")
tune.register_env('myEnv', lambda config: env(stock_data, bars_count=BARS_COUNT, state_1d=False))
config_model = sac.DEFAULT_CONFIG.copy()
config_model["policy_model"] = sac.DEFAULT_CONFIG["policy_model"].copy()
config_model["env"] = "myEnv"
config_model["gamma"] = 1.0
config_model["no_done_at_end"] = True
config_model["tau"] = 3e-3
config_model["target_network_update_freq"] = 32
config_model["num_workers"] = 1 # Run locally.
config_model["twin_q"] = True
config_model["clip_actions"] = True
config_model["normalize_actions"] = True
config_model["learning_starts"] = 0
parser.add_argument("--cuda", default=False, action="store_true", help="Enable cuda")
parser.add_argument("--data", default=DEFAULT_STOCKS, help="Stocks file or dir to train on, default=" + DEFAULT_STOCKS)
parser.add_argument("--year", type=int, help="Year to be used for training, if specified, overrides --data option")
parser.add_argument("--valdata", default=DEFAULT_VAL_STOCKS, help="Stocks data for validation, default=" + DEFAULT_VAL_STOCKS)
parser.add_argument("-r", "--run", required=True, help="Run name")
args = parser.parse_args()
device = torch.device("cuda" if args.cuda else "cpu")
saves_path = os.path.join("saves", args.run)
os.makedirs(saves_path, exist_ok=True)
if args.year is not None or os.path.isfile(args.data):
if args.year is not None:
stock_data = data.load_year_data(args.year)
else:
stock_data = {"YNDX": data.load_relative(args.data)}
env = environ.StocksEnv(stock_data, bars_count=BARS_COUNT, reset_on_close=True, state_1d=False, volumes=False)
env_tst = environ.StocksEnv(stock_data, bars_count=BARS_COUNT, reset_on_close=True, state_1d=False)
elif os.path.isdir(args.data):
env = environ.StocksEnv.from_dir(args.data, bars_count=BARS_COUNT, reset_on_close=True, state_1d=False)
env_tst = environ.StocksEnv.from_dir(args.data, bars_count=BARS_COUNT, reset_on_close=True, state_1d=False)
else:
raise RuntimeError("No data to train on")
env = gym.wrappers.TimeLimit(env, max_episode_steps=1000)
val_data = {"YNDX": data.load_relative(args.valdata)}
env_val = environ.StocksEnv(val_data, bars_count=BARS_COUNT, reset_on_close=True, state_1d=False)
writer = SummaryWriter(comment="-simple-" + args.run)
net = models.SimpleFFDQN(env.observation_space.shape[0], env.action_space.n).to(device)
tgt_net = ptan.agent.TargetNet(net)
parser.add_argument("--val", default=VAL_STOCKS, help="Validation data, default="+VAL_STOCKS)
parser.add_argument("-r", "--run", required=True, help="Run name")
args = parser.parse_args()
device = torch.device("cuda" if args.cuda else "cpu")
saves_path = SAVE_DIR / f"simple-{args.run}"
saves_path.mkdir(parents=True, exist_ok=True)
data_path = pathlib.Path(args.data)
val_path = pathlib.Path(args.val)
if args.year is not None or data_path.is_file():
if args.year is not None:
stock_data = data.load_year_data(args.year)
else:
stock_data = {"YNDX": data.load_relative(data_path)}
env = environ.StockEnv(stock_data, bars_count=BARS_COUNT)
env_tst = environ.StockEnv(stock_data, bars_count=BARS_COUNT)
elif data_path.is_dir():
env = environ.StockEnv.from_dir(data_path, bars_count=BARS_COUNT)
env_tst = environ.StockEnv.from_dir(data_path, bars_count=BARS_COUNT)
else:
raise RuntimeError("No data to train on")
env = gym.wrappers.TimeLimit(env, max_episode_steps=1000)
val_data = {"YNDX": data.load_relative(val_path)}
net = models.SimpleFFDQN(env.observation_space.shape[0], env.action_space.n).to(device)
tgt_net = drl.agent.TargetNet(net)
selector = drl.actions.EpsilonGreedySelector(epsilon=EPS_START)
help="Count of bars to feed into the model")
parser.add_argument("-n",
"--name",
required=True,
help="Name to use in output images")
parser.add_argument("--commission",
type=float,
default=0.1,
help="Commission size in percent, default=0.1")
parser.add_argument("--conv",
default=False,
action="store_true",
help="Use convolution model instead of FF")
args = parser.parse_args()
prices = data.load_relative(args.data)
env = environ.StocksEnv({"TEST": prices},
bars_count=args.bars,
reset_on_close=False,
commission=args.commission,
state_1d=args.conv,
random_ofs_on_reset=False,
reward_on_close=False,
volumes=False)
if args.conv:
net = models.DQNConv1D(env.observation_space.shape, env.action_space.n)
else:
net = models.SimpleFFDQN(env.observation_space.shape[0],
env.action_space.n)
def test_simple(self):
prices = data.load_relative("data/YNDX_160101_161231.csv")
env = environ.StocksEnv({"YNDX": prices})
s = env.reset()
obs, reward, done, info = env.step(0)
self.assertAlmostEqual(reward, 0.0, 6)
EPSILON = 0.02
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("-d", "--data", required=True, help="CSV file with quotes to run the model")
parser.add_argument("-m", "--model", required=True, help="Model file to load")
parser.add_argument("-b", "--bars", type=int, default=50, help="Count of bars to feed into the model")
parser.add_argument("-n", "--name", required=True, help="Name to use in output images")
parser.add_argument("--commission", type=float, default=0.1, help="Commission size in percent, default=0.1")
parser.add_argument("--conv", default=False, action="store_true", help="Use convolution model instead of FF")
args = parser.parse_args()
prices = data.load_relative(args.data)
env = environ.StocksEnv({"TEST": prices}, bars_count=args.bars, reset_on_close=False, commission=args.commission,
state_1d=args.conv, random_ofs_on_reset=False, reward_on_close=False, volumes=False)
if args.conv:
net = models.DQNConv1D(env.observation_space.shape, env.action_space.n)
else:
net = models.SimpleFFDQN(env.observation_space.shape[0], env.action_space.n)
net.load_state_dict(torch.load(args.model, map_location=lambda storage, loc: storage))
obs = env.reset()
start_price = env._state._cur_close()
total_reward = 0.0
step_idx = 0
rewards = []
parser.add_argument("--valdata",
default=DEFAULT_VAL_STOCKS,
help="Stocks data for validation, default=" +
DEFAULT_VAL_STOCKS)
parser.add_argument("-r", "--run", required=True, help="Run name")
args = parser.parse_args()
device = torch.device("cuda" if args.cuda else "cpu")
saves_path = os.path.join("saves", args.run)
os.makedirs(saves_path, exist_ok=True)
if args.year is not None or os.path.isfile(args.data):
if args.year is not None:
stock_data = data.load_year_data(args.year)
else:
stock_data = {"BANK": data.load_relative(args.data)}
env = environ.StocksEnv(stock_data,
bars_count=BARS_COUNT,
reset_on_close=True,
state_1d=True,
volumes=False)
env_tst = environ.StocksEnv(stock_data,
bars_count=BARS_COUNT,
reset_on_close=True,
state_1d=True)
elif os.path.isdir(args.data):
env = environ.StocksEnv.from_dir(args.data,
bars_count=BARS_COUNT,
reset_on_close=True,
state_1d=True)
env_tst = environ.StocksEnv.from_dir(args.data,
def from_dir(cls, data_dir, **kwargs):
prices = {
file: data.load_relative(file)
for file in data.price_files(data_dir)
}
return StocksEnv(prices, **kwargs)
saves_path = SAVES_DIR / f"simple-{args.run}"
print(saves_path)
saves_path.mkdir(parents=True, exist_ok=True)
data_path = pathlib.Path(args.data)
print(data_path)
val_path = pathlib.Path(args.val)
# create env
if args.year is not None or data_path.is_file():
if args.year is not None:
stock_data = data.load_year_data(args.year)
else:
stock_data = {
"YNDX": data.load_relative(data_path, filter_data=args.fd)
}
env = environ.StocksEnv(stock_data, bars_count=BARS_COUNT)
env_tst = environ.StocksEnv(stock_data, bars_count=BARS_COUNT)
elif data_path.is_dir():
env = environ.StocksEnv.from_dir(data_path,
filter_data=args.fd,
bars_count=BARS_COUNT)
env_tst = environ.StocksEnv.from_dir(data_path,
filter_data=args.fd,
bars_count=BARS_COUNT)
else:
raise RuntimeError("No data to train on")
# print(env._prices.keys)
# raise Exception(222)
