Betting Exchange Research Blog

On probability of winning a tennis match

2012-02-04T01:29:00.000-08:00

I present end to end solution for predicting a winner of ATP tennis match from names of both tennis players, surface and match type. I start with presenting requirements for tennis predictions, then I discuss mathematical model applied for predicting a winner of tennis match, followed by software design and implementation of prediction application. Validating accuracy of tennis prediction models formulates a topic of my future work on tennis markets.

The product of my efforts presented here is a software library written in Scala programming language, which calculates probability of winning a tennis match. This library is open sourced and it is publicly available on GitHub. If you want to play with it, I recommended starting with unit tests, which should make it a little more clear how to use it.

Requirements

Tennis prediction application is intended for supporting trading decisions on a Betfair betting exchange markets.

User story:

As a trader,
I want to calculate probability of winning a tennis match,
so that I can support my trading decisions.

Input:

Full names of tennis players, e.g. Roger Federer and Milos Raonic. ATP players only.
Court surface - CLAY, GRASS, HARD.
Match type - THREE_SET_MATCH, FIVE_SET_MATCH.
Prediction year - For calculating tennis probability for the current day, specify the current year (2012). To obtain tennis probability at the end of the past year, specify a year from the past, e.g. 2011. In the future, trader would like to specify a full date for prediction, either from the past, e.g. 2 year ago, or from the future, e.g. in 6 months.

Output:

Probability of winning a tennis match for the first specified tennis player - It is a number between 0 and 1 (probability). Probability of winning a tennis match by the second player is 1-probability.

Error should be reported if probability cannot be calculated. For example, if a player is not recorded on http://www.atpworldtour.com/ website.

In the future, trader may want to know what is the confidence level of winning probability. Consider two games for the same player P1 against players P2 and P3. The probability of winning the game by player P1 against players P2 and P3 may be the same value of 0.4. But it may happen that the player P3 hasn't played any tennis match for last 3 months, which potentially could make us less confident about prediction for a game including this player. Trader would like to know about it. In other words, the probability of winning a game should be defined by two numbers, probability and a confidence level, possibly as a http://en.wikipedia.org/wiki/Normal_distribution.

Tennis prediction model

I considered a few different prediction methods for calculating probability of winning a tennis match, which could be classified into three categories:

Predicting tennis outcome from probabilities of winning a point on serve and serve return by both players. Modelling a tennis game as a finite markov chain.

Neural networks. Predicting market outcome from tennis player statistics including percentage of first serve, winning percentage on the first serve return and few others.

Somboonphokkaphan - 2009 - Tennis Winner Prediction based on Time-Series History with Neural Modeling

Official ATP ratings and logistic regression.

I rejected prediction methods based on ATP ratings and logistic regression, which predict match winner from historical match outcomes, not taking into account probabilities of winning a tennis point. I believe the more data the better - there are far more points than matches played in tennis. Nonetheless, I still can see a value in applying logistic regression on top of probabilistic model. For instance, probabilistic model might be used for generating ratings for tennis players, which could be fit with logistic regression into tennis probability function.

From both neural network and markov chain methods I prefer the latter, because it allows for modelling probability of winning a tennis match with two numbers: probability and uncertainty level, modeled as 'mean' and standard deviation respectively (http://en.wikipedia.org/wiki/Normal_distribution). This lets to differentiate between two players with similar probability of winning a point but with different uncertainty levels, which could be interpreted as player's consistency in a game.

Eventually, I selected markov chain model, which calculates tennis match winner from probabilities of winning a point on serve and return by both players. Probability of winning a point is calculated from player statistics such as probability of first serve, probability of winning a point on first and second serve and probability of first and second serve return. Then probabilities of winning a game, set, tiebreak and match are calculated. My implementation of this prediction model is based on those two research papers:

Accuracy of this model depends on two factors. First, probability of winning a point on serve by both players must be precise. Every precision error at this level propagates down through probabilities of winning a tennis game, set and match.

Second, the algorithm for calculating game, set and match probabilities, which is based on markov chain, makes assumption that points in tennis match are independently and identically distributed. In other words, whether the probability of winning every point on serve by a player in a tennis match is constant or maybe it depends on a current score or who won last couple of points. Klassen and Magnum show in their paper (Klaassen, Magnus - 2001 - Are Points in Tennis Independent and Identically distributed Evidence From a Dynamic Binary Panel Data Model), that points are not independent and identically distributed, however deviations are small and making this idd assumption should be fine in many use cases. How making this assumption impacts trader's needs for precise tennis predictions, I don't know yet.

I'm not expecting this model to be very accurate, at least in its generic form, where probability of winning a point is derived purely from percentages of points won on serve and return by both players and by 'average player'. I implemented it to get some reference point I can compare other models with. I'm planning to discount most recent tennis matches less and I also want to compare it with Bradley-Terry, Elo, Glicko and TrueSkill models.

Design and implementation

There are three dedicated components contributing to functionality of comparing ATP tennis players: tennis-trader-compare, atpworldtour-api and tennis-probability-calculator.

Component diagram for comparing ATP tennis players

The tennis-trader-compare component provides a high level interface for predicting outcome of tennis match. Interface definition.

The atpworldtour-api is an adapter for http://www.atpworldtour.com/ tennis statistics, which are used for calculating probability of winning a tennis point. Interface definition.

Tennis-probability-calculator contains functions for calculating probability of winning a point, gem, set, tie break and tennis match. Interface definition.

Flow of control

Sequence diagram for comparing ATP tennis players

Trader calls tennis-trader-compare with player full names, surface, match type and prediction year and receives probability of winning a tennis match.
Tennis-trader-compare component obtains ATP match facts from atpworldtour-api component, e.g. frst serve %,1st serve point won %, 2nd serve point won %.
Tennis-trader-compare calls tennis-probability-calculator to calculate probability of winning a point and tennis match by both players.

Resources

This list below contains additional research papers, which I collected for a purpose of my work described in this blog post.

Neural Networks and Genetic Algorithm in trading on a Betting Exchange

2012-01-11T22:23:00.000-08:00

This is a report on learning neural networks for trading on betting exchange horse racing markets.

Neural Network [1] was learned using Market Simulator [2] with data collected for a period of 3 months between January and April 2011 for Horse Racing GB win only markets, which allows for replaying betting exchange market on a betting exchange and evaluating trading decisions.

Example of collected market data:

{"time":1282481934744,"eventType":"CREATE_MARKET","marketId":101655582,"marketName":"7f Mdn Stks","eventName":"/GB/Folk 22nd Aug","numOfWinners":1,"marketTime":"2010-08-22 14:10:00","runners": [{"runnerId":4848193,"runnerName":"Dubawi Gulf"},{"runnerId":4818333,"runnerName":"Apace"},{"runnerId":4932434,"runnerName":"Menha"},{"runnerId":4932435,"runnerName":"Flying Arch"},{"runnerId":4883524,"runnerName":"Hello Tomorrow"},{"runnerId":4932436,"runnerName":"Mazagee"}]}
{"time":1282481934744,"eventType":"PLACE_BET","betSize":38.0,"betPrice":5.9,"betType":"LAY","marketId":101655582,"runnerId":4818333}
...
{"time":1282482515736,"eventType":"PLACE_BET","betSize":314.0,"betPrice":1.61,"betType":"BACK","marketId":101655582,"runnerId":4848193}
{"time":1282482515736,"eventType":"CANCEL_BETS","betsSize":5.0,"betPrice":18.0,"betType":"LAY","marketId":101655582,"runnerId":4932435}
{"time":1282482515736,"eventType":"PLACE_BET","betSize":17.0,"betPrice":20.0,"betType":"LAY","marketId":101655582,"runnerId":4932435}

Collected data included market prices, traded volume, volume of unmatched bets by price, current risk position, but no knowledge from historical market data was taken into account such as how good a given horse is comparing to other horses in a race. The output of neural network was either trading action to be taken in a current state, e.g. place bet, cancel bet, or indicator whether a given action, e.g. place bet ( (specified as an input to neural network), is good or not decision.

Neural Network wasn't learned from examples, as those didn't exists on how to trade in HR markets, but rather than that, it was optimized with genetic algorithm [3] and simulated annealing [4]. This type of learning neural networks could be perceived as an example of reinforcement learning [5] in an environment, in which we don't know how to act to achieve the goal, e.g. what trading decisions should be taken, but we know when we reach the goal, in this case it is positive expected profit [6] from trading on a betting exchange markets.

The best instance of learned neural network gives a positive profit per market by average of 5£ including 5% winning commission from trading on HR betting exchange markets. But it also involves a big number of betting transactions, which causes additional transaction fees and takes overall profit per market from 5£ down to 2£. Adding additional costs around setting up hardware, technology and maintenance, limits the usage of presented trading technique to a research activity only. Involving a knowledge gained from historical data potentially could take this technique from a lab project to production ready system.

Neural network structure

Structure 1:

Input neurons - Runner prices, traded volume, unmatched volume, derivatives of price and traded volume, risk position.
Hidden layer - Single hidden layer.
Output neurons - Actions to be taken, e.g. 3 neurons: A (place back bet), B (place lay bet), C(place hedge bet).
Activation function - Hyperbolic tangent. If output neuron value is higher than 0 then action is taken.

Structure 2:

Input neurons - Runner prices, traded volume, unmatched volume , derivatives of price and traded volume, risk position, a proposal for a single action to be taken, e.g. place back bet.
Hidden layer - Single hidden layer.
Output neuron - Single neuron indicating how good action specified by an input layer is. Before taking any action, all possible actions are evaluated with neural network and the best one is executed.

The latter neural network produces good results (positive profit) faster than the former one, due to a smaller number of weights inside the neural network to be learned.

Learning process

First, neural network is initialized with an initial set of random weights, then market simulation is executed evaluating trading quality (market expected profit) of an agent over 100-300 markets. The overall expected profit from all markets is a quality value of a neural network. In the next step, neural network weights are updated applying evolutionary algorithm or simulated annealing and simulation process is repeated. A single learning iteration takes about 1 minute and the whole process took weeks till neural network was trained for giving positive profit. Learning was conducted on Intel Core i7 2.8GHz 8 Cores PC.

The best learning results were achieved by applying co-evolution version of learning described above, where a number of traders have to fight each other on a betting exchange markets. With this approach weights of best traders are crossed each other by applying genetic algorithm.

What's next?

In the next step I plan to take advantage of a knowledge from historical market data while learning and then executing trading agents. I'm looking at adopting probability theory, Bayesian networks [7], logistic regression [8] and other techniques suitable for analysing huge amount of historical market data.

Notes

A number of trading examples examined for a purpose of this research work are available here:
http://code.google.com/p/betting-ai/source/browse/#svn%2Ftrunk%2Ftrader-examples

All software for a purpose of this project is written in a Scala programming language.

References

Neural Network - http://en.wikipedia.org/wiki/Neural_network
Market Simulator - http://blog.danmachine.com/2010/08/horse-racing-market-simulation.html
Genetic algorithm - http://en.wikipedia.org/wiki/Genetic_algorithm
Simulated annealing - http://en.wikipedia.org/wiki/Simulated_annealing
Reinforcement learning - http://en.wikipedia.org/wiki/Reinforcement_learning
Expected value - http://en.wikipedia.org/wiki/Expected_value
Bayesian networks - http://en.wikipedia.org/wiki/Bayesian_networks
Logistic regression - http://en.wikipedia.org/wiki/Logistic_regression

Real-time trading on a betting exchange with virtual money

2011-07-29T16:17:00.000-07:00

Last year I created market data collector and market simulator, then I started analyzing betting exchange markets. Now I developed a computer system which allows for examining markets on a betting exchange real-time using virtual money. As opposed to my historical analysis, which was mostly automated AI aided process, real-time analysis is a purely manual activity.

Figure 1 Design for real time analysis of betting exchange markets.

First I developed betting exchange and I deployed it to Amazon Cloud, it is available at http://betex.danmachine.com. Then I fed this betting exchange with horse racing real-time market data coming from Betfair betting exchange, so that I could place bets on those markets using virtual money.

After that I created Google gadgets for displaying real time charts for win and place markets and to be able to place bets on a betting exchange.

Figure 2 Google dashboard including real time charts for win and place markets and bet placement widget.

Having that, I'm able to observe betting exchange markets real-time and place bets not risking real money.

The key software development technologies I applied are Scala for back-end and Javascript for front-end.

References

Betting Exchange Engine - http://code.google.com/p/betting-exchange/
Betting Exchange Server - http://code.google.com/p/betting-exchange-app/
Betting Exchange Feeder - http://code.google.com/p/betting-exchange-feeder/
Market Data Collector - http://code.google.com/p/betting-exchange-event-collector/
Betting Google Gadgets - http://code.google.com/p/betting-exchange-google-gadget/

Stochastic optimisation in analysing efficiency of betting exchange markets

2011-03-18T10:54:00.000-07:00

Currently, my research is centred around investigating semi-strong form efficiency [1] in betting exchange markets. Semi strong efficient market hypothesis says that all publicly available information about the market is reflected in the current market prices. In other words, this hypothesis claims that it is not possible to make a positive profit from a long term betting, having access to all publicly available information, including historical prices trends, traded volume, news from magazines and newspapers, scored goals and red cards in football markets, number of aces in tennis markets, and so on.

Sometime ago, I reached a point at which my studying of betting exchange markets became complex and time consuming, consequently I decided to introduce stochastic optimisation [2] to boost performance of my research. I present, how I was analysing betting exchange markets before and after applying stochastic optimisation.

Analysing betting exchange markets without adopting stochastic optimisation

Collect event driven market data - Market data is collected in a form of market events, e.g. PLACE_BET, CANCEL_BET [3], which is used later for replaying markets with market simulator and betting exchange engine [4]. At the moment I'm collecting data for horse racing markets 10 minutes before in-play time, but in the future I will probably extend the scope of my research to cover in play football and tennis markets as well.

Design trading strategy - For example, to examine a hypothesis,which says that exchange price movements are correlated with traded volume, I design a trading strategy, which represents this claim. If this trading strategy gives a long term profit, then I could argue that market is inefficient with respect to correlation between price and traded volume.

Evaluate trading strategy with market simulator and collected market data - Testing trading strategy on a historical data. At the moment I use data sets of 500 horse racing win markets, 10 minutes before in play time. In the world of financial markets, this phase refers to back testing [5].

Is trading strategy profitable? - If trading strategy is profitable I claim that market is inefficient and I proceed to prove it by running trading strategy on a real betting exchange markets [6][7]. Otherwise I repeat research process from designing new trading strategy.

A single research iteration, starting with defining market efficiency hypothesis, then designing trading strategy and evaluating it on market simulator takes a lot of time. It's quite clear that some optimisation process would be helpful to speed up this research process.

Analysing betting exchange markets with adopting stochastic optimisation

This version of a process for analysing betting exchange markets introduces one additional step, which is responsible for improving trading strategy applying stochastic algorithms. Consider a trading strategy which places a bet using simple if-else rule:

if(runner.price > betPrice) placeBackBet else placeLayBet.

In this example, stochastic optimisation is looking for the value of the betPrice parameter, for which trading strategy gives the highest possible profit. In reality, trading strategies are parametrised with multiple factors, which makes it much harder and time consuming to search for the best solution in a multi dimensional space. At the moment I use 'co-evolution gradient ascent with random restarts' algorithm, which is described in Essentials of Meta-heuristics book [8]. Still, there are other types of optimisation in my scope of interest, including other evolution algorithms and genetic programming.

I use two separate market data sets for stochastic optimisation and evaluating optimised trading strategy with market simulator. Both sets contain about 500 markets each.

For more information on how I use stochastic optimisation in practice please look at the following unit tests in Scala:

Optimising single dimension trading strategy - http://code.google.com/p/betting-ai/source/browse/tags/betting-ai-1.3/trading-optimiser/src/test/scala/dk/bettingai/tradingoptimiser/CoevolutionHillClimbingTest.scala
Optimising multi dimensional trading strategy - http://code.google.com/p/betting-ai/source/browse/tags/betting-ai-1.3/trader-examples/src/test/scala/dk/bettingai/trader/pricepriceslope/PricePriceSlopeTraderRandomTest.scala

References

Semi-strong form efficiency - http://en.wikipedia.org/wiki/Efficient-market_hypothesis
Stochastic optimisation - http://en.wikipedia.org/wiki/Stochastic_optimization
Design of event driven market data collector - http://blog.danmachine.com/2010/07/bettingai-market-data-collector-design.html
Replaying horse racing markets with market simulator - http://blog.danmachine.com/2010/08/horse-racing-market-simulation.html
Trading on a Betfair Betting Exchange with Apache SCXML- http://blog.danmachine.com/2009/04/trading-at-betfair-betting-exchange.html
Back testing - http://en.wikipedia.org/wiki/Backtesting
Automated betting with BetFair, Business Intelligence and Eclipse BIRT - http://blog.danmachine.com/2009/03/automated-betting-with-betfair-business.html
Essentials of metaheuristics - http://www.goodreads.com/book/show/9734814-essentials-of-metaheuristics

Moving from Java to Scala - One year later...

2011-01-22T16:49:00.000-08:00

One year ago I posted on moving from Java to Scala [1]. At that time my experience with Scala was limited to reading some technical materials and to implementing a few simple mathematical algorithms such as weighed average. Even though I hadn't developed any project in Scala yet, I had a good feeling that moving from Java to Scala could be similarly right decision as moving from C/C++ to Java 10 years ago. Having only a good feeling usually is not enough to adopt a new programming language in a commercial project but it is certainly sufficient to use it for a research open source project. Because I was just about to start a new research project to develop artificial intelligence aided trading simulator [2], I decided to choose Scala programming language instead of a well known and commercially proven Java. Now, one year later, after writing 8622 lines of code in Scala [3], reading Programming in Scala book [4] and attending Martin Odersky's Scala course [5], I believe I'm in a good position to review my original statement on moving from Java to Scala. Was it a good decision or I made a mistake? I will try to answer this question in a context of research open source project as well as I will make an attempt to apply my observations to enterprise and commercial environment.

Evaluation methodology

Reading this Scala evaluation please put a bit of attention to what is it about and what it is not. For sure, I'm not trying to examine Scala just by looking only at its design, syntax and other language capabilities. Instead of that, I'm aiming to answer the questions raised in the introduction above. Was it a good decision or I made a mistake adopting Scala? Is Scala ready for Enterprise project or not yet? To answer those questions, in addition to evaluating Scala itself, a few other factors have to be considered:

Programming language - Here, I evaluate features of Scala programming language, its paradigm, design and so on. In other words, all parts and aspects of Scala that were important for me developing trader simulator.

Testing - How do we test Scala code?

Performance - How fast Scala programs are?

Tools - Doing any serious software development and not using some useful tools is hardly possible. The most worth to look at are: Integrated Development Environment, build tool, continuous integration, code coverage, static code analysis, memory and cpu profiler.

Language extensions - Powerful and robust programming language doesn't guarantee any success yet. Third party tools, libraries and frameworks, that come from both open source community and commercial vendors, are very important as well.

Interoperability - Interoperability with other programming languages by no means is a must requirement in developing some kinds of computer systems, especially with the most popular ones such as Java and C/C++.

Monitoring and maintenance - In enterprise, assuring high availability at the level 99.99 and higher is a fundamental thing and requires wide range of tools for production monitoring and analysis.

Support - Adapting new technology, particularly programming language, always involves some risk. Active world wide community, availability of trainings, forum, mailing list is very important. Additionally, well established global commercial company that stays behind programming language makes us to believe that we won't stay alone in the future.

Scala skills - Even the most powerful weapon won't win the battle if you don't have a well skilled army that is able to use it.

Time to Market - Eventually, whether or not it is worth to use a particular technology is a business decision that is based on some short and long term financial indicators. Though, we do software for money and having a fun may be just a nice side effect of that.

One more aspect that has to be taken into account for completeness of this evaluation is a business domain to which programming language is applied to. In this case it is risk management, data collection, market simulation and trading on betting exchange [6] markets.

There is not much point evaluating any programming language and not taking business domain into account. There are many programming languages in the world and some may fit one business domain whereas others master somewhere else. For instance Erlang fit well telecom, C is great for developing embedded systems, dynamic languages such as Ruby or Groovy are useful for developing web applications and Java fit well everywhere as a general purpose language. Scala has some better and worse appliances as well.

To evaluate Scala programming language in a context of all categories and business domain mentioned above, I will examine all of them one by one applying the following point system:

1 - poor, 2 - fair, 3 - good, 4 - very good, 5 - excellent

Finally I will make an attempt to interpret those scores and to come up with some relevant conclusions.

Evaluation

Over last year, developing trading simulator I was taking some notes on many aspects of adopting Scala programming language in a light of all evaluation categories presented above. I share with you all my thoughts and observation I made on Scala and I hope you will find them useful when taking your own decision on adopting Scala for some of your projects.

Programming language

The trading simulator, that I decided to use Scala for, can be characterized as a complex algorithmic system that each line of code matters rather than a CRUD (create, read, update, delete) application [7]. Writing most of the code requires a lot of thinking up front and looking at a written code should make it obvious what it does and how does it work. For many reasons Java doesn't fit here well, mostly due to following an imperative programming [8] paradigm and its verbose nature of a programming style. What I'm looking here for is a functional programming [9] and Scala is a place where I found it being simple and natural to use.

Before I carry on, please forgive me for presenting hardly any Scala code in this post. I do it on purpose, because my goal is not to show you how Scala syntax looks like and how to use it. For that, there are much better resources to go for, for instance great Programming in Scala book. In reverse, I prefer to focus on sharing with you my experience with Scala and then you can decide yourself whether or not it's worth to pursue it further.

Now, probably some people would question, why Scala and not other functional programming language such as Lisp [10] or Erlang [11]? Well, the main reason is that Scala code compiles to a byte code and runs on Java virtual machine, thus it is compatible with other Java applications. It is especially important if a majority of your code and libraries that you already use are coming from a Java world. The two libraries I was using myself for Trading Simulator project were Esper Complex Event Processing [12] and Jackson JSON parser [13]. I would probably stay with Java if I couldn't use them in Scala.

At this moment, others might ask why Scala and not let say Clojure [14] that is a functional programming language running on Java virtual machine as well? To answer this question we need to look at two features that distinguish both Scala and Clojure. First, Scala syntax is similar to Java, whereas Clojure is a Lisp dialect, that for me, a person who has been working mostly with Java for last 10 years, makes it far easier to use Scala than Clojure. Second, Scala is a statically typed language [15] and Clojure is a dynamic programming language [16]. Static typing is a core feature for me when developing critical and complex applications, First of all, debugging and maintaining statically typed code is easier and faster, secondly code written in a statically typed language is less error prone due to picking up some errors on a compile time and that is true regardless how good unit tests are.

There is one more important aspect of Scala that I'd like to mention to you. Scala is a multi-paradigm programming language, it means that it allows for mixing multiple programming styles such as object oriented, imperative and functional programming. Whether it's good or not, it is not a question that could be answered with a simple yes or no. Supporters would say that programmers can pick up the best of all styles depends on theirs needs. Others would argue that putting together some features found in many other programming languages can't work well, mostly by increasing complexity and making a programming language obscure.

If you ask myself on this topic, to some degree, I would agree with both positive and negative arguments above on multi-paradigm in Scala. On one hand, if Scala would be a pure functional language I wouldn't go for it. I like functional programming and I'm finding it very useful in many aspects of software development but I would lie if I said that imperative programming is a devil that we should all avoid. It's just not true and it's fair enough to look how popular Java nowadays is. One example of a computer system that imperative programming fits very well is a stateful high performance betting exchange engine that is a part of trading simulator I was developing over last year. Moreover, it fits there even better when mixed up with functional programming.

Regarding to a negative argument on a high complexity of Scala I have to admit that to a some level I agree with that. For instance please take a look at the one of the most commonly used method in a Scala version of a List class.

//Builds a new collection by applying a function to all elements of this list.
def map [B, That] (f: (A) ⇒ B)(implicit bf: CanBuildFrom[List[A], B, That]) : That

Is it obvious to you what it is for? Would a novice Scala programmer understand it? Well, probably not easily, but definitely such syntax could discourage many of developers. To be fair, I have to mention that in Scala 2.8 this method in a Scala doc is presented following much simpler syntax, but in overall, it may not change a quite bad initial impression.

def map [B] (f: (A) ⇒ B) : List[B]

Additionally, some complexity in Scala is dictated by assuring compatibility with Java. For example in Scala there is an Option class that can take two values, Some and None. It's a great replacement for null value in Java and all would be fine if null value wasn't available in Scala too. When I asked Martin Odersky why is that, he explained me it's mainly to be able to stay compatible with Java. I think it's a relatively low cost of that.

There are many other examples that I could bring up to demonstrate how potentially evil Scala could be but it doesn't make too much sense. The Scala code that for someone is obscure, for others could be a nice and neat form of solving some specific problems. Personally, in most cases I found Scala syntax simple and natural to use and my opinion has not been changed after spending one year developing quite advanced application in Scala.

Next positive aspect of Scala is its conciseness. We all know how Java verbose is and how many boiler code developers write everyday including constructors, getters, variable initialisation (type and generics), semicolons and many others. To illustrate that I present how a Person class is defined in both Java and Scala:

Java version:

public class Person {
  private final String firstName;
  private final String lastName;

  public Person(String firstName, String lastName) {
   this.firstName=firstName;
   this.secondName=secondName;
  }

  public String getFirstName() { return this.firstName; }
  public String getLastName() { return this.lastName; }

  //hashcode, equals and toString methods
}

Scala version:

case class Person(firstName:String, lastName: String)

If you think that I'm showing to you some marketing gadget similar to presentations on 'How to build a web based application in 5 minutes', I do assure you it is not the case. Over last year, I was discovering every month, more and more examples that were proving to me how useful concise syntax in Scala is.

There are a few other features in Scala that are worth some attention, I won't describe them in details but I encourage you to read about them yourself in a Programming in Scala book. Those features include, creating DSL (domain specific language) in Scala [17], pattern matching [18], tail recursion [19], type inference [20], implicit conversions, xml and json parsing and concurrent programming with Actors [21].

Until now, I wasn't too critical on Scala, does it mean that Scala is a perfect programming language? Unfortunately, every rose has its thorn and Scala has one as well. It's a poor backward compatibility in Scala. For example, I started developing trading simulator with Scala 2.7 and then I migrated to version 2.8. Even though I wrote no more than 3K lines of code I faced a few compilation errors and one failure of a functional unit test. One of areas widely affected by those changes in Scala is Collections API (see Scala 2.8 Release Notes [22]). Scala team and Martin Odersky himself are justifying all those significant changes by improving overall quality and design of Scala. That of course makes sense but sometimes I feel that this improvement process is happening to fast and some formal body similar to JCP (Java Community Process) [23] would help. That is especially important now, at the day when Scala is entering Enterprise world.

To summarise, how I'm describing Scala so far, it's a statically typed and multi-paradigm programming language that runs on Java virtual machine and provides Java like syntax with a few improvements. It sounds a bit familiar, doesn't it? Isn't it the old good Java with support of closures and some syntax improvements. If so, why I don't wait for some time until closures are supported in Java? Though I could live without closures for 10 years, so why I can't wait a bit more time? Actually this was one of the main questions I asked myself one year ago, before I started trading simulator. Then I asked the same question one year later to Martin Odersky and now I will try to answer this question to myself as well as to you dear readers in the end of this post.

My overall score to Scala programming language is very good (4).

Testing

Developers are provided with all they need to test Scala applications efficiently. To follow a Test Driven Development methodology [24], they can use popular in Java world Junit tool [25]. If someone is more keen on Behaviour Driven Development [26] then ScalaTest is a way to go [27]. I use both of them and they work very well. Especially, the second tool deserves some attention here, as it's a good example to illustrate one more powerful feature of Scala that I haven't presented to you yet. Please look at the following test written in a ScalaTest tool.

scenario("pop is invoked on a non-empty stack") {
  given("a non-empty stack")
  when("when pop is invoked on the stack")
  then("the most recently pushed element should be returned")
  and("the stack should have one less item than before")
}

What is interesting here that it's an absolutely correct Scala code. Its syntax is provided by a domain specific language, which is built on top of Scala. Can Java make it? probably not. To make it working in Java we would need to create a DSL on top of Groovy and then call it from Java, for instance Easyb testing tool [28] represents this approach. Though, it's a bit problematic as calling Java code from Groovy carries on some level of overhead and complexity due to integrating two different languages.

In my opinion, there are some business domains where ability to create domain specific languages in Scala is an extremely useful feature. The one example is a domain specific language for trading on financial markets.

My overall score to Scala testing is very good (4).

Performance

At first sight the performance in Scala is very good, comparable to Java, thus Scala code compiles to the same byte code as Java does and runs on the same Java virtual machine. Nevertheless, how fast Scala code is, may vary from case by case and usually it's up to the way how the code is written. This awareness how to write a high performance Scala code is especially important for Java developers who are not very experienced in both Scala and functional programming.

For instance poor knowledge of Collections API in Scala may lead developers to call often a size() method on a List class. Because this method is not an indexed sequence as it is in Java, therefore calling it is a very expensive operation as it has to traverse through all elements in a List to count all of them. The other example is to implement a function that multiplies all numbers in a List by 2 and then filter out all that are greater than 10. In Java, we would probably create a single loop that does this work but in Scala, following functional programming we could write:

list.map(e => e*2).filter(e => e>10)

Looks simple and in many cases that's the solution we would use but under the hood it's much more expensive algorithm that the iterative version in Java (more details). On the other hand, having a choice between imperative and functional programming, availability of tail-recursion and so on, we can achieve better performance in Scala than in Java by carefully choosing proper algorithms for particular tasks.

There is one important thing for me that I noticed myself after one year I spent with Scala. In Java, usually development can be characterized as 'write first then think' approach, in Scala it's in an opposite way 'think first then write'. In Java, most of code is constructed by combining some loops and variables together that in many cases is a routine work. Whereas in Scala, developer is much more encouraged to think first and then write. From my own experience, when applying 'think first then write' approach, the final result of software development work can be impressive.

Next thing that I learnt myself by adopting the 'think first then write' approach and gaining some good skills in functional programming is that I became a better developer, whichever programming language I use, either Scala, Java or something else.

Going back to a performance aspect in Scala, I would like to mention one improvement that was added to Scala version 2.8. It's a specialisation for auto boxing [29], which regarding to Iulian Dragos [30], creator of this feature, provides a performance improvement of a factor of 4 to 30. Iulian gave an interesting talk on this topic on December 2010 at Skills Matter in London. The pod cast is available here:

http://skillsmatter.com/podcast/scala/scala-performance-improvements-of-a-factor-of-4-to-30-boxing-and-specialization

My overall score to Scala performance is very good (4).

Tools

Until now, there are not too many development tools created specifically to serve Scala, but fortunately, thanks to compatibility with Java it doesn't look so bad.

For a build tool, I adopted maven [31], which with some help of maven-scala-plugin [32] works very well. Having that we use maven, there shouldn't be any problem to adopt some of popular Continuous Integration [33] tools such as Bamboo [34] or Ant Hill Pro [35]. Alternatively you could use SBT [36], simple build tool for Scala. You will find a pod cast on a Simple Build Tool here:

http://skillsmatter.com/podcast/scala/simple-build-tool.

As Integrated Development Environment I utilised Eclipse Scala IDE plugin [37]. When I started using this plug-in more than one year ago it was very unstable and it was crashing my Eclipse a couple times a day. It was so frustrating to a level that I nearly abandoned Scala. By good luck I've been keeping up and sometime later, Scala IDE plug-in was getting better and better. At the moment there are still some features barely supported such as re-factoring or debugging, nonetheless at least it is stable enough to not complain to much. I heard some good opinions on IntelliJ Scala plugin [38] but because I haven't used it myself I'm not able to give you more information.

For a purpose of a memory and CPU profiling I use Jprofiler [39] and Eclipse MAT (Memory Analyser Tool) [40]. Despite of being dedicated Java tools, they can be used for analysing Scala applications as well. Personally, I found some difficulties while using those tools with Scala, for example they won't let you to analyse parts of your application that use some Scala features that are not available in Java, for instance companion objects and closures. I wouldn't say that it will stop you from using those tools, just the user experience may not be so good as when analysing Java applications.

One family of tools that in my opinion at the moment are hardly usable in Scala are those, which do some sort of code analysis, for instance code coverage [41] and static code analysis [42]. Especially the code coverage tools are those, that I always use quite extensively. I tried to use Eclipse Emma plugin [43] to check ad-hoc a code coverage for a written Scala code and it just didn't work, blowing up with some errors. I have no evidence on other code coverage tools but even if they work somehow, the reports they generate may not be well tuned against Scala code.

Static code analysis tools are even less usable. I evaluated two popular Java tools, pmd [44] that operates on a source code level, and find bugs tool [45], which inspects Java byte code. Both of them report a big number of warnings and errors that are not relevant to a Scala code. That is not a surprise as those tools are optimized to run against Java code.

My overall score to Scala tools is fair(2).

Language extensions

Most of libraries and frameworks are available to Scala due to compatibility with Java, otherwise we wouldn't have to much choice. The two worth to mention native Scala extensions are Lift web framework [46] and Akka actors platform [47]. I have no much experience with Lift web framework so far, so I will leave you alone with it. In terms of Akka, it's a very interesting project lead by Jonas Bonér [48]. In a few words, it's a platform for developing event driven, distributed, scalable and fault tolerant systems adopting Actors concurrency model.

The majority of libraries and frameworks from a Java world, should be possible to use quite smoothly, which among other things, is thanks to implicit conversions [49] in Scala. For example, in Java to convert between two different implementations of a List we would need to call explicitly some custom code that populates an output list by iterating through all elements of an input list. In Scala we also need to write a such code, but the difference is that it is called behind the scene. Please consider the Scala code example below.

//Initialises java.util.ArrayList object with three integers and converts it implicitly to a Scala List.
val newList:List = Arrays.toList(1,2,3)

It is like extending generic language rules for type conversions such as those between numeric types and it really makes it far easier to use external libraries in Scala.

My overall score to Scala language extensions is good (3).

Interoperability

Interoperability between Scala and other programming languages, including Java/C/C++, is very good, mostly because of running on Java virtual machine. What Java may talk to, Scala can do as well. Taking into account support for implicit conversions described above, I would state that Scala is one of the leaders of interoperability among all programming languages.

My overall score to Scala interoperability is excellent (5).

Monitoring and maintenance

For me, the main monitoring tool to analyse production Scala applications is JMX (Java Management Extensions) [50], and again, this is with no surprise thanks to compatibility with JAVA. This tool does its job well when we want to analyse some predefined statistics, but sometimes we need to investigate some aspects of a production application while it's running and JMX can't provide all required data.

To deal with such scenarios, Java provides Java Virtual Machine Tool Interface (JVM TI) [51] that allows for inspecting running Java applications but it can be used for Scala too. Imagine, there is a method inside running Scala application that calculates and returns some data and we want to be informed every time when this method is invoked and what is the value it returns. We can do such things with a btrace [52], command line dynamic monitoring tool from open source world. Eventually if we prefer more sophisticated and powerful platform for monitoring production applications we could choose Dynatrace [53] commercial product. The first one works well with Scala, though not as good as with Java, because it's not a dedicated Scala tool. I haven't tried the second one with Scala but I expect it to work as well, thus it uses the same JVM TI interface as btrace does.

My overall score to Scala monitoring and maintenance is good (3).

Support

Scala community, including forum, mailing list and blogs, is not the biggest in the world, but it's very energetic. My feeling is that most people who are part of a Scala community are very passionate developers, which are always happy to help others to solve theirs problems. It was especially important for me on the beginning of my adventure with Scala.

Next important part of a Scala support are books and here I also found a great position. It's a Programming in Scala book by Marting Oderski, Lex Spoon and Bill Venners. There is big chance that I wouldn't pursue Scala if this book hadn't existed. I'm a such sort of person who usually start learning some new technology by reading some good book. If one doesn't exist, then probably this technology is not worth a penny (at least not yet).

One thing that would definitely help Scala to spread around the world is a global commercial vendor, such as Oracle or IBM. But even if no one ever exist it doesn't mean that Scala can't became a globally used programming language. Nobody should under estimate the power of an open source world wide community.

My overall score to Scala support is good (3).

Scala skills

Even though I don't posses any professional data on a number of Scala developers in the world, I think no one will argue that it is far behind other programming languages such as Java or C/C++. I performed two simple experiments to get some data for you. First I checked for Scala job trends [54] and the number of job offers for Scala developers is barely noticeable but is growing dynamically over last two years. Second I searched for Scala developers on the linkedin.com social site and I got 1709 results. Just to mentioned that querying for Java developers returned 249,589 entries. It doesn't look good, does it?

One positive aspect I found is that looking for Scala developers we could search for Java developers with Scala interests as well. The learning curve is not massive as Scala follows Java syntax. In such case, at least on experienced Scala developer would help the team adopting new programming language.

My overall score to Scala skills is poor (1).

Summary

To summarise Scala evaluation, this is a scores matrix for all categories (1 - poor, 2 - fair, 3 - good, 4 - very good, 5 - excellent).

Programming language - very good (4)
Testing - very good (4)
Performance - very good (4)
Tools - fair (2)
Language extensions - good (3)
Interoperability - excellent (5)
Monitoring and maintenance - good (3)
Support - good (3)
Scala skills - poor (1)

The best way to decide on some technology for some project is to ask about the time to market [55], however the problem arises when we stay in front of deciding on some new, not proved yet technology. In that cases, emerging technologies usually are on hiding to nothing, they can hardly win. But sometimes new technologies find a place on a market and I believe that Scala is one of them.

Scala already has beaten Java for developing my research projects and I have no temptation to move back. How about Scala in Enterprise? Here, I'm not so optimistic. Java is a really strong player and being just a better programming language may not be enough. What if Java finally provides functional programming and some better and more concise syntax? What if then Scala disappears from a market and we are in a half way through migrating our applications from Java to Scala? Will we move back to Java? Who will pay for that? Those are the questions that everyone must answer himself.

One advice I can give you myself is to not adapt Scala, just because someone says it's cool, so I want to be cool too. Something that works well in someone's business domain may not work for you. Be reasonable and try to get some experience with Scala first, for instance by getting involved in some open source projects.

Thank you for your attention and I hope you enjoyed it. I invite you to comment on this post and to share your thoughts with others. Daniel.

References

Post on moving from Java to Scala - http://blog.danmachine.com/2009/12/time-to-change-moving-from-java-to.html
Initial post on applying artificial intelligence to betting exchange research - http://blog.danmachine.com/2010/04/betting-ai-artificial-intelligence.html
Betting AI project sources - http://code.google.com/p/betting-ai/source/browse/#svn%2Ftrunk
Programming in Scala book by Marting Oderski, Lex Spoon and Bill Venners - http://www.goodreads.com/book/show/5680904-programming-in-scala
Scala course by Marting Odersky and Julain Dragos - http://skillsmatter.com/course/scala/object-oriented-meets-functional-an-exploration-of-scala
Betting exchange - http://en.wikipedia.org/wiki/Betting_exchange
CRUD - http://en.wikipedia.org/wiki/Create,_read,_update_and_delete
Imperative programming - http://en.wikipedia.org/wiki/Imperative_programming
Functional programming - http://en.wikipedia.org/wiki/Functional_programming
Lisp programming language - http://en.wikipedia.org/wiki/Lisp_(programming_language)
Erlang programming language- http://en.wikipedia.org/wiki/Erlang_(programming_language)
Esper Complex Event Processing tool - http://http://esper.codehaus.org/
Jackson high-performance JSON parser - http://jackson.codehaus.org/
Clojure programming language - http://clojure.org/
Static typing - http://en.wikipedia.org/wiki/Static_typing#Static_typing
Dynamic typing - http://en.wikipedia.org/wiki/Static_typing#Dynamic_typing
DSL (Domain Specific Language) - http://en.wikipedia.org/wiki/Domain-specific_language
Pattern matching - http://en.wikipedia.org/wiki/Pattern_matching
Tail recursion - http://en.wikipedia.org/wiki/Tail_recursion
Type inference - http://en.wikipedia.org/wiki/Type_inference
Actor model - http://en.wikipedia.org/wiki/Actor_model
Scala 2.8 Release Notes - http://www.scala-lang.org/node/7009
JCP (Java Community Process) - http://jcp.org
Test Driven Development - http://en.wikipedia.org/wiki/Test_driven_development
Junit Test Driven Development tool - http://junit.org/
BDD (Behavior Driven Development) - http://en.wikipedia.org/wiki/Behavior_driven_development
ScalaTest BDD tool - http://www.scalatest.org/getting_started_with_feature_spec
Easyb BDD tool - http://code.google.com/p/easyb/
Auto boxing - http://en.wikipedia.org/wiki/Object_type_(object-oriented_programming)#Autoboxing
Iulian Dragos - http://lamp.epfl.ch/~dragos/
Maven build tool - http://en.wikipedia.org/wiki/Apache_Maven
Maven-scala-plugin - http://scala-tools.org/mvnsites/maven-scala-plugin/
Continuous Integration - http://en.wikipedia.org/wiki/Continuous_integration
Bambo CI tool - http://www.atlassian.com/software/bamboo/
Ant Hill Pro CI tool - http://www.anthillpro.com/html/default.html
Simple Build Tool - http://code.google.com/p/simple-build-tool/
Eclipse Scala IDE - http://www.scala-ide.org/
IntelliJ Scala IDE - http://confluence.jetbrains.net/display/SCA/Getting+Started+with+IntelliJ+IDEA+Scala+Plugin
Jprofiler tool - http://www.ej-technologies.com/products/jprofiler/overview.html
Eclipse Memory Analyser Tool - http://www.eclipse.org/mat/
Code coverage - http://en.wikipedia.org/wiki/Code_coverage
Static code analysis - http://en.wikipedia.org/wiki/Static_code_analysis
Eclipse Emma code coverage plugin - http://www.eclemma.org/
PMD static code analysis tool - http://pmd.sourceforge.net/
Find bugs static code analysis tool - http://findbugs.sourceforge.net/factSheet.html
Lift web framework - http://liftweb.net/
Akka actors platform - http://akka.io/
Jonas Bonér home page - http://jonasboner.com/
Type conversion - http://en.wikipedia.org/wiki/Type_conversion
Java Management Extensions (JMX) - http://en.wikipedia.org/wiki/Java_Management_Extensions
Java Virtual Machine Tool Interface (JVM TI) - http://en.wikipedia.org/wiki/Java_Virtual_Machine_Tools_Interface
Btrace dynamic tracing tool - http://kenai.com/projects/btrace/pages/Home
Dynatrace monitoring production applications tool - http://www.dynatrace.com/en/
Job trends report on Scala jobs - http://www.indeed.com/jobtrends?q=scala&l=
Time to market - http://en.wikipedia.org/wiki/Time_to_market

Analysing Betting Exchange markets with Complex Event Processing, Esper and Scala

2010-11-25T05:04:00.000-08:00

Recently, I posted on analysing betting exchange markets with betting market simulator and time line charts (read more...) At that time, I demonstrated charts with runner price that don't present a significant analytical value, except of being a good example to introduce charting feature of betting market simulator. This day, I present how to analyse betting exchange markets with Esper complex event processing tool and Scala. This should be more useful in practice than studying simple metrics such as runner price or traded volume.

Complex event processing is a broad concept. I use it for analysing different types of market data such as price, probability, traded volume, risk metrics, etc. Complex event processing allows me to combine all those metrics altogether and prepare custom analysis quickly and with minimal programming effort. I found it useful in both real time event processing as well as in historical analyses. There are many complex event processing tools on the market, both commercial and open source. The one I use is Esper, an open source tool that makes complex event processing simple in Java programming language.

One of core features of Esper is an ability to create sliding windows and then, on top of that, to calculate some metrics such as avg, min, max or recognise patterns such as correlation between runner price and runner traded volume. Additionally, sliding windows may be used to calculate derivatives, which is an example that I will present in this post. Basically, I will demonstrate how to calculate first derivative of runner traded volume with respect to time and then how to calculate the second derivative. I'm finding those metrics useful to analyse correlation between market runner implied probability and traded volume for betting markets.

Below I present three charts for horse racing market during 10 minutes before market is turned in play. The first chart shows implied probability (1/runner price) for all market runners, for that, no complex event processing is required. The second chart presents the first derivative of traded volume with respect to time for all market runners, where as the last one displays the second derivative of runner traded volume.

To create a chart with implied probabilities for all market runners, we need to iterate through all market runners, then calculate runner implied probability and add it to chart values that will be used to generate time line chart after simulation with Market Simulator tool is finished:

-------------------------------------------------------------------------------------------------------------
// For all market runners add implied probability to time line chart
for(runnerId <- ctx.runners.map(_.runnerId)) {
//get best back and lay prices for market runner
  val bestPrices = ctx.getBestPrices(runnerId)

// calculate average price between best back and lay prices
  val avgPrice = PriceUtil.avgPrice(bestPrices._1.price -> bestPrices._2 .price)

//add average prices to chart values
  ctx.addChartValue(runnerId.toString, 1/avgPrice)
}
-------------------------------------------------------------------------------------------------------------

Scala class to calculate implied probability is here.

Figure 1 Implied probability for all market runners, y_axis - traded volume, x_axis - time

In order to display derivative of runner traded volume with respect to time we use the following formula:

y(v1,v0,t1,t0) = (v1 - v0) / (t1-t0) where

y - derivative of runner traded volume with respect to time
v1- runner traded volume at time t1
v0 - runner traded volume at time t0
t1 - time t1, in this example t1-t0 = 120sec
t0 - time t0

To calculate this function value for every second during last 10 minutes before horse racing market is turned in play, a sliding window is a way to go. Having a sliding window available for every second with a size of 120sec, we can obtain the first and the last values of traded volume in that window. The last value is a traded volume at time t1, whereas the first value is a traded volume at time t0, which is t1-120sec. All that to work requires just a bit of Esper declarative configuration.

First of all, we need to send a timestamped event to Esper engine with trader volume for a market runner:

-------------------------------------------------------------------------------------------------------------

//Create market event as a map with three attributes: runnerId, traded volume and timestamp
val event = Map("runnerId" -> runnerId,"tradedVolume" -> ctx.getRunnerTradedVolume(runnerId).totalTradedVolume,"timestamp"-> ctx.getEventTimestamp/1000)

//Send event to Esper
epService.getEPRuntime().sendEvent(event, "TradedVolumeEvent")
-------------------------------------------------------------------------------------------------------------

then we create a sql like query to calculate derivative value and register it with Esper engine. One thing worth to mention is the last part of this query 'group by runnerId'. Events have to be grouped by runner id, because events for many market runners are processed.

-------------------------------------------------------------------------------------------------------------
val expression = "select runnerId, (last(tradedVolume)-first(tradedVolume)) / (last(timestamp)-first(timestamp)) as delta from TradedVolumeEvent.win:time(120 sec) group by runnerId"

val statement = epService.getEPAdministrator().createEPL(expression)
-------------------------------------------------------------------------------------------------------------

The value of this query is calculated every time when new event is added to Esper engine, a simple listener updates time line chart with derivative value:

-------------------------------------------------------------------------------------------------------------
statement.addListener(new UpdateListener {
def update(newEvents: Array[EventBean], oldEvents: Array[EventBean] ) {
val delta = newEvents(0).get("runnerId"),newEvents(0).get("delta").asInstanceOf[Double]

ctx.addChartValue("tv" + delta)
}
})
-------------------------------------------------------------------------------------------------------------

Scala class to calculate derivative of traded volume is here.

Figure 2 Derivative of traded volume for all market runners with respect to time

Calculating the second derivative of runner traded volume requires two phases. First of all, the first derivative of traded volume is calculated and added to Esper engine as an event:

-------------------------------------------------------------------------------------------------------------

insert into TradedVolumeDeltaEvent select runnerId,timestamp,(last(tradedVolume)-first(tradedVolume))/(last(timestamp)-first(timestamp)) as tradedVolumeDelta from TradedVolumeEvent.win:time(120 sec) group by runnerId

-------------------------------------------------------------------------------------------------------------

Then the second derivative is calculated using sql like query:

-------------------------------------------------------------------------------------------------------------

select runnerId,(last(tradedVolumeDelta)-first(tradedVolumeDelta))/(last(timestamp)-first(timestamp)) as tradedVolumeDeltaPrim from TradedVolumeDeltaEvent.win:time(120 sec) group by runnerId

-------------------------------------------------------------------------------------------------------------

Scala class to calculate the second derivative of traded volume is here.

Figure 3 Second derivative of traded volume for all market runners with respect to time.

There are junit tests for all three scala classes that I'm referring to (here), so you can run them yourself if you want to play with examples on complex event processing that I presented in this post. Those junit tests generate the same html graphs as above into a target directory. Eventually please use maven command 'mvn clean install' inside http://code.google.com/p/betting-ai/source/browse/trunk/trader-examples/ to run all junit tests with one call.

References:

Complex Event Processing - http://en.wikipedia.org/wiki/Complex_event_processing
Esper - http://esper.codehaus.org/
Scala - http://www.scala-lang.org/
Betting Market Simulator - http://code.google.com/p/betting-ai/

Market analysis with time line charts

2010-10-22T05:12:00.000-07:00

In my last post I was writing about analysing trading strategies with a market simulator. This time I'd like to present a charts feature that makes it easier to analyse trading strategies. Before I start, a bit of information for those who read my blog for the first time.

The market simulator I'm referring to, allows for betfair market simulations that produce results very close to running trading strategies on real betfair markets. It's due to replaying market in a form of bet placement events on a real betting exchange engine.

Time line charts can present any data including standard metrics such as price, probability, traded volume, customer ifwin, customer expected liability, etc, as well as any transformation of those basic metrics, e.g. math functions such as derivativess, statistical, etc. I present below three chart examples. The first chart represents probability for all market runners during last 10 minutes before market is turned in play.

1. Probability for all market runners

Where as the second and third charts present market expected profit for two different trading strategies. As you can see, one of them generates profit, while the next one generates loss.

2. Market current expected for a market (profit)

3. Market current expected for a market (loss)

One more thing worth to mention is a great flexibility that makes it possible to presents aggregated metrics across both time and many markets. What metrics are presented is up to a trader implementation class. Consider the trader implementation below:

def execute(eventTimestamp:Long,ctx: ITraderContext)= {
if(bestPrices._2.price>2)
ctc.placeBet(2,bestPrices._2.price,BACK,runnerId)
ctx.addChartValues(ctx.risk.ifWin)
}

There is a method on a trader context named ctx.addChartValues(...), that adds timestamped metrics to be displayed on a chart after simulation is finished. Let say we want to present log(ifWin), then just call:

ctx.addChartValues(log(ctx.risk.ifWin))

References

Background, vision and high level design of the market simulator: http://blog.danmachine.com/2010/04/betting-ai-artificial-intelligence.html
Background, vision and high level design of the market data collector: http://blog.danmachine.com/2010/07/bettingai-market-data-collector-design.html
Project home page: http://code.google.com/p/betting-ai/

Horse racing market simulation

2010-08-27T05:14:00.000-07:00

At this point of time, the Betting AI provides both market data collector and market simulator tools. Market data collector provides history of a market on a betting exchange in a form of market events, where as market simulator allows for testing trading strategies based on a historical market data. After simulation is finished the following report is generated (simulation for one day on UK horse racing markets, 21 markets):

***********************************************************************************

*Project homepage: http://code.google.com/p/betting-ai/ *

*Licenced under Apache License 2.0(http://www.apache.org/licenses/LICENSE-2.0) *

***********************************************************************************

Simulation is started. Simulation progress: 0% 4% 9% 14% 19% 23% 28% 33% 38% 42% 47% 52% 57% 61% 66% 71% 76% 80% 85% 90% 95% 100%

Simulation is finished in 65907 milliseconds.

Expected profit report for trader dk.trader.Trader:

7f Mdn Stks: /GB/Folk 22nd Aug minProfit/prob=-92.58/0.63 maxProfit/prob=345.0/0.01 expProfit=9.05 expAggrProfit=9.05 mBets=128 uBets=7

2m6f Hcap Hrd: /GB/Newt 22nd Aug minProfit/prob=-173.4/0.14 maxProfit/prob=80.4/0.14 expProfit=1.84 expAggrProfit=10.89 mBets=23 uBets=4

1m6f Hcap: /GB/Muss 22nd Aug minProfit/prob=-1182.9/0.19 maxProfit/prob=522.0/0.06 expProfit=24.83 expAggrProfit=35.73 mBets=226 uBets=17

1m Hcap: /GB/Muss 22nd Aug minProfit/prob=-1036.8/0.27 maxProfit/prob=615.0/0.01 expProfit=-11.99 expAggrProfit=23.74 mBets=222 uBets=9

3m2f Hcap Chs: /GB/Newt 22nd Aug minProfit/prob=-968.55/0.21 maxProfit/prob=1153.65/0.18 expProfit=-25.4 expAggrProfit=-1.66 mBets=184 uBets=12

2m5f Nov Chs: /GB/Newt 22nd Aug minProfit/prob=-1812.6/0.24 maxProfit/prob=1659.15/0.33 expProfit=-105.13 expAggrProfit=-106.8 mBets=468 uBets=14

2m3f Nov Hrd: /GB/Newt 22nd Aug minProfit/prob=-729.3/0.16 maxProfit/prob=738.36/0.31 expProfit=-3.33 expAggrProfit=-110.13 mBets=178 uBets=10

5f Mdn: /GB/Folk 22nd Aug minProfit/prob=-932.6/0.29 maxProfit/prob=591.4/0.11 expProfit=-8.61 expAggrProfit=-118.74 mBets=233 uBets=12

1m Hcap: /GB/Muss 22nd Aug minProfit/prob=-1687.7/0.16 maxProfit/prob=1637.55/0.34 expProfit=46.21 expAggrProfit=-72.53 mBets=421 uBets=24

7f Sell Stks: /GB/Folk 22nd Aug minProfit/prob=-3.0/0.09 maxProfit/prob=7.65/0.28 expProfit=0.07 expAggrProfit=-72.46 mBets=3 uBets=5

5f Sell Stks: /GB/Muss 22nd Aug minProfit/prob=-1699.8/0.28 maxProfit/prob=1462.06/0.3 expProfit=-112.54 expAggrProfit=-185.0 mBets=384 uBets=11

2m6f Hcap Hrd: /GB/Newt 22nd Aug minProfit/prob=-1088.4/0.2 maxProfit/prob=454.8/0.08 expProfit=-8.51 expAggrProfit=-193.51 mBets=156 uBets=8

2m1f NHF: /GB/Newt 22nd Aug minProfit/prob=-1068.0/0.2 maxProfit/prob=1105.8/0.29 expProfit=38.09 expAggrProfit=-155.42 mBets=230 uBets=16

7f Mdn Stks: /GB/Muss 22nd Aug minProfit/prob=-822.6/0.45 maxProfit/prob=1197.9/0.1 expProfit=-26.43 expAggrProfit=-181.85 mBets=333 uBets=12

1m4f Hcap: /GB/Muss 22nd Aug minProfit/prob=-750.72/0.4 maxProfit/prob=561.0/0.03 expProfit=-13.69 expAggrProfit=-195.55 mBets=207 uBets=7

7f Hcap: /GB/Folk 22nd Aug minProfit/prob=-849.45/0.25 maxProfit/prob=471.0/0.07 expProfit=-20.03 expAggrProfit=-215.57 mBets=167 uBets=5

5f Hcap: /GB/Muss 22nd Aug minProfit/prob=-564.3/0.18 maxProfit/prob=219.0/0.04 expProfit=7.55 expAggrProfit=-208.02 mBets=102 uBets=5

6f Hcap: /GB/Folk 22nd Aug minProfit/prob=-1268.7/0.2 maxProfit/prob=1548.0/0.16 expProfit=35.25 expAggrProfit=-172.78 mBets=361 uBets=22

2m1f Mdn Hrd: /GB/Newt 22nd Aug minProfit/prob=-922.5/0.18 maxProfit/prob=684.15/0.23 expProfit=53.31 expAggrProfit=-119.47 mBets=280 uBets=18

1m1f Hcap: /GB/Folk 22nd Aug minProfit/prob=-875.91/0.32 maxProfit/prob=2577.9/0.16 expProfit=-19.39 expAggrProfit=-138.86 mBets=489 uBets=20

1m4f Hcap: /GB/Folk 22nd Aug minProfit/prob=-589.23/0.35 maxProfit/prob=1018.5/0.22 expProfit=-10.18 expAggrProfit=-149.05 mBets=249 uBets=11

------------------------------------------------------------------------------------

TotalExpectedProfit=-149.05 TotalMatchedBets=5044 TotalUnmachedBets=249

The list below presents a few market events for a horse racing market:

{"time":1282481934744,"eventType":"CREATE_MARKET","marketId":101655582,"marketName":"7f Mdn Stks","eventName":"/GB/Folk 22nd Aug","numOfWinners":1,"marketTime":"2010-08-22 14:10:00","runners": [{"runnerId":4848193,"runnerName":"Dubawi Gulf"},{"runnerId":4818333,"runnerName":"Apace"},{"runnerId":4932434,"runnerName":"Menha"},{"runnerId":4932435,"runnerName":"Flying Arch"},{"runnerId":4883524,"runnerName":"Hello Tomorrow"},{"runnerId":4932436,"runnerName":"Mazagee"}]}
{"time":1282481934744,"eventType":"PLACE_BET","betSize":38.0,"betPrice":5.9,"betType":"LAY","marketId":101655582,"runnerId":4818333}
...
{"time":1282482515736,"eventType":"PLACE_BET","betSize":314.0,"betPrice":1.61,"betType":"BACK","marketId":101655582,"runnerId":4848193}
{"time":1282482515736,"eventType":"CANCEL_BETS","betsSize":5.0,"betPrice":18.0,"betType":"LAY","marketId":101655582,"runnerId":4932435}
{"time":1282482515736,"eventType":"PLACE_BET","betSize":17.0,"betPrice":20.0,"betType":"LAY","marketId":101655582,"runnerId":4932435}

Example of trader implementation:

/**Executes trader implementation so it can analyse market on a betting exchange and take appropriate bet placement decisions.
*
* @param ctx Provides market data and market operations that can be used by trader to place bets on a betting exchange market
*/
def execute(ctx: ITraderContext) = {

for(runner <- ctx.runners) {
val bestPrices = ctx.getBestPrices(runner.runnerId)

if(bestPrices._1>2) {
ctx.placeBet(2,bestPrices._1,BACK,runner.runnerId)
ctx.placeBet(2,bestPrices._1 - 0.02,LAY,runner.runnerId)
}
if(bestPrices._2<2.2) {
ctx.placeBet(2,bestPrices._2,LAY,runner.runnerId)
ctx.placeBet(2,bestPrices._2 + 0.02,BACK,runner.runnerId)
}
}
}

Project home page
http://code.google.com/p/betting-ai/

The BettingAI - Market Data Collector Design

2010-07-07T04:45:00.000-07:00

Background

Trading analyst wants to analyse trading strategies using historical market data and the Market Simulator tool. For the purpose of that, a real market data for markets on the Betfair betting exchange has to be collected.

Vision

The vision is to create a standalone application that is collecting market data until it is terminated by a user. Collected market data is written to files on a file system (one file per market) in a format that is supported by the Market Simulator tool.

The following input parameters for the application are provided:

Betfair account credentials: user name, password and product id.
Time interval of the market data collection.

The market data should be collected for:

Horse racing win only markets.
The time period starting 10 minutes before market start time until market is turned in play.

Requirements

As a trading analyst.

I want to collect market data for markets on the Betfair betting exchange.

So that I can run market simulation and test trading strategy for a real market data.

Acceptance criteria:

Market data is collected in a format that is support by the MarketSimulator ver 1.0
Market data is stored in text files (one file per one market)
Market data is collected for all Horse Racing win only markets.
Market data is collected starting 10 minutes before market start time until it's turned in play.
Installation package supported by both Windows and Linux operating systems is provided.
Command line interface is provided with the following input parameters:

Betfair account credentials: user name, password and product id.
Time interval of the market data collection.

User interface

As a trading analyst I want to start market data collector from the command line interface as presented below:

MarketDataCollector bfUser=john bfPassword=bravo6 bfProductId=82 collectionInterval=1

user name, password and product id - Credentials for the Betfair account that is used for market data collection.
collectionInterval [seconds] - The time interval for the market data collection.

[BEGINNING OF THE OUTPUT]

Market data collection is started.

[THE END OF THE OUTPUT]

Component design

Market Data Collector Launcher - Parses input parameters and starts scheduler for Market Data Collector Task.

Market Data Collector Task - Gets market events for all monitored markets and stores them in files on a file system (one file per market).

Market Event Producer

First of all, get list of all monitored markets from the betfair api. Then for each market do the following:

Get market prices and total traded volume from the Betfair API.

Calculate market events that represent the delta between previous and current state of the market. If no previous market state is available then CREATE_MARKET event will be generated as the first on the list.

Add those market events to the Betex (Implementation of a betting exchange), then get market prices and total traded volume for the market and compare both data against market prices and total traded volume that was received from the Betfair API. The reason for that is to check if market events have been generated correctly. If both data don't match then exception should be thrown.

After all markets are processed, market events for all market are returned.

Market Event Calculator - Calculates market events that represent the delta between previous and current state of the market. If no previous market state is available then CREATE_MARKET event will be generated as the first event on the list.

Deployment design

Java VM - The Betting AI application is written in the Scala programming language that is running within the Java virtual machine.

Scala - The scala language distribution, contains scala libraries that are required to run scala applications.

Market Data Collection - Executables of the Market Data Collector, contains start script to run market data collection.

File system - Market Data Collector is storing collected market data on a files system (one file per market).

Betfair API WS - This is Betfair public API that is used to collect market data.

The Betting AI (Artificial intelligence) - domain model, components, deployment

2010-04-19T02:54:00.000-07:00

Previous part of the betting ai design.

Domain model

Betting Exchange - "...is a form of bookmaking in which the operator offsets its risk perfectly through technology, such that the effect to the customer is that customers are seen to bet between themselves..." - from Wikipedia.

Market - "...The market is where you place a bet on an event. Any given event, such as a soccer match, may have a number of different markets: for example, Match Odds, a Handicap and First Goalscorer markets. This is the place to view the odds and have a bet..." - from Betfair help.

market id - Unique market id.
market name - e.g. Match Odds or Place market
event name - e.g. Mat Utd vs Arsenal
market state - active/in play/settled
selection id - Unique selection id, e.g. 100 for Manchester United and 101 for Arsenal.
selection name - e.g. Arsenal

Bet - "...A ‘Back’ bet is a bet on something to happen – a horse to win a race, a football team to win, a person to be evicted from Big Brother etc. It’s just like the bet you’d regularly place with a traditional bookmaker or tote, or even with your mates..." - from Betfair help. "...Laying a bet means you are betting on something not to happen – a match not to end in a draw, a horse not to come in first, a rugby team not to win by over 7 pts etc..." - from Betfair help

bet price - Bet odds. Chances of winning written in a decimal format = 1/probability, e.g. 1/0.5 = 2 ( fifty-fifty).
bet size, e.g. 20£
bet type - Back or lay.
market id/selection id - Unique id of a particular selection in a given market.
bet status - Unmatched, matched, cancelled (by user), lapsed (by a betting exchange, e.g. when market is turned in play), settled.

Historical market data - Represents the whole market life cycle: market creation, bet placement, turning market in play, bet placement in play and market settlement. It allows to replay a market from the past.

Trader - Responsible for analysing market and taking appropriate bet placement decision. The aim of bet placement is to guarantee the highest profit with the lowest risk. There are two types of traders, a real trader that is represented by human and artificial trader that is represented by computer software. The main aim of this project is to provide a simulation environment for testing artificial traders.

Expected profit - This is a measure that tells, what would be the profit in a long term if the same market was processed many times. For instance if the expected market profit is 10, then it means that for 100 'exactly the same' markets the profit would be 1000. It may happen that for the first market the profit will be -23 and for the next market it will be 12, but in total, based on a theory of probability it should be approximately 1000.

Component design

Components:

User - A person who is using the market simulation. Usually it's a market analyst or a real trader.

Simulator App - Provides a command line interface to the market simulation. Read the configuration of the historical market data and the trader implementation, runs simulation and displays expected profit report on the screen.

Simulator - Does exactly the same as a simulator application, but provides application programming interface instead of command line interface.

Market Event Processor - Parses historical market event in a string format, e.g. CREATE_MARKET and calls appropriate method on a betting exchange, e.g. createMarket(market:Market)

Trader - Analyses markets on a betting exchange and places bets.

Expected Profit Calculator - Reads matched bets for user (e.g. trader) from a betting exchange and calculates expected market profit report.

Betex - It's a betting exchange that provide peer-to-peer betting services.

Flow of control:

User starts the market simulator giving the path to the file with the historical market data and the name of the trader implementation class. After the market simulation is finished the market expected profit report for the trader is printed on the screen.

The Simulator Application calls the Simulator component with the input parameters provided by the user.

The Simulator component reads the file with historical market data and for each historal market event, calls both MarketEventProcessor and Trader. After all historical market events are processed, it calls the ExpectedProfitCalculator to get the market expected profit report.

Deployment design

Java VM - The Betting AI application will be written in the Scala programming language that is running within the Java virtual machine.

Scala - The scala language distribution, contains scala libraries that are required to run scala applications.

Betting AI application - Binaries of the betting ai application, contains start script to run market simulation.

Historical market data file - This file contains historical market data that is used for market simulation.

Trader implementation class - This file contains trader implementation that market simulation is executed for.

References

Project home page: http://code.google.com/p/betting-ai/

The Betting AI (Artificial intelligence) - user interface and input data

2010-04-14T01:17:00.000-07:00

Previous part of the betting ai design.
Next part of the betting ai design.

User interface

As a trading analyst I want to run the market simulation from a command line interface as presented below:

app_name marketData=[market_data_file] traderImpl=[trader_impl_class]

app_name - Name of the application, e.g. market_simulator

marketData - Text file with market data that will be used for the simulation. Go to the next chapter 'Input data' for more details.

traderImpl - Fully classified name of the trader implementation class that the simulation will be executed for. Go to the next chapter 'Input data' for more details.

After simulation is started, the following output is presented on the screen:

[BEGINNING Of THE OUTPUT]

Simulation is started.
Simulation progress: 1% 2% 3% 4% 5% 6% ....................................................... .................................................................................................................
..................................100%
Simulation is finished in 23 sec.

Expected profit report for trader com.dk.bettingai.trader.SimpleTraderImpl:

Catt 7th Apr: 14:10 7f Claim Stks    expProfit=28 expAggrProfit=28 mBets=34 uBets=17
Catt 7th Apr: 14:40 1m6f Hcap       expProfit=4   expAggrProfit=32 mBets=27 uBets=2
...
Nott 7th Apr: 17:20 1m Hcap         expProfit=-6 expAggrProfit=136 mBets=45 uBets=57
-------------------------------------------------------------------------------------
TotalExpectedProfit=136 TotalMatchedBets=457 TotalUnmachedBets=262
[END Of THE OUTPUT]

Definitions:

expProfit - Expected market profit based on all matched bets on the market placed by trader.

expAggrProfit- Expected profit for the market and all prior markets.

mBets - Number of matched bets on the market placed by trader.

uBets - Number of unmatched bets on the market placed by trader.

TotalExpectedProfit - Expected profit for all markets and all matched bets placed by trader.

TotalMatchedBets - Number of all matched bets for all markets placed by trader.

TotalUnmatchedBets - Number of all unmatched bets for all markets placed by trader.

Input data

To run the market simulation, user has to provide the historical market data and the trader implementation class.

The historical market data is provided as a text file, that contains the number of events for the market management and the bet placement. The list below presents all possible event types:

CREATE_MARKET

Market id, market name, event name, number of winners, market time.
List of selections: selection id, selection name.

TURN_MARKET_INPLAY

Market id.

SETTLE_MARKET

Market id, list of selection ids for winners.

PLACE_BET

Bet size, bet price, bet type (back/lay), market id, selection id.

CANCEL_BET

Bet id.

The trader implementation class implements the following interface:

Interface name: Trader

Interface operations:

execute():void

setBetexPublicApi(betexPublicApi: BetexPublicApi):void

BetexPublicApi:

getActiveMarkets

Input - None.
Output - All markets that are not closed. The following attributes are returned: market id, market name, event name, market time.

getMarketData

Input - Market id.
Output - All back and lay stakes for each price on the exchange for a given market.
Output - Market id, market name, event name, selection ids/names, number of winners, market status (active/in play/settled), market time.
Output - matched amounts at each price on all of the runners.

placeBet - Place a bet on a betting exchange.

Input: Bet size, bet price, bet type (back/lay), market id, selection id

cancelBet - Cancel a bet.

Input - Bet id.
Output - None.

getBets - Returns bets for a given user on a betting exchange

Input: User id, bet status (matched, unmatched, matched_unmatched, settled, cancelled, lapsed)
Output: List of bets (bet id, bet size, bet price, bet type, market id, selection id, bet status).

References

Project home page: http://code.google.com/p/betting-ai/

The Betting AI (Artificial intelligence) - requirements

2010-04-09T04:14:00.000-07:00

Previous part of the betting ai design.
Next part of the betting ai design.

Functional requirements

Use case scenario:
As a trading analyst

I want to choose historical market data for the simulation, e.g. all market data for the period from 01.02.2010 to 10.02.2010

Historical market data represents the whole market life cycle: market creation, bet placement, turning market in play, bet placement in play and market settlement.

Then I want to choose trader implementation that the bet placement intelligence should be tested for.

Trader implementation should be executed every time the historical market event is processed. For instance when market is created or when bet is placed or market is turned in play. When trader is executed it can check the market state, runner prices, etc. and take appropriate trading decisions.

Then I want to run simulation.

The aim of the simulation is to test, how a trader implementation would behave if it was running live on the betting exchange. Of course the market simulation will never return the same results as testing trader on a real betting exchange, however they both should be similar as far as possible.

Finally I want to see expected trader profit based on matched bets placed by trader and market probabilities derived from market prices before market is turned in play.

Expected trader profit for market tells us what would be the profit in a long term if this market was processed many times. For instance if the expected market profit is 10, then it means that for 100 exactly the same markets the profit would be 1000. It may happen that for the first market the profit will be -23 and for next market it will be 12, but in total, based on a theory of probability it should be approximately 1000.

Non-functional requirements

Performance - Running the market simulation for 10 markets with 10 runners each and collected data for 10 minutes with 1 second interval should take maximum 1 second.

Command line interface - The market simulation should be started from the command line interface.

Multi-platform - It should be possible to run the market simulation on Windows and Linux operating systems.

Historical market data - All historical market data for the market simulation should be read from a single file on a file system.

Installation - The application for the market simulation should be delivered as a zip file. To install and run the market simulation the following steps should be required:

Unzip the application.
Go to the application folder.
Run start script and provide file with the historical market data and the trader implementation.
Print the simulation report to the output screen.

Easy to run the market simulation for different traders - Running the market simulation for different traders should require only to change the name of the trader provided on the command line interface.

References

Project home page: http://code.google.com/p/betting-ai/

The Betting AI (Artificial intelligence) - project initiation

2010-04-05T02:30:00.000-07:00

Next part of the betting ai design.

Background

In 2008 I started a research project that was to analyse and understand behaviours on a betting exchange. On the beginning of my research I created FlexiBet, automated betting system based on state machines. For the purpose of the Flexibet project I developed betting-scxml, domain specific language for creating automated betting strategies based on SCXML state machines.

Having that, I created a few betting strategies and I put them live to get some data to analyse. In the next step I analysed collected data, then I created new betting strategy and I put it live again to get more data to analyse.

I was evolving betting strategies and analysing collected data for one year or so, until it became time consuming and difficult to continue. It was because of using manual data analysis, mostly based on SQL and Eclipse Birt Business Intelligence. Despite of being simple and handy for creating simple reports, I found it difficult to analyse complex data.

Vision

The vision is to apply neural network technique to analyse markets on a betting exchange. I want to create a trader based on a neural network that can take appropriate bet placement decisions. Then, trader should be tested on a historical market data to measure how efficient the trader's intelligence is.

Use case scenario:
I want to choose historical market data for the simulation, e.g. all market data for the period from 01.02.2010 to 10.02.2010

Then I want to choose trader implementation that the bet placement intelligence should be tested for.

Then I want to run simulation.

Finally I want to see expected trader profit based on matched bets placed by trader and market probabilities derived from market prices before market is turned in play.

References

Project home page: http://code.google.com/p/betting-ai/

Time to change - Moving from Java to Scala

2009-12-29T02:58:00.000-08:00

The end of the year is a good time to look backwards and ask yourself a few questions. The question I'm asking myself every year is whether or not it's a good moment to change my core programming language. The last time I answered 'yes' was eight years ago.

That time I was working for a software company where the lion's share of software code was written in C/C++ and nobody wanted to hear about Java. There were two major reasons for that, first of all, people generally were against any changes, secondly almost everyone used to think that Java is slow and not appropriate programming language for developing large scale and distributed computer systems. Finally choosing Java for developing next-gen company products was a bull's eye shot.

Now, eight years later, I feel again that it's a good moment to go forward. This time I'm moving from Java to Scala. In reference to scala-lang.org:

Scala is a general purpose programming language designed to express common programming patterns in a concise, elegant, and type-safe way. It smoothly integrates features of object-oriented and functional languages, enabling Java and other programmers to be more productive. Code sizes are typically reduced by a factor of two to three when compared to an equivalent Java application [1]

A good way to present the difference between two programming languages is to show the same code written in both of them. The code below presents following steps:

Create list of three decimal prices [2].
Convert prices to probabilities, probability = 1/price.
Print all probabilities to the console.

Scala code:

//Convert prices to probabilities
//and display them to the console
object PriceToProbability extends Application {
 val prices = List(2d,3d,4d)
 val probabilities = prices.map(s => 1/s)
 probabilities.foreach(println)
}

Java code:

//Convert prices to probabilities
//and display them to the console
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class PriceToProbability {

 public static void main(String[] args) {

   List prices = Arrays.asList(2d,3d,4d);
   List probabilities = new ArrayList();

   for(Double price: prices) {
     probabilities.add(1/price);
   }

   for(Double probability: probabilities) {
     System.out.println(probability);
   }
 }
}

Nice, isn't it? Although it's a very simple example, it illustrates how neat and concise Scala could be. Is a Scala for you? it depends on the business domain that you want to apply it for. My domain is mostly represented by risk management and algorithmic trading and many aspects of Scala fit there perfectly. For example functional programming is very useful for implementing various calculations and mathematical algorithms.

For those, who want to learn more about Scala, I'd like to recommend very good book, actually one of the best books I read this year. Despite the fact it's a technical book I would compare it to reading Harry Potter. Simple language, easy to understand, short chapters and can't stop reading it. Here is the link: Programming in Scala by Martin Odersky

Reference

Bio heat map of the Barclays Premier League - Winner 2009/10

2009-12-04T11:51:00.000-08:00

The picture below presents a bio heat map of a betting exchange market.

Market: Barclays Premier League - Winner 2009/10 market.
Time: 04 December 2009 19:51

Function: tv = f(r,p,t)

tv - total traded volume on the given runner in a particular market
r - market runner
p - price
t - time

Color - green to black to red

green - 0 traded volume
black - middle between min and max
red - max traded volume

Bio heat map of a betting market

2009-11-29T07:34:00.000-08:00

It's a beginning of my research on a lifetime of a betting exchange market and my preliminary goal is to underatand how market grows and evolves during its lifetime.

One of my first thoughts was to present a market in a form suitable for analysis using a sense of sight and image recognition. In the first instance I decided to try a bio heat map that is commonly used in a science to present gene, weather or biological maps.

The picture below presents a bio heat map for a betting exchange market: tv = f(r,p,t)

tv - total traded volume on the given runner in a particular market
r - market runner
p - probability
t - time

Color - green to black to red

green - 0 traded volume
black - middle between min and max
red - max traded volume

Having that, I'm going to record a lifetime of a market and replay it with an increased speed and make some initial analyses.

AndroBet - The Betting Exchange simulation game

2009-08-26T05:51:00.002-07:00

Andro Bet is a betting exchange simulation game. The aim is to make the highest profit by backing and laying the same selection in the market. Game starts with the screen presenting market view for a single selection that player can place bets on. After 3 minutes of the game the runner outcome (winner or loser) is calculated and the profit&loss is displayed on the screen.

On top of market view there is a status bar. On the left side of a status bar there is a profit for outcomes (winner and loser) that is based on all player's matched bets. On the right side of a status bar there is a remaining time of a game. In the centre of a market view there is a ladder price widget. The middle column contains all unmatched bets for all users on a betting exchange. Unmatched back bets are on the blue background, whereas unmatched lay bets are on the pink background. Each cell contains two numbers, on top of a cell there is a price, whereas on the bottom of a cell there is total value of unmatched bets for all users on this price. The left and right columns present all unmatched back and lay bets placed by a player. The player's unmatched back bets are in the left column, whereas the player's unmatched lay bets are in the right column. When the player’s bet is matched then it disappears from the cell.

Player may place back and lay bets, but once bet is placed, it can’t be cancelled. Bets are placed by tapping the cells, in the left and right columns of a market view. The size of one bet is 2, whereas the price is determined by the row tapped by a player. To place a back bet, tap the cell in the left column. To place a lay bet, tap the cell in the right column. The left and right columns display only player’s bets that remain unmatched.

After game is finished the result is presented to a player. It contains starting price that is used to calculate selection’s outcome and the player’s profit.

Resources

AndroBet on YouTube: http://www.youtube.com/watch?v=dEDwtmKLIZc

AndroBet on Google Code: http://code.google.com/p/androbet/

Trading at BetFair betting exchange with Apache SCXML

2009-04-21T14:00:00.000-07:00

The main concept of trading is to buy at low price and to sell at high price, e.g. to buy/sell shares at a stock exchange. Similar idea is behind a betting exchange, but instead of shares issued by companies there are horse racing, tennis and football markets, instead of buying/selling shares, bets are placed. For example if two bets are placed on the same horse in a horse race, one bet at a lower price that the horse will lose and second bet at a higher price that the horse will win ,then whether or not a horse is a winner there is always a profit from these two bets.

How to trade at BetFair trading exchange?

At BetFair betting exchange (Figure 1) there are markets, e.g. tennis match or horse race. On each market there are runners, e.g. horses in a horse race. On runners the back/lay bets are placed. Back bet means that the runner will win, lay bet when it will lose. Bets are placed on a given price, which represents the chances of winning, e.g. price 2.0 is a 50% of chances (1/2=0.5), price 1.01 is a 99% of chances (1/1.01=0.99), 1000 is a 0.1% of chances (1/1000=0.001). For example when a back bet is placed for 3$ at price of 2 and horse wins, then the profit is (3*2)-3 = 3$.

Figure 1. Horse racing market with runners and prices (source: betfair.com).

On the same time the price to lay (pink color) is always higher than the price to back (blue color), and placing two bets (back and lay) on the same time never gives a profit. Example:

Bets on a first runner (Shemoli):

Back bet for 2$ at price 2.12
Lay bet for 2$ at price 2.14

When the runner is a winner then the profit/loss is: 2*(2.12-1) -2(2.14-1) = 2.24 - 2.28 = - 0.04
When the runner is a looser then the profit/loss is: -2 + 2 = 0

But firstly, when the back bet is placed, e.g, on a price 3.0 and some time later the lay bet is placed on a price 2.12 then the profit/loss is never negative. Example:

Bets on a first runner (Shemoli):

Back bet for 2$ at price 3.0
Lay bet for 2$ at price 2.14

When the runner is a winner then the profit/loss is: 2*(3-1) -2(2.14-1) = 4 - 2.28 = 1.72
When the runner is a looser then the profit/loss is: -2 + 2 = 0

The chart below (Figure 2) presents the price over the time for Shemoli runner. The key point of trading is to predict the trend of price. It allows to back on a high price and lay at a low price and to make a profit regardless of a market outcome.

Figure 2. Price chart for horse runner (source: betfair.com).

How I use Apache SCXML to trade at BetFair?

The simplest scenario of trading is to place two bets on the same runner, one back bet and one lay bet. It can be described by the following states and transitions between them (Figure 3):

No bets - When the runner price is increasing (price.slope>15), then a back bet is placed on it (placeBet betType='B' size=2 price=runner.priceToBack). The 'price.slope' parameter determines the angle of a price trend over last 15 minutes. When the angle is bigger than 0 then price is increasing, when is less than 0 then it is decreasing.

Back matched - When the best available price to lay on the runner is lower than the price that the back bet was matched on, then a lay bet is placed. It assures the profit regardless of a market outcome.

Lay matched - Back and lay bets are matched. Do not place any more bets on the runner.

Figure 3. Trading strategy (States machine) GUI editor.

My betting application allows to trade exactly in the same way as described above and usually it's a several minutes to prepare and execute new betting strategy:

Creata a state machine diagram using GUI editor.

Export state machine to SCXML file (see Figure 4) - SCXML is an xml format from W3C consortium, that describes a state machine. Because of a generic nature of SCXML, I extended it with many features, e.g. placeBet, cancelBet, variables used in conditions: runner.slope, runner.bwinPrice, runner.oddsCheckerPrice.

Import SCXML file to my betting application, where it's executed by betting engine based on Apache SCXML - Apache SCXML is a Java library to parse and execute state machines in a SCXML format.

Figure 4. State machine for trading strategy in a SCXML format.

The presented example of state machine for betting strategy is very simple, however complex state machines can be created as well. The diagram below presents state machine for trading strategies on Soccer and Horse Racing markets.

Figure 4. State machine for trading strategies at Soccer and Horse Racing markets.

Conclusion

Adopting state machine to design and execute trading strategies is a powerful technique. First of all it's an easy and quick to design any kind of strategy and present it in a simple graphical format. More over it doesn't require any special skills and can be performed by trading specialist, who doesn't know to much about computers or programming languages. Also describing trading strategy as a state machine allows to prepare very useful reports, e.g. what is the profit/loss per states over the time. Such report provides information that is essential to eliminate wrong states and evolve toward better design. In the end I'd like to mention that state machine can evolve itself, empowered by Business Intelligence and Machine Learning techniques.

Resources

Scxml Betting Engine on Google Code

References

Bye,
Daniel

Automated betting with BetFair, Business Intelligence and Eclipse BIRT

2009-03-14T14:05:00.000-07:00

When you place a single bet on a tennis match (market), you need to decide, which tennis player (runner) to bet on. Usually it’s based on your intelligence. By your intelligence I mean experience, knowledge, common sense, etc. When you use automated betting, then you place a lot of bets every day and the decision process becomes much more complicated. I this case you need something more than your intelligence, what you need is a Business Intelligence (BI).

Regarding to Wikipedia, Business Intelligence (BI) refers to skills, technologies, applications and practices used to help a business acquire a better understanding of its commercial context. In my betting application I use Business Intelligence for:

Historical data analysis – e.g. create reports/charts to show profit for sports/regions over the time.

Data mining – e.g. to recognize some particular situations when I win or lose.

Automated decision making system - based on evolutionary algorithms, e.g. eliminate wrong betting strategies during evolution process.

In this post I describe how I analyse historical data using Eclipse Business Intelligence and Reports Tools (BIRT) technology. Eclipse BIRT is an open source Java project from IBM and it’s a powerful tool, especially to create custom multi dimensional reports and charts. It provides easy to use GUI designer to create and run reports. The GUI designer can be used as a stand alone application or a plugin in Eclipse IDE. Also a web based reports viewer is provided, which in my opinion isn’t very good. Finally there is a very well documented API, that allows to integrate BIRT charts and reports into a thirt-party applications.

The examples below present BIRT chart and table report integrated into web console of my betting application.

Figure 1 Profit per week over the time.

Figure 2 Profit per sport/region over the time.

How I use Eclipse BIRT?

In my betting application BIRT reports and charts are integrated into a web console, which is based on a Wicket framework. The figure 3 presents all components involved in designing, generating and presenting reports to the user.

Figure 3 Design of Birt reports.

Diagram details:

ReportsViewer - Allows to choose report and values for report parameters and displays report to the user as html page. List of available reports is obtained from reports directory on a file system.

Reports files - BIRT reports created by reports designer.

Reports Designer - GUI reports designer provided by Eclipse BIRT (see Figure 4). It's a powerful tool and allows to create almost all types of reports and charts you can ever think about. The best is that it can be used by a non technical person, e.g. business intelligence specialist. Also it is possible to parametrize reports, e.g. create report to show profit per sport/report with two input parameters: sport and region.

BirtEngine - Generates report in a html/pdf format based on a report file and reports data from data source, e.g. from database.

Database - Repository of betting history, e.g. account statement, markets, bets, prices.

Figure 4 BIRT Designer.

Conclusion

Business Intelligence is a crucial element of every automated betting application. Correctly used can significantly improve performance of betting. Moreover, it discovers new horizons and ways of betting hidden behind a huge amount of historical data.

References

Bye,
Daniel

BetFair Java API with Apache CXF, Spring and Maven

2009-02-26T14:33:00.000-08:00

In this post I present how to login and place a bet on BetFair in Java. Betfair provides a webservice API to get events, markets, place a bet and do many other things. There are several ways to use this API in Java but personally I prefer one of the easiest and quickest of them, which is based on Apache CXF technology.

Apache CXF is a professional open-source Java library to create webservice clients and servers. It generates a webservice java client automatically from a wsdl file, that works very well with BetFair API. Thus calling most of a BetFair operations such a login, getEvents, placeBet is very simple and is just a couple of lines.

The diagram below presents how BetfairService is designed and used in my betting application:

Diagram details:

BFGlobalService/BFExchangeService - Betfair webservices generated by Apache CXF. GlobalService contains login operation and others, which don't require logging in. Whereas ExchangeService allows to get market data, place bets, get account information and others, which require user to be logged in.

BettingServiceImpl - BetFair Facade, that simplifies access to the BetFair operations from a BettingEngine.

BettingEngine - Module of my application responsible for executing betting strategies.

How to login to a Betfair account?

The login operation is provided by a BFGlobalService. To login to a Betfair account three parameters are required: user, password and productId. For Betfair free API the productId is 82.

//Login to a BetFair account.
//
public void login(String userName, String password, int productId) {

//Creating login command which contains all login parameters.
LoginReq req = new LoginReq();
req.setUsername(userName);
req.setPassword(password);
req.setProductId(productId);
req.setLocationId(0);
req.setVendorSoftwareId(0);

//Calling BetFair webservice login operaton.
LoginResp resp = globalWebService.login(req);

//Checking login result and storing session token, which is necessary to call BFExchangeService operations, e.g. getMarkets, placeBet.
if (resp.getErrorCode().equals(LoginErrorEnum.OK))
{
state.setSessionToken(resp.getHeader(). getSessionToken());
} else {
throw new BetFairException("Login error. Error code: " + resp.getErrorCode() + ", api code: "
+ resp.getHeader().getErrorCode());
}
}

How to place a bet?

The placeBet operation is provided by a BFExchangeService. There are many different bet types available. This example show how to place a back/lay bet on a betting exchange. The code snippet below presents a placeBet method with parameters:

marketId/selectionId - Which market runner the bet is placed on, e.g. draw in a football match, tennis player in a tennis match or horse in a horse race.

betType - Back or lay , e.g. back bet means that something will happen, e.g. draw in a football match, lay means that it will not happen, e.g. tennis player will not win the match.

betCategory - Exchange or SP(starting price) bet.

price - Binary odds of a bet, e.g. 2.0

size - Stake of a bet, e.g. 20 dollars.

//Place a bet on a BetFair
//betting exchange.
public void placeBet(int marketId, int selectionId, BetTypeEnum betType, BetCategoryTypeEnum betCategory,
double price, double size) {

//Creating request header with a session token returned by login operation.
APIRequestHeader requestHeader = new APIRequestHeader();
requestHeader.setSessionToken(sessionToken);

//Creating placeBet command, which contains all required parameters.
PlaceBetsReq req = new PlaceBetsReq();
req.setHeader(requestHeader);

ArrayOfPlaceBets arrayOfBets = new ArrayOfPlaceBets();
PlaceBets placeBets = new PlaceBets();
placeBets.setAsianLineId(0);
placeBets.setBetCategoryType(betCategory);
placeBets.setPrice(price);
placeBets.setSize(size);
placeBets.setBspLiability(0d);
placeBets.setBetPersistenceType( BetPersistenceTypeEnum.NONE);
placeBets.setBetType(betType);
placeBets.setMarketId(marketId);
placeBets.setSelectionId(selectionId);
arrayOfBets.getPlaceBets().add(placeBets);
req.setBets(arrayOfBets);

//Calling placeBet operation on a BetFair webservice.
PlaceBetsResp resp = exchangeWebService.placeBets(req);
if (resp.getErrorCode().equals(...) {
//Checking placing bet result.
}
}

How to generate BFGlobal and BFExchange services with Maven and cxf-codegen-plugin?

Because my betting tool uses a Maven build system, I use a cxf-codegen-plugin to generate java classes for BetFair webservices. There are two plugin executions to generate java classes for BFGlobal and BFExchange services. Java classes are generated from the wsdl files. See lines 17 and 37.


org.apache.cxf
cxf-codegen-plugin
2.0.5-incubator



generate-sources_BFGlobalService
generate-sources


${basedir}/target/generated-sources/src/main/ java




${basedir}/src/main/wsdl/ BFGlobalService.wsdl





wsdl2java




generate-sources_BFExchangeService
generate-sources


${basedir}/target/generated-sources/src/main/ java




${basedir}/src/main/wsdl/ BFExchangeService.wsdl





wsdl2java

How to configure BFGlobal and BFExchange services with Spring?

The BFGlobal and BFExchange services are created by a JaxWsProxyFactory bean, which is configured using the class name of generated webservice and the url of a BetFair webservice. Afterwards BetFair services are injected into a BetFair facade, which is used by my betting application.

Resources

Betfair JAVA API on Google Code

References

Bye,
Daniel