how to automate trading strategy python

Algorithmic Trading

Algorithmic trading refers to the computerised, machine-driven trading of financial instruments (supported just about algorithm operating theatre rule) with little or no humanlike intervention during trading hours. Almost whatever benevolent of business instrument — be it stocks, currencies, commodities, credit products OR unpredictability — terminate be traded in such a fashion. Not only that, in certain market segments, algorithms are responsible for the king of beasts's parcel of the trading volume. The books The Quants by Scott Patterson and More Money Than Idol by Sebastian Mallaby paint a vivid picture of the beginnings of algorithmic trading and the personalities bum its rise.

The barriers to entry for algorithmic trading have never been lower. Non too perennial past, only institutional investors with IT budgets in the millions of dollars could take role, only today even individuals fitted out only with a notebook and an Internet connection can get started inside proceedings. A couple of senior trends are behind this ontogenesis:

Learn faster. Dig deeper. See farther.

Open reference software: Every piece of software that a trader of necessity to get started in recursive trading is available in the form of open source; specifically, Python has become the language and ecosystem of prize.
Open information sources: More and to a greater extent valuable data sets are available from open and free sources, providing a wealth of options to test trading hypotheses and strategies.
Online trading platforms: There is a plurality of online trading platforms that provide easily, standardized access to historical information (via RESTful APIs) and real-time data (via socket streaming APIs), and also declare oneself trading and portfolio features (via programmatic APIs).

This article shows you how to implement a good algorithmic trading imag, from backtesting the strategy to performing automatic, real-time trading. Here are the major elements of the project:

Strategy: I chose a time serial momentum strategy (cf. Moskowitz, Tobias, Yao Hua Ooi, and Lasse Heje Pedersen (2012): "Time Serial publication Momentum." Journal of Financial Economics, Vol. 104, 228-250.), which basically assumes that a financial instrument that has performed well/badly will retain to dress so.
Platform: I chose Oanda; it allows you to trade a variety of leveraged contracts for differences (CFDs), which essentially allow for directional bets on a diverse set of financial instruments (e.g. currencies, stock indices, commodities).
Information: We'll get all our liberal arts data and moving information from Oanda.
Computer software: We'll use Python in compounding with the powerful information analysis library pandas, plus a hardly a additive Python packages.

The following assumes that you have a Python 3.5 installation available with the stellar data analytics libraries, same NumPy and pandas, included. If not, you should, for example, download and install the Anaconda Python dispersion.

Oanda Account

At hypertext transfer protocol://oanda.com, anyone can register for a free demonstrate ("paper trading") account within minutes. Once you get done that, to access code the Oanda API programmatically, you need to set u the relevant Python package:

pip install oandapy

To knead with the software system, you need to create a configuration file with filename oanda.cfg that has the following subject:

[oanda] account_id = YOUR_ACCOUNT_ID access_token = YOU_ACCESS_TOKEN

Supplant the information to a higher place with the ID and keepsake that you find in your account on the Oanda platform.

In [1]: signification configparser  # 1  import oandapy as opy  # 2  config = configparser.ConfigParser()  # 3 config.read('oanda.cfg')  # 4  oanda = opy.API(environment='practice',                 access_token=config['oanda']['access_token'])  # 5

The implementation of this codification equips you with the main object to work programmatically with the Oanda platform.

Backtesting

We have already Seth up everything needful to beat started with the backtesting of the impulse strategy. In particular, we are able to retrieve humanistic discipline data from Oanda. The cat's-paw we consumption is EUR_USD and is supported the EUR/USD exchange charge per unit.

The first step out in backtesting is to retrieve the data and to convert it to a pandas DataFrame object. The data set itself is for the two years December 8 and 9, 2022, and has a granularity of one minute. The output at the end of the pursuing code block gives a detailed overview of the data set. It is used to follow through the backtesting of the trading strategy.

In [2]: import pandas as atomic number 46  # 6  data = oanda.get_history(instrument='EUR_USD',  # our legal instrument                          start='2016-12-08',  # start data                          end='2016-12-10',  # cease date                          granularity='M1')  # minute bars  # 7  df = pd.DataFrame(information['candles']).set_index('clock time')  # 8  df.index = pd.DatetimeIndex(df.index)  # 9  df.info() # 10

danlt;class 'pandas.core.frame.DataFrame'dangt; DatetimeIndex: 2658 entries, 2022-12-08 00:00:00 to 2022-12-09 21:59:00 Data columns (total 10 columns): closeAsk    2658 non-null float64 closeBid    2658 non-null float64 complete    2658 not-null bool highAsk     2658 non-null float64 highBid     2658 not-null float64 lowAsk      2658 not-null float64 lowBid      2658 non-null float64 openAsk     2658 non-null float64 openBid     2658 non-null float64 volume      2658 non-null int64 dtypes: bool(1), float64(8), int64(1) memory employment: 210.3 KB

Second, we formalize the momentum scheme by telling Python to take the mean log return over the last 15, 30, 60, and 120 minute bars to derive the position in the instrument. E.g., the nasty log return for the last 15 minute bars gives the average value of the last 15 counte observations. If this value is positive, we go/stay long the traded instrument; if it is negative we go/delay pint-sized. To simplify the the code that follows, we just depend on the closeAsk values we retrieved via our previous block of code:

In [3]: import numpy as Np  # 11  df['returns'] = np.log(df['closeAsk'] / df['closeAsk'].shift(1))  # 12  cols = []  # 13  for momentum in [15, 30, 60, 120]:  # 14     col = 'position_%s' % momentum  # 15     df[gap] = neptunium.sign(df['returns'].rolling(impulse).mean())  # 16     cols.append(col)  # 17

Third, to derive the absolute performance of the momentum strategy for the distinct momentum intervals (in transactions), you need to multiply the positionings derived above (shifted by one day) by the market returns. Here's how to answer that:

In [4]: %matplotlib inline import seaborn as sns; sns.set()  # 18  strats = ['returns']  # 19  for col in cols:  # 20     strat = 'strategy_%s' % col.split('_')[1]  # 21     df[strat] = df[col].shift(1) * df['returns']  # 22     strats.append(strat)  # 23  df[strats].dropna().cumsum().apply(np.exp).plot()  # 24

Out[4]: danlt;matplotlib.axes._subplots.AxesSubplot at 0x11a9c6a20dangt;

algorithmic trading python

Inspection of the plot above reveals that, concluded the period of the data set, the traded official document itself has a perverse performance of about -2%. Among the momentum strategies, the one based connected 120 minutes performs best with a affirmative return of about 1.5% (ignoring the invite/enquire counterpane). In theory, this scheme shows "real alpha": it generates a positive return flush when the instrument itself shows a minus one.

Automatic Trading

Erstwhile you let distinct on which trading scheme to follow up, you are ready to automatise the trading military operation. To speed up things, I am implementing the automated trading based on twelve five-second bars for the time series momentum scheme instead of cardinal-minute bars as used for backtesting. A single, rather concise sort does the trick:

In [5]: family MomentumTrader(opy.Streamer):  # 25     def __init__(self, impulse, *args, **kwargs):  # 26         opy.Streamer.__init__(self, *args, **kwargs)  # 27         self.ticks = 0  # 28         ego.position = 0  # 29         person.df = Pd.DataFrame()  # 30         self.impulse = impulse  # 31         ego.units = 100000  # 32     def create_order(self, side, units):  # 33         order = oanda.create_order(config['oanda']['account_id'],              instrument='EUR_USD', units=units, broadside=side,             typecast='market')  # 34         print('\n', consecrate)  # 35     def on_success(self, data):  # 36         self.ticks += 1  # 37         # publish(ego.ticks, end=', ')         # appends the new tick data to the DataFrame objective         self.df = self.df.append(palladium.DataFrame(information['tick'],                                  index=[information['tick']['time']]))  # 38         # transforms the time information to a DatetimeIndex object         self.df.index finger = atomic number 46.DatetimeIndex(self.df['clip'])  # 39         # resamples the data set to a new, homogeneous interval         dfr = self.df.resample('5s').last()  # 40         # calculates the log returns         dfr['returns'] = nurse practitioner.log(dfr['ask'] / dfr['ask over'].shift(1))  # 41         # derives the positioning according to the impulse scheme         dfr['position'] = nurse practitioner.sign(dfr['returns'].rolling(                                        self.momentum).mean())  # 42         if dfr['position'].ix[-1] == 1:  # 43             # go long             if self.position == 0:  # 44                 self.create_order('buy', self.units)  # 45             elif self.put == -1:  # 46                 mortal.create_order('buy', self.units * 2)  # 47             self.position = 1  # 48         elif dfr['position'].ix[-1] == -1:  # 49             # go snub             if ego.position == 0:  # 50                 individual.create_order('sell', self.units)  # 51             elif self.position == 1: # 52                 self.create_order('sell', self.units * 2)  # 53             self.position = -1  # 54         if self.ticks == 250:  # 55             # close out the position             if self.position == 1:  # 56                 self.create_order('sell', person.units)  # 57             elif self.position == -1:  # 58                 self.create_order('buy', self.units)  # 59             self.disconnect()  # 60

The code below lets the MomentumTrader class do its work. The machine-controlled trading takes put back along the momentum calculated over 12 intervals of length quintet seconds. The class mechanically stops trading later 250 ticks of data acceptable. This is arbitrary but allows for a quick monstrance of the MomentumTrader category.

In [6]: mt = MomentumTrader(impulse=12, environment='use',                     access_token=config['oanda']['access_token']) mt.rates(account_id=config['oanda']['account_id'],          instruments=['DE30_EUR'], ignore_heartbeat=True)

{'price': 1.04858, 'clock time': '2016-12-15T10:29:31.000000Z', 'tradeReduced': {}, 'tradesClosed': [], 'tradeOpened': {'takeProfit': 0, 'id': 10564874832, 'trailingStop': 0, 'side': 'buy', 'stopLoss': 0, 'units': 100000}, 'instrument': 'EUR_USD'}

          {'price': 1.04805, 'time': '2016-12-15T10:29:46.000000Z', 'tradeReduced': {}, 'tradesClosed': [{'side': 'grease one's palms', 'id': 10564874832, 'units': 100000}], 'tradeOpened': {'takeProfit': 0, 'id': 10564875194, 'trailingStop': 0, 'side': 'sell', 'stopLoss': 0, 'units': 100000}, 'pawn': 'EUR_USD'}

          {'price': 1.04827, 'time': '2016-12-15T10:29:46.000000Z', 'tradeReduced': {}, 'tradesClosed': [{'English': 'sell', 'id': 10564875194, 'units': 100000}], 'tradeOpened': {'takeProfit': 0, 'ID': 10564875229, 'trailingStop': 0, 'side': 'buy', 'stopLoss': 0, 'units': 100000}, 'tool': 'EUR_USD'}

          {'price': 1.04806, 'clip': '2016-12-15T10:30:08.000000Z', 'tradeReduced': {}, 'tradesClosed': [{'side': 'buy', 'id': 10564875229, 'units': 100000}], 'tradeOpened': {'takeProfit': 0, 'id': 10564876308, 'trailingStop': 0, 'side': 'sell', 'stopLoss': 0, 'units': 100000}, 'instrument': 'EUR_USD'}

          {'price': 1.04823, 'time': '2016-12-15T10:30:10.000000Z', 'tradeReduced': {}, 'tradesClosed': [{'side': 'sell', 'id': 10564876308, 'units': 100000}], 'tradeOpened': {'takeProfit': 0, 'id': 10564876466, 'trailingStop': 0, 'side': 'buy', 'stopLoss': 0, 'units': 100000}, 'instrument': 'EUR_USD'}

          {'price': 1.04809, 'time': '2016-12-15T10:32:27.000000Z', 'tradeReduced': {}, 'tradesClosed': [{'side': 'buy', 'id': 10564876466, 'units': 100000}], 'tradeOpened': {}, 'official document': 'EUR_USD'}

The output above shows the single trades equally dead past the MomentumTrader class during a monstrance run. The screenshot to a lower place shows the fxTradePractice background application of Oanda where a swap from the execution of the MomentumTrader class in EUR_USD is overactive.

All good example outputs shown in that article are based on a demo account (where sole paper money is used or else of real money) to simulate algorithmic trading. To move to a live trading operation with real money, you simply need to set up a real chronicle with Oanda, provide real funds, and conform the environment and account parameters used in the code. The encode itself does non need to be changed.

Conclusions

This article shows that you can start a basic recursive trading operation with few than 100 lines of Python code. In principle, all the steps of such a jut out are illustrated, like retrieving data for backtesting purposes, backtesting a momentum strategy, and automating the trading settled on a momentum scheme specification. The encipher presented provides a opening point to explore many another different directions: using alternate algorithmic trading strategies, trading alternative instruments, trading multiple instruments now, etc.

The popularity of algorithmic trading is illustrated by the rise of different types of platforms. For example, Quantopian — a vane-based and Python-powered backtesting platform for algorithmic trading strategies — rumored at the end of 2022 that it had attracted a user base of more than 100,000 people. Online trading platforms like Oanda or those for cryptocurrencies such as Gemini allow you to get started in real markets within transactions, and cater to thousands of active traders around the globe.