Algorithmic Trading (Part 2): Pairs Trading and Statistical Arbitrage

pairs-trading-dashboard-2

This post is part of a series:
Part 1 can be found here.

A Pairs Trading Overview

This post will address what pairs trading is, how you can test for a pairs trading opportunity, and how to implement a pairs trading strategy.

For information on the libraries I’ve used and how I structured my trading methods, I recommend starting with my previous post on the subject.

Pairs Trading is a Statistical Arbitrage strategy. In the strategy, a trader trades two stocks that tend to “move together”. More formally, they are stationary. This means that a linear combination of the two securities revolves around a fixed mean with a relatively small error. Here’s an example of what that might look like:

cointegration-example

When the distance between these securities expands, the expectation is that they will converge back to their typical relationship. If the distance between them shrinks, the expectation is that they will diverge back to their typical relationship. When a trader expects a convergence, they will short the higher stock and buy the lower stock. This position is reversed when a divergence is expected.

This strategy is described as “market neutral”. If the pair of securities moves up or down at the same rate while a convergence or divergence position is open, there is no net change in the portfolio value. Instead, a trader is only profiting on the spread.

A pair can be described as stationary if their spread tends to be fixed, or if the ratio of one security over the other revolves around a mean. Pairs that satisfy this criteria are called “cointegrated pairs”.

Testing for Cointegrated Pairs

Like many things quant-related, an in-depth explanation of cointegration is best provided by this post at QuantStart. In that post, Halls-Moore describes the difference between cointegration and correlation, and gives some theoretical context to the tests that are featured in this post.

As referenced above, the pair I chose to test is Verizon Communications Inc. (VZ) and Chesapeake Utilities Corporation (CPK). Here’s a scatterplot of the securities from 2009 to 2013.

vz-cpk-scatter

To implement the Hurst exponent, I copied a function from QuantStart. Hurst values greater than .5 indicate that the series is trending. Hurst values equal to .5 indicate that it follows a random walk. Hurst values less than .5 indicate that it is mean-reverting. Testing VZ and CPK between 2009 and 2013, we can see a Hurst exponent of 0.226:

from datetime import datetime
import logbook
import pytz
from numpy import log, polyfit, sqrt, std, subtract
from zipline.utils.factory import load_from_yahoo

def hurst(ts):
	"""Returns the Hurst Exponent of the time series vector ts"""
      #Taken from quantstart
	# Create the range of lag values
	lags = range(2, 100)
	# Calculate the array of the variances of the lagged differences
	tau = [sqrt(std(subtract(ts[lag:], ts[:-lag]))) for lag in lags]
	# Use a linear fit to estimate the Hurst Exponent
	poly = polyfit(log(lags), log(tau), 1)
	# Return the Hurst exponent from the polyfit output
	return poly[0]*2.0

logbook.StderrHandler().push_application()
start = datetime(2009, 1, 1, 0, 0, 0, 0, pytz.utc)
end = datetime(2013, 1, 1, 0, 0, 0, 0, pytz.utc)
sec1 = 'VZ'
s1 = load_from_yahoo(stocks= [sec1], indexes={}, start=start,
                        end=end, adjusted = True)
sec2 = 'CPK'
s2 = load_from_yahoo(stocks= [sec2], indexes={}, start=start,
                        end=end, adjusted = True)
s1.dropna()
s2.dropna()
data = s1.join(s2)
data['Ratio'] = s1[sec1]/s2[sec2]
print(hurst(data['Ratio']))

As a warning, testing for cointegration over the same time period that the strategy runs exposes it to look-ahead bias. The results are positively skewed by prior knowledge that a cointegrated relationship is maintained over the period. But for an example, this will be overlooked.

For those curious, the QuartStart article also provides a more direct test for cointegration, using the “statsmodel” library. It provides a test statistic and a set of confidence values, accurately gauging how stationary a time-series is. The example time-series shown above is below the 1% threshold provided by the test, giving strong evidence that the series is stationary.

Implementing the Trading Strategy

Now that we’ve tested the pair for cointegation, we can implement a Pairs Trading Strategy. It will look structurally similar to my previous post on RSI Strategies. For those who simply want to see the code all in one place, I’ve included it at the bottom of the post.

Here’s the dashboard used to the run the algorithm. Note that I’ve passed my yahoo data to the algorithm with the run_algorithm() function. Otherwise the zipline will use it’s own internal data to run the algorithm:

#All the necessary libraries
import talib as ta
from talib import MA_Type
import matplotlib.pyplot as plt
import matplotlib.patches as mpatches
import matplotlib as mpl
import warnings
from datetime import datetime
import logbook
from logbook import Logger
log = Logger('Algorithm')
import pytz
import zipline
import zipline.utils.factory as factory
from zipline.algorithm import TradingAlgorithm
from zipline.utils.factory import load_from_yahoo
from zipline.api import order, symbol, get_order, record
import statsmodels.tsa.stattools as ts
from zipline.utils.run_algo import load_extensions
import os

warnings.filterwarnings("ignore")

#Choosing a security and a time horizon
logbook.StderrHandler().push_application()
start = datetime(2008, 1, 1, 0, 0, 0, 0, pytz.utc)
algo_start = datetime(2009, 1, 1, 0, 0, 0, 0, pytz.utc)
end = datetime(2013, 1, 1, 0, 0, 0, 0, pytz.utc)
sec1 = 'VZ'
s1 = load_from_yahoo(stocks= [sec1], indexes={}, start=start,
                        end=end, adjusted = True)
sec2 = 'CPK'
s2 = load_from_yahoo(stocks= [sec2], indexes={}, start=start,
                        end=end, adjusted = True)
s1.dropna()
s2.dropna()
data = s1.join(s2)

#Run the algorithm, passing along the yahoo data and a distinct start time
zipline.run_algorithm(start = algo_start, end = end,
              initialize=Mean_Reversion_Strategy.initialize,
               handle_data=Mean_Reversion_Strategy.handle_data,
               analyze= Mean_Reversion_Strategy.analyze,
               data=data,
               capital_base = 100000)

The initialize function provides an opportunity to set important flag variables outside of the “handle_data” function:

    def initialize(context):
        context.stock_1 = context.symbol(sec1)
        context.stock_2 = context.symbol(sec2)
        context.days = 150
        context.BB_over = False
        context.BB_under = False
        context.long_converg = False
        context.long_diverg = False

The “handle_data” function is where the actual algorithm is stored. The logic of the algorithm is very similar to the previous RSI Strategy. Instead of the RSI, the strategy uses Bollinger Bands. Instead of a single security, this strategy uses the ratio of VZ/CPK.

Bollinger Bands create three lines: one at the mean of the series in the lookback period, one two standard deviations above the mean, and one two standard deviations below the mean. This strategy makes a takes a convergence position (short VZ and long CPK) when the VZ/CPK ratio crosses from above the upper band, heading back towards the mean. It takes a divergence position (long VZ and short CPK) when the VZ/CPK ratio crosses from below the lower band, heading back towards the mean. A zoomed in example should help make this more clear:

zoomed-in-example-2

There’s a segment of the algorithm which dynamically determines which stock is trading higher than the other. In a scenario where VZ has been trading above CPK for most of the backtest, but they cross (creating a VZ/CPK ratio of < 1), the logic of the algorithm is preserved. Lastly, the “handle_data” function records relevant variables to be displayed in a graph like the one at the top of this post:

    def handle_data(context, data):
      try:
            trailing_window_1 = data.history(context.stock_1, 'price', context.days, '1d')
            trailing_window_2 = data.history(context.stock_2, 'price', context.days, '1d')
            trailing_ratio = trailing_window_1/trailing_window_2
      except:
        return

      if (trailing_window_1[-1] >= trailing_window_2[-1]):
            upper_stock = context.stock_1
            lower_stock = context.stock_2
      else:
            upper_stock = context.stock_2
            lower_stock = context.stock_1

      coint = ts.coint(trailing_window_1,trailing_window_2)
      upper, middle, lower = ta.BBANDS(trailing_ratio.values, timeperiod=20, nbdevup=2, nbdevdn=2)

      crossover_top = False
      crossover_bottom = False

      #Setting flags
      if(trailing_ratio[-1] > upper[-1]):
            context.BB_over = True

      if(trailing_ratio[-1] < lower[-1]):
            context.BB_under = True

      if(trailing_ratio[-1] < upper[-1] and context.BB_over):
            context.BB_over = False
            crossover_top = True   

      if(trailing_ratio[-1] > lower[-1] and context.BB_under):
            context.BB_under = False
            crossover_bottom = True

      #Wipe away any extraneous positions and orders
      if (not (context.long_converg or context.long_diverg)):
            context.order_target(context.stock_1, 0)
            context.order_target(context.stock_2, 0)

      #Trading Logic
      if(crossover_top and not (context.long_converg or context.long_diverg)):
            context.order_target_percent(upper_stock, -.5)
            context.order_target_percent(lower_stock, .5)
            context.long_converg = True

      elif(crossover_bottom and not (context.long_converg or context.long_diverg)):
            context.order_target_percent(upper_stock, .5)
            context.order_target_percent(lower_stock, -.5)
            context.long_diverg = True

      if(context.long_converg and trailing_ratio[-1] <= middle[-1]):
           context.order_target(upper_stock, 0)
           context.order_target(lower_stock, 0)
           context.long_converg = False
           context.long_diverg = False 

      elif(context.long_diverg and trailing_ratio[-1] >= middle[-1]):
           context.order_target(upper_stock, 0)
           context.order_target(lower_stock, 0)
           context.long_converg = False
           context.long_diverg = False

      '''
      elif((context.BB_over or context.BB_under) and (context.long_converg or context.long_diverg)):
            context.order_target(context.stock_1, 0)
            context.order_target(context.stock_2, 0)
            context.long_converg = False
            context.long_diverg = False
            '''

      record(security_1=trailing_window_1[-1],
            security_2=trailing_window_2[-1],
            coint = coint[0],
            ratio = trailing_ratio[-1],
            up = upper[-1],
            mid = middle[-1],
            lo = lower[-1],
            long_converg = context.long_converg,
            long_diverg = context.long_diverg)

Drawing the Results

The “analyze”function is used to create the graphical dashboard shown at the top of the post. Most of the subtleties of the function come in the form of formatting tweaks:

    def analyze(context, perf):
        perf = perf.dropna()
        fig = plt.figure()

        #Portfolio Plot
        ax1 = plt.subplot2grid((11,1), (0,0), rowspan=3, colspan=1)
        perf.algorithm_period_return.plot(ax=ax1, label = 'Algorithm')
        perf.benchmark_period_return.plot(ax=ax1, label = 'Benchmark (^GSPC)')
        ax1.set_title('Portfolio Returns (%)', size = 11)

        #Securities Plot
        ax2 = plt.subplot2grid((11,1), (3,0), rowspan=3, colspan=1)
        s1_line, = ax2.plot(perf.security_1, label = sec1)
        s2_line, = ax2.plot(perf.security_2, label = sec2)
        ax2.set_title('Security Value ($)', size = 11)

        #Ratio Plot
        ax3 = plt.subplot2grid((11,1), (6,0), rowspan=3, colspan=1)
        ax3.plot(perf['ratio'], label = 'Stock Ratio', color = 'black')
        ax3.plot(perf['up'], label = 'Upper Band', color = 'green')
        ax3.plot(perf['mid'], label = 'Mean Band', color = 'blue')
        ax3.plot(perf['lo'], label = 'Lower Band', color = 'red')
        ax3.set_title('Ratio with Bollinger Bands', size = 11)

        #Holdings Area Plot
        ax4 = ax2.twinx()
        ax4.fill_between(perf.index, 1,
                         where = perf['long_converg'] > 0, alpha = 0.3, color='g')
        ax4.fill_between(perf.index, 1,
                         where = perf['long_diverg'] > 0, alpha = 0.3, color='r')
        long_patch = mpatches.Patch(color='g', alpha = 0.3, label='Long Convergence')
        short_patch = mpatches.Patch(color='r', alpha = 0.3, label='Long Divergence')
        ax4.axis('off')

        #Cointegration Value Plot
        ax5 = plt.subplot2grid((11,1), (9,0), rowspan=2, colspan=1, sharex=ax2)
        ax5.text(0.16, -0.80,
                 'Algorithm Return: ' + str(round(perf.algorithm_period_return[-1],3)) + '\n'  +
                 'Benchmark Return: ' + str(round(perf.benchmark_period_return[-1],3)) + '\n' +
                  'Treasury Return: ' + str(round(perf.treasury_period_return[-1],3)),
                 fontsize = 12, color = 'white',
                 transform=ax5.transAxes,
                 verticalalignment='bottom',
                 horizontalalignment='center')

        #Adds Performance Metrics Below the Plot
        ax5.text(0.50, -0.80,
                 'Sortino: ' + str(round(perf.sortino[-1],3)) + '\n'  +
                 'Max Drawdown: ' + str(round(perf.max_drawdown[-1],3)) + '\n' +
                 'Volatility: ' + str(round(perf.algo_volatility[-1],3)),
                 fontsize = 12, color = 'white',
                 transform=ax5.transAxes,
                 verticalalignment='bottom',
                 horizontalalignment='center')
        ax5.text(0.84, -0.80,
                 'Sharpe: ' + str(round(perf.sharpe[-1],3))  + '\n' +
                 'Alpha: ' + str(round(perf.alpha[-1],3)) + '\n'  +
                 'Beta: ' + str(round(perf.beta[-1],3)),
                 fontsize = 12, color = 'white',
                 transform=ax5.transAxes,
                 verticalalignment='bottom',
                 horizontalalignment='center')

        ax5.plot(perf['coint'], label = 'Cointegration')
        ax5.set_title('Trailing Cointegration', size = 11)

        #Changing the Chart Format
        mpl.rc('axes',edgecolor='w')
        ax2.title.set_color('w')
        ax3.title.set_color('w')
        ax5.title.set_color('w')
        ax1.title.set_color('w')
        ax2.tick_params(axis="y", labelcolor="w", labelsize= 9)
        ax3.tick_params(axis="y", labelcolor="w", labelsize= 9)
        ax1.tick_params(axis="y", labelcolor="w", labelsize= 9)
        ax5.tick_params(axis="y", labelcolor="w", labelsize= 9)
        ax5.tick_params(axis="x", labelcolor="w")
        rect = fig.patch
        rect.set_facecolor('black')
        ax5.grid(b=True, which='both', color='0.65',linestyle='-')
        ax3.grid(b=True, which='both', color='0.65',linestyle='-')
        ax1.grid(b=True, which='both', color='0.65',linestyle='-')
        ax2.grid(b=True, which='both', color='0.65',linestyle='-')

        #Adding Legends
        rounded = dict(boxstyle='round')
        ax1.legend(loc = 'center', bbox_to_anchor=(0, 0, 2.15, 1), borderaxespad=0, prop={'size':8})
        ax5.legend(loc = 'center', bbox_to_anchor=(0, 0, 2.15, 1), borderaxespad=0, prop={'size':8})
        ax3.legend(loc = 'center', bbox_to_anchor=(0, 0, 2.15, 1), borderaxespad=0, prop={'size':8})
        ax2.legend(loc = 'center', bbox_to_anchor=(0, 0, 2.15, 1), handles=[s1_line, s2_line, long_patch, short_patch],  borderaxespad=0, prop={'size':8})

        #Plot Performanc Metrics
        plt.show()

Performance and Tweaks

The output of the analyze class is shown at the top of the post. It includes some standard performance metrics.

The advantages of this strategy are its essentially nonexistent beta and relatively low max drawdown values. Since it is market-neutral, the strategy outperforms the S&P in bear markets, like the example period chosen. In bull markets, however, the strategy underperforms:

bull-performance

The strategy’s performance can be tweaked through the Bollinger Bands. The following line can be amended, so that lines are drawn closer than two standard deviations above/below the mean. Lower values mean that the algorithm trades more frequently, often with a higher volatility:

 upper, middle, lower = ta.BBANDS(trailing_ratio.values, timeperiod=20, nbdevup=2, nbdevdn=2)

For this pair, lowering the nbdevup and nvdevdn values usually resulted in higher volatility without higher returns. If you consider it graphically, waiting until the ratio is 2 standard deviations away from the mean allows you to collect a larger spread when you sell out at the mid line, as compared to a 1.5 standard deviation band.

Still, I believe these values are worth experimenting with if you’re attempting to optimize your pairs trade.

Mean Reversion Class

class Mean_Reversion_Strategy:

    def initialize(context):
        context.stock_1 = context.symbol(sec1)
        context.stock_2 = context.symbol(sec2)
        context.days = 150
        context.BB_over = False
        context.BB_under = False
        context.long_converg = False
        context.long_diverg = False

    def handle_data(context, data):
      try:
            trailing_window_1 = data.history(context.stock_1, 'price', context.days, '1d')
            trailing_window_2 = data.history(context.stock_2, 'price', context.days, '1d')
            trailing_ratio = trailing_window_1/trailing_window_2
      except:
        return

      if (trailing_window_1[-1] >= trailing_window_2[-1]):
            upper_stock = context.stock_1
            lower_stock = context.stock_2
      else:
            upper_stock = context.stock_2
            lower_stock = context.stock_1

      coint = ts.coint(trailing_window_1,trailing_window_2)
      upper, middle, lower = ta.BBANDS(trailing_ratio.values, timeperiod=20, nbdevup=2, nbdevdn=2)

      crossover_top = False
      crossover_bottom = False

      #Setting flags
      if(trailing_ratio[-1] > upper[-1]):
            context.BB_over = True

      if(trailing_ratio[-1] < lower[-1]):
            context.BB_under = True

      if(trailing_ratio[-1] < upper[-1] and context.BB_over):
            context.BB_over = False
            crossover_top = True   

      if(trailing_ratio[-1] > lower[-1] and context.BB_under):
            context.BB_under = False
            crossover_bottom = True

      #Wipe away any extraneous positions and orders
      if (not (context.long_converg or context.long_diverg)):
            context.order_target(context.stock_1, 0)
            context.order_target(context.stock_2, 0)

      #Trading Logic
      if(crossover_top and not (context.long_converg or context.long_diverg)):
            context.order_target_percent(upper_stock, -.5)
            context.order_target_percent(lower_stock, .5)
            context.long_converg = True

      elif(crossover_bottom and not (context.long_converg or context.long_diverg)):
            context.order_target_percent(upper_stock, .5)
            context.order_target_percent(lower_stock, -.5)
            context.long_diverg = True

      if(context.long_converg and trailing_ratio[-1] <= middle[-1]):
           context.order_target(upper_stock, 0)
           context.order_target(lower_stock, 0)
           context.long_converg = False
           context.long_diverg = False 

      elif(context.long_diverg and trailing_ratio[-1] >= middle[-1]):
           context.order_target(upper_stock, 0)
           context.order_target(lower_stock, 0)
           context.long_converg = False
           context.long_diverg = False

      '''
      elif((context.BB_over or context.BB_under) and (context.long_converg or context.long_diverg)):
            context.order_target(context.stock_1, 0)
            context.order_target(context.stock_2, 0)
            context.long_converg = False
            context.long_diverg = False
            '''

      record(security_1=trailing_window_1[-1],
            security_2=trailing_window_2[-1],
            coint = coint[0],
            ratio = trailing_ratio[-1],
            up = upper[-1],
            mid = middle[-1],
            lo = lower[-1],
            long_converg = context.long_converg,
            long_diverg = context.long_diverg)

    def analyze(context, perf):
        perf = perf.dropna()
        fig = plt.figure()

        #Portfolio Plot
        ax1 = plt.subplot2grid((11,1), (0,0), rowspan=3, colspan=1)
        perf.algorithm_period_return.plot(ax=ax1, label = 'Algorithm')
        perf.benchmark_period_return.plot(ax=ax1, label = 'Benchmark (^GSPC)')
        ax1.set_title('Portfolio Returns (%)', size = 11)

        #Securities Plot
        ax2 = plt.subplot2grid((11,1), (3,0), rowspan=3, colspan=1)
        s1_line, = ax2.plot(perf.security_1, label = sec1)
        s2_line, = ax2.plot(perf.security_2, label = sec2)
        ax2.set_title('Security Value ($)', size = 11)

        #Ratio Plot
        ax3 = plt.subplot2grid((11,1), (6,0), rowspan=3, colspan=1)
        ax3.plot(perf['ratio'], label = 'Stock Ratio', color = 'black')
        ax3.plot(perf['up'], label = 'Upper Band', color = 'green')
        ax3.plot(perf['mid'], label = 'Mean Band', color = 'blue')
        ax3.plot(perf['lo'], label = 'Lower Band', color = 'red')
        ax3.set_title('Ratio with Bollinger Bands', size = 11)

        #Holdings Area Plot
        ax4 = ax2.twinx()
        ax4.fill_between(perf.index, 1,
                         where = perf['long_converg'] > 0, alpha = 0.3, color='g')
        ax4.fill_between(perf.index, 1,
                         where = perf['long_diverg'] > 0, alpha = 0.3, color='r')
        long_patch = mpatches.Patch(color='g', alpha = 0.3, label='Long Convergence')
        short_patch = mpatches.Patch(color='r', alpha = 0.3, label='Long Divergence')
        ax4.axis('off')

        #Cointegration Value Plot
        ax5 = plt.subplot2grid((11,1), (9,0), rowspan=2, colspan=1, sharex=ax2)
        ax5.text(0.16, -0.80,
                 'Algorithm Return: ' + str(round(perf.algorithm_period_return[-1],3)) + '\n'  +
                 'Benchmark Return: ' + str(round(perf.benchmark_period_return[-1],3)) + '\n' +
                  'Treasury Return: ' + str(round(perf.treasury_period_return[-1],3)),
                 fontsize = 12, color = 'white',
                 transform=ax5.transAxes,
                 verticalalignment='bottom',
                 horizontalalignment='center')
        ax5.text(0.50, -0.80,
                 'Sortino: ' + str(round(perf.sortino[-1],3)) + '\n'  +
                 'Max Drawdown: ' + str(round(perf.max_drawdown[-1],3)) + '\n' +
                 'Volatility: ' + str(round(perf.algo_volatility[-1],3)),
                 fontsize = 12, color = 'white',
                 transform=ax5.transAxes,
                 verticalalignment='bottom',
                 horizontalalignment='center')
        ax5.text(0.84, -0.80,
                 'Sharpe: ' + str(round(perf.sharpe[-1],3))  + '\n' +
                 'Alpha: ' + str(round(perf.alpha[-1],3)) + '\n'  +
                 'Beta: ' + str(round(perf.beta[-1],3)),
                 fontsize = 12, color = 'white',
                 transform=ax5.transAxes,
                 verticalalignment='bottom',
                 horizontalalignment='center')

        ax5.plot(perf['coint'], label = 'Cointegration')
        ax5.set_title('Trailing Cointegration', size = 11)

        #Changing the chart format
        mpl.rc('axes',edgecolor='w')
        ax2.title.set_color('w')
        ax3.title.set_color('w')
        ax5.title.set_color('w')
        ax1.title.set_color('w')
        ax2.tick_params(axis="y", labelcolor="w", labelsize= 9)
        ax3.tick_params(axis="y", labelcolor="w", labelsize= 9)
        ax1.tick_params(axis="y", labelcolor="w", labelsize= 9)
        ax5.tick_params(axis="y", labelcolor="w", labelsize= 9)
        ax5.tick_params(axis="x", labelcolor="w")
        rect = fig.patch
        rect.set_facecolor('black')
        ax5.grid(b=True, which='both', color='0.65',linestyle='-')
        ax3.grid(b=True, which='both', color='0.65',linestyle='-')
        ax1.grid(b=True, which='both', color='0.65',linestyle='-')
        ax2.grid(b=True, which='both', color='0.65',linestyle='-')

        #Adding Legends
        rounded = dict(boxstyle='round')
        ax1.legend(loc = 'center', bbox_to_anchor=(0, 0, 2.15, 1), borderaxespad=0, prop={'size':8})
        ax5.legend(loc = 'center', bbox_to_anchor=(0, 0, 2.15, 1), borderaxespad=0, prop={'size':8})
        ax3.legend(loc = 'center', bbox_to_anchor=(0, 0, 2.15, 1), borderaxespad=0, prop={'size':8})
        ax2.legend(loc = 'center', bbox_to_anchor=(0, 0, 2.15, 1), handles=[s1_line, s2_line, long_patch, short_patch],  borderaxespad=0, prop={'size':8})

        #Plot Performanc Metrics
        plt.show()

Advertisements

4 thoughts on “Algorithmic Trading (Part 2): Pairs Trading and Statistical Arbitrage

  1. Pingback: Algorithmic Trading (Part 1): Backtesting an RSI Strategy – Keith Selover

  2. Pingback: Algorithmic Trading (Part 2): Pairs Trading and Statistical Arbitrage – Stock Trading NTS

  3. Pingback: Quantocracy's Daily Wrap for 11/10/2016 | Quantocracy

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s