{"data":{"markdownRemark":{"html":"
\nThe model is based on the following paper by Professor Rama Cont:\nVolatility Clustering in Financial Markets: Empirical Facts and Agent–Based Models\n
\n

In this introductory tutorial, you will learn to make a simple agent-based model of traders trading in a stylised financial market such as a stock market.

\n

The model is comprised of traders and a common information signal observed by all traders, which we can think of as a 'news arrival' process. All traders compare this information signal to an internal trading threshold.

\n

Traders place a buy order when they believe the trading signal is positive and a sell order when they believe the signal is negative.

\n

The net volume of buy and sell orders is mapped through a function that generates a change in the asset price (e.g. stock price).

\n

Realistic price dynamics (e.g. stylised facts) emerge from the model based on simple behavioural rules and the interaction of heterogeneous agents.

\n

This model is defined by the following classes:

\n\n

Model Class

\n

The AgentBasedModel Class contains useful functionality to help build agent-based models. The TradingModel Class extends AgentBasedModel, so it inherits these useful features as a foundation for its own class. We implement the setup() and step() methods as part of the TradingModel class.

\n\n
import simudyne.core.Model;\n\npublic class TradingModel extends AgentBasedModel<GlobalState> {\n  @Override\n  public void setup() {\n  \tsuper.setup();\n  }\n\n  @Override\n  public void step() {\n  \tsuper.step();\n  }\n}
\n

Agents

\n

We build the trading model as an agent-based-model, with two agents, Trader and Market.

\n

Each agent needs to be created as a class which extends simudyne.core.abm.Agent. We also need to specify the global variable available to the agent (by default simudyne.core.abm.GlobalState), which we will discuss extending later on.

\n

Trader.java

\n
import simudyne.core.abm.Agent;\nimport simudyne.core.abm.GlobalState;\n\npublic class Trader extends Agent<GlobalState> {}
\n

Market.java

\n
import simudyne.core.abm.Agent;\nimport simudyne.core.abm.GlobalState;\n\npublic class Market extends Agent<GlobalState> {}
\n

We create groups of the agents, which registers the agents in the model. For this example, we create a group of 1000 Trader agents, and a group with a single Market agent. Create the groups inside the setup method, so they are created once, when the model is setup.

\n

The Trader agents and Market agents are all connected to each other, so they can send messages to each other. Read more about connecting agents here.

\n

We then call super.setup() to setup the AgentSystem.

\n

We then create Accumulators which we will use to keep track of the Traders buys, sells and market price across the model. By default, accumulators are meant to aggregate per-step statistics and are reset at each step. To override this behavior, call myAccumulator.setPersistent(true) in the setup() method. Accumulators take two parameters. A String for the accumulator name which will be used to access the accumulator, and an optional String for the accumulator display name - this is the name that will display in the console when showing the value of the accumulator.

\n

We call super.step inside the step method to reset the accumulators at the beginning of every step.

\n

Trader.java

\n
import simudyne.core.abm.AgentBasedModel;\nimport simudyne.core.abm.GlobalState;\nimport simudyne.core.abm.Group;\nimport simudyne.core.annotations.ModelSettings;\nimport simudyne.core.annotations.Variable;\n\n@ModelSettings(macroStep = 100)\npublic class TradingModel extends AgentBasedModel<GlobalState> {\n\n  {\n    createLongAccumulator(\"buys\", \"Number of buy orders\");\n    createLongAccumulator(\"sells\", \"Number of sell orders\");\n    createDoubleAccumulator(\"price\", \"Price\");\n  }\n\n  @Override\n  public void setup() {\n    Group<Trader> traderGroup = generateGroup(Trader.class, 1000);\n    Group<Market> marketGroup = generateGroup(Market.class, 1);\n\n    traderGroup.fullyConnected(marketGroup);\n    marketGroup.fullyConnected(traderGroup);\n\n    super.setup();\n  }\n\n  @Override\n  public void step() {\n    super.step();\n\n    run(\n      Trader.processInformation(),\n      Market.calcPriceImpact(),\n      Trader.updateThreshold()\n    );\n  }\n}
\n

In the step method of the model, we define the sequence of actions that takes place within a step. Firstly, the traders process the information signal - and decide whether to place buy or sell orders. Then the market calculates the price impact of the buy and sell orders. Finally the traders update their trading thresholds.

\n

Don't worry if the model doesn't compile at this point. We start with defining what methods we will need to make the model building process easier. Once we know which methods we require, we can go and create them.

\n

TradingModel.java

\n
@Override\npublic void step() {\n  super.step();\n\n  run(\n    Trader.processInformation(),\n    Market.calcPriceImpact(),\n    Trader.updateThreshold());\n  }
\n

We now create methods in the Trader and Market classes for each of these actions in the sequence. Sequences are a list of Actions, so every method will have to return an Action, see Actions and Sequencing. We create the Actions inside the Agent classes rather than in the sequence directly in order to make the sequence easy to read, more information on class organisation can be found here.

\n

Trader.java

\n
import simudyne.core.abm.Action;\nimport simudyne.core.abm.Agent;\nimport simudyne.core.abm.GlobalState;\n\npublic class Trader extends Agent<GlobalState> {\npublic static Action<Trader> processInformation() {\n  return Action.create(Trader.class, trader -> {});\n}\n\npublic static Action<Trader> updateThreshold() {\n  return Action.create(Trader.class, trader -> {});\n}\n}
\n

Market.java

\n
import simudyne.core.abm.Action;\nimport simudyne.core.abm.Agent;\nimport simudyne.core.abm.GlobalState;\n\npublic class Market extends Agent<GlobalState> {\npublic static Action<Market> calcPriceImpact() {\n  return Action.create(Market.class, market -> {});\n}\n}
\n

Messaging

\n

All actions are triggered by messages, agents will only complete the actions in the sequence if they have received a message. Therefore, at every action, we need to send a message to the next agent in the sequence. For more information on messaging, see Messaging Semantics.

\n

Setting up Messages

\n

When we send messages, the body of the messages to send are also represented as classes. We create a shared message class to declare all message classes as static classes in one place.

\n

We start by creating message classes for two messages being sent in the first action of the sequence, BuyOrderPlaced, and SellOrderPlaced.

\n

Messages.java

\n
public class Messages {\n  public static class BuyOrderPlaced { }\n  public static class SellOrderPlaced { }\n}
\n

Trader Behaviour (part 1)

\n

The first method called in the sequence is Trader.processInformation(). We can see below that the trader compares the informationSignal to their tradingThresh. Based on the relative magnitudes of the two variables, they may place a buy or sell order - or do nothing. The traders also broadcast a message to let the market know that they have placed their orders. A broadcast will send a message to all agents connected to the Trader, which in this case, is the Market agent.

\n

We will discuss in Globals how to pass the information signal through the model. Until then, we will set the information signal to a random number for each Trader.

\n

Trader.java

\n
import simudyne.core.abm.Action;\nimport simudyne.core.abm.Agent;\nimport simudyne.core.abm.GlobalState;\n\nimport java.util.Random;\n\npublic class Trader extends Agent<GlobalState> {\n\n  static Random random = new Random();\n\n  public double tradingThresh = random.nextGaussian();\n\n  public static Action<Trader> processInformation() {\n    return Action.create(Trader.class, trader -> {\n      double informationSignal = random.nextGaussian() * 0.01;\n\n      if (Math.abs(informationSignal) > trader.tradingThresh) {\n        if (informationSignal > 0) {\n          trader.buy();\n        } else {\n          trader.sell();\n        }\n      }\n    });\n  }\n\n  private void buy() {\n    getLongAccumulator(\"buys\").add(1);\n    broadcastMessage(new Messages.BuyOrderPlaced());\n  }\n\n  private void sell() {\n    getLongAccumulator(\"sells\").add(1);\n    broadcastMessage(new Messages.SellOrderPlaced());\n  }\n\n  public static Action<Trader> updateThreshold() {\n    return Action.create(Trader.class, trader -> {});\n  }\n}
\n

Market Behaviour

\n

The next action in the sequence of events is performed by the market. The method Market.calcPriceImpact() is called. The market starts by checking that it has received a message from the traders confirming that orders have been placed. It then calculates the netDemand for the asset (buys - sells) and uses this value to compute a priceChange. It also updates the price of the asset.

\n

As with the information signal, the number of traders and a lambda value will be passed as a global value. For now, we get the number of traders by assuming that all connected agents to the market are traders, and getting the number of connected agents using getLink(). We set the value of lambda to 10 for now.

\n

The market computes the price change based on the net demand generated by the traders. The Market sets the new price using the accumulator, and sends the price change as a message to all connected traders so that as in the code snippet under the Trader Behaviour (II) section, the traders may update their trading threshold to equal the previously observed price change.

\n

Market.java

\n
import simudyne.core.abm.Action;\nimport simudyne.core.abm.Agent;\nimport simudyne.core.abm.GlobalState;\n\npublic class Market extends Agent<GlobalState> {\n\n  public static Action<Market> calcPriceImpact() {\n    return Action.create(Market.class, market -> {\n\n      double lambda = 10;\n\n      int buys = market.getMessagesOfType(Messages.BuyOrderPlaced.class).size();\n      int sells =\n        market.getMessagesOfType(Messages.SellOrderPlaced.class).size();\n\n      int netDemand = buys - sells;\n\n      if (netDemand == 0) {\n        market.broadcastMessage(0);\n      } else {\n        int nbTraders = market.getLinks().size();\n        double priceChange = (netDemand / (double) nbTraders) / lambda;\n\n        market.getDoubleAccumulator(\"price\").add(priceChange);\n        market.broadcastMessage(priceChange);\n      }\n    });\n  }\n}
\n

Trader Behaviour (part 2)

\n

The final action in the sequence is where traders update their trading threshold. This introduces agent heterogeneity into the model - a key feature of agent based models and the source of the interesting pricing dynamic in this model.

\n

Trader.java

\n
public static Action<Trader> updateThreshold() {\n\n  return Action.create(Trader.class, trader -> {\n    double updateFrequency = 0.01;\n    if (random.nextDouble() <= updateFrequency) {\n      trader.tradingThresh = trader.getMessageOfType(Integer.class).getBody();\n    }\n  });\n}
\n

Globals

\n

A Globals class that extends GlobalState is created to store values that will be accessible throughout the model.

\n

For this model, there are several values that need to be accessible throughout the model.\nWe create a globals class inside the Model class, with fields for each of the following values.

\n\n

The Model needs to now extend AgentBasedModel of type globals.

\n

TradingModel.java

\n
import simudyne.core.abm.AgentBasedModel;\nimport simudyne.core.abm.GlobalState;\nmport simudyne.core.abm.Group;\nimport simudyne.core.graph.DoubleAccumulator;\nimport simudyne.core.graph.LongAccumulator;\n\nimport java.util.Random;\n\npublic class TradingModel extends AgentBasedModel<TradingModel.Globals> {\n\n  public static final class Globals extends GlobalState {\n\n    public double updateFrequency = 0.01;\n    public long nbTraders = 1000;\n    public double lambda = 10;\n    public double volatilityInfo = 0.001;\n    public double informationSignal = new Random().nextGaussian() * volatilityInfo;\n  }\n...\n}
\n

We need to change the type of all our agents to the new Globals object, instead of the default GlobalState.

\n
public class Trader extends Agent<TradingModel.Globals> {...}\npublic class Market extends Agent<TradingModel.Globals> {...}
\n

We change the Model setup to use the number of traders from the globals state when creating the Traders group.

\n

TradingModel.java

\n
@Override\npublic void setup() {\n  Group<Trader> traderGroup = generateGroup(Trader.class, getGlobals().nbTraders);\n  Group<Market> marketGroup = generateGroup(Market.class, 1);\n\n  traderGroup.fullyConnected(marketGroup);\n  marketGroup.fullyConnected(traderGroup);\n\n  super.setup();\n}
\n

We update the Trader to use the update frequency and information signal from the global state.

\n

Trader.java

\n
public class Trader extends Agent<TradingModel.Globals> {\n\n  static Random random = new Random();\n\n  public double tradingThresh = random.nextGaussian();\n\n  public static Action<Trader> processInformation() {\n    return Action.create(\n        Trader.class,\n        trader -> {\n          double informationSignal = trader.getGlobals().informationSignal;\n\n          if (Math.abs(informationSignal) > trader.tradingThresh) {\n            if (informationSignal > 0) {\n              trader.buy();\n            } else {\n              trader.sell();\n            }\n          }\n        });\n  }\n\n  public static Action<Trader> updateThreshold() {\n    return Action.create(\n        Trader.class,\n        trader -> {\n          double updateFrequency = trader.getGlobals().updateFrequency;\n          if (random.nextDouble() <= updateFrequency) {\n            trader.tradingThresh = trader.getMessageOfType(Double.class).getBody();\n          }\n        });\n  }\n\n\t...\n}
\n

... and update the Market to use the number of traders and value of lambda from the globals.

\n

Market.java

\n
public static Action<Market> calcPriceImpact() {\n    return Action.create(\n        Market.class,\n        market -> {\n          int buys = market.getMessagesOfType(Messages.BuyOrderPlaced.class).size();\n          int sells = market.getMessagesOfType(Messages.SellOrderPlaced.class).size();\n\n          int netDemand = buys - sells;\n\n          if (netDemand == 0) {\n            market.broadcastMessage(0);\n          } else {\n            long nbTraders = market.getGlobals().nbTraders;\n            double lambda = market.getGlobals().lambda;\n            double priceChange = (netDemand / (double) nbTraders) / lambda;\n            price += priceChange;\n\n            market.getDoubleAccumulator(\"price\").add(price);\n            market.broadcastMessage(priceChange);\n          }\n        });\n  }
\n

We recalculate the value of the information signal every step.

\n
@Override\npublic void step() {\n  getGlobals().informationSignal = new Random().nextGaussian() *\n\t\tgetGlobals().volatilityInfo;\n  ...\n}
\n

Reporting

\n

The next step is adding annotations to the model to connect parts of it with the console(Annotations).

\n

We use the @Input annotation to mark a field as an input field that the user will be able to change at any point in time in the model, and the @Constant annotation for fields that can only be changed before the model is setup.

\n

We give our annotations user friendly names that will be used in the console

\n

TradingModel.java

\n
@ModelSettings(macroStep = 100)\npublic class TradingModel extends AgentBasedModel<TradingModel.Globals> {\n\n  public static final class Globals extends GlobalState {\n    @Input(name = \"Update Frequency\")\n    public double updateFrequency = 0.01;\n\n    @Constant(name = \"Number of Traders\")\n    public long nbTraders = 1000;\n\n    @Input(name = \"Lambda\")\n    public double lambda = 10;\n\n    @Input(name = \"Volatility of Information Signal\")\n    public double volatilityInfo = 0.001;\n\n    public double informationSignal = new Random().nextGaussian() * volatilityInfo;\n  }\n...\n}
\n

Model outputs are annotated as @Variable. Accumulators will be automatically reported so don't need to be annotated as @Variable

\n

Visualising Output

\n

The model output is displayed on the console. Here we have run the model for 800 ticks - with each tick representing one trading day. We can observe that the price walk looks like a real financial time-series. Further statistical analysis of the properties of these data would reveal that the prices generated behave like those generated in real financial markets.

\n

\n \n