Deep reinforcement learning (DRL), which balances exploration (of uncharted territory) and exploitation (of current knowledge), has been recognized as an advantageous approach for automated stock trading. DRL framework is powerful in solving dynamic decision making problems by learning through interaction with an unknown environment, and thus providing two major advantagesportfolio scalability and market model independence [5] . In quantitative finance, stock trading is essentially making dynamic decisions, namely to decide where to trade, at what price, and what quantity, over a highly stochastic and complex stock market. As a result, DRL provides useful toolkits for stock trading [21, 44, 48, 45, 10, 8, 26] . Taking many complex financial factors into account, DRL trading agents build a multi-factor model and provide algorithmic trading strategies, which are difficult for human traders [3, 47, 24, 22] .
Preceding DRL, conventional reinforcement learning (RL) [43] has been applied to complex financial problems [31] , including option pricing, portfolio optimization and risk management. Moody and Saffell [36] utilized policy search and direct RL for stock trading. Deng et al. [12] showed that applying deep neural networks profits more. There are industry practitioners who have explored trading strategies fueled by DRL, since deep neural networks are significantly powerful at approximating the expected return at a state with a certain action. With the development of more robust models and strategies, general machine learning approaches and DRL methods in specific are becoming more reliable. For example, DRL has been implemented on sentimental analysis on portfolio allocation [27, 22] and liquidation strategy analysis [2] , showing the potential of DRL on various financial tasks.
However, to implement a DRL or RL driven trading strategy is nowhere near as easy. The development and debugging processes are arduous and error-prone. Training environments, managing intermediate trading states, organizing training-related data and standardizing outputs for evaluation metrics -these steps are standard in implementation yet time-consuming especially for beginners. Therefore, we come up with a beginner-friendly library with fine-tuned standard DRL algorithms. It has been developed under three primary principles:
• Completeness. Our library shall cover components of the DRL framework completely, which is a fundamental requirement;
• Hands-on tutorials. We aim for a library that is friendly to beginners. Tutorials with detailed walk-through will help users to explore the functionalities of our library;
• Reproducibility. Our library shall guarantee reproducibility to ensure the transparency and also provide users with confidence in what they have done.
In this paper, we present a three-layered FinRL library that streamlines the development stock trading strategies. FinRL provides common building blocks that allow strategy builders to configure stock market datasets as virtual environments, to train deep neural networks as trading agents, to analyze trading performance via extensive backtesting, and to incorporate important market frictions. On the lowest level is environment, which simulates the financial market environment using actual historical data from six major indices with various environment attributes such as closing price, shares, trading volume, technical indicators etc. In the middle is the agent layer that provides fine-tuned standard DRL algorithms (DQN [29] [34], DDPG [29] , Adaptive DDPG [27] , Multi-Agent DDPG [30] , PPO [40] , SAC [18] , A2C [33] and TD3 [11] , etc.), commonly used reward functions and standard evaluation baselines to alleviate the debugging workloads and promote the reproducibility. The agent interacts with the environment through properly defined reward functions on the state space and action space. The top layer includes applications in automated stock trading, where we demonstrate three use cases, namely single stock trading, multiple stock trading and portfolio allocation.
The contributions of this paper are summarized as follows:
• FinRL is an open source library specifically designed and implemented for quantitative finance. Trading environments incorporating market frictions are used and provided.
• Trading tasks accompanied by hands-on tutorials with built-in DRL agents are available in a beginner-friendly and reproducible fashion using Jupyter notebook. Customization of trading time steps is feasible.
• FinRL has good scalability, with a broad range of fine-tuned state-of-the-art DRL algorithms. Adjusting the implementations to the rapid changing stock market is well supported.
• Typical use cases are selected and used to establish a benchmark for the quantitative finance community. Standard backtesting and evaluation metrics are also provided for easy and effective performance evaluation.
The remainder of this paper is organized as follows. Section 2 reviews related works. Section 3 presents FinRL Library. Section 4 provides evaluation support for analyzing stock trading performance. We conclude our work in Section 5.
We review related works on relevant open source libraries and existing applications of DRL in finance.
Recent works can be categorized into three approaches: value based algorithm, policy based algorithm, and actor-critic based algorithm. FinRL has consolidated and elaborated upon those algorithms to build financial DRL models. There are a number of machine learning libraries that share similar features as our FinRL library.
• OpenAI Gym [4] is a popular open source library that provides a standardized set of task environments. OpenAI Baselines [13] implements high quality deep reinforcement learning algorithms using gym environments. Stable Baselines [19] is a fork of OpenAI Baselines with code cleanup and user-friendly examples.
• Google Dopamine [7] is a research framework for fast prototyping of reinforcement learning algorithms. It features plugability and reusability.
• RLlib [28] provides high scalability with reinforcement learning algorithms. It has modular framework and is very well maintained.
• Horizon [17] is a DL-focused framework dominated by PyTorch, whose main use case is to train RL models in the batch setting.
Recent works show that DRL has many applications in quantitative finance [14] .
Stock trading is usually considered as one of the most challenging applications due to its noisy and volatile features. Many researchers have explored various approaches using DRL [38, 37, 10, 9, 48, 16] . Volatility scaling can be incorporated with DRL to trade futures contracts [48] . By adding a market volatility term to reward functions, we can scale up the trade shares with low volatility, and vice versa. News headline sentiments and knowledge graphs can also be combined with the time series stock data to train an optimal policy using DRL [37] . High frequency trading with DRL is also a hot topic [16] . Deep Hedging [5, 6] represents hedging strategies with neural networks learned by modern DRL policy search. This application has shown two key advantages of the DRL approach in quantitative finance, which are scalability and model independent. It uses DRL to manage the risk of liquid derivatives, which indicates further extension of our library into other asset classes and topics.
FinRL library consists of three layers: environments, agents and applications. We first describe the overall architecture, and then present each layer.
The architecture of the FinRL library is shown in Fig. 1 , and its features are summarized as follows:
• Three-layer architecture: The three layers of FinRL library are stock market environment, DRL trading agent, and stock trading applications. The agent layer interacts with the environment layer in an exploration-exploitation manner, whether to repeat prior working-well decisions or to make new actions hoping to get greater rewards. The lower layer provides APIs for the upper layer, making the lower layer transparent to the upper layer. • Modularity: Each layer includes several modules and each module defines a separate function. One can select certain modules from any layer to implement his/her stock trading task. Furthermore, updating existing modules is possible.
• Simplicity, Applicability and Extendibility: Specifically designed for automated stock trading, FinRL presents DRL algorithms as modules. In this way, FinRL is made accessible yet not demanding. FinRL provides three trading tasks as use cases that can be easily reproduced. Each layer includes reserved interfaces that allow users to develop new modules.
• Better Market Environment Modeling: We build a trading simulator that replicates live stock market and provides backtesting support that incorporates important market frictions such as transaction cost, market liquidity and the investor's degree of risk-aversion. All of those are crucial among key determinants of net returns.
Considering the stochastic and interactive nature of the automated stock trading tasks, a financial task is modeled as a Markov Decision Process (MDP) problem. The training process involves observing stock price change, taking an action and reward's calculation to have the agent adjusting its strategy accordingly. By interacting with the environment, the trading agent will derive a trading strategy with the maximized rewards as time proceeds.
Our trading environments, based on OpenAI Gym framework, simulate live stock markets with real market data according to the principle of time-driven simulation [4] . FinRL library strives to provide trading environments constructed by six datasets across five stock exchanges.
We give definitions of the state space, action space and reward function.
State space S. The state space describes the observations that the agent receives from the environment. Just as a human trader needs to analyze various information before executing a trade, so our trading agent observes many different features to better learn in an interactive environment. We provide various features for users:
• Balance b t ∈ R + : the amount of money left in the account at the current time step t.
• Shares own h t ∈ Z n + : current shares for each stock, n represents the number of stocks. • Closing price p t ∈ R n + : one of the most commonly used feature. • Opening/high/low prices o t , h t , l t ∈ R n + : used to track stock price changes. • Trading volume v t ∈ R n + : total quantity of shares traded during a trading slot. • Technical indicators: Moving Average Convergence Divergence (MACD) M t ∈ R n and Relative Strength Index (RSI) R t ∈ R n + , etc. • Multiple-level of granularity: we allow data frequency of the above features to be daily, hourly or on a minute basis.
Action space A. The action space describes the allowed actions that the agent interacts with the environment. Normally, a ∈ A includes three actions: a ∈ {−1, 0, 1}, where −1, 0, 1 represent selling, holding, and buying one stock. Also, an action can be carried upon multiple shares. We use an action space {−k, ..., −1, 0, 1, ..., k}, where k denotes the number of shares. For example, "Buy 10 shares of AAPL" or "Sell 10 shares of AAPL" are 10 or −10, respectively.
Reward function r(s, a, s ′ ) is the incentive mechanism for an agent to learn a better action. There are many forms of reward functions. We provide commonly used ones [14] as follows:
• 
• FinRL also supports user defined reward functions to include risk factor or transaction cost term such as in [12, 48, 5] 
The application of DRL in finance is different from that in other fields, such as playing chess and card games [42, 46] ; the latter inherently have clearly defined rules for environments. Various finance markets require different DRL algorithms to get the most appropriate automated trading agent. Realizing that setting up training environment is a time-consuming and laborious work, FinRL provides six environments based on representative listings, including NASDAQ-100, DJIA, S&P 500, SSE 50, CSI 300, and HSI, plus one user-defined environment. With those efforts, this library frees users from tedious and time-consuming data pre-processing workload.
We are well aware that users may want to train trading agents on their own data sets. FinRL library provides convenient support to user imported data to adjust the granularity of time steps. We specify the format of the data for each of the use cases. Users only need to pre-process their data sets according to our data format instructions.
FinRL library includes fine-tuned standard DRL algorithms, namely, DQN [29] [34], DDPG [29] , Multi-Agent DDPG [30] , PPO [40] , SAC [18] , A2C [33] and TD3 [11] . We also allow users to design their own DRL algorithms by adapting these DRL algorithms, e.g., Adaptive DDPG [27] , or employing ensemble methods [45] . The comparison of DRL algorithms is shown in Fig. 2 The implementation of the DRL algorithms are based on OpenAI Baselines [13] and Stable Baselines [19] .
Standard metrics and baseline trading strategies are provided to support trading performance analysis. FinRL library follows a training-validation-testing flow to design a trading strategy. 
FinRL provides five evaluation metrics to help users evaluate the stock trading performance directly, which are final portfolio value, annualized return, annualized standard deviation, maximum drawdown ratio, and Sharpe ratio.
Baseline trading strategies should be well-chosen and follow industrial standards. The strategies will be universal to measure, standard to compare with, and easy to implement. In FinRL library, traditional trading strategies serve as the baseline for comparing with DRL strategies. Investors usually have two objectives for their decisions: the highest possible profits and the lowest possible risks of uncertainty [41] . FinRL uses five conventional strategies, namely passive buy-and-hold trading strategy [32] , mean-variance strategy [1] , and min-variance strategy [1] , momentum trading strategy [15] , and equal-weighted strategy to address these two mutually limiting objectives and the industrial standards.
With our use cases as instances, the stock market data are divided into three phases in Fig. 3 .
Training dataset is the sample of data to fit the DRL model. The model sees and learns from the training dataset. Validation dataset is used for parameter tuning and to avoid overfitting. Testing (trading) dataset is the sample of data to provide an unbiased evaluation of a fine-tuned model. Rolling window is usually associated with the training-validation-testing flow in stock trading because investors and portfolio managers may need to rebalance the portfolio and retrain the model periodically. FinRL provides flexible rolling window selection such as on a daily basis, monthly, quarterly, yearly or by user specified. 
In order to better simulate practical trading, we incorporate trading constraints, risk-aversion and automated backtesting tools.
Automated Backtesting. Backtesting plays a key role in performance evaluation. Automated backtesting tool is preferable because it reduces the human error. In FinRL library, we use the Quantopian pyfolio package [39] to backtest our trading strategies. This package is easy to use and consists of various individual plots that provide a comprehensive image of the performance of a trading strategy.
Incorporating Trading Constraints. Transaction costs incur when executing a trade. There are many types of transaction costs, such as broker commissions and SEC fee. We allow users to treat transaction costs as a parameter in our environments:
• Flat fee: a fixed dollar amount per trade regardless of how many shares traded.
• Per share percentage: a per share rate for every share traded, for example, 1/1000 or 2/1000 are the most commonly used transaction cost rate for each trade.
Moreover, we need to consider market liquidity for stock trading, such as bid-ask spread. Bid-ask spread is the difference between the prices quoted for an immediate selling action and an immediate buying action for stocks. In our environments, we can add the bid-ask spread as a parameter to the stock closing price to simulate real world trading experience.
Risk-aversion. Risk-aversion reflects whether an investor will choose to preserve the capital. It also influences one's trading strategy when facing different market volatility level.
To control the risk in a worst-case scenario, such as financial crisis of 2007-2008, FinRL employs the financial turbulence index turbulence t that measures extreme asset price fluctuation [25] : where y t ∈ R n denotes the stock returns for current period t, µ ∈ R n denotes the average of historical returns, and Σ ∈ R n×n denotes the covariance of historical returns. It is used as a parameter that controls buying or selling action, for example if the turbulence index reaches a pre-defined threshold, the agent will halt buying action and starts selling the holding shares gradually.
We demonstrate with three use cases: single stock trading [10, 8, 26, 48] , multiple stock trading [44, 45] , and portfolio allocation [22, 27] . FinRL library provides practical and reproducible solutions for each use case, with online walk-through tutorial using Jupyter notebook (e.g., the configurations of the running environment and commands). We select three use cases and reproduce the results using FinRL to establish a benchmark for the quantitative finance community. Fig. 4 and Table 1 demonstrate the performance evaluation of single stock trading. We pick largecap ETFs such as SPDR S&P 500 ETF Trust (SPY) and Invesco QQQ Trust Series 1 (QQQ), and stocks such as Google (GOOGL), Amazon (AMZN), Apple (AAPL), and Microsoft (MSFT). We use PPO algorithm in FinRL and train a trading agent. The maximum drawdown in Table 1 is large due to Covid-19 market crash. Table 2 show the performance and multiple stock trading and portfolio allocation over the Dow Jones 30 constitutes. We use DDPG and TD3 to trade multiple stocks, and allocate portfolio.
In this paper, we have presented FinRL library that is a DRL library designed specifically for automated stock trading with an effort for educational and demonstrative purpose. FinRL is characterized by its extendability, more-than-basic market environment and extensive performance evaluation tools also for quantitative investors and strategy builders. Customization is easily accessible on all layers, from market simulator, trading agents' learning algorithms up towards profitable strategies. In a trading strategy design, FinRL follows a training-validation-testing flow and provides automated backtesting as well as benchmark tests. As a walk-through tutorial in Jupyter notebook format, we demonstrate easily reproducible profitable strategies under different scenarios using FinRL: (i) single stock trading; (ii) multiple stock trading; (iii) incorporating the mechanism of stock information penetration. With FinRL Library, implementation of powerful DRL driven trading strategies is made an accessible, efficient and delightful experience.