The application of machine learning (ML) to solve complex problems is now pervasive across domains, and the finance industry is not an exception. As Krishnamachari (Krishnamachari, 2017) noted, the role of humans in the finance industry has already declined significantly since the big data and AI revolution. Many prior works have attempted to apply various ML algorithms in the finance domain. Kim and Won (Kim and Won, 2018)
proposed long short-term memory (LSTM) with multiple generalized autoregressive conditional heteroskedasticity (GARCH) models to predict the volatility of the stock price index. Leiet al. (Lei et al., 2020)
However, most studies have focused on the methodology itself, not on how to actually deploy models in real-world systems. As Sculley et al. (Sculley et al., 2015) asserted, it is important to be aware of ML-specific risk factors in systems, such as boundary erosion, data dependencies, and a variety of anti-patterns. They encouraged better abstractions, testing methodologies, and design patterns in ML systems to avoid the incurrence of massive maintenance costs. To avoid the possible issues, many ML platforms, such as Bighead (Brumbaugh et al., 2019) and NSML (Sung et al., 2017), have been presented by various organizations and individuals. However, these platforms are limited to developing and deploying ML models for general purposes. Few platforms have aimed to unlock the power of ML in quantitative investment, as Qlib (Yang et al., 2020) did.
Thus, we propose an ML platform called Shai-am for developing and deploying ML-based investment strategies. It aims to abstract strategic logic into isolated components to maximize reusability. We design the core framework in Python for implementing investment strategies to expose unified interfaces. Moreover, we aim to allow ML or quantitative researchers to focus solely on core logic without deeply concerning themselves with resources and dependencies. Shai-am leverages various open-source projects to enable such an environment; designing pipelines and allocating resources can be done flexibly in the platform. This paper explores Shai-am’s overall design goals and architecture and how it can be utilized in financial business.
In this section, we review the open-source projects that we use in our platform and other related works.
Kubernetes (Bernstein, 2014) is an open-source container orchestration system for deploying and managing containerized applications. It abstracts the underlying infrastructure, managing and scaling resources automatically. Recently, many previous works have taken advantage of it to build ML or data analysis systems. For example, Lee et al. (Lee et al., 2020) proposed a cloud native ML platform with dynamic orchestration and microservice-oriented containerization using Kubernetes. They improved the efficiency of computing resources and solved the difficulty of maintaining ML development environments. Tesliuk et al. (Tesliuk et al., 2019) developed a data analysis pipeline on Kubernetes for single particle imaging (SPI) experiments. Flexible modification or replacement of pipeline components and scaling of individual components was possible due to the nature of Kubernetes. Katib (Tesliuk et al., 2019), a scalable automatic machine learning (AutoML) platform, is also built on Kubernetes, encapsulating each component as a microservice.
Apache Airflow (Foundation, 2022) is an open-source workflow platform known for its scalability and extensibility. It aims to be a Kubernetes-friendly project to take advantage of Kubernetes’ increased stability and autoscaling abilities. In addition, Airflow allows users to define and schedule jobs programmatically in Python, allowing for dynamic pipeline generation (Foundation, 2022). Although Airflow is a general solution for controlling workflows, it is often used to construct ML pipelines. Bighead (Brumbaugh et al., 2019), a framework-agnotic, end-to-end ML platform developed by Airbnb, exploited the virtues of Airflow. Its offline execution engine is built on top of Airflow, managing training, inference, and evaluation jobs.
MinIO (MinIO, 2022) is a high-performance object storage that is compatible with Amazon S3 cloud storage (Amazon, oms3). It is also Kubernetes native, offering consistent performance in diverse environments. MinIO can store unstructured data, such as images, videos, log files, and even trained ML models. Thus, several prior works have used MinIO in their ML experiments. For instance, Buniatyan (Buniatyan, 2019)
, proposing a methodology for processing input data of deep learning models, stored his training data and artifacts in MinIO. Baxevanakiset al. (Baxevanakis et al., 2022) built a DeepFake detection service based on a deep learning model using MinIO for its main storage.
2.4. Related Work
2.4.1. API Design
In general, application programming interface (API) design is essential because it is closely related to the usability of the API. A well-designed API enables users to understand the whole architecture easily and reduces the overall complexity. It also facilitates the development and maintenance of any kind of project. One example is Scikit-learn (Pedregosa et al., 2011), an open-source Python library for solving medium-scale supervised and unsupervised ML problems. It provides simple and efficient interfaces so that it can be integrated easily into applications in various domains (Buitinck et al., 2013). Sktime (Löning et al., 2019) is a Scikit-learn compatible Python library that focuses on ML with time series. Löning et al. (Löning et al., 2019) emphasized the importance of a unified interface and the way that their design impacts the solution of time series tasks.
2.4.2. ML Platforms for Finance
Many organizations and individuals have built ML platforms to reduce the pain of the whole ML modeling process. Airbnb introduced Bighead (Brumbaugh et al., 2019)
to help its data science and engineering teams develop and deploy ML models efficiently. Similarly, NSML(Sung et al., 2017) was made to improve the overall efficiency of model development. Most of the works are oriented to the general ML development process, and few platforms have been built to deal with ML in finance specifically. Qlib (Yang et al., 2020) is one of few ML platforms focusing on quantitative investment. Its goal is to empower quantitative researchers to take full advantage of ML technologies in investment.
Backtesting refers to a methodology for testing an investment strategy based on historical data. There are several open-source backtesting modules built in Python, such as Backtrader (Rodriguez, 2020) and Zipline (Inc, 2020). Previous studies have utilized these modules to evaluate their models. Fazeli (Fazeli, 2019) used deep learning for predicting stock trends and backtested it using Backtrader. Picasso et al. (Picasso et al., 2019) also used Backtrader to evaluate the market prediction of their deep learning model. Joshi (Joshi, 2018) proposed an LSTM to predict the next day’s stock price and verified his idea with Zipline.
3. Overall System Design
3.1. Infrastructure and Modeling Environment
We set up a Kubernetes cluster (Bernstein, 2014) on premise, installing a private Docker registry, Apache Airflow (Foundation, 2022), and MinIO (MinIO, 2022). The Docker registry stores the images for executing strategy instances. We choose Airflow as our workflow platform to schedule and run the containerized pipelines for ML-based strategies. Before deploying actual pipelines, analyzing data and conducting experiments are mandatory to develop an investment strategy. For such an environment, we launch a Kubernetes service with the same image used in the pipeline for each researcher. A researcher accesses the container on the cluster remotely, performs various experiments, and pushes final implementations to the remote Git repository. The object storage, MinIO, is for saving logs of pipelines, artifacts and, most importantly, strategy instances. The overall modeling environment in Shai-am is shown in Figure 1.
3.2. Framework for Investment Strategies
Python is the most preferred language for the fields of machine learning and data analysis, offering clean high-level APIs (Raschka et al., 2020)
. To accommodate other popular ML frameworks or libraries in Python, such as TensorFlow(Abadi et al., 2016)
, PyTorch(Paszke et al., 2017), and Scikit-learn (Pedregosa et al., 2011), we choose it as the main language. In addition, our primary focus is not high frequency trading (HFT) or intraday trading; run-time optimization is not a critical issue. Our ML-based strategies aim to replace the decision-making process of traditional asset managers in investment. Our core interfaces are designed to maximize reusability and minimize the silo effect. Further details of the interfaces are elaborated in Section 4. All source codes, including the interfaces and implementations of our investment strategies, are managed with Git as the complete Python project. One can easily clone the repository and install it as a Python package.
3.3. ML Pipeline
Our ML pipeline is defined as Airflow’s directed acyclic graph (DAG). We configure Airflow with KubernetesExecutor and define each task using KubernetesPodOperator. The task runs a Python script importing our core framework package. Since each component of the pipeline is executed as a Kubernetes pod, configuring the execution environment, including Docker image and resources (cpu, gpu, memory, etc.), is flexible. After a train pipeline runs successfully, a trained ML-based strategy instance is saved in MinIO with a unique identification number. Due to the volatile nature of the pod, anything needed to be archived, such as a log, artifact, or strategy, is saved to MinIO. A pipeline for inference is scheduled appropriately depending on the properties of the strategy. When the pipeline runs, it loads the strategy object from the storage and executes it as described in Section 4.3. The output of the strategy, such as a portfolio, is also saved in MinIO.
4. Core Framework Design
We unify the process of loading data from the remote data source by developing the loader module. By calling the module, researchers can load data easily in Python without knowing the detailed structure of the data source. Based on the loader module, one needs to implement the BaseDataPipeline interface to generate any data needed for an investment strategy. BaseTimeSeriesDatasetGenerator extends the base interface and is oriented toward generating a time series dataset. The generated dataset must be a TimeSeriesDataset object, which is likely to be an input of the algorithm for the time series. Since the type of time series dataset is identical, time series–related operations, such as splitting the dataset based on the date, can be performed by calling the common methods. A unified interface for generating a dataset also helps others understand how data are preprocessed and infer the characteristics of the algorithms that will use the dataset.
The objective of algorithm interfaces is to encapsulate the core logic and distinguish a broad category of algorithms while leaving maximum flexibility to researchers. Quantitative investment logic can be any type of algorithm; however, we want to identify its characteristics by defining a general interface for each kind. The BaseAlgorithm interface is at the core of the algorithm interfaces. It requires the implementation of save and load methods for saving and loading an object. The BaseRLAlgorithm interface extends to expose methods related to reinforcement learning. Moreover, an environment for the reinforcement learning algorithm must implement the interface defined in OpenAI Gym (Brockman et al., 2016). Another child interface, BaseEstimator
, is for supervised and unsupervised learning algorithms, similar to theestimator interface introduced in Scikit-learn. We also apply its key concepts of using mix-in classes and multi-inheritance (Buitinck et al., 2013).
The BaseStrategy interface is the most essential part of our investment framework. The interface is designed to be as simple as possible so that even a person without great expertise in Python can carry out a strategy. We expect domain experts in traditional finance, such as traders, managers, and even research analysts, to contribute to implementing strategies based on the framework. In addition to methods for saving and loading an object, the interface exposes two main methods: reset and execute. A reset method is for setting the date range for which the strategy is to be executed. After the reset is called, valid dates on which the strategy can be carried out are returned. Any date in the list of the valid dates is passed to call execute. The output of execute must be an outcome instance that has content and extra information such as an investment horizon. A type of content varies depending on the type of strategy. For example, for an allocation strategy, a content of its outcome must be a portfolio instance that has information about assets and their weights. The interface also requires passing an investment universe, benchmark, and type of strategy to a constructor. These attributes are useful at the conceptual level to identify a strategy’s basic characteristics. After instantiation, such information can be retrieved easily by calling the getters.
The BaseDPStrategy interface extends the base interface to represent a strategy that utilizes data from the remote data source. A list of BaseDataPipeline objects that are needed to execute a strategy must be passed to the constructor and can be accessed by calling the getter after instantiation. BaseDPStrategy adds the configs setter to configure the BaseDataPipeline objects. Finally, the BaseMLStrategy interface extends the BaseDPStrategy to embrace ML algorithms for an investment strategy. A list of BaseAlgorithm objects is required for the constructor. A BaseDataPipeline object generates data for an algorithm; however, there is no direct dependency between two objects in terms of implementation. The strategy interface is the highest-level interface encapsulating the core logic for investment and the way in which the required data are generated. Executing the saved strategy object is straightforward, as shown in Listing 1.
The backtesting module exploits the fact that all strategies implement the same interface described in Section 4.3. This module unifies the process of backtesting an investment strategy, mediating the burden of writing custom codes for each one. The key aspect of the module is that its implementation is totally separated from how the strategy is implemented. It only calls its getters and methods defined in the strategy interface. Based on the strategy’s investment universe and benchmark, the module queries price data and metadata from the remote data source. The loaded data are used to evaluate the strategy both horizontally and vertically. A horizontal condition determines whether the strategy is analyzed at monthly, quarterly, or yearly frequency, or in a customized time interval. In addition, the module is able to break down the performance of the strategy into individual assets, sectors, broad categories, or countries, depending on the given vertical condition.
5. Use Case
Shai-am is adopted as the main platform in managing ML-based investment products, such as open-ended funds, trusts, and wrap accounts. For each product, at least two pipelines are deployed, as shown in Figure 2: one for creating a strategy instance corresponding to the product and the other for actually carrying out the strategy. All selected strategies and their outcomes, such as portfolios, ranks, and signals, are saved and managed in MinIO. Saved results are used to make decisions on portfolio rebalancing, asset selection, or hedging. The backtesting module periodically loads the saved objects and evaluates their recent performances in diverse aspects. Researchers monitor the backtesting results on a daily basis to see if strategies are working as intended. In this way, human intervention is minimized, and the number of investment products being managed is no longer a critical issue.
In this paper, we present Shai-am, a scalable ML platform specialized in managing ML-based investment strategies. It is designed to maximize the productivity of researchers and developers while minimizing the risk of technical debt. We focus on abstracting quantitative investment logic into functionally isolated modules to increase reusability and foster a collaborative environment. We will continue working on Shai-am to seek better investment strategies based on modern ML technologies.
- Abadi et al. (2016) Martín Abadi, Paul Barham, Jianmin Chen, Zhifeng Chen, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Geoffrey Irving, Michael Isard, et al. 2016. TensorFlow: a system for Large-Scale machine learning. In 12th USENIX symposium on operating systems design and implementation (OSDI 16). 265–283.
- Amazon (oms3) Amazon. https://aws.amazon.com/s3/. Amazon Simple Storage Service(Amazon S3). https://min.io/
- Baxevanakis et al. (2022) Spyridon Baxevanakis, Giorgos Kordopatis-Zilos, Panagiotis Galopoulos, Lazaros Apostolidis, Killian Levacher, Ipek B Schlicht, Denis Teyssou, Ioannis Kompatsiaris, and Symeon Papadopoulos. 2022. The MeVer DeepFake Detection Service: Lessons Learnt from Developing and Deploying in the Wild. arXiv preprint arXiv:2204.12816 (2022).
- Bernstein (2014) David Bernstein. 2014. Containers and cloud: From lxc to docker to kubernetes. IEEE cloud computing 1, 3 (2014), 81–84.
- Brockman et al. (2016) Greg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and Wojciech Zaremba. 2016. Openai gym. arXiv preprint arXiv:1606.01540 (2016).
- Brumbaugh et al. (2019) Eli Brumbaugh, Mani Bhushan, Andrew Cheong, Michelle Gu-Qian Du, Jeff Feng, Nick Handel, Andrew Hoh, Jack Hone, Brad Hunter, Atul Kale, et al. 2019. Bighead: a framework-agnostic, end-to-end machine learning platform. In 2019 IEEE International Conference on Data Science and Advanced Analytics (DSAA). IEEE, 551–560.
- Buitinck et al. (2013) Lars Buitinck, Gilles Louppe, Mathieu Blondel, Fabian Pedregosa, Andreas Mueller, Olivier Grisel, Vlad Niculae, Peter Prettenhofer, Alexandre Gramfort, Jaques Grobler, et al. 2013. API design for machine learning software: experiences from the scikit-learn project. arXiv preprint arXiv:1309.0238 (2013).
- Buniatyan (2019) Davit Buniatyan. 2019. Hyper: Distributed cloud processing for large-scale deep learning tasks. In 2019 Computer Science and Information Technologies (CSIT). IEEE, 27–32.
- Fazeli (2019) Arvand Fazeli. 2019. Using Deep Learning for Predicting Stock Trends. (2019).
- Foundation (2022) The Apache Software Foundation. 2022. Apache airflow. https://airflow.apache.org/
- Inc (2020) Quantopian Inc. 2020. Zipline. https://zipline.ml4trading.io/
Developing an Artificial Neural Network Algorithmic Trading System.Available at SSRN 3889600 (2018).
- Kim and Won (2018) Ha Young Kim and Chang Hyun Won. 2018. Forecasting the volatility of stock price index: A hybrid model integrating LSTM with multiple GARCH-type models. Expert Systems with Applications 103 (2018), 25–37.
- Krishnamachari (2017) Rajesh T Krishnamachari. 2017. Big Data and AI Strategies. (2017).
Lee et al. (2020)
Chun-Hsiang Lee, Zhaofeng
Li, Xu Lu, Tiyun Chen,
Saisai Yang, and Chao Wu.
Multi-Tenant Machine Learning Platform Based on
Proceedings of the 2020 6th International Conference on Computing and Artificial Intelligence. 5–12.
- Lei et al. (2020) Kai Lei, Bing Zhang, Yu Li, Min Yang, and Ying Shen. 2020. Time-driven feature-aware jointly deep reinforcement learning for financial signal representation and algorithmic trading. Expert Systems with Applications 140 (2020), 112872.
- Löning et al. (2019) Markus Löning, Anthony Bagnall, Sajaysurya Ganesh, Viktor Kazakov, Jason Lines, and Franz J Király. 2019. sktime: A unified interface for machine learning with time series. arXiv preprint arXiv:1909.07872 (2019).
- MinIO (2022) MinIO. 2022. Multi-Cloud Object Storage. https://min.io/
- Paszke et al. (2017) Adam Paszke, Sam Gross, Soumith Chintala, Gregory Chanan, Edward Yang, Zachary DeVito, Zeming Lin, Alban Desmaison, Luca Antiga, and Adam Lerer. 2017. Automatic differentiation in pytorch. (2017).
- Pedregosa et al. (2011) Fabian Pedregosa, Gaël Varoquaux, Alexandre Gramfort, Vincent Michel, Bertrand Thirion, Olivier Grisel, Mathieu Blondel, Peter Prettenhofer, Ron Weiss, Vincent Dubourg, et al. 2011. Scikit-learn: Machine learning in Python. the Journal of machine Learning research 12 (2011), 2825–2830.
- Picasso et al. (2019) Andrea Picasso, Simone Merello, Yukun Ma, Luca Oneto, and Erik Cambria. 2019. Technical analysis and sentiment embeddings for market trend prediction. Expert Systems with Applications 135 (2019), 60–70.
- Raschka et al. (2020) Sebastian Raschka, Joshua Patterson, and Corey Nolet. 2020. Machine learning in python: Main developments and technology trends in data science, machine learning, and artificial intelligence. Information 11, 4 (2020), 193.
- Rodriguez (2020) Daniel Rodriguez. 2020. Backtrader. https://www.backtrader.com/
- Sculley et al. (2015) David Sculley, Gary Holt, Daniel Golovin, Eugene Davydov, Todd Phillips, Dietmar Ebner, Vinay Chaudhary, Michael Young, Jean-Francois Crespo, and Dan Dennison. 2015. Hidden technical debt in machine learning systems. Advances in neural information processing systems 28 (2015).
- Sung et al. (2017) Nako Sung, Minkyu Kim, Hyunwoo Jo, Youngil Yang, Jingwoong Kim, Leonard Lausen, Youngkwan Kim, Gayoung Lee, Donghyun Kwak, Jung-Woo Ha, et al. 2017. Nsml: A machine learning platform that enables you to focus on your models. arXiv preprint arXiv:1712.05902 (2017).
- Tesliuk et al. (2019) Anton Tesliuk, Sergey Bobkov, Viacheslav Ilyin, Alexander Novikov, Alexey Poyda, and Vasily Velikhov. 2019. Kubernetes container orchestration as a framework for flexible and effective scientific data analysis. In 2019 Ivannikov Ispras Open Conference (ISPRAS). IEEE, 67–71.
- Yang et al. (2020) Xiao Yang, Weiqing Liu, Dong Zhou, Jiang Bian, and Tie-Yan Liu. 2020. Qlib: An ai-oriented quantitative investment platform. arXiv preprint arXiv:2009.11189 (2020).