Article

Apply Maximum Drawdown Daily Report for Fund Holding

July 20,2022

Raksina Samasiri

Introduction

Maximum Drawdown (MDD) is an indicator of downside risk, with large MDDs suggesting that down movements could be volatile. However, while MDD measures the most significant loss, it does not account for the frequency of losses and the size of any gains.

In this article, we're going to retrieve pricing data of funds from Datastream Python library and calculate their MDDs using Python code.

What can you do with a maximum drawdown?

MDD can be used to measure the risk of losing money from the portfolio performance as it is the most negative cumulative return over a given time period. In other terms, it is the maximum percentage loss that occurred in a return data series, measured as the worst period of "peak to valley" performance for the fund, regardless of whether the drawdown consisted of consecutive months of negative performance. The maximum drawdown is based on simple returns.

The formula to calculate Maximum Drawdown is

Where,

P is the Peak (the highest price) of the period
L is the lowest price of the period

Example of Maximum Drawdown

In this article, we’re going to calculate the MDD with the daily prices of funds. To make it easier to explain, let’s look at this period of the sample fund above. During this period, the 1^st peak of this fund is 14.63 AUD, and it decreases to 13.60 AUD, which is the 1^st lowest price of the period, then it increases to 14.71 AUD and 14.93 AUD, which are 2^nd peak and 5^th peak of the period respectively. However, as MDD is the most negative cumulative return over a given time period, the prices to be calculated are the 1^st peak and 1^st lowest price, not the 5^th peak, which is the maximum price during this period (you may see the image above to see the MDD line that shows the most negative cumulative return).

The MDD calculation of this fund is

Which is around -7.04 (rounded from -7.04032809296)

Now that we know how to calculate the MDD. Let's calculate MDDs of funds using Python code with the data retrieved from the DataStream Python library.

Calculate Maximum Drawdown with Python

We’re going to implement the Python function to calculate MDD, its input data is the dictionary of instruments that contain the dictionary of its price (value) of each date (key), below is an example input with two instruments.

    	
            {('RIC1':

    {'2022-02-22': 14.65,

    {'2022-02-23': 14.61,

    {'2022-02-24': 14.99,

    {'2022-02-25': 15.03,

    {'2022-02-26': 15.31,

    {'2022-02-27': 15.05},

  ('RIC2':

    {'2022-02-22': 4.55,

    {'2022-02-23': 4.61,

    {'2022-02-24': 4.99,

    {'2022-02-25': 5.43,

    {'2022-02-26': 5.31,

    {'2022-02-27': 5.05}}

Here's how we're going to calculate the MDD of each instrument

With the same logic of this flowchart, the code below can be used to get the MDD of each instrument

    	
            def cal_mdd(price_dict):
    # (1) create Python dictionary to store MDD of each instrument
    mdd = {}
    for _ in price_dict:
        # (2) declare variable to store min and max price of each range
        max_price, min_price = -1, -1
        # (3) create Python list to store drawdown of each range
        mdds = []
        for date in price_dict[_]:
            #print(str(date)+": "+str(price_dict[_][date]))
            price = price_dict[_][date]
            # (4) set new min/max price if this price is higher than current max price
            if price > max_price or max_price == -1:
                if min_price != -1 and max_price != -1:
                    # (5) calculate drawdown % of the previous min-max
                    mdds.append((min_price-max_price)/max_price*100)
                max_price = price
                min_price = -1
            # (6) set only new min price if this price is lower than current min price
            if price < min_price or min_price == -1:
                min_price = price
        # (7) calculate drawdown % of the latest min-max
        mdds.append((min_price-max_price)/max_price*100)
        # (8) store maximum drawdown into Python dictionary with its instrument as a key
        ## use min() function as the drawdowns are less than zero
        mdd[_] = min(mdds)
    return(mdd)

Retrieve and calculate the data using DataStream

In this section, I will walk through a DataStream Web Service example used to retrieve economic indicators by countries. The example uses the DatastreamPy library to connect and retrieve data from Datastream. To use this Python library, please refer to the Getting Started with Python document.

Step 1) Below is the stuff required to get started with DataStream

- DSWS API service enabled
-  Child ID and password
-  Your login ID is usually designed to start with Z, have 3 letters and 3 numbers
-  for example ZXXX123
-  Python 3.6 or above (I’m using Python 3.9.12 here)
-  Python libraries used
  -  DatastreamPy=1.0.10
-  DateTime=4.4
-  pandas=1.3.5

Step 2) Searching for the instrument that you’re looking for

The RIC, a ticker-like code used and maintained by Refinitiv to identify financial instruments, is required to get the data of an instrument, to search for the instrument's RIC, the datatype search tool can be used. First, log in with your DataStream credentials. Then type the keyword you’d like to search for (box '1' in the screenshot below). It's shown that the RIC of JPM Japan Equity A Acc USD fund is LP60101474 (boxes '2, 3' in the screenshot below). The ‘P’ button at the bottom left of the search result is the available field of this instrument, which is Price-Trade (box 'available field: Pride - Trade' in the screenshot below)

Step 3) Let's do the coding part

1. Import necessary libraries, which are DatastreamPy for Datastream Python library (for more detail, please check Getting Started with Python) and isnan from math Python library for checking the NaN value in the dataframe

    	
            import DatastreamPy as dsws

from math import isnan

2. Do the authentication with DataStream credentials
Replace <username> with your username and <password> with your password.

    	
            ds = dsws.Datastream(username = '<username>', password = '<password>')

3. Use the code below to get daily price in the last 1 year of these three instruments using DataStream.

Parameter	Description	Example format
tickers	Tickers here are set to 3 RICs (LP68511418,LP68087222,LP68663339), this can be replace with any RICs of fund	tickers = 'RIC1,RIC2,RIC3,...,RICn' tickers = 'LP68511418,LP68087222,LP68663339'
fields	Set to 'X', which is the default value. The default value can be checked using Datastream datatype search tool provided earlier	fields = ['FIELD'] fields = ['X']
start	Take the date of the last 12 months as a starting point for the data	start = '-12M'
end	Take today's date as an ending point of the data	end = '0M'
freq	Frequency of the data, D, which is day is used in this case	freq = 'D'

    	
            df = ds.get_data(tickers = 'LP68511418,LP68087222,LP68663339', fields = ['X']
                 , start = '-12M', end = '0M', freq='D')
display(df)

4. Then we're going to prepare the Python dictionary of price of all the dates of each instrumet by converting the dataframe to Python dictionary and set the RIC as a key, price as a value.

    	
            def data_prep(df):
    price_dict = df.to_dict()
    price_dict = dict((key[0], value) for (key, value) in price_dict.items())
    for date in price_dict:
        price_dict[date] = dict((key, value) for (key, value) in price_dict[date].items() if not isnan(value))
    return(price_dict)
 
price_dict = data_prep(df)
price_dict

5. Calculate MDD of this price_dict with the function defined above

    	
            mdd_last_1_year = cal_mdd(price_dict)
mdd_last_1_year

Now we already have a Python dictionary named mdd_last_1_year that contain the instrument's RIC as a key and its MDD as a value

    	
            {'LP68511418': -21.79250166383198,

 'LP68087222': -14.638469783164323,

 'LP68663339': -36.206896551724135}

What can you do with MDDs?

Let's look at an example of using MDD as a factor to consider investing in any instruments, I'm going to do the backtesting by looking at the yearly MDD of the previous year and select funds with less MDD to be invested, then check the result by checking their return of the previous year to see if it helps me to loss less.

First, we're going to look at the instruments below, which are the active mutual funds in technology in the Lipper Global schema classification with the green strategy.

Instrument	Instrument description
LP40221832	AGF Global Sustainable Equity Fund
LP40109383	Artisan Sustainable Emerging Markets Fund
LP40229598	BlackRock Global Impact Fund
LP40229602	BlackRock International Impact Fund
LP40228661	PIMCO Climate Bond Fund
LP40048702	Pax High Yield Bond Fund
LP40221655	Pear Tree Essex Environmental Opportunities Fd
LP40005806	Putnam Sustainable Leaders Fund

From this, we're retrieving their price using Datastream and calculating their MDDs with the same code that was mentioned in the previous section, but with the list of these instruments instead.

    	
            instruments = 'LP40221832,LP40109383,LP40229598,LP40229602,LP40228661,LP40048702,LP40221655,LP40005806'
 
df_prev_year = ds.get_data(tickers = instruments, fields = ['X']
                 , start = '-24M', end = '-12M', freq='D')
price_dict = data_prep(df_prev_year)
mdd_prev_year = cal_mdd(price_dict)
mdd_prev_year

Here's their yearly MDDs of the last year.

    	
            {'LP40221832': -8.717978107627955,

 'LP40109383': -11.370786516853938,

 'LP40229598': -10.834371108343701,

 'LP40229602': -19.906166219839147,

 'LP40228661': -2.4832855778414498,

 'LP40048702': -2.2889842632331923,

 'LP40221655': -16.933066933066936,

 'LP40005806': -8.81461598406788}

Regarding this data, instead of investing in all of the instruments, I'm going to select only the instruments with less MDD (which have a higher value as the MDD is a minus number). Hence, I select half of the instruments with less MDD, which are

Instrument	Previous year MDD
LP40221832	-8.717978107627955
LP40228661	-2.4832855778414498
LP40048702	-2.2889842632331923
LP40005806	-8.81461598406788

Next, let's see the result by checking their return for the last year, this data is being retrieved using Eikon Data API (for more detail, check Eikon Data API Overview and its quick start guide)
The code below is used, the data is taken from the field named 'TR.TotalReturn1YrCrossAsset', which is 1-year total return that incorporates the price change and any relevant dividends for the last year.

    	
            import eikon as ek
 
ek.set_app_key('### Your Eikon App Key ###')
 
year_return, err = ek.get_data(['LP40221832','LP40109383','LP40229598','LP40229602','LP40228661','LP40048702','LP40221655','LP40005806'],
                      ['TR.TotalReturn1YrCrossAsset'])
year_return_dict = dict(zip(year_return['Instrument'], year_return['1 Year Total Return Cross Asset']))

And their returns are as the table below, we could see that the instruments that we decided to invest for are also a top 4 of return compared to other instruments in the list.

No.	Instrument	Yearly return	Decide to invest?
1	LP40221832	-23.2527537	Yes
2	LP40109383	-32.323344	No
3	LP40229598	-32.2921591	No
4	LP40229602	-35.0363303	No
5	LP40228661	-11.3077075	Yes
6	LP40048702	-14.267095	Yes
7	LP40221655	-32.3474739	No
8	LP40005806	-19.5482169	Yes

Conclusion

Regarding the backtesting above, it shows that checking the MDD can help prevent the loss from the investment by avoiding the instruments with the huge MDD. However, in the real scenario, other factors should be considered before the investment as well. Feel free to discover more articles in this developer forum to learn how the data can be used in any cases.

Last but not least, The Maximum Drawdown (MDD) is an indicator of downside risk over a specific time period, which is daily data of the last 1 year in this case. This data can be used to check the fund's past performance to be a part of the factors to consider investing in it. I hope you have fun with this article and if you have any questions or issues regarding API usage, please don’t hesitate to post your question on our Q&A forum

Reference

DataStream Web Service (including Overview, Quickstart guide, Documentation, Useful resources provided for downloading, tutorials)
DataStream datatype search tool