Mastering MLOps practices for a trading bot

Most algorithms for analyzing stock price behavior are based only on the historical price, but it is also important to consider the impact of company news. Therefore, our main idea was to create a system that could predict the price not only according to a schedule, but also according to text news. 

The main idea of the algorithm was to combine the company news, the stock price and technical analysis. This requires 3 machine learning models: 

 

As the foundation of the language model, we chose the GPT-2 transformer. This model was introduced by OpenAI in early 2019. The model was previously trained on a WebText dataset consisting of 45 million links to websites. 

GPT-2 converts the text at the input into a special matrix that contains a contextual representation of words. Next, this matrix is transformed using a single linear layer into a binary classification. 

The resulting language model is universal for all companies. 

As a result of testing the trading strategy, we obtained positive results (most of the transactions are positive, the drawdown is less than 1%, the average profit of the transaction is 1.8%). 

We were rather pleased with the results thus far. We do, however, need to dive a little deeper into the world of MLOps to demonstrate how this was able to help us and how Vertex AI is ready for ML.  

Custom training will be performed inside the Docker container. To do this, you must first prepare the training code of the model. Here are the features of the code for learning in Vertex AI: 

1. Get command line arguments for training configuration: 

def get_args(): 
    parser = argparse.ArgumentParser() 
    parser.add_argument( 
        '--model-name', 
        default="gpt_linear_full", 
        help='The name of your saved model') 
    parser.add_argument( 
        '--model_dir', 
        help='Directory to output model and artifacts', 
        type=str, 
    parser.add_argument('--data-uri', type=str,   default='bert_main_dataset_11k_news.csv', help="Dataset path or gcp uri") 
    parser.add_argument("--mode", default='stocks_news', type=str, help="train or stocks_news.") 
    parser.add_argument("--num-epochs", default=N_EPOCHS, type=int, help="num epochs") 
    parser.add_argument("--batch", default=BATCHSIZE, type=int, help="batch size") 
    return parser.parse_args() 

2. If the — data-uri parameter is a link to a file in a bucket, you need to download it: 

filename = args.data_uri 
if 'gs://' in filename: 
      new_filename = 'gs_file.csv' 
      scheme, bucket_name, path, file = process_gcs_uri(args.model_dir) 
      file_path = filename.split('//')[1].split('/', maxsplit=1)[1] 
      from google.cloud import storage 
      storage_client = storage.Client() 
      bucket = storage_client.get_bucket(bucket_name) 
      blob = bucket.blob(path) 
      blob.download_to_filename(new_filename) 
      filename = new_filename 

3. Gcs uri parsing code: 

def process_gcs_uri(uri: str) -> (str, str, str, str):    ''' 
    Receives a Google Cloud Storage (GCS) uri and breaks it down to the scheme, bucket, path and file        Parameters: 
                uri (str): GCS uri        Returns: 
                scheme (str): uri scheme 
                bucket (str): uri bucket 
                path (str): uri path 
                file (str): uri file    ''' 
    url_arr = uri.split("/") 
    if "." not in url_arr[-1]: 
        file = "" 
    else: 
        file = url_arr.pop() 
    scheme = url_arr[0] 
    bucket = url_arr[2] 
    path = "/".join(url_arr[3:]) 
    path = path[:-1] if path.endswith("/") else path 
    return scheme, bucket, path, file 

4. To log learning results in tensorboard, you need to set the path from the environment variable ‘AIP_TENSORBOARD_LOG_DIR’: 

tensorboard_callback = tf.keras.callbacks.TensorBoard( log_dir=os.environ['AIP_TENSORBOARD_LOG_DIR'],histogram_freq=1) 

or 

from torch.utils.tensorboard import SummaryWriter 
writer = SummaryWriter(os.environ['AIP_TENSORBOARD_LOG_DIR']) 

5. Upload the model files to Cloud Storage by a tensorflow model example: 

tf_model.save_weights("best_model.h5") 
scheme, bucket, path, file = process_gcs_uri(args.model_dir) 
storage_client = storage.Client() 
bucket = storage_client.bucket(bucket) 
blob = bucket.blob(f"{path}/{args.model_name}.h5") 
blob.upload_from_filename('best_model.h5') 

6. As a result, we have the following training code: 

def main(): 
  # parse args 
  args = get_args() 
  # download dataset 
  filename = args.data_uri 
  if 'gs://' in filename: 
       new_filename = 'gs_file.csv' 
      scheme, bucket_name, path, file = process_gcs_uri(args.model_dir) 
      file_path = filename.split('//')[1].split('/', maxsplit=1)[1] 
      from google.cloud import storage 
      storage_client = storage.Client() 
      bucket = storage_client.get_bucket(bucket_name) 
      blob = bucket.blob(path) 
      blob.download_to_filename(new_filename) 
      filename = new_filename 
  N_EPOCHS = args.num_epochs 
  BATCHSIZE = args.batch 
  # train model 
  model = train_bert_sentiment(data_path=filename) 
  # save model 
  save_model(best_model, args.model_dir, args.model_name) 

The model training code now needs to be packed into a Docker container. To do this, let’s create a Dockerfile. As a base image, we use a ready-made image from the Google Cloud list containing the desired version of the framework and other necessary dependencies: 

FROM us-docker.pkg.dev/vertex-ai/training/pytorch-gpu.1-9:latest 
WORKDIR /component 
RUN pip install transformers==3.0.2 tqdm 
COPY gpt_model.py . 
COPY transformers_utils.py . 
ENTRYPOINT ["python", "gpt_model.py"] 

It is important to set the ENTRYPOINT in the format exactly as in the example, as this will allow you to set arguments for training. 

Now let’s assemble the container with a tag in the format gcr.io/project_name/image_name: 

docker build -f Dockerfile_train_text_model -t gcr.io/gems-ai-ml/pytorch_gpu_train_text . 

Then send the container to the Container Registry: 

docker push gcr.io/gems-ai-ml/pytorch_gpu_train_text 

You can now train the model in Vertex AI. To do this, go to the Training tab and create a new custom job using the Create button. 

1. In the Vertex AI section of the Google Cloud console, navigate to the Training page 
2. Select the Custom Jobs tab 
3. To view the Training Detail page, select the training job 
4. At the top of the page, click the Open TensorBoard button 

In this article, we have talked about the key points of custom learning in Vertex AI. This platform contains all the necessary components for MLOps. It is also worth paying attention to AutoML which allows you to obtain a machine learning model without specific deep knowledge. 

We also need to mention that at the operation stage there were also disadvantages, mainly related to versioning. You can create a dataset entity only if your file matches the desired schema, otherwise you must store it in cloud storage. Custom models are stored as a container, which makes it a bit difficult to add a new version for them.