# Category Archives: strategies

## Money Management

It has been almost a year since my last post.  I have been far too busy getting a new trading desk up and running.   I  thought to discuss money management, since am revisiting right now.

## Overview

It is easy to think that trading signal is the most important aspect of a trading strategy, but money management (and execution) can be even more important.   Loosely defined, money management is a mechanism for position-level risk management.  The mechanism attempts to regulate, accomplishing a number of things:

1. ride out a profitable signal as long as there is continued profit potential
1. close out a profitable position when the p&l is drifting sideways
2. close out a profitable position, alternatively when there is a drawdown
3. otherwise, allow the position to continue to profit, even through transient negative noise
2. close out our losing positions as quickly as possible
1. close position once we have a view that it is unlikely to be profitable
3. close out strategy if seems unstable
1. for example keeps hitting stop-loss
2. risk measures indicative of unstable market situation for strategy

A desirable feature of a money manager is that when pairing the money manager and signal together, we have a return distribution with positive skew and very limited negative tails.   We can even have a signal with < 50% wins, but because of the generated bias in + returns / – returns, have an overall positive equity curve.   Of course I would advocate for much a much higher win ratio than 50%

## Signal → Position

I take the approach of having a trading signal that scales between [-1,1] or [0,1] on a continuous basis.   In my trading systems the money manager not only works as a risk manager, but also decides how to scale the signal into a desired position.

For example, if our maximum position is $5 million, we might scale our desired position from 0 to$5 million (if the signal reaches full power at 1).  The 0 or close to 0 level would indicate being out of market, 0.5 being at 1/2 strength or 2.5 million in.   Here is an example signal from 0 to 1:

Trading signals can be noisy, though we do our best to provide smooth signals.   Without regulation of how we map the signal to position size, the up and down dips in the signal would imply thrashing in and out of position, which would be costly.

Hence, we should try to enforce direction monotonicity, so as to avoid thrashing.

## Types of stop-loss

There are a number of stop-loss types we should consider:

1. stop-loss:
1. stop when (smoothed) equity curve has reached a negative return threshold
2. stop-profit:
1. exit an up-to-current profitable trade, but one that has lost some % from the high
3. stop-drift
1. a time and slope based stop that closes out a position whose equity curve is drifting more-or-less sideways for a significant period

## Risk Reentry Avoidance

On a stop-loss not only want to close the position, but also have to “back away” from the signal, such that we do not immediately get back into an undesirable situation.   Depending on why we exited the position, we may want to:

1. disable market entry until the signal has gone to zero
2. impose a time penalty
3. impose a market reentry restriction (wait for the market regime to reach a certain stage)

## A FSM

Here is a finite state machine that illustrates a possible state system guiding position scaling and money management:

The state system expresses some of the above money management features.   To make it effective, one needs to be clever about deciding on whether a negative movement is a sign to get out or a transient movement.   One can use a combination of signal, smoothed series, and aspects of order book and trade data to have a better read on this.

11 Comments

Filed under strategies

## Thought Experiment On Randomness

Was discussing pseudo-random number generators with a colleague, around desirable attributes of the distribution, periodicity, etc — all fun and important stuff.

It reminded me of a chain of thought ranging from complexity theory to the philosophical.   Pardon the armchair physics and philosophy.

As we know from information theory, any sequence generated by an algorithm with no exogenous input, except perhaps an initial state, cannot be random.   There are multiple measures of randomness in theoretical computer science around measuring the degree of pattern in a given sequence (or string).    One that appeals to me, is the Kolmogorov complexity measure (I was reminded of this by recent posts on Shtetl-Optimized) which is approximately:

for some string x (say a random sequence we are testing), what is the shortest possible program in some universal computer language K(x) that prints x and halts.

Intuitively, if a sequence is truly random, there is no algorithm that can generate it short of the sequence literal itself.  Assuming we a looking at very long sequences of  X (our random sequence), the program to produce that must also be very large (as long as the literal) and hence have a very high K(x) measure.  A long pseudo random sequence may look to be quite complex at first glance, but can be described by a short program generating the sequence, and hence has a low K(x) measure.

Not being a complexity theorist, I’m playing pretty loose with the definition, but you get the idea.

Going further, one thing I’ve often thought about, is whether randomness truly exists in the universe.   This may be equivalent to asking, is the universe computable.  This question and theory around this has been proposed and discussed since the 1950s.   Are the random distributions we see in quantum states, for example, just manifestations of a complex computable function, probably one with many dimensions and long periodicity.

If the fabric of the universe is computable, then it stands to reason that what is contained within is also.  In this scenario, we being computable machines made of this macro-stuff called matter, are just very complex functions of our initial states;  Not just our initial state (our conception and program therein), but the state vector of all influences in the universe, our surroundings, and other automata.

Well you can see where this goes.   Free will is a function of our reason and environment, but our reasoning function is also predetermined by this astronomical state vector / ongoing computation.

Anyway, I was reluctant to post this for a while, but thought it would be fun for a change.  Starts with science and ends with philosophical possibility.

Addendum
I should add, the data we receive from “random” physical processes appears to be random.  If we assume a computable universe, the generating function for these random processes could be vast given the possibility of an “astronomical”, but finite, number of inputs (or dimension).   i.e.  Our approximation of the K(x) function appears to be large just because we do not know how to determine the generating function.   Hence in a short life-time of observation and computation, such a function would have the appearance of randomness (as in maximal complexity) and infinite period.

11 Comments

Filed under strategies

## Update

It has been a while since I’ve posted and apologize for leaving the prior subject mid-thread.   I’ve become extraordinarily busy with a new company, but will revert to research mode and follow-up once things settle down.

In the mean time, one of my long-term side interests has been biological systems.  These are interesting because are probably most complex systems we can study.   Our understanding of specific cells and interactions has grown enormously within a century, but we’re still only scratching the surface given crude measurement tools and the mind boggling complexity.   Computational biology provides a simulation based approach to studying these problems, and hence is of particular interest to me.

Some “holy grails” that have interested me:

1. creation of artificial lifeforms to “prove” that life is nothing more than a system (done: Craig Venter’s team)
2. mapping of neural structures into simulation
3. creation of alternative chemistry’s / energy / replicating processes

Here is an article I just found of a researcher in the UK that is having some success with creating structures and processes based on metal salts as an alternative to carbon forms:  Life cells made of metal.   It seems like they have been able to create cell-like structures and may be close to a means of generating energy for the entity via photosynthesis.   Whether this is a fruitful or not, remains to be seen.

6 Comments

Filed under strategies

## Smoothed UKF

The smoothed UKF performs smoothing on the state system a-posteriori.   The standard form of this filter is useful in getting an accurate view on prior states, but will not provide a smoothed online state estimate for the current or next period (i.e. no better estimate than the non-smoothed UKF).

That said the smoothed UKF is still useful as:

1. can be used to estimate the MLE for a stable parameter
2. a timeseries of smoothed prior states can be regressed to project a smoothed forward state (but is not part of the UKF framework)

The form of UKF smoother that will briefly discuss is the forward-backward smoother.   As the name suggests, the first pass is to perform standard UKF filter, estimating the distribution $p({x_t}|{x_{t - 1}},{y_{1:t}})$ at each timestep.  Whereas the smoothing estimates a smoothed distribution in reverse, implying $p(x_{t - 1}^S|x_t^S,\Sigma _t^S)$.   The boundary $x_T^S,\Sigma _T^S$ is simply the last state and covariance estimated by the forward filter.

The smoothing approach is then for each $x_{t }^S, \Sigma _t^S$, determine the predicted $x_{t+1 }^-, \Sigma _{t+1}^-, \Sigma _{t,t+1}^-$, and back out an appropriate adjustment given a computed kalman gain and the difference between the predicted t+1 and actual t+1 state:

$\left[\mu _{t+1}^ - ,\sum _{t+1}^ - ,\sum _{t,t + 1}^ - \right] = UT\left( {{X_t},\sum _{t,t}^{},f(.), \cdots } \right)$

$K = \sum _{t,t + 1}^ - {\left( {\sum _{t + 1}^ - } \right)^{ - 1}}$
$X_t^S = X_t^{} + K\left( {X_{t + 1}^S - \mu _{t + 1}^ - } \right)$
$\sum _t^S = \sum _t^{} + K\left( {\sum _{t + 1}^S - \sum _{t + 1}^ - } \right){K^T}$

Results
A simple example of a non-linear function is the Sine function.   Tracking the sine function using a linearization of the sine function with standard Kalman filter will perform poorly.  My test case for the UKF was the following function with noise:

$y(t) = {a_t}\sin \left( {{\theta _t}} \right) + {\varepsilon _t}$

where ${a_t}$ and $\theta _t$ are linear functions of time.  The states in the system track: $A(t),\frac{{dA}}{{dt}},\theta (t),\frac{{d\theta }}{{dt}}$.   Here is UKF tracking without smoothing:

And here is the same with smoothing:

Code
I’m enclosing R code for the augmented UKF and smoothed UKF.   For readability I have not optimized all of the R code (i.e. there are some for loops that could be vectorized).   Here is the common part (defining the Unscented Transform).

## modified number of columns
ncols <- function (x) ifselse(is.matrix(x), ncol(x), length(x))

## modified number of rows
nrows <- function (x) ifelse(is.matrix(x), nrow(x), length(x))

#
#	Determine transformed distribution across non-linear function f(x)
#
#
unscented.transform.aug <- function (
MUx,				# mean of state
P, 					# covariance of state
Nyy,				# noise covariance matrix of f(x)
f,					# non-linear function f(X, E)
dt,					# time increment
alpha = 1e-3,		# scaling of points from mean
beta = 2,			# distribution parameter
kappa = 1)
{
Nyy <- as.matrix(Nyy)

## constants
Lx <- nrows(MUx)
Ly <- nrows(Nyy)
n <- Lx + Ly

## create augmented mean and covariance
MUx.aug <- c (MUx, rep(0, Ly))
P.aug <- matrix(0, Lx+Ly, Lx+Ly)
P.aug[1:Lx,1:Lx] <- P
P.aug[(Lx+1):(Lx+Ly),(Lx+1):(Ly+Ly)] <- Nyy

## generating sigma points
lambda <- alpha^2 * (n + kappa) - n
A <- t (chol (P.aug))
X <- MUx.aug + sqrt(n + lambda) * cbind (rep(0,n), A, -A)

## generate weights
Wc <- c (
lambda / (n + lambda) + (1 - alpha^2 + beta),
rep (1 / (2 * (n + lambda)), 2*n))
Wm <- c (
lambda / (n + lambda),
rep (1 / (2 * (n + lambda)), 2*n))

## propagate through function
Y <- apply(X, 2, function (v)
{
f (dt, v[1:Lx], v[(Lx+1):(Lx+Ly)])
})

if (is.vector(Y))
Y <- t(as.matrix(Y))

## now calculate moments
MUy <- Y %*% Wm

Pyy <- matrix(0, nrows(Nyy), nrows(Nyy))
Pxy <- matrix(0, nrows(MUx), nrows(Nyy))

for (i in 1:ncols(Y))
{
dy <- (Y[,i] - MUy)
dx <- (X[1:Lx,i] - MUx)

Pyy <- Pyy + Wc[i] * dy %*% t(dy)
Pxy <- Pxy + Wc[i] * dx %*% t(dy)
}

list (mu = MUy, Pyy = Pyy, Pxy = Pxy)
}


The UKF without smoothing:

#
#	Augmented UKF filtered series
#		- note that f and g are functions of state X and error vector N  f(dt, Xt, E)
#		- Nx and Ny state and observation innovation covariance
#		- Xo is the initial state
#		- dt is the time step
#
ukf.aug <- function (
series,
f,
g,
Nx,
Ny,
Xo = rep(0, nrow(Nx)),
dt = 1,
alpha = 1e-3,
kappa = 1,
beta = 2)
{
data <- as.matrix(coredata(series))

## description of initial distribution of X
oMUx <- Xo
oPx <- diag(rep(1e-4, nrows(Xo)))

Yhat <- NULL
Xhat <- NULL

for (i in 1:nrow(data))
{
Yt <- t(data[i,])

## predict
r <- unscented.transform.aug (oMUx, oPx, Nx, f, dt, alpha=alpha, beta=beta, kappa=kappa)
pMUx <- r$mu pPx <- r$Pyy

## update
r <- unscented.transform.aug (pMUx, pPx, Ny, g, dt, alpha=alpha, beta=beta, kappa=kappa)
MUy <- r$mu Pyy <- r$Pyy
Pxy <- r$Pxy K <- Pxy %*% inv(Pyy) MUx = pMUx + K %*% (Yt - MUy) Px <- pPx - K %*% Pyy %*% t(K) ## set for next cycle oMUx <- MUx oPx <- Px ## append results Yhat <- rbind(Yhat, t(MUy)) Xhat <- rbind(Xhat, t(MUx)) } list (Yhat = Yhat, Xhat = Xhat) }  The UKF with smoothing: ukf.smooth <- function ( series, # series to be filtered f, # state mapping X[t] = f(X[t-1]) g, # state to measure mapping Y[t] = g(X[t]) Nx, # state innovation error covar Ny, # measure innovation covar Xo = rep(0, nrow(Nx)), # initial state vector dt = 1, # time increment alpha = 1e-3, kappa = 1, beta = 2) { data <- as.matrix(coredata(series)) Lx <- nrow(as.matrix(Nx)) Ly <- nrow(as.matrix(Ny)) ## description of initial distribution of X oMUx <- Xo oPx <- diag(rep(1e-4, nrows(Xo))) Ey <- rep(0, nrows(Ny)) Ex <- rep(0, nrows(Nx)) Ms <- list() Ps <- list() ## forward filtering for (i in 1:nrow(data)) { Yt <- t(data[i,]) ## predict r <- unscented.transform.aug (oMUx, oPx, Nx, f, dt, alpha=alpha, beta=beta, kappa=kappa) pMUx <- r$mu
pPx <- r$Pyy ## update r <- unscented.transform.aug (pMUx, pPx, Ny, g, dt, alpha=alpha, beta=beta, kappa=kappa) MUy <- r$mu
Pyy <- r$Pyy Pxy <- r$Pxy

K <- Pxy %*% inv(Pyy)
MUx = pMUx + K %*% (Yt - MUy)
Px <- pPx - K %*% Pyy %*% t(K)

## set for next cycle
oMUx <- MUx
oPx <- Px

## append results
Ms[[i]] <- MUx
Ps[[i]] <- Px
}

## backward filtering, recursively determine N(Ms[t-1],Ps[t-1]) from N(Ms[t],Ps[t])
for (i in rev(1:(nrow(data)-1)))
{
## transform
r <- unscented.transform.aug (Ms[[i]], Ps[[i]], Nx, f, dt, alpha=alpha, beta=beta, kappa=kappa)
MUx <- r$mu Pxx <- r$Pyy
Pxy <- r$Pxy[1:Lx,] K <- Pxy %*% inv(Pxx) Ms[[i]] <- Ms[[i]] + K %*% (Ms[[i+1]] - MUx) Ps[[i]] <- Ps[[i]] + K %*% (Ps[[i+1]] - Pxx) * t(K) } Yhat <- NULL Xhat <- NULL for (i in 1:nrow(data)) { MUy <- g(dt, Ms[[i]], Ey) MUx <- Ms[[i]] ## append results Yhat <- rbind(Yhat, t(MUy)) Xhat <- rbind(Xhat, t(MUx)) } list (Y = data, Yhat = Yhat, Xhat = Xhat) }  Finally, here is the Sine test: # # Amplitude varying sine function state function: # # Yt = Amp[t] Sin(theta[t]) + Ey # # Theta[t] = Theta[t-1] + Omega[t-1] dt + Ex,1 # Omega[t] = Omega[t-1] + Ex,2 # Amp[t] = Amp[t-1] + Accel[t-1] dt + Ex,3 # Accel[t] = Accel[t] + Ex,4 # sine.f.xx <- function (dt, Xt, Ex) { nXt <- c ( Xt[1] + dt*Xt[2] + Ex[1], Xt[2] + Ex[2], Xt[3] + Ex[3], Xt[4] + Ex[4]) nXt } # # Amplitude varying sine function observation function: # # Yt = Amp[t] Sin(theta[t]) + Ey # # Theta[t] = Theta[t-1] + Omega[t-1] dt + Ex,1 # Omega[t] = Omega[t-1] + Ex,2 # Amp[t] = Amp[t-1] + Accel[t-1] dt + Ex,3 # Accel[t] = Accel[t] + Ex,4 # sine.f.xy <- function (dt, Xt, Ey) { y <- Xt[3] * sin(Xt[1] / pi) + Ey[1] as.matrix(y) } #debug(unscented.transform.aug) #debug(ukf.aug) series.r <- sapply (1:500, function(x) (1+x/500) * sin(16 * x/500 * pi)) + rnorm(500, sd=0.25) ## unsmoothed test u <- ukf.aug ( series.r, sine.f.xx, sine.f.xy, Nx = 1e-3 * diag(c(1/3, 1, 1/10, 1/10)), Ny = 1, Xo = c(0.10, 0.10, 1, 1e-3), alpha=1e-2) data <- rbind ( data.frame(t = 1:500, y=series.r, type='raw', window='Price'), data.frame(t = 1:500, y=u$Yhat, type='filtered', window='Price'),
data.frame(t = 1:500, y=u$Xhat[,3], type='amp', window='Params')) ggplot() + geom_line(aes(x=t,y=y, colour=type), data) + facet_new(window ~ ., scales="free_y", heights=c(3,1)) ## smoothed test u <- ukf.smooth ( series.r, sine.f.xx, sine.f.xy, Nx = 1e-3 * diag(c(1/3, 1, 1/10, 1/10)), Ny = 1, Xo = c(0.10, 0.10, 1, 1e-3), alpha=1e-2) data <- rbind ( data.frame(t = 1:500, y=series.r, type='raw', window='Price'), data.frame(t = 1:500, y=u$Yhat, type='filtered', window='Price'),
data.frame(t = 1:500, y=u$Xhat[,3], type='amp', window='Params')) ggplot() + geom_line(aes(x=t,y=y, colour=type), data) + facet_new(window ~ ., scales="free_y", heights=c(3,2))  If you find the above code useful or have improvements to suggest, kindly send me a note. Thanks. Next Steps Some next steps: 1. Determine state-system appropriate for market making & cycling regimes 2. Determine Multi-Model switching approach 3. Evaluation & Analysis I will probably make a digression onto another topic in the next posting before revisiting this. Stay tuned. p.s. if you use wordpress, they have a latex equation rendering capability I just discovered (hence better inlining in this post). 10 Comments Filed under strategies ## Unscented Transform & Filters The unscented transform (and filter) was developed as a practical alternative to MC sampling in estimating the conditional distribution functions of hidden state systems. We want to determine the hidden state (Xt) given observations (Yt): The Sequential MC approach to determining this distribution p(Xt | Y1:t) is calculated as folows: This works for us, since we know the observations y[1:t] and we should have a view on the likelihood of state X given Y by projecting samples of X into Y via function g(.). There are various approaches to determining the likelihood and reducing the number of particles (samples) required to arrive at a robust integration (such as SIR). The basic MC particle sampling algorithm is as follows: 1. generate N samples of X[t],i from f (X[t-1] + noise), transformed from X[t-1] to X[t] via that f(.) function 2. determine “particles” as p(Yt | X’[t],i) / normalizing constant, where p(Yt|Xt) can be determined by applying function g(x) and determining likelihood of computed Yt given Xt. 3. some resampling and kernel weighted selection may occur, depending on algorithm 4. Mean is then the probability weighted average of the Xt’s (as indicated in the above integral) I’ve implemented and used a number of variations of these in the past. MC approaches are unavoidable for complex distributions (for instance ones that are multi-modal). That said particle filters can be orders of magnitude slower than the Kalman family of filters. Unscented Transform Enter the unscented transform. Much as with the SMC approach, the unscented transform uses sampling to determine the mean and higher-order moments of the distribution: p(x[t] | y[1:t]). Instead of generating numerous random samples, the unscented approach is to take samples at specific points around the current mean. The unscented approach also avoids approximating the non-linearity of system functions, instead looks to determine the simpler problem of approximating the distribution. 2^d + 1 sample (or sigma) points are determined around the mean and transformed through the non-linear functions to arrive at a view of the distribution of the state vector. As illustrated in Julier and Uhlmann’s 1997 seminal paper: The sigma points determined around the mean (Si and with associated weights Wi), are transformed through the non-linear system function allowing us to determine the moments of the distribution p(μ, P), with mean μ and covariance P (higher order moments can be computed as well): It then becomes a question of how to select these sigma points Si around the mean Xt. We know that we want to choose Si = Xt + Ei, where each vector Ei provides an appropriate spread in a given dimension, along the orientation of the distribution. If these points are well chosen, will provide enough information to reconstruct moments of the distribution. Under the assumption that Xt (pre-transform) is elliptically distributed, it turns out that the column vectors of the Cholesky decomposition of the covariance matrix specify vectors co-linear with the axes of the distribution. These are determined and scaled as follows: For more detail read the following paper. Why the UKF? The typical implementation of the EKF uses a linear (and sometimes quadratic) approximation in the update of the distributions. This can fail spectacularly (or just present significant error) unless your system is well behaved through 1st order dynamics. The UKF approach also does not require calculation of Jacobian or Hessian matrices, which for some problems may be extremely difficult or impossible to provide. Next Step I am particularly interested in the forward-backward UTF with smoothing. I have found that smoothing on the priors (not just the immediate t-1) provides a better forecast for the current and next periods. Will write more about this next. Leave a Comment Filed under strategies ## Thinking About State Space Filters I have not used stochastic state based systems for a couple of years, but have decided to revisit. I had previously implemented a number of systems with both the EKF and 3 variants of particle filter, but encountered various issues. In particular, found the parameterization of the evolution via the covariance matrices to be opaque and problematic for some systems. Also both the EKF and particle filters were subject to numerical instability if the mean of the state distribution or observed samples shifted significantly with likelihoods approaching 0. I’ve decided to revisit state space filters but with a different filtering approach, for the purposes of coming up with a different approach to multi-regime pricing. I’ll start with an introduction. The traditional state space model is a discrete (or discretized continuous) system represented by a measurement equation and state evolution equation: Where: 1. X is a n dimensional vector representing the state of the system on timestep t 2. Y is a m dimensional vector representing the measurement on timestep t (for example a price in our price series) 3. f(.) is our state evolution function mapping the t-1 th state to the t th state 4. g(.) is our state to measurement mapping 5. ε_x our state noise / error ~ N (0, Σx) 6. ε_y our observation noise / error ~ N(0,Σy) Kalman Family of Filters The kalman family of filters uses a bayesian logic to implement a linear error correction model, such that errors in the estimation of Yt propagate back to the evolving state Xt (or more precisely, an evolving distribution of Xt). The traditional Kalman filter assumes a linear function f(.) and g(.), usually expressed as matrices: We are interested in estimating the state Xt given the noisy observed data Yt, hence are interested in the pdf p(x[t] | y[1:t]). Given that we will have a lagged (t-1) view on this pdf via the recursion inherent in filtering, we first need to be able to compute p(x[t] | y[1:t-1]) and then using that p(x[t] | y[1:t]): Hence as pointed out in (Hartikainen 2008) the above linear state equations map to distributions: I won’t go into the math for the Kalman filter, as would like to discuss its issues and move on to more sophisticated approaches. The 3 main issues I have with the Kalman Filter: 1. can only express the evolution of linear state functions 2. hard to calibrate degree of fit via state and measurement noise covariance matrices 3. can become numerically unstable with unexpected noise (probabilities go to 0 or may oscillate wildly) The Extended Kalman Filter partially solves one of these issues (that of non-linear state functions) by adjusting the kalman distribution estimation to use 1 or 2 terms of the taylor series expansion of the state and observation functions. This works well for functions completely described by 1st and 2nd derivatives, although has similar drawbacks in terms of calibration and stability. Short of using a numerically expensive particle filter, it seems that a variant the Unscented Kalman Filter (UKF) presents the best choice for the potential state systems I will be using. The UKF using a deterministic sampling approach mapped through the non-linear functions, provides multiple moments for the underlying distribution. The distribution can then be described with greater accuracy than afforded through the EKF’s taylor expansion. Topics to be Discussed: 1. Unscented Transform 2. Smoothing 3. Need for a Multiple Model approach with Markovian switching 4. Filter approach for multiple models 5. Possible Models 3 Comments Filed under strategies ## Pricing & Regime (part 1) High frequency trading tends to fall into the following categories: 1. some form of prop market making (probably largest %) 2. gaming other players or microstructure 3. short-period arbitrage 4. execution algos One might also run medium frequency strategies that pursue: 1. trend (if there is sufficient momentum) 2. cycles (follow the pivots for high amplitude price cycles) 3. longer-period arbitrage Focusing on market making and trend/cycle following, understanding price regime (the gross characteristics of price movement) and pricing function (a view on expected forward price) is important. Regime We might like to have an indication of regime to determine whether we should be market making, following a trend, following cycles, etc. In particular, with market making, there will be periods in the market where market making is “dangerous” (i.e. is almost guaranteed to lose money). Aside from the obvious danger in gapping prices around news or other events, the main danger is in offering during periods of strong momentum. There will be a strong order selection bias such that when the market is going up (down) you receive buying (selling) orderflow almost exclusively, and end up with short inventory against an appreciating (depreciating) price. Hence, there will be periods during a trading day that are “good” for market making (i.e. when there is balanced order flow and very gradual price drift) and periods which are better suited for momentum or high-amplitude cycle following strategies. Pricing Pricing provides us with an expected mean and its derivatives over some forward period, as well as an estimate of noise and MR activity. This information is invaluable in determining appropriate market making offering prices and in following high amplitude price activity. Goals We would like to have the following: 1. A pricing function with (often) good accuracy over some forward period, tailored to the requirements of the regime 2. A notion of price regime 3. Other metrics such as upper and lower noise around the price function (mean), period and amplitudes of monotonic segments, etc. In the context of market making we are looking to have a monotonic and almost linear price function that represents a mean or a mode through price noise. Calibrated in this fashion one has a convenient view on the forward price function and the upper and lower bounds on prices we are willing to offer on. This combined with inventory can be used to dynamically bias the offerings. In the context of momentum or cycling we are looking for a pricing function that follows the momentum or cycles with appropriate curvature and is reasonably predictive (or retrospective with low-lag) with respect to pivot points. Example Here is an example of a pricing function (the green line) during a momentum period (over the course of some hours), encountering a disturbance and change in regime to a cycling mode thereafter: Here is the continuation within the series with the pricing function in a momentum / cycling mode: Note that the above is smoothed a-posteri, so the trajectory of the filter has more noise as it progresses tick to tick. History Of Approaches I’ve used many approaches in the past in modeling the price function: 1. variety of filters from the signal processing space 2. signal decompositions and partial reconstitutions 3. a number of different stochastic state systems with an EKF (extended kalman filter) 4. direct calibration of least squares splines with various heuristic rules My current approach is the #4, but would like to find a good solution using a SDE in a bayesian framework, as is more elegant and flexible. My past experience with EKFs was that they are hard to parameterize (via the state and measurement covariances) and can easily become unstable in the presence of unexpected noise. A few months ago Max Dama posted a link to a paper describing a TV-VAR model, but more of interest, an alternate approach to describing the kalman filter evolution rate with discount factors. The discounting approach solves one of the problems in parameterizing Kalman filters. That and in discussion with some other quants (hi Sasha) recently motivated me to reexamine the SDE approach. I’ll be discussing an approach in some detail in the next posts. 3 Comments Filed under strategies ## Detecting Price Direction in Order Flow As indicated in a previous post, high-freq market data is typically in the form of order updates, for example: This can be used to reconstruct the orderbook at any given instant, but can also be used to analyze movements within the orderbook. The most primitive approaches look at the incidence of size being removed or hitting a given price-level. More sophisticated approaches try to determine order streams to see where an order is being moved to in the book. Given that we can produce a variety of measures that can add information to our trading decisions. Here is an example of a USD/JPY on a downward move of 10 pips with strong momentum. The mid price is in the upper pane and the cumulative bid and ask movements (derived from order data) are in the lower pane: One will note that the ask flows are more aggressive than the bid flows. The above is not yet terribly useful, as the cumulative flows look to follow the price path more or less during a period of momentum. Momentum More interesting is to look at what is happening in the book: The reds represent areas of high cancellation and blues high insertion (I amplify this by scaling by the size of movement from one region to another). You’ll notice the following: 1. Seller Book There is high movement into the inside (or more aggressive) areas of the book, in-line with the fact that the price has downward momentum. There are vertically “trailing” deletions from the outside price levels as traders move their prices en-mass to the inside. 2. Buyer Book Buyers / market makers are risk adverse and are moving their orders deeper into the book away from the inside. Again we see a trail of deletions in the inside-most levels and strong movements in a couple of deeper bands. Sideways Movement What does “sideways” or non-directional movement look like then? It looks a lot more random, with some upward and downward directional patterns in sequence. Cleaning It Up The activity can be denoised to produce a signal that is much easier to read: Summary The approach is particularly useful for understanding movements over a short to medium timeframe. However long-running price movements often have periods of “indecision” where the flow and price flounders for a period. Ultimately this sort of approach needs to be evaluated on multiple windows to accomodate various timeframes. (sorry this is mostly pretty pictures without much explanation. Should provide some ideas though). 12 Comments Filed under strategies ## Ponzi-Like Bidding Scheme Just for fun: There is a retail bidding site QuiBids which has received a bit of press in the US recently. The attraction is that they offer products (such as ipads) for, say, an average price of$30-50 (whatever the highest bid is).    One may wonder how this works.

Most auctions are “penny auctions”, meaning that each bid placed on an item increments the price by $0.01. Prospective buyers pay for each bid they put forward on an item. In fact, the company charges$0.60 / bid.   So with an end-auction price of, say, $50, the ipad has brought in$3000, because there were 5000 bids to achieve that price.  Wow, these guys are making a lot of money in terms of % markup!

The bidding session gets prolonged by ~10 seconds each time a bid is made in the last seconds.   Basically, it seems to me that the winner is the person in the pool of bidders that has not exhausted his prepaid bids or otherwise given up.

Since one can see the bidder with the top bid in real-time as the end-game bidding occurs, perhaps one could game it, observing the timeseries of bids each participant has placed and come up with a view on likelihood of having reached their bidding limit.   At that point one would start testing by putting in a bid and determine who is left.

If the gaming commission understood what they are doing here, suspect they would have to get a gambling license.    Interesting “not-quite-a-scam” business concept.   I have to think that eventually most participants, not having won anything will discontinue with the site.

2 Comments

Filed under strategies

## Bipartite Matching

For very low-level order analysis we try to determine continuity from one order to the next as a stream of orders across a period.   This is applicable for orders generated by a given trader (algo) that are more-or-less continually in the market.

In most cases an order near the top of book has a short lifetime, but an algo will maintain continuity through resubmission into the order book at a different price level.   This stream of orders is often masked in various ways, but often has discernable patterns, depending on the sophistication or consideration towards masking this in the algo.

Going from order deletions to new order insertions we want to attempt to match up the old and new orders (where applicable), to determine the continuity of an order stream.   We therefore want to map from an old-set to a new-set:

However, in order to determine, we have to explore all possible mappings with weights between these edges:

The optimal mapping will be one that finds the set of one-to-one edges that has maximal weight.   This is a problem in graph theory and optimisation theory.   This can be expressed rather neatly as a linear constraints problem where we have:

Where Xij is a matrix of 0 or 1, 1 indicating an edge and 0 no edge.  Wij is a corresponding matrix of weights for each edge.   Integer (or integral) linear programming solutions are classified as NP-hard and do not have an efficient algorithm.    We will be evaluating these on a relatively small # of orders each time, so the cost of a brute force solution is not bad.

The real trick is in determining the weights, representing the degree of similarity.  Going further, one may generate a tree of these (that spans out exponentially, but is trimmed regularly).   Some decisions on prior matches will be wrong and should be reevaluated holistically.

Is it worth the effort?   Depends on what information you are interested in and what your game is.   We do a mixture range ultra-high frequency to medium frequency.   This is one sub-problem of a bigger picture.

### Addendum

I should mention that the worst case brute-force approach involves examining combined weights for each permutation of edges.  This is a O(n!) algorithm that quickly becomes uncomputable.   For the specific bipartite matching problem, rather than the general Integral Linear Programming problem there are much more efficient solutions.   One of the simplest (though not the most efficient) is the “Hungarian algorithm“.   A reader pointed out a paper for an “online” approach to matching as well.

6 Comments

Filed under strategies