Skip to content

Latest

Using Dashboard to Deploy and Backtest Strategies - Part 1

Introduction

Welcome to the second part of the Hummingbot Dashboard quickstart. In this section, we'll guide you through the essential steps to set up the project and get Dashboard up and running.

Prerequisites

Before diving in, there are a couple of essential tools you'll need:

Update Linux Packages

It's a good practice to ensure your Linux system is up-to-date. Updating your system ensures that you have the latest security patches, bug fixes, and system improvements, reducing potential conflicts or issues during installation.

Run the following command:

sudo apt update && sudo apt upgrade -y && sudo apt install -y build-essential

Anaconda

Anaconda is a powerful distribution of Python and R for scientific computing and data science. It's vital for managing different environments for your projects. Download the installer for your environment from the Anaconda website and then run it.

For example, here is how to download and run the Linux installer:

wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh
bash Miniconda3-latest-Linux-x86_64.sh

Follow the prompts on the installer screens. If you are unsure about any setting, accept the defaults. You can change them later.

To make the changes take effect, close and then re-open your Terminal window. Afterwards, run the conda command from your path:

conda

You should see a response similar to:

usage: conda [-h] [-V] command ...

conda is a tool for managing and deploying applications, environments and packages.

Options:

positional arguments:
  command
    clean        Remove unused packages and caches.
    compare      Compare packages between conda environments.

Docker

Docker is a platform that allows you to develop, ship, and run applications inside containers. It's necessary for ensuring that the dashboard runs in a consistent environment. If Docker isn't installed on your system, click here to follow the installation guide.

The easiest way to install Docker is to install Docker Desktop, which includes Docker Compose along with Docker Engine and Docker CLI which are Compose prerequisites. Here are links to installers for each major OS:

For command-line Linux distributions, you can install Docker Engine following the steps below:

curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh
sudo usermod -aG docker $USER

Installing Dashboard

1. Access the Dashboard Repo

Hummingbot Dashboard is open-source, allowing anyone to access, modify, and contribute to its codebase. To get started, visit the project repository on GitHub at the following link: hummingbot/dashboard.

2. Clone the Repository

To get a local copy of the project, clone the repository by running the command:

git clone https://github.com/hummingbot/dashboard

3. Set Up the Conda Environment

Once you've cloned the repository and navigated into its root directory, it's time to create a Conda environment. This environment ensures that all the required dependencies for the dashboard are installed and isolated from other projects. Run the following commands:

cd dashboard
make env_create

4. Activate the Environment

After creating the environment, you'll need to activate it:

conda activate dashboard

5. Launch the Dashboard

With the environment activated, initiate the dashboard with:

make run

It might take a while to load the dashboard for the first time. Subsequent launches will typically be faster. Once the dashboard is up, open a web browser and navigate to https://localhost:8501 to view it.

Next Steps

Congratulations - you've successfully set up the Hummingbot Dashboard. In the next tutorial, we'll delve into managing your credentials and understanding the registration process.

Manage Credentials

Using Dashboard to Deploy and Backtest Strategies - Part 2

Introduction

In this section, we'll dive into the importance of securely managing credentials in the Hummingbot Dashboard, ensuring that your information remains private and under your control.

Enabling Credential Management

If you plan to expose Dashboard externally or enable multiple users, managing credentials securely is paramount.

To add authentication layer to Dashboard, modify the AUTH_SYSTEM_ENABLED variable in the CONFIG.py file. By default, it is set to False.

Change it to True and save the file:

AUTH_SYSTEM_ENABLED = True

Afterwards, stop Dashboard and restart it with make run. Users will now be asked to log in when accessing Dashboard at https://localhost:8501.

Setting User Credentials

We present two methods for setting user credentials for Dashboard:

1. Manual Password Hashing

In this method, we manually declare the users and their corresponding passwords in the credentials.yml file.

credentials:
  usernames:
    admin:
      email: [email protected]
      name: Admin User
      password: abc # To be replaced with hashed password: hashed_passwords = stauth.Hasher(['abc', 'def']).generate()
In the default file above, the template password abc is a placeholder for the hashed password.

To generate a hashed password for a given string, follow these instructions:

  1. Run conda activate dashboard to ensure that you're in the Dashboard environment is active.
  2. Afterwards, enter the Python console with:
    python
    
  3. Import the auth library and hash the password:
    import streamlit_authenticator as st_auth
    hashed_password = st_auth.Hasher("YOUR_PASSWORD")
    hashed_password
    
  4. In the credentials.yml file, Replace the admin user's password with this hashed_password.
  5. Run exit() to exit the Python console.
  6. Access the dashboard at https://localhost:8501 and enter the username(admin) and string(YOUR_PASSWORD) used to generated the hashed password.

2. Whitelisted Email Registration

While the method works for 1-2 users, it might be cumbersome if numerous users interact with Dashboard.

Instead, you can edit the preauthorized section in credentials.yml. This method below allows you to whitelist a list of emails and allow users to set their own passwords. Each user is added to the credentials file.

  1. Define a whitelist of emails authorized to access the dashboard.
  2. In the pre_authorized: section of `credentials.yml``, add the emails of users who will be pre-authorized to register and create their credentials.
    pre_authorized:
      emails:
        - [email protected]
        - [email protected]
    
  3. Users with whitelisted emails can fill out a registration form upon their first login.
  4. Upon registration, Dashboard will hash and store their credentials automatically in this file.

Logging Out

Once logged in, you have the freedom to navigate through the various sections of the dashboard. However, to log out securely, ensure you return to the main Hummingbot Dashboard page and click the logout button. This ensures optimal security for your credentials and the dashboard's functionality.

Next Steps

Next, learn how to use the master bot profile to manage the keys you store in Dashboard.

Using the Master Bot Profile

Using Dashboard to Deploy and Backtest Strategies - Part 3

Introduction

In this installment, we show how to utilize the Master Bot Profiles to create and store API keys, along with exploring available scripts in the Hummingbot Dashboard. Let's break down the essentials!

Role of the Master Bot Profile

The Master Bot plays a pivotal role in the credential management process in Hummingbot. It serves as a centralized location where exchange API keys and the scripts/strategies available to new bots are securely stored. When spawning new bots from the dashboard, they inherit the encrypted keys and available scripts/strategies from the Master Bot.

How Does It Work?

  1. Create an instance of the Master Bot from Docker
  2. Connect to this Docker instance
  3. Add exchange credentials to this instance.
  4. Spawn new bots from Dashboard, which will use the encrypted data from the Master Bot for credential access.

Future Profiles

In the future, plans are in place to introduce additional bot profiles. Each profile can possess different API keys and available scripts, enabling users to specify the profile they want to use when spawning a new bot.

Adding Exchange Credentials

To test the Master Bot's functionality, we'll connect to the Binance exchange as an example:

  1. Ensure Docker is running, as it's essential for spawning new bots.
  2. Navigate to the Credentials tab in the dashboard.
  3. Click on the Start button to initiate the Master Bot.
  4. Open a terminal and enter the command docker attach hummingbot-master_bot_conf to attach to the Master Bot.
  5. Connect to the desired exchange (e.g., Binance) and input the required API keys using the command connect binance (replace binance wih the name of exchange you want to connect to).
  6. Fetch the balance to verify the connection.

Scripts Exploration

The Hummingbot Dashboard offers a variety of pre-written scripts that can be utilized as templates for new bots. Here's how you can explore and modify them:

  1. In the dashboard, navigate to the File Explorer.
  2. Browse through available scripts. Those prefixed with "V2" are part of the V2 framework.
  3. For deeper understanding and advanced configurations, consider joining the Bot Camp, which offers comprehensive training on these scripts.
  4. Open any script to view its content. The built-in editor allows for direct modifications.
  5. If you're more comfortable with an external IDE, you can edit scripts there and then upload them back to the dashboard.

Saving Changes

The process of integrating credentials and leveraging available scripts is streamlined to ensure both security and efficiency. Whether you're editing scripts directly in the dashboard or using an external IDE, remember to save your changes to any scripts you modify.

If you make modifications in the dashboard's editor, use Apply button to apply changes, and then Ctrl + S to save.

Next Steps

The Master Bot Profile ensures the secure handling of credentials and offers users flexibility in creating bots. Next, learn how to create and manage new instances:

Managing Bots

Using Dashboard to Deploy and Backtest Strategies - Part 4

Introduction

In this tutorial, we'll dive into the process of spawning new bots, starting a strategy, making modifications, and running one for a set duration. Let's get started!

Managing Bot Instances

Hummingbot Broker

On the instances page, to the right, you'll notice the Hummingbot broker. Before creating any bot, it's essential to start this broker. This component is responsible for enabling communication between the dashboard and the bot, facilitating commands such as starting or stopping a strategy.

Creating Bot Instances

On the left, you'll find the creation card. Here, you'll input:

  • Name of the container
  • Desired Docker image (useful if you have a custom Hummingbot version with unique strategies)
  • Profile to start from (for now, only the master bot is available, but more profiles will be added in the future)

Once a bot is created, a card will appear allowing you to select a strategy from those available. After choosing a strategy, press "Start" to launch the bot with the selected strategy.

Available Strategies

The strategies available for selection are the same ones present in the master bot. Once you've chosen one, simply press "Start," and the bot will initiate with your chosen strategy.

Customize Strategy

Below the instances page, the file explorer allows users to view and modify the specific scripts or files for each bot they create. Each bot has its distinct set of scripts that can be adapted to fit specific trading requirements or strategies.

Putting it all together

To provide a comprehensive example:

  1. Navigate to the Instances tab.
  2. Start the HB broker (may take a few minutes).
  3. Create a bot instance, giving it a name like "dman" and using the Hummingbot latest Docker image and the master bot profile.
  4. View the available strategies and select one (e.g., the "Bollingrid multiple pairs").
  5. Use the file explorer to customize the chosen strategy as needed.
  6. Execute the strategy, monitor its performance, and make necessary adjustments or stop it as required.

Next Steps

The subsequent chapter will focus on analyzing the results of our deployed strategies.

Analyze Bot Performance

Using Dashboard to Deploy and Backtest Strategies - Part 5

Introduction

You can use the Strategy Performance page in Dashboard to analyze the performance of your Hummingbot strategies and scripts.

The images below utilize this SQLite database file (as described in this video): bot_battle.sqlite.

Upload Data

First, import your trading data by uploading the SQLite database file associated with your trading strategy.

  1. Locate the SQLite Database File: Navigate to the /data folder of your Hummingbot instance. Here, you'll find the SQLite database file named after your trading strategy. For instance, in the provided screenshot, the strategy's name appears to be bot_battle, hence the file bot_battle.sqlite.

  2. Upload the Database File: Drag and drop the SQLite database file into the designated area in the Hummingbot Dashboard. Alternatively, click on "Browse files" to manually search for and select the SQLite database file from your computer.

  3. File Confirmation: After successfully uploading, you'll see a confirmation message stating "File uploaded and saved successfully!".

  4. Select Database: Once uploaded, select the database file from the dropdown menu (e.g., bot_battle.sqlite) to begin analyzing the performance of your trading strategy.

Note

Ensure the database file size does not exceed 1GB.

Continue with the next steps in the Hummingbot Dashboard to dive deeper into your strategy's performance metrics and insights.

Select Pairs to Analyze

With Dashboard's auto-identification feature, the pairs and exchanges in the database file are recognized automatically. Users can then effortlessly select the desired trading pairs for in-depth analysis, streamlining the decision-making process.

Check the trading pairs that you want to explore:

Dashboard Widgets

Dashboard uses the trades data to construct various widgets that the users can interactive with:

Explore Trading Pair

This widget provides an overview of a specific trading pair's performance over a selected time range.

Usage:

  • Select a Time Range: Use the date and time selectors at the top to analyze a specific trading period.

  • Overview Cards: These cards give quick insights on the Net Profit/Loss, Total Trades, Accuracy, Profit Factor, Duration, Price Change,

Market Activity Widget

The Market Activity Widget provides a detailed visualization of the market's activity over a specific time interval. It allows users to get an in-depth understanding of various metrics including buy/sell orders, profit/loss, and inventory changes.

Usage:

  • Candles Interval: Use the dropdown to select the desired interval for the candlestick data. Options might include timeframes like 1m, 5m, 15m, etc. This selection determines the granularity of the candlesticks shown in the chart.

  • Candles per Page: Adjust the number of candlesticks displayed on a single page by changing this value. This can help in narrowing or expanding the time frame viewed at once.

  • Show Panel Metrics: Click on this button to toggle additional metrics on or off, providing a cleaner or more detailed view based on your needs.

  • Price Chart: Visualizes the price movement, buy/sell orders, and other metrics over the selected time range. Drag your mouse to get detailed information over a window.

  • PnL Chart: This chart displays Profit and Loss over time, giving a clear indication of market performance. Positive values show profit, while negative values indicate a loss.

  • Quote Inventory Change: Provides a bar graph representation of how your the value of your quote assets as a percentage of the overall value of your base and quote assets percentage changes over time, assisting users in identifying significant inventory shifts.

Intraday Performance Widget

Intraday Performance

Description:

  • This widget presents a radial or polar chart showcasing intraday performance.
  • Each spoke of the wheel represents an hour of the day, starting from 12 PM and continuing clockwise.
  • The chart's segments represent the realized profit and loss (PnL) for each hour, where color intensity and segment length indicate the magnitude.
  • Drag and drop over a segment to zoom in.

Returns Distribution Widget

Returns Distribution

Description:

  • This widget displays a histogram showing the distribution of returns, classified into losses (in red) and profits (in green).
  • The x-axis represents the range of return values, with negative values indicating losses and positive values indicating profits.
  • The y-axis indicates the frequency or count of occurrences for each return value.
  • Peak bars in the histogram show the most common return values for the dataset, allowing users to quickly grasp where the majority of returns lie.

Next Steps

Next, learn how you can also use Dashboard to backtest and optimize Hummingbot V2 strategies:

Backtesting and Optimization

Using Dashboard to Deploy and Backtest Strategies - Part 6

Introduction

In this chapter, we delve deep into one of the most critical aspects of bot trading: backtesting strategies using historical data. Dashboard provides a comprehensive framework that helps you do everything from downloading historical data to backtesting strategies and optimizing hyperparameters.

Download Historical Data

First things first, you need historical data to backtest a trading strategy. Dashboard helps you fetch OHCLV candle data from certain exchanges. You can define the exchange, specify trading pairs (separated by a comma), select the time intervals, and choose the number of days for which you want the historical data.

Clicking the "Get data" option will initiate a Docker container running a script that downloads the desired data. The data will be stored in the data folder, in the candles subfolder.

Available Controllers

Once you have the data, the next step is to define a strategy controller template for backtesting. The "Create" tab showcases a list of available controller templates.

Current examples include directional strategies such as bollinger v1, macd bollinger v1, and trend following v1, as well as market making strategies such as dman_v1, dman_v2, and dman_v3. You can also create and add your own custom controller.

Optimizing the Bollinger Strategy

In the video, we take a deep dive into optimizing the bollinger_v1 controller, which defines a directional trading strategy that uses Bollinger Bands to determine potential buy and sell signals. The strategy considers factors like the length of the Bollinger band, the number of standard deviations, and specific thresholds for taking long or short positions.

Optimization with Optuna

Using the Optuna framework, Dashboard can fine-tune hyperparameters automatically. By selecting a strategy and defining specific optimization parameters, you can initiate the optimization process. The system will then try out numerous combinations of parameters to find the most profitable set.

To demonstrate the entire process, we take the example of optimizing the near-usdt trading pair using 120 days of historical 3-minute candles data.

  1. We download the candles data which will be saved inside the /data/candles folder.

  2. Go to the Create page amd select one of the directional strategies. You can use the same values included in the video or use your own.

  3. Next in the Optimize screen, select the strategy name and click Create, change the pair to near-usdt and modify the desired values in the script and save the file.

  4. Select the study name and enter the number of trials and click Run.

Upon completion of optimization, you'll be presented with the results, showing which trials yielded the best net profit and loss (PNL). This gives you a clear understanding of which strategy parameters work best.

Next Steps

As we conclude this chapter, we set the stage for the next one, where we will analyze the results in-depth using the Hummingbot dashboard and deploy the most promising strategies for real-time trading.

Deploying Backtested Strategies

Using Dashboard to Deploy and Backtest Strategies - Part 7

Introduction

Now, let's dive into the process of evaluating the optimization results and subsequently deploying the selected strategies.

Visualizing and Evaluating Strategies

Upon completion of the optimization process, it's time to visualize the results. By selecting a specific experiment, you're presented with a scatter plot showing the net Profit & Loss (PnL) on the Y-axis and the maximum drawdown on the X-axis. Each dot on this plot represents a unique combination of strategy parameters. Hovering over these dots reveals detailed information about each experiment.

When you've identified a promising trial, you can move on to a more granular analysis. By choosing a specific trial, you can view its performance on candlestick charts, giving you a clearer picture of how the strategy would have performed historically.

Saving Best Configs

If a particular configuration resonates with your trading objectives and you believe it's worth deploying, you can save it for later use. This step involves selecting the strategy, viewing its performance, and then saving the configuration for deployment.

You can repeat this process for multiple configurations, allowing you to cherry-pick the best ones for real-time trading.

Deploying Strategies

After saving your preferred configurations, navigate to the Deploy page. Here, you can select the configurations you wish to deploy, assign a name, and initiate the deployment process directly from a controller configuration. Under the hood, this uses a generic script to launch the strategy, so you just need to manage the controller configuration file.

In this live demonstration, we analyze the optimization results for a particular trading pair. We observe the performance of various configurations, considering factors like take profit, stop loss, and time limits. This hands-on approach gives you a practical understanding of how to interpret results and make informed decisions.

Running Multiple Configs

After selecting the desired configurations, we demonstrate how to deploy them. These strategies are then run simultaneously, offering a more consistent trading performance that averages out the outcomes of all chosen strategies. This method helps avoid overfitting, ensuring a more stable trading experience.

In conclusion, this chapter equips you with the tools and knowledge to evaluate optimization results critically and deploy the best-performing strategies for real-time trading. It emphasizes the importance of a balanced approach, ensuring that you don't overly rely on a single configuration but rather diversify for better consistency.

Conclusion and Next Steps

Conclusion and Next Steps

Using Dashboard to Deploy and Backtest Strategies - Conclusion

Thank you for following along with this series. Your dedication and time spent learning about Dashboard and its various functionalities are greatly appreciated!

Recap

Throughout this series, we covered a range of topics, including:

  • Setup and Credentials: We walked through the initial steps of setting up, connecting credentials, and managing the credentials of the HummingBot instances and dashboard.

  • Deploying and Managing Bots: You've learned how to deploy new bots and execute various strategies effectively.

  • Backtesting and Optimizing Strategies : An in-depth exploration of the dashboard's latest features was provided, emphasizing backtesting, optimization, and deployment.

What's Next?

If you're serious about delving deeper and enhancing your trading bot capabilities, consider Botcamp, a professional training program for market makers and algo traders. This comprehensive program combines new content modules and live sessions each month to help you understand the intricacies of the market. You'll learn to create and backtest market making strategies, directional trading, and other strategies using Dashboard.

Most importantly, you'll gain hands-on experience with Bot Battles, Botcamp's monthly bot trading competitions. It's a great opportunity to measure your progress and learn from others. In addition, joining the Botcamp community allows you to expand your professional network, form teams to compete together, and share insights.


Thank you once again for joining us on this journey. I hope the knowledge you've gained here serves you well in your trading endeavors. All the best with your future trading bot projects!

Directional Trading with MACD and Bollinger Bands

Welcome to the inaugural post in our Strategy Experiments series, where we publish hypotheses, code, and performance analyses of live bot strategies.

We're thrilled to return to the Hummingbot blog with an exciting experiment: developing a crypto trading bot using the open-source Hummingbot platform. This bot employs an indicator-based directional strategy on the Binance Futures exchange, leveraging MACD and Bollinger Bands.

Sign up for Binance Futures using our Hummingbot referral code to receive a 10% fee rebate!

Introducing Strategy Experiments

As the first entry in our Strategy Experiments series, we aim to foster a collaborative environment where users can share their strategic insights with the community, enhancing growth and knowledge exchange among quantitative traders.

We invite everyone to contribute their Strategy Experiments, regardless of outcome, as there is valuable learning in each experience. Through sharing insights and discussing novel concepts, we aspire to cultivate a vibrant ecosystem for continual improvement and refinement of trading strategies.

Below is a detailed account of our first experiment. You can watch the accompanying video or read the following description.

Creating a Custom Market Making Strategy

Introduction

Welcome to the new Hummingbot Quickstart Guide! This will teach you how to build and customize market making strategy using Hummingbot over 5 exercises.

Whether you're a beginner or an experienced trader, this guide should help you get started with creating your own custom trading strategies using Hummingbot. So, let's dive in and start building!

Note

Introduced in version 1.4.0Scripts enable users to build customized strategies and access the full power of Hummingbot exchange connectors without creating a full-blown strategy. Scripts are light Python files that can be run and modified without re-compilation, which let users can stop a script, adjust the code, and start it without leaving the Hummingbot client interface. See Examples for a list of the current sample scripts in the Hummingbot codebase.

Getting Started

First, check out the Installation section to install Hummingbot. You may install it using Docker (easiest for new users) or from source (best for developers).

If you have questions or need help, join the official Hummingbot Discord and ask for help on the #support channel from our community.

If you have installed Hummingbot successfully, you should see a welcome screen like the one below:

The Hummingbot CLI helps you manage, configure, and run your bots. Familiarize yourself with the basic features in Hummingbot, especially the User Interface.

Exercises

We will start with a simple "Hello World" example of a Hummingbot script and gradually add more functionality to it with each exercise. By the end, you should gain a basic understanding of how to create a market making strategy and use market data to customize its behavior.

Exercise 1: Create Hello World Script

  • How a basic script works
  • Fetching real-time prices (best bid, best ask, mid-price, last traded price)
  • Emitting custom log messages

Exercise 2: Create Market Making Script

  • Building the Pure Market Making strategy as a simple script
  • Placing orders using exchange API
  • Cancelling orders using exchange API
  • Handle an order fill event

Exercise 3: Customize Status Command

  • Overriding the default status command with custom output

Exercise 4: Add Basic Price Ceiling/Floor

  • Motivation for adding this type of logic to a market making strategy
  • Adding a price ceiling/floor feature to your script

Exercise 5: Add Dynamic Price Ceiling/Floor

  • Creating custom OHLCV candles and technical indicators from order book data
  • Making the price ceiling/floor feature dynamic with Bollinger Bands

Additional Resources