Forex Gemini Code Free Download

Algorithmic Trading

Algorithmic trading refers to the computerized, automated trading of financial instruments (based on some algorithm or rule) with fiddling or no homo intervention during trading hours. About whatever kind of financial instrument — be it stocks, currencies, commodities, credit products or volatility — can exist traded in such a style. Not only that, in certain market segments, algorithms are responsible for the king of beasts's share of the trading volume. The books The Quants by Scott Patterson and More than Money Than God past Sebastian Mallaby paint a vivid picture of the ancestry of algorithmic trading and the personalities behind its rise.

The barriers to entry for algorithmic trading have never been lower. Not too long ago, but institutional investors with Information technology budgets in the millions of dollars could take part, but today even individuals equipped only with a notebook and an Internet connection can go started within minutes. A few major trends are backside this evolution:

Learn faster. Dig deeper. See farther.

Open source software: Every piece of software that a trader needs to get started in algorithmic trading is bachelor in the class of open source; specifically, Python has become the language and ecosystem of choice.
Open data sources: More and more valuable information sets are available from open and free sources, providing a wealth of options to exam trading hypotheses and strategies.
Online trading platforms: There is a large number of online trading platforms that provide easy, standardized access to historical information (via RESTful APIs) and real-time information (via socket streaming APIs), and as well offer trading and portfolio features (via programmatic APIs).

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

Strategy: I chose a time serial momentum strategy (cf. Moskowitz, Tobias, Yao Hua Ooi, and Lasse Heje Pedersen (2012): "Time Series Momentum." Journal of Financial Economic science, Vol. 104, 228-250.), which basically assumes that a financial instrument that has performed well/desperately volition go on to exercise so.
Platform: I chose Oanda; it allows you to trade a variety of leveraged contracts for differences (CFDs), which substantially let for directional bets on a various fix of financial instruments (due east.one thousand. currencies, stock indices, commodities).
Data: We'll get all our historical information and streaming information from Oanda.
Software: We'll utilize Python in combination with the powerful data assay library pandas, plus a few boosted Python packages.

The following assumes that you accept a Python iii.5 installation available with the major data analytics libraries, similar NumPy and pandas, included. If non, you should, for example, download and install the Anaconda Python distribution.

Oanda Account

At http://oanda.com, anyone can register for a gratuitous demo ("newspaper trading") account within minutes. In one case yous accept done that, to access the Oanda API programmatically, yous need to install the relevant Python packet:

pip install oandapy

To work with the bundle, you need to create a configuration file with filename oanda.cfg that has the following content:

[oanda] account_id = YOUR_ACCOUNT_ID access_token = YOU_ACCESS_TOKEN

Replace the data above with the ID and token that you lot find in your account on the Oanda platform.

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

The execution of this code equips you with the principal object to work programmatically with the Oanda platform.

Backtesting

We have already gear up everything needed to get started with the backtesting of the momentum strategy. In particular, we are able to retrieve historical data from Oanda. The instrument nosotros apply is EUR_USD and is based on the EUR/USD exchange rate.

The first step in backtesting is to recall the data and to catechumen information technology to a pandas DataFrame object. The data set itself is for the two days December 8 and nine, 2016, and has a granularity of 1 infinitesimal. The output at the cease of the following code block gives a detailed overview of the data set. It is used to implement the backtesting of the trading strategy.

In [2]: import pandas as pd  # vi  data = oanda.get_history(instrument='EUR_USD',  # our musical instrument                          start='2016-12-08',  # beginning data                          finish='2016-12-x',  # cease date                          granularity='M1')  # minute confined  # 7  df = pd.DataFrame(data['candles']).set_index('time')  # viii  df.index = pd.DatetimeIndex(df.index)  # nine  df.info() # 10

<grade 'pandas.core.frame.DataFrame'> DatetimeIndex: 2658 entries, 2016-12-08 00:00:00 to 2016-12-09 21:59:00 Information columns (total 10 columns): closeAsk    2658 non-null float64 closeBid    2658 non-null float64 complete    2658 non-aught bool highAsk     2658 not-null float64 highBid     2658 non-null float64 lowAsk      2658 non-naught float64 lowBid      2658 non-null float64 openAsk     2658 non-null float64 openBid     2658 non-null float64 book      2658 non-nothing int64 dtypes: bool(1), float64(8), int64(1) memory usage: 210.iii KB

2nd, nosotros formalize the momentum strategy by telling Python to take the mean log render over the last 15, 30, 60, and 120 infinitesimal bars to derive the position in the instrument. For instance, the mean log return for the last xv infinitesimal bars gives the average value of the last 15 return observations. If this value is positive, we get/stay long the traded musical instrument; if information technology is negative nosotros go/stay brusk. To simplify the the code that follows, nosotros only rely on the closeAsk values nosotros retrieved via our previous block of code:

In [3]: import numpy every bit np  # 11  df['returns'] = np.log(df['closeAsk'] / df['closeAsk'].shift(1))  # 12  cols = []  # 13  for momentum in [15, 30, 60, 120]:  # fourteen     col = 'position_%south' % momentum  # 15     df[col] = np.sign(df['returns'].rolling(momentum).hateful())  # xvi     cols.append(col)  # 17

Third, to derive the absolute performance of the momentum strategy for the different momentum intervals (in minutes), you demand to multiply the positionings derived above (shifted past 1 day) by the market returns. Hither'south how to exercise that:

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

Out[4]: <matplotlib.axes._subplots.AxesSubplot at 0x11a9c6a20>

algorithmic trading python

Inspection of the plot to a higher place reveals that, over the period of the data fix, the traded instrument itself has a negative performance of about -2%. Among the momentum strategies, the one based on 120 minutes performs all-time with a positive return of about 1.five% (ignoring the bid/enquire spread). In principle, this strategy shows "existent alpha": it generates a positive return fifty-fifty when the musical instrument itself shows a negative ane.

Automated Trading

Once you have decided on which trading strategy to implement, y'all are ready to automate the trading functioning. To speed upwardly things, I am implementing the automated trading based on twelve v-second bars for the time series momentum strategy instead of ane-minute confined as used for backtesting. A single, rather concise class does the play a joke on:

In [five]: grade MomentumTrader(opy.Streamer):  # 25     def __init__(self, momentum, *args, **kwargs):  # 26         opy.Streamer.__init__(cocky, *args, **kwargs)  # 27         self.ticks = 0  # 28         self.position = 0  # 29         self.df = pd.DataFrame()  # thirty         cocky.momentum = momentum  # 31         self.units = 100000  # 32     def create_order(self, side, units):  # 33         order = oanda.create_order(config['oanda']['account_id'],              musical instrument='EUR_USD', units=units, side=side,             type='market place')  # 34         impress('\n', order)  # 35     def on_success(cocky, data):  # 36         self.ticks += 1  # 37         # print(cocky.ticks, finish=', ')         # appends the new tick data to the DataFrame object         self.df = self.df.append(pd.DataFrame(data['tick'],                                  index=[data['tick']['time']]))  # 38         # transforms the time data to a DatetimeIndex object         cocky.df.index = pd.DatetimeIndex(self.df['time'])  # 39         # resamples the data set to a new, homogeneous interval         dfr = self.df.resample('5s').last()  # xl         # calculates the log returns         dfr['returns'] = np.log(dfr['enquire'] / dfr['ask'].shift(1))  # 41         # derives the positioning co-ordinate to the momentum strategy         dfr['position'] = np.sign(dfr['returns'].rolling(                                        cocky.momentum).mean())  # 42         if dfr['position'].ix[-ane] == 1:  # 43             # get long             if self.position == 0:  # 44                 self.create_order('purchase', self.units)  # 45             elif self.position == -one:  # 46                 self.create_order('buy', self.units * 2)  # 47             self.position = ane  # 48         elif dfr['position'].nine[-1] == -1:  # 49             # go short             if self.position == 0:  # 50                 self.create_order('sell', cocky.units)  # 51             elif self.position == 1: # 52                 self.create_order('sell', self.units * 2)  # 53             self.position = -i  # 54         if self.ticks == 250:  # 55             # close out the position             if self.position == 1:  # 56                 self.create_order('sell', self.units)  # 57             elif self.position == -ane:  # 58                 cocky.create_order('buy', self.units)  # 59             self.disconnect()  # 60

The lawmaking below lets the MomentumTrader grade practise its work. The automated trading takes place on the momentum calculated over 12 intervals of length v seconds. The form automatically stops trading after 250 ticks of data received. This is arbitrary only allows for a quick sit-in of the MomentumTrader class.

In [half dozen]: mt = MomentumTrader(momentum=12, environment='practice',                     access_token=config['oanda']['access_token']) mt.rates(account_id=config['oanda']['account_id'],          instruments=['DE30_EUR'], ignore_heartbeat=True)

{'toll': ane.04858, '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'}

          {'cost': one.04805, 'time': '2016-12-15T10:29:46.000000Z', 'tradeReduced': {}, 'tradesClosed': [{'side': 'buy', 'id': 10564874832, 'units': 100000}], 'tradeOpened': {'takeProfit': 0, 'id': 10564875194, 'trailingStop': 0, 'side': 'sell', 'stopLoss': 0, 'units': 100000}, 'instrument': 'EUR_USD'}

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

          {'cost': 1.04806, 'time': '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, 'fourth dimension': '2016-12-15T10:30:x.000000Z', 'tradeReduced': {}, 'tradesClosed': [{'side': 'sell', 'id': 10564876308, 'units': 100000}], 'tradeOpened': {'takeProfit': 0, 'id': 10564876466, 'trailingStop': 0, 'side': 'purchase', 'stopLoss': 0, 'units': 100000}, 'instrument': 'EUR_USD'}

          {'toll': i.04809, 'time': '2016-12-15T10:32:27.000000Z', 'tradeReduced': {}, 'tradesClosed': [{'side': 'buy', 'id': 10564876466, 'units': 100000}], 'tradeOpened': {}, 'instrument': 'EUR_USD'}

The output above shows the unmarried trades every bit executed by the MomentumTrader class during a sit-in run. The screenshot beneath shows the fxTradePractice desktop awarding of Oanda where a trade from the execution of the MomentumTrader class in EUR_USD is agile.

All example outputs shown in this article are based on a demo account (where only newspaper money is used instead of real money) to simulate algorithmic trading. To move to a live trading functioning with real money, you only need to prepare a existent business relationship with Oanda, provide real funds, and adjust the surroundings and account parameters used in the lawmaking. The lawmaking itself does not demand to exist changed.

Conclusions

This commodity shows that you can outset a basic algorithmic trading performance with fewer than 100 lines of Python code. In principle, all the steps of such a project are illustrated, like retrieving data for backtesting purposes, backtesting a momentum strategy, and automating the trading based on a momentum strategy specification. The lawmaking presented provides a starting point to explore many different directions: using alternative algorithmic trading strategies, trading alternative instruments, trading multiple instruments at once, etc.

The popularity of algorithmic trading is illustrated by the rise of unlike types of platforms. For case, Quantopian — a web-based and Python-powered backtesting platform for algorithmic trading strategies — reported at the end of 2016 that it had attracted a user base of more than than 100,000 people. Online trading platforms similar Oanda or those for cryptocurrencies such as Gemini let you to get started in real markets inside minutes, and cater to thousands of active traders around the globe.