Sasha Kuznetsov's Blog

Interactive AI Paper Explainers with intuitivepapers.ai

Fri, 05 Jun 2026 00:00:00 -0700

Can we use AI to explain machine learning papers properly, with the prerequisites, math, and interactive figures?

When I read a machine learning paper, I often spend a lot of time looking up the ideas it builds on. A paper describes a new contribution, but understanding that contribution may require working through several other papers first.

I sometimes ask an LLM to explain a paper to me. This is useful for getting started, but I have found that the explanations can sound convincing while getting important details wrong. A sign in an equation, whether a result is exact or approximate, or which variable is being updated can change the meaning quite a bit. And if I don’t already understand the paper, these errors are difficult to notice.

I wanted explanations that build up the intuition and math together, with figures I could interact with. I’ve explored this on a smaller scale in my gradient descent demo: changing a parameter and watching what happens can make an algorithm much easier to understand.

Starting With One Paper

I first worked on an explainer of the DiffusionBlocks paper with Claude. This took about a week of iteration. Getting the math right meant going back to the original sources, and in the process I found what appeared to be a sign error in the paper’s equations.

This made me wonder how much of the process I could automate. Could I put together a system that reads a paper and its references, works through the math, creates interactive figures, and checks the resulting explanation?

The result is intuitivepapers.ai. At the time of the original post, I had used it to produce twenty explainers, covering papers such as Attention, BERT, GANs, VAEs, CLIP, PPO, Mamba, and Adam.

The intuitivepapers.ai homepage.

The paper library. Each card previews a figure from the corresponding explainer.

Interactive Explanations

Each explainer starts with the prerequisites and works towards the paper’s main idea. A navigation panel, called the concept tower, lists these concepts in the order they depend on each other. Where it helps, the explanation also includes code to connect the math to an implementation.

The figures are interactive. For example, PPO uses a clipped objective to limit the incentive for certain changes to a policy. In the figure below, you can change the probability ratio and the sign of the advantage, and see where the objective becomes flat. This makes it easier to see when clipping takes effect than by looking at the equation alone.

Exploring PPO's clipped objective by changing the probability ratio and the sign of the advantage.

The figures also work on a phone:

The PPO explainer on a phone.

Another example is CLIP, which learns to associate images with text. The grid below shows the scores for pairs of images and captions. The diagonal contains the matching pairs; the other cells are mismatches. We can use this to see what the training objective is trying to achieve.

CLIP's image and caption scores. The matching pairs lie along the diagonal.

Generating an Explainer

Asking an LLM to explain a paper in one pass wasn’t sufficient for what I wanted. I split the work into stages: reading the sources, checking the claims and equations, designing the figures, writing the explanation, and reviewing the draft.

The checks use the paper itself, the primary literature it refers to, and the authors’ code. Separate critic passes then look for problems in the draft before it is published. The idea is to make verification an explicit part of the process, rather than assume that a plausible explanation is correct.

The pipeline runs on a timer on the Mac mini under my desk. It takes the next paper from a queue and works through these steps, including deploying the finished page, mostly without my involvement. Feedback submitted by readers is used to correct the page and update the instructions for future explainers.

Below is another example of the output, showing the pieces of a Mamba block. The library had over a hundred custom figures when I put this post together, drawn using canvas rather than a charting library.

A breakdown of a Mamba block, from the Mamba explainer.

Final Notes

This started with a paper I wanted to understand, and became an experiment in automating the work of explaining one. Checking the sources is useful, but it doesn’t make an automatically generated explanation infallible. The feedback and correction process is part of the project too.

If there’s a paper you’ve been meaning to work through, take a look at intuitivepapers.ai. You can request a paper or upvote one that’s already in the queue. And if you notice an error in an explanation, please send feedback through the page so it can be corrected.

ccmux: Managing AI Coding Agents Across Devices

Fri, 05 Jun 2026 00:00:00 -0700

A tmux session manager I built with friends to keep track of coding agents across my machines, and use them from my phone.

I often have three or four coding agents running across different machines. Keeping them running is easy enough with tmux, but keeping track of them is another problem. Which machine did I start that task on? Is the agent still working, or has it been waiting for me to answer a question?

I also wanted to interact with these agents from my phone. If a task is running on my Mac mini, I should be able to check on it and respond without going back to my desk.

So, together with Daniel Mandragona and Mike Choi, I built ccmux: a tmux session manager that collects coding agent sessions from multiple machines into one terminal interface. Below, I’ll walk through how it works and show some examples.

A tour of ccmux, with five agent sessions running across four projects.

Keeping Track of Sessions

The dashboard lists the sessions and shows whether each agent is active, idle, or needs input. It also shows the other machines on the network, and tracks Claude’s usage quota.

The dashboard. Colours indicate the state of each session; the panels on the right show devices and usage.

To open a session, select it and press Enter. This attaches to the agent’s terminal. When you’re done, press Ctrl-b d to detach and return to the dashboard. The agent continues running on the machine where it started.

Attaching to a session, then detaching with Ctrl-b d. tmux keeps the session alive in between.

How It Works

There are a few pieces to this. tmux keeps the terminal sessions alive, including when you disconnect. Tailscale connects the machines through a private network, so they can reach each other even when they aren’t on the same Wi-Fi. The terminal interface is built with Charm.

Each machine runs a daemon that keeps track of its sessions. ccmux queries these daemons to build the dashboard, and connects to the selected session over SSH or Mosh. The actual agent stays on its original machine; we’re connecting to its terminal from somewhere else.

Claude Code is the default agent, but ccmux also supports Codex, Cursor, Antigravity, and others. The session management works the same way for each of them, since they run inside tmux.

Using It From a Phone

Phone access was a big part of why I wanted to build this. However, a phone is a somewhat awkward SSH client: connections can drop when it switches networks or goes to sleep. Mosh helps with this by allowing the connection to recover after an interruption.

The terminal interface at phone width, connecting over Mosh.

The same interface works in an iPhone terminal, as shown below. Notifications are useful here too: with a compatible terminal app, I can be notified when an agent needs input instead of repeatedly checking on it.

ccmux running in Moshi on an iPhone.

We also built a native iOS app that connects to the same daemon over the Tailscale network. It has a session dashboard and an interactive terminal, which connects to tmux through a WebSocket bridge.

The native iOS app: session dashboard on the left, terminal on the right.

There are two input modes: Raw mode for interacting with the terminal directly, and Chat mode for composing messages to the agent.

Switching between terminal input and composing a message.

Final Notes

I used ccmux daily for months, and other people started using it too. In the meantime, a lot of tools for managing coding agents appeared, including projects with funding and much larger teams. We decided to move on rather than try to keep up with those as a three-person side project.

I’m glad we built it. It solved a problem I had, and I wanted to put together this post to document the result.

The site is still at ccmux.ai, and the source is available on GitHub under FSL-1.1-MIT. If you’d like to try it, the setup instructions cover installation and connecting your machines.

3D Reconstruction From Public Photos with Machine Learning

Thu, 21 Aug 2025 00:00:00 -0700

Can we reconstruct the world from public photos?

Mapping the World

The internet provides an abundance of public photos from various sources: Reddit, Youtube, Google Maps photo uploads, and so forth.

Public photos available on Google Maps

I wondered: is it possible to create a 3D map of the world from all this data? Cameras remove all the 3D information when the photo is taken - but using state of the art machine learning, we can bring it back, and turn a photo like this:

Public Safeway input image 0.

Into a 3D model like this:

Your browser does not support the video tag.

Another example, from the famous Singapore Airport:

Public SG Airport input image.

Your browser does not support the video tag.

And even an image of a forest:

Public Forest input image.

Your browser does not support the video tag.

To achieve this, I used an ML depth model and some linear algebra.

Camera Projection

We can consider a camera as performing a projection from 3D to 2D, as in the image below. This removes information about the 3rd dimension: depth.

Camera projection from 3D to 2D. Source: [1]

Our task is to recover this 3rd dimension, and then figure out how to undo this projection.

Camera Intrinsics

It is not sufficient to know the depth for every pixel in the image to reconstruct it in 3D. This is because the properties of the camera - most importantly the focal length - determine how points in 3D get mapped to pixels in 2D, and so to undo this mapping, we need to have these properties of the camera. Consider the demonstration of this below, where different focal lengths produce significantly different images:

A demonstration of the effect of focal length on image. Source: [2]

Logically it follows that if we want to reconstruct the face in 3D from any of these images, we need to know the camera properties.

Using properties of similar triangles shown below, it can be seen that the relation between the image points and the 3D points are simple:

$$ \begin{align} x = f \frac{X}{Z} \space\space\space\space\space y = f \frac{Y}{Z} \tag{1} \label{eq:camera perspective projection} \end{align} $$

Camera Perspective Projection

Reversing this transformation to map image points back to 3D, we find:

$$ \begin{align} X = \frac{x \cdot Z}{f} \space\space\space\space\space Y = \frac{y \cdot Z}{f} \space\space\space\space\space Z = Z \tag{2} \label{eq:inverse camera perspective projection} \end{align} $$

So, the two missing pieces we need are the depth at each pixel, $Z$, and the focal length of the camera, $f$. Neither of these are immediately available from public photos. The EXIF data, which may have camera information, is typically removed.

Note, it’s also possible to describe the full transformation between 3D and 2D coordinate frames, taking into account the camera’s pose, shown below. But for the purpose of this article, we just consider the camera’s local coordinate frame.

Complete Camera Model. Source: [3]

Depth Masks

Apple’s recently released DepthPro model made this project possible. While depth models have existed for a long time, I noticed this model was different in two ways: 1. It provided depth in an absolute, metric scale, which meant 3D reconstructions would actually have metric proportions, even when generated from a single mono image 2. It estimated the focal length of the camera for me

Depth Pro Teaser. Source: [4]

I ran this model on a bunch of public photos, estimating the depth masks and focal lengths, as shown below. For example, for this image:

Public Safeway input image 1.

The corresponding estimated depth mask and focal length are:

Safeway depth mask 1 and focal length predicted by the DepthPro model.

I then used equations $(2)$ to map each pixel back into 3D, created a point cloud, and then visualized it with Open3D:

Your browser does not support the video tag.

3D Reconstruction

Check out all my examples, below. Notably, check out the NYC skyline example. I was curious to see how well it would work on a huge scene, like the skyline of NYC. As expected, the depth pro model did not produce a good depth mask. The training dataset almost certainly focused on smaller scales.

COEX Mall

Public COEX Mall input image.

COEX Mall depth mask and focal length predicted by the DepthPro model.

Your browser does not support the video tag.

Forest

Public Forest input image.

Forest depth mask and focal length predicted by the DepthPro model.

Your browser does not support the video tag.

NYC Skyline

Public NYC input image.

NYC depth mask and focal length predicted by the DepthPro model.

Your browser does not support the video tag.

Safeway 1

Public Safeway input image 0.

Safeway depth mask 0 and focal length predicted by the DepthPro model.

Your browser does not support the video tag.

Safeway 2

Public Safeway input image 1.

Safeway depth mask 1 and focal length predicted by the DepthPro model.

Your browser does not support the video tag.

Singapore Airport

Public SG Airport input image.

SG Airport depth mask and focal length predicted by the DepthPro model.

Your browser does not support the video tag.

Footnotes

Camera projection from 3D to 2D. Source: ResearchGate
A demonstration of the effect of focal length on image. Source: DIY Photography
Complete Camera Model. Source: Robot Academy
Depth Pro Teaser. Source: Apple

Predicting How the Market Will Open Tomorrow

Sun, 23 Mar 2025 00:00:00 -0700

Predicting the Future

One weekend there was bad economic news, and I was wondering how it would impact the market at open on Monday. I looked into this question, and I learned that while the stock market is closed, futures trading of underlying indices continues, and we can look to the futures market to understand how traders are already reacting to and pricing in new information - like a crystal ball 🔮.

As future prices and current prices are related, we can calculate what the futures markets are pricing as the current fair value of each index by discounting the future value backwards in time. This gives us the implied opening price of each index even before the market opens - so on Sunday night we can see whether the market will likely open higher or lower the next day.

Below, I walk through all the pieces of this calculation, culminating in a dashboard I built that gives us a sneak preview of the the next day’s opening movements at impliedopen.com.

A preview of the dashboard I built which gives us a sneak peek of market movements the next day.

Futures

Futures (future contracts) are instruments that allow traders to bet on the future price of an underlying asset at the future contract’s date of expiry. Note the price and expiry date of the SP500 future below. It’s currently trading higher than the SP500 price, but what does this tell us about what the current value of the SP500 is?

To relate the futures’ price to the current fair value being priced by the futures market, we have to account for the time between now and the future expiry date.

SP500 Future Contract

We do this by using the cost of carry model, which takes into account the risk-free interest rate, the dividend yield, and the time to maturity. It assumes that the price of the index should grow at the current risk-free rate (essentialy a no arbitrage assumption) minus decreases in price due to divedends being paid out.

We can express this relationship as:

$$ \begin{align} F = S \times e^{(r - q) \times t} \tag{0} \label{eq:coc} \end{align} $$

where $F$ is the futures price, $S$ is the current stock price, $r$ is the risk-free interest rate, $q$ is the dividend yield, and $t$ is the time to maturity.

Going Back in Time

To calculate the current fair value of the stock price from the futures price, we can discount the futures price backwards in time, inverting the above formula:

$$ \begin{align} S = F \times e^{-(r - q) \times t} \tag{1} \label{eq:discount} \end{align} $$

Before the market opens, the fair value is our best estimate of the opening price of the index.

Risk Free Rate

Does a risk-free investment even exist? Well, treasury bills - debt issued by the US treasury - are considered (nearly) riskless because:

US government has a low chance of default; it can print its own money has a good history of paying debts
short maturity reduces exposure to interest rate changes and long-term uncertainties
very liquid market
no credit risk as the US government won’t go bankrupt like in the case of corporate or municipal bonds

For the risk-free rate in these calculations, I choose the 3 month T-bill.

3 Month US Treasury Yield

We assume that the underlying assets will grow at atleast the risk-free rate, because otherwise investors wouldn’t bother putting their money in these instruments.

Dividend Yield

While we assume that the underlying instruments will grow at atleast the risk-free rate, we have to account for the fact that the underlying indices will drop when dividends are paid out by a commensurate amount. To do this, I am using the most recent dividend yield of each index - but a more accurate model will probably anticipate what the forward looking dividend yield will be.

Below is the latest SP500 dividend yield which I use for my calculations.

Latest SP500 Dividend Yield

Putting it All Together

I collect the last index price, the current trading futures price, my best estimate of the dividend yield, risk-free rate, and time to expiry, and calculate my current best estimate of the fair value of each major index. I’ve put all the pieces together on impliedopen.com, which I’ve embedded below:

This dashboard is most useful when the futures market is open but the regular market is closed - so we can use the futures market to understand what traders are pricing in before the regular market open. When the regular market is open, it provides the “true” current value of each index - as priced by the market.

Market Status View

Final Notes

I put this dashboard together pretty quickly, and ended up just scraping a lot of the values which I cache once a minute on my own API :) My apologies if things break or it goes down - at some point I will replace things with proper APIs, or this dashboard will become irrelevant as markets move towards 24/7 trading. In any case, I wanted to put together this blog post for permenance.

It is what it is.

If you notice errors in my calculations or have suggestions or other feedback, please reach out to me and let me know!

A Telegram Bot for Importing Sticker.ly Packs

Wed, 05 Apr 2023 00:00:00 -0700

Import animated Sticker.ly packs into Telegram with ease

Sticker.ly is a popular sticker pack creation and management app for Android and iPhone devices with over 100 million downloads on the Google Play store alone. It supports importing sticker packs into iMessage, WhatsApp, and Telegram. However, the ability to import animated sticker packs is limited to WhatsApp only.

Your browser does not support the video tag.

As an avid Telegram user and evangelist, I often encourage my friends to join the platform to communicate with me. Many of them are frustrated by the lack of access to the rich sticker library available on other platforms like WhatsApp. I promised to fix this, and I finally did. Introducing: the Sticker.ly Sticker Pack Import Bot

Your browser does not support the video tag.

To use the bot, simply provide a Sticker.ly pack URL, such as https://sticker.ly/s/HBBCR8. The bot will then convert the stickers into an animated format compatible with Telegram and provide a link for you to add the animated sticker pack to your library.

Your browser does not support the video tag.

Although the bot also supports importing static sticker packs, I recommend against using it for this purpose, since Sticker.ly and Telegram natively support the import of static packs out of the box.

Please note that the bot is currently in beta, so some failures may occur. If you encounter issues with creating a sticker pack, try again and follow the in-bot instructions to delete a partially created sticker pack if necessary.

Blackbox Optimization and Hyperparameter Tuning With Google's Vizier

Thu, 23 Feb 2023 00:00:00 -0800

Automatically and intelligently optimize any kind of system

When you build an machine learning model - or some other kind of algorithmic system - you will have to make choices about the architecture of your system. For example, for a machine learning application, you may need to decide how many neurons to have in a neural network layer, or the rate of gradient descent. Or if you are building a particle filter to track the state of a robot, you may need to choose the shape of a likelihood function. You may be looking for a buffer size and thread count that minimize your use of computing resources. How can you find the optimal architecture for your system?

You could try to find it manually. You can try different values for the number of neurons. You could try different rates of gradient descent. But this process is slow and tedious, and suceptible to pitfalls. Thankfully there exist services that can optimize your system for you, in an intelligent and efficient way.

Introducing Vizier

Vizier is an optimization service created at Google for blackbox and hyperparameter optimization. It can be used to optimize any kind of system as long as you can pass inputs to the system - that are suggested by Vizier - and get outputs from the system - metrics that Vizier is trying to optimize, such as by maximizing or minimizing them. The system itself is treated as a blackbox.

Blackbox optimization doesn't requre any understanding of the system itself, as long as you can pass inputs and get outputs. Source: Per Instance Algorithm Configuration for Continuous Black Box Optimization - Scientific Figure on ResearchGate. Available from: https://www.researchgate.net/figure/black-box-Optimization_fig1_322035981 [accessed 23 Feb, 2023]

Unlike non-blackbox optimization systems such as gradient descent which require an understanding of the relationship between the parameters of the system and the metric being minimized or maximized, a blackbox system like Vizier does not require any insight into the system itself. It can still search the parameter space efficiently for you, and find the values of the parameters that optimize your system. This also makes it more robust to complex, discontinuous and non-convex metric functions.

Parameters vs Hyperparameters

Aside: the distinction comes from machine learning applications, where “parameters” are considered the values inside the model used for inference and found through training on a dataset, while hyperparameters describe the architecture of the model or the training procedure. However, a blackbox optimization service like Vizier can be used to optimize any kind of system, but it won’t be an efficient way of training a machine learning model. But it is a good way to optimize the architecture of the model.

An Example

I am going to use an example that is not machine learning related, but still demonstrates the power and simplicity of a blackbox optimization algorithm such as Vizier. Say we have a noisy signal like the one below:

Some noisy signal.

Let’s try to find an analytical function that fits this signal. We can’t decide if we want to fit a Gaussian or Laplace function to the signal, and both functions have their own parameters - such as mean and variance - that we are also trying to estimate.

As long as we can give Vizier a metric we are trying to optimize, it will find an optimal function for us.

Setting Up The Problem

The first parameter we want to search is the model type: Gaussian or Laplace:

{
    'parameter_id': 'model',
    'categorical_value_spec' : {
        'values': [
            'gaussian',
            'laplace',
        ]
}

But each model has its own set of parameters that defines its shape. Let’s call these “child parameters” of each model.

For the Gaussian, these are the mean mu ($\mu$) and standard deviation sigma ($\sigma$).

Gaussian distribution with parameters mu and sigma. Taken from: https://commons.wikimedia.org/wiki/File:Normal_Distribution_PDF.svg

For the Laplace - the notation depends on the literature - but generally there is the location parameter or mean mu ($\mu$) and scale factor b ($b$).

Laplace distribution with parameters mu and b. Taken from: https://commons.wikimedia.org/wiki/File:Laplace_pdf_mod.svg

For disambiguity from the mean of the Gaussian, let’s refer to the location parameter of the Laplace distribution as a instead of mu.

When trying to fit the Gaussian distribution, we don’t want Vizier to try to estimate the parameters of the Laplace distribution and vice versa. Luckily we can specify the parameters of each distribution as child, or conditional, parameters of the parent model parameter:

'conditional_parameter_specs': [
{
    "parameter_spec": {
        "parameter_id": "mu",
        "scale_type": 'UNIT_LINEAR_SCALE',
        "double_value_spec": {
        "min_value": 0,
        "max_value": 10.0,
        },
    },
    "parent_categorical_values": {
        "values": ['gaussian']
    }
},
{
    "parameter_spec": {
        "parameter_id": "sigma",
        "scale_type": 'UNIT_LINEAR_SCALE',
        "double_value_spec": {
        "min_value": 1e-1,
        "max_value": 5.0,
        },
    },
    "parent_categorical_values": {
        "values": ['gaussian']
    }
},
    {
    "parameter_spec": {
        "parameter_id": "a",
        "scale_type": 'UNIT_LINEAR_SCALE',
        "double_value_spec": {
        "min_value": 0,
        "max_value": 10.0,
        },
    },
    "parent_categorical_values": {
        "values": ['laplace']
    }
},
{
    "parameter_spec": {
        "parameter_id": "b",
        "scale_type": 'UNIT_LINEAR_SCALE',
        "double_value_spec": {
        "min_value": 1e-1,
        "max_value": 5.0,
        },
    },
    "parent_categorical_values": {
        "values": ['laplace']
    }
}]

Lastly, we need to define the metric that Vizier will be to optimizing. I want to fit a function to the signal as closely as possible, and I will evaluate how well it fits the signal by calculating the sum of squares of residuals between the analytical function and the data. The smaller this number, the better the fit. All we need to tell Vizier is that there is this metric we are trying to minimize:

metric_ssr = {
    'metric_id': 'sum_of_squared_residuals',
    'goal': 'MINIMIZE',
}

We put all of this together and that defines our problem:

study = {
    'display_name': 'vizier_experiment',
    'study_spec' :
    {
        'parameters': [param_model],
        'metrics': [metric_ssr]
    }
}

Note that Vizier has no understanding of the parameters themselves. Gaussian and Laplace are simply types of a categorical parameter, and to Vizier have no meaning besides that. They are given meaning by my code that consumes them, but to Vizier, that code lives in a blackbox. I’m leaving out the code for brevity, but you can find it all at the link at the end of the article to see what I mean.

Searching

For each trial, Vizier suggests a set of parameters for us to try. We evaluate how well these parameters work ourselves, calculate the metric (the sum of squared residuals) and return the result of the metric evaluation to Vizier. Vizier uses the result to generate the next set of parameters to try.

Vizier suggesting parameters for trials.

Notice that Vizier only suggests Gaussian parameters when the model is Gaussian, and vice versa for the Laplace model.

How does Vizier search for optimal parameters? It can do a grid or random search, but the real magic is the combination of other algorithms it employs: Gaussian process bandits, linear combination search, or their variants.

Via GCP we can check these cool charts of Vizier’s progress:

A study table showing the evolution of the metric being optimized and the parameters of each trial.

A parallel chart showing the sets of parameters attempted and the resulting metric value.

Optimized Fit

We can see that the Laplace distribution slightly wins out over the Gaussian:

Parallel chart zoomed in to show the top trials that minimize the sum of squared residuals. A better fit is found with a Laplace distribution than a Gaussian distribution.

We query Vizier for the optimal trial parameters and plot them:

Optimized parameters that fit the noisy signal.

It’s almost a perfect fit! The parameters Vizier found are close to the parameters I used to generate the signal before adding noise: a Laplace distribution with $a=5$ and $b=2$.

Original Laplace signal.

For comparison, a Gaussian would have a rounder peak and thinner tails.

A comparative Gaussian distribution.

How Can I Reproduce This?

The colab I used to generate this article can be found here. I used GCP’s Vertex AI Vizier API because it generates some cool charts like the ones I included in this post, but be aware it can be expensive ($1/trial). Vizier is also open-source and available here.

Monte Carlo Options Pricing

Fri, 17 Dec 2021 00:00:00 -0800

The options casino

Predicting the movement of stock prices is an alluring challenge with the promise of riches. Unfortunately, predicting future stock prices consistently and reliably is generally considered impossible. However, we can use models to make useful predictions, manage risk, and profit probalistically.

Geometric Brownian Motion

One such commonly used model is geometric Brownian motion (1, 2) - in fact, the famous Black-Scholes options pricing formula assumes this model as well. This has the form

$$ \begin{align} S(t) = S(0)\exp{((\mu-\frac{\sigma^2}{2})t + \sigma B(t))} \tag{0} \label{eq:gbm} \end{align} $$

where $B(t)$ is standard Brownian motion. If we let $S(0)$ to be the initial stock price, $\mu$ to be the mean compounding return, and $\sigma$ to be the volatility of a stock, then we can generate very realistic price paths.

$\mu$ 0

$\sigma$ 0

So, what does this mean, and why is this a good model for security prices?

Logarithmic Returns

In quantitative finance it is common to deal with continuously compounded returns rather than simple returns. What that means is that instead of examining a simple return between trading periods $1 + R_t = \frac{S(t)}{S(t-1)}$ we will examine the compounding return $r_t = \ln{(1 + R_t)} = \ln{\frac{S(t)}{S(t-1))}}$. This has the very nice property that one can recover the price of a stock by simply summing up the logarithmic returns as:

$$ \begin{align} S(t) = S(0)\exp{(r_1 + r_2 + ... + r_{t-1})} \tag{1} \label{eq:rr} \end{align} $$

This is also convenient because a common assumption in finance is that the logarithmic returns of a stock are independent and normally distributed with mean $\mu$ and variance $\sigma^2$. Note that for small returns, simple returns $R_t$ approximate logarthmic returns $r_t$ since $r_t = \ln{(1 + R_t)} \approx R_t$, so the difference between the two returns is not substantial, and thus one can assume both simple and logarathmic returns are normally distributed. Next, if the logarithmic returns are normally distributed, then this in turn implies the stock price is lognormally distributed. This has been observed empirically to some extent, although in real life stock prices tend to have “fatter tails” - meaning rare events happen more often than a normal distribution would predict. Here are the monthly returns for IBM stock showing this behaviour.

Monthly simple and logarithmic returns of IBM stock with fitted normal distributions. We observe more returns at the extremities of the distributions than the normal distribution would predict. We call these 'fat tails' or 'excess kurtosis'. This image has been taken from 'Analysis of Financial Time Series, 3rd Ed.' by Ruey S. Tsay.

This model also works well because it only permits positive security prices. Securities tend to only have positive prices (although in some cases they can go negative - see the oil crash of 2020).

So, we want a process that generates a series of normally distributed returns $r_t$ - which invites Brownian motion as a natural choice.

Brownian motion

Brownian motion describes the motion of a particle in a fluid or gas. Such a particle bounces around “randomly” within the fluid surrounding it. The path it creates appears quite noisy and random. It can essentially be considered a limiting form of the random walk where both the time between steps and the step length approach zero (with some caveats: namely, if the time step is $t$, the step length must be $\sqrt{t}$ - this produces a process whose variance scales exactly with time). Consider flipping a coin to determine whether to take a step forward or backward. Now let the time between steps approach zero. You would trace a path that looks like this:

1 dimensional [arithmetic] Brownian motion. Geometric Brownian motion is the exponential of this process. CC BY-SA 3.0, Source

Brownian motion has the very nice property that the trajectories are normally distributed, which is exactly what we are looking for. We can simulate a Brownian process with discrete steps by sampling from a normal distribution (although if you only cared about the terminal value of a time series, you could sample from any distribution with unit variance; due to the central limit theorem the sum of random variables would approach a Gaussian distribution in the long term anyway).

Hence, Brownian motion provides us with the series of normally distributed logarathmic returns $r_t$ as required in $\eqref{eq:rr}$:

$$ \begin{align} r(t) = (\mu-\frac{\sigma^2}{2})t + \sigma B(t) \tag{2} \label{eq:bm} \end{align} $$

Taking the exponential of this process, we’ve recovered an equation for modelling stock price movement.

Of particular interest here is the drift rate $\mu - \frac{\sigma^2}{2}$ which causes the process to drift linearly, as the name suggests. $\mu$ is obvious - it’s the mean continuosly compounding return for the stock, and in the absence of noise (or volatility), the stock price would only grow (or decrease) by this compounding amount. But what about $\frac{\sigma^2}{2}$? Well, it turns out that the expected value of a lognormally distributed variable is $\exp(\mu + \sigma^2/2)$. Since the stock price is lognormally distributed (while returns are normally distributed), and since we require that the expected value of the stock price after continuous compounding to be $S(0)\exp(\mu t)$, we must apply the correction term of $- \frac{\sigma^2}{2}$ to the process.

There’s also a philsophical argument to be made for choosing Brownian motion as the basis for this model. A common assumption made in finance is that markets are efficient, so there should be no arbitrage opportunities. Hence, the market should be unpredictable - if an actor could predict it, that would be an arbitrage opportunity that would be exploited away. Hence, random noise (which is what Brownian motion is, essentially) is a good choice for modelling markets.

Option Pricing

Monte-Carlo simulation is a statistical technique inspired by the casinos of Monaco. Much like gamblers resigning their fates to probability, we hand over the results of statistical analysis to chance. By running enough trials, we can make conclusions with statistical significance.

Consider evaluating a call option with a strike prices of $105 for this stock. What would be the expected value of the option at expiry, given a geometric Brownian model for the stock’s movement? We can estimate this by generating a series of price paths, each of which can be considered a trial. The terminal value of each trial is related to the intrinsic value of the option via the relation $V = \max(0, S - K)$ where $S$ is the stock price and $K$ is the strike price. The mean terminal value provides us with an estimate of the option’s value at expiry, while the standard deviation of terminal values provides us with a measure of how certain we are that the option will expire close to this value.

We can increase the number of trials to increase the statistical certainty of the estimate. Re-running the simulation (by clicking “Regenerate”) on a large number of trials (below) yields a much smaller discrepency between experiments than on a small number of trials (above).

More Advanced Scenarios

Monte-Carlo simulation of terminal values is a relatively simple simulation, and one that is not too useful as this analysis can probably be completed analytically. The true power of Monte-Carlo simulation is unlocked when analysing scenarios that are more difficult to solve analytically, if not impossible. For example, if we wanted to analyse an American-style option, which can be exercised anytime, we might want to count the probability of a stock price exceeding the strike price at any time during the lifetime of that option. We could do this by counting how many trials cross the strike price boundry, which is easy to do with a Monte-Carlo simulation.

Interactive Gradient Descent Demo

Mon, 15 Nov 2021 00:00:00 -0800

What is this special algorithm?

Gradient descent is an optimization algorithm for finding the (local) minimum of a function.

Why is that useful?

Say you have some function $f(x,y)$. This function may represent a cost to you, and $x$ and $y$ are some inputs that vary the cost. Naturally, you are going to try to find the values of $x$ and $y$ that minimize the cost. This is a problem of finding the minimum of $f(x,y)$. For example, we may want to find the minimum of this function, which is plotted below:

$$ \begin{align} f(x,y)=3(1 - x)^2 e^{- x^2 - (y + 1)^2} - 10(\frac{x}{5} - x^3 - y^5) e^{-x^2 - y^2} - \frac{1}{3} e^{-(x+1)^2 - y^2} \tag{0} \label{eq:cost_func} \end{align} $$

This is where gradient descent can help.

Why gradient descent?

From elementary calculus, you may remember a procedure for finding the minimum of a function. You could find the first derivative, set it to zero, and solve that equation:

$$ \begin{align} f'(x,y)=0 \tag{1} \label{eq:first_deriv} \end{align} $$

This will reveal the locations of the extrema (maxima and minima) of the function. The sign of the second derivative $f''(x,y)$ can reveal whether the extrema are local maxima or minima. However, solving the first derivative equation $\eqref{eq:first_deriv}$ can be non-trivial, and often require numeric methods. And as your cost function involves higher and higher dimensions, e.g. $f(x,y,z,w,q,u,v,...)$ the problem can become unmanageable. Gradient descent provides an efficient procedure for locating minima by utilizing the first derivative in a clever way.

The gradient descent algorithm

The motivation behind gradient descent is intuitive, and I bet you would arrive at the same procedure in an analogous physical situation. Imagine you find yourself in a thick fog, and you can only see a few feet in front of you and feel the slope of the ground beneath you. You are trying to get to the bottom of a valley as quickly as possible. Surely, you won’t waste your time walking along a flat slope - or worse, head uphill. To descend quickly, you will inspect the slope at your location, and proceed in the direction where the slope is steepest downwards. Gradient is a synonym for slope, hence, you would be performing gradient descent. Conversely, if you were trying to find the top of the hill, you would follow the steepest part of the surface up, wherever you are. This is gradient ascent.

Gradient

Gradient is essentially another word for slope. Most people will be familiar with finding a slope in a 1-dimensional situation. In 1-D, since one can only proceed either forward or backward, the slope is clearly defined. However, in higher dimensions - imagine you find yourself on a hike - the slope may have a different value depending on which direction you go. How does one define the slope at this point?

In vector calculus, one uses the gradient operator $\nabla$, which is a vector of the slopes (or first derivatives) along each dimension.

$$ \begin{align} \nabla f(x,y)= \begin{bmatrix} \frac{\partial f}{dx} (x,y) \\ \frac{\partial f}{dy} (x,y) \end{bmatrix} \tag{2} \label{eq:gradient} \end{align} $$

On a 2D surface defined by $f(x,y)$, this would be the slope along the x-axis and the slope along the y-axis. The slope in any particular direction (which is important, since we are not constrained to move only along either the x-axis or the y-axis) can be found by summing the corresponding x and y components of the slope in that direction. In other words, the dot product of a direction vector with the gradient produces the slope in that direction.

Another interesting property of the gradient is that it gives the direction of the steepest slope. One can see this mathematically - since the slope in any particular direction can be found by dotting that direction vector with the gradient, the dot product is maximized when the gradient is dotted with itself!

Below, I plot the negative gradient of $f(x,y)$ with Mathematica. This gives us the direction of steepest descent at every point on $f$.

Gradient of f plotted as a vector field.

Follow the steepest part down

Earlier we agreed that if you were blindly navigating down a valley, you would follow the steepest direction of the ground down if you wanted to get to the bottom as quickly as possible. Mathematically, you are traversing down the valley along the gradient at each point, since the gradient vector at each point is the direction of the steepest descent. Looking at the image above, we can see that means following the arrows will lead us to a minimum (but be wary - each minimum has its own basin of attraction! More on that later).

Thus we can define a procedure. It may go something like this:

Inspect the slope at your position and determine the direction of steepest descent
Walk 5 steps in that direction
If you are still descending, go to 1. Otherwise, you’re at the bottom!

You may be wondering how I arrived at 5 steps. Well, it was totally arbitrary. But we can let it be a parameter of our procedure. Let’s call it a descent rate, and assign it the symbol $\alpha$. The larger the descent rate, the less often we’ll have to inspect the slope around us. Computationally, this is more efficient - but as you’ll see, this can lead to pitfalls.

Furthermore, we can make another optimization. When the local slope is still steep, we are probably far from the bottom of the valley. But as the slope gets flatter, we can figure that we are probably approaching the bottom. Hence we may want to descend at a rate proportional to the gradient. Let’s define the gradient with the symbol $\bar{g}$, and redefine our gradient descent procedure:

Inspect the slope at your position and determine the direction of steepest descent
Walk $\alpha \times \|\bar{g}\|$ steps in that direction
If you are still descending, go to 1. Otherwise, you’re at the bottom!

Next, how do we determine if we are still descending? One approach is to check how much we’ve descended on every iteration. If we’re barely changing altitude, then we’re probably essentially at the bottom already.

Mathematically, our procedure looks like:

$$ \begin{align} \bar{p}_{n+1} = \bar{p}_n - \alpha \nabla f(x,y) \tag{3} \label{eq:grad_descent} \end{align} $$

where $p_n$ is our position at the $n^{th}$ iteration of our descent. Try it out on the demo below. Varying the rate $\alpha$ varies the rate of the descent, while varying $X$ and $Y$ vary the initial starting point on the surface. What do you notice?

X 0

Y 0

α 0

Observations

You may notice that gradient descent is sensitive to the initial position. It will pull you towards a local minimum, which may not be the global minimum. The area of the domain that causes gradient descent to converge to a particular minimum is known as that minima’s basin of attraction.

You may also notice that increasing the descent rate $\alpha$ reduces the number of iterations required to arrive at the minimum. But making it too large causes the algorithm to overshoot, and possibly diverge.

Machine learning

You’ve probably heard of gradient descent in the context of machine learning. In that context, the cost function represents the error of our machine learning model. For example, it may be the error of classifying images, and the inputs to the cost function are the weights of the model we are varying. Hence, we can use gradient descent to find the optimal configuration of weights that minimize the classification error of the neural network! In this field, the descent rate $\alpha$ has a special name: it is known as the learning rate. Maybe it’s what our brains have been doing all along.

The Lucid Motors Configurator is A Video Game Streaming to Your Browser

Wed, 28 Jul 2021 00:00:00 -0700

It makes sense when you realize video game engines are the best simulators out there.

A Clever Solution

Lucid Motors went public on Monday, and although I am not going to be buying a Lucid anytime soon, I found myself looking at their vehicle configurator out of curiosity. It is a piece of art. It allows you to observe and interact with the vehicle from almost every direction, inside and out:

Lucid's configurator for their flagship elite vehicle, the Lucid Air Dream.

You can simulate various colours and trims, open and close the doors, and even retract the center console display. The backdrop of the Golden Gate bridge reflects off the glassy puddles. The configurator preserves all sorts of details of the vehicle, including lights under the door handles that activate when you are using them. I feel like I got an accurate enough feel for the vehicle, I don’t even have to see it in person anymore.

So how did Lucid manage to pull this off? Can you expect the average user’s web browser to render a scene like this in real-time, reflections and all? The answer is probably not. It works because the scene you are seeing is rendered with Unity, a video game engine, running in the cloud - offloading the intense computational load to an Amazon server - and streamed back to your browser via WebRTC - a peer-to-peer video streaming protocol.

The Model

Initially, I naively assumed that the model was being rendered in my browser via the latest WebGL library (an API for rendering 2D and 3D graphics in web browsers with hardware acceleration). And since the model must have been rendered locally, it had to exist in my RAM somewhere, so I could extract it and load it up in a 3D model editor. Specifically, I wanted to see if I could remove the sun visors interrupting the almost seamless glass canopy - an effect achieved by Tesla’s Model X, I’m not sure why Lucid didn’t follow.

Lucid Air sun visors interrupting the glass canopy.

So I dove into the code. After some time with the browser debug tools, skimming thousands of lines of minified Javascript, recording and examining the network requests between my laptop and Lucid’s servers, I realized the answer was quite literally just being printed in the console the whole time:

The Configurator is a webRTC stream.

There’s no local model being rendered. What I’m seeing is a video.

So what’s happening here? The configurator initializes with a 2D display - that is, a choppy panorama of images which provide the illusion of a 3D interaction. This is how most online interactive 3D displays are constructed. You can see a demo of that below:

A choppy 3D view, created by a series of 2D images.

Then, the client tests my bandwidth and latency, and if it’s fast enough to support a realtime video feed, it upgrades the session to 3D:

You upgrade to a 3D session if you have the bandwidth.

This initiates a webRTC connection. WebRTC is a peer-to-peer streaming protocol. The scene is rendered elsewhere, and streamed via webRTC to my browser.

Inspecting the contents of their get_token request reveals some more details about their mechanics.

Contents of the get_token request.

The first box reveals that, to test your bandwidth, they partially download from a 25 MB test image to your device, and time how long that takes. This is the image, if you’re curious (don’t worry, I’ve compressed it down 10x).

Doesn't have much to do with automobiles, but it will test your bandwidth just fine.

By the way, this image seems to be an effect produced by the plasma plugin from GIMP. It loads quite slowly; as it resembles noise it must be largely incompressible.

Opening up chrome://webrtc-internals/ reveals some details about the webRTC connection streaming the 3D scene to my browser.

Chrome's debug tools provide more information about the webRTC connection.

At this point, you may have noticed that none of the URLs here are on a lucid domain, but rather under zlthunder. Who are they?

ZeroLight

Searching the web for zlthunder brings you to a company called ZeroLight. They indicate that they provide cloud-based 3D visualization, specializing in automotive. It all makes sense now!

Cloud based 3D visualization specialists.

It wasn’t much longer until I found this blog post from Unity (the prominent video game engine) explaining how ZeroLight leveraged the engine to create a realistic virtual showroom, with optimized physics, reflections, and all.

Video games have brought us a long way.

Now I put all the pieces together. When I connect to the site, they load a 2D configurator. If my internet connection can handle it, they connect me to an instance of Unity - a 3D video game engine - running on an AWS server. The server receives my mouse inputs, rotating and zooming the field of view, renders the results in the cloud, and streams them back to me.

Sounds Expensive

Imagine you have a 1,000 users connected to the site: you need a 1,000 hardware accelerated instances of a video game engine receiving inputs and streaming back large amounts of realtime video- just like the cloud video games products that are Stadia and GeForce Now, among others. But it seems they’re very aware of that: to save on costs, they disconnect you after 60s of inactavity:

Downgrading on idle must save a lot of money.

What is a Video Game Engine Anyway?

Although it may seem a surprising use of a video game engine at first, a video game engine is really just an optimized simulator. Established game engines like Unity incorporate decades of research into simulating light rays and other physical phenomona. So if you want to simulate reality, even if that reality is a showroom, a video game engine is a perfect, ready-to-use tool, that can be extended to many applications.

In hindsight, I probably could have figured out how Lucid’s configurator worked by doing some searching and coming across the article from Unity. But reverse-engineering the configurator provided a closer look inside the challenges, solutions, and mechanics of their product, and I felt like a detective working from the ground up. What I found most amusing, though, was the incredible complexity we have achieved in technology today. A super realistic physics simulator, running on a remote server in an Amazon data center, receiving commands from my computer and streaming back the video feed at the speed of light, so that I can play with a car configurator. And all we needed to get to the moon was a calculator!

Bringing Colour and Life to Black and White Photos

Sat, 12 Jun 2021 00:00:00 -0700

Machine learning allows us to colourise black and white photos with ease, but at what risk?

A Different Universe

Although colourised photos have technically existed for a century or more (Sergey Prokudin-Gorsky and Piotr Vedenisov, pioneers of colour photography, traveled around Imperial Russia documenting it in full colour), the majority of the 20th century was documented in black and white. Even later in the century, much of the world did not have the luxury of colour film- my father was developing his own black and white photos into the 1980s-90s in Soviet Ukraine, and while Americans recorded full colour footage of the Vietnam War, the North’s perspective seems to be relegated to black and white photography.

Young boy near the Sim River, a very early colour photograph from Imperial Russia. This was achieved by taking multiple pictures of the same scene with different colour filters. Courtesy of the Library of Congress.

Some will argue that black and white footage has its own special quality, and this may be true. But for me black and white footage disconnects me from the scene. It is clearly distant in time. We all associate black and white footage with the past, as the trope of black and white footage in cinematagrophy to refer to a memory shows. And as someone who experiences reality in full colour, black and white footage is difficult to experience. I struggle to put myself into the scene or the characters’ shoes, because in my mind it exists in a different, black and white universe. And yet when that footage is colourized, all of sudden everything appears more real, more believable, more tangible. It is then clear that whatever is depicted in the footage is of the same Earth and of the same people, people like you or me.

And so when my father recently began digitizing our collection of family photos - as physical photos deteriorate, or are otherwise at risk of being lost forever, along with the histories, memories, and legacies preserved by them - I felt an urge to colourise them, too - so that I could experience them to a fuller extent, and so that my family members could reminisce about their loved ones who are no longer around or remember the memories of their past and their youth.

Colorizing Photos With AI

Color restoration can be done manually and laboriously. Machine learned models offer a quick and inexpensive way to colourize photos, but they have their limitations, as we will discuss later in this post. I did not train my own model for this purpose. Others have already invested thousands of hours into developing and training models to do exactly that. I found an existing model that does a very good job.

I used the Image Colorization API from DeepAi. The production model deployed by DeepAi appears to be a form of the DeOldify model, which can be found at this github repo.

I don’t think the DeepAi API allows you to adjust the model parameters, but you can if you run it yourself from the repo above or a colab instance. MyHeritage also offers this API as a service with tunable parameters.

What I did was create a quick script that enables bulk colorization of directories. It iterates over all the photos in a directory, sends them off to Image Colorization API from DeepAi, and downloads the result into a separate folder (ignoring images that have already been colourised). If that would be useful to you, just set your own DeepAi API key as an environment variable and run this script:

export DL_API_KEY=<your-deep-ai-key>
python3 main.py /path/to/images

My Family Photos

Here are some examples of the results on our family photos.

My mother holding my brother in early '90s Kherson, Ukraine. Courtesy of the Kuznetsov family.

Now in colour.

My grandmother, Allarkadina, likely sometime in the '50s, on her way to university. She graduated from multiple institutes, specializing in electrical engineering, and had a successful career as a marine electrical engineer.

In colour.

Looks so nice and alive.

Those words from my father upon seeing the newly coloured photos made it all worth it.

Photos From the Vietnam War

A couple weeks after preparing a bulk colourising script for my family photos, a post titled “The Vietnam War from the North Vietnamese Side” made it to the top of Hacker News. It seemed like a perfect opportunity to apply the script, and offer a new perspective on historical footage. Just as “They Shall Not Grow Old” made the horrors of WW1 living and real, so did I aim to make the characters and scenes from the perspective of North Vietnam.

Destruction of the jungle wrought by Agent Orange.

In colour.

Locals inspecting a downed American aircraft piloted by Lt. Stephen Owen Musselman. The pilot did not survive- war is hell.

In colour.

All the original black and white images can be found here, with the colourised versions here.

Response on Hacker News

My efforts were met with both praise

and contempt

Too bad about the [flagged] comment, because it raised an interesting point. The comment read something like 'Please don't do this.'

but most importantly, they generated a lot of very interesting discussions.

The full thread spurred by the colourised photos can be found here.

Limitations

There were two aspects of the discussion that stood out to me. First, was the reminder of the limitations of AI.

For example, the model invoked on an old image of the Golden Gate under construction produces a white bridge. It’s not wholly inaccurate, to be fair- the bridge was indeed white early in its construction, but by the time the picture was taken, the bridge had already been covered in red primer (according to the source at the DeOldify repository). So while the training data probably did contain the Golden Gate under construction, and the model could identify the same bridge under construction here, it could not discern the date and know that the bridge had already been primed with red at this point.

A white Golden Gate? It was white- but not when this picture was taken.

Some scenes are ambiguous. For example, based on the features in the following, the model cannot differentiate between the ground being field or asphalt, and incorrectly colours the asphalt green, where a human colouriser may get it right.

The model can't tell that the ground is asphalt and not grass.

Another interesting observation was that clothes seemed to often lack distinctive hues, textures, features, or context that made them accurately colourisable. The model tended to colour clothes purple - unless they had distinctive features or context. This is probably because when the model cannot make a good inference about the colour of the clothes, purple is a conservative bet, somewhere in the middle of the ambiguous colour space, that minimizes the training loss.

I don't think clothes in the past were as often as purple as this model makes it out to be.

Indeed, my father requested to correct the colour of some of the articles in the photos. Unfortunately I did not pursue this request, nor is it immediately obvious to me how I could. But as one commenter remarked, even when the colours are wrong, they still bring the images to life.

Ethical Considerations

Now that some of the limitations are clear, we are in a good position to consider the ethical ramifications of a colourising AI. This is was the second aspect of discussion that stood out to me. Ethics did not occur to me when I undertook the project, but some of the feedback I received spurred me to reflect, and for that I am thankful.

The main ethical consideration is truth. Similar to the controversy around deepfakes confusing us to what is true, artificial coloration can alter our experience of history. The AI makes choices about the colours of the past, which are not necessarily accurate. For example, if we keep and disseminate the white version of the Golden Gate, produced by such an AI, then the version of the bridge that is experienced by viewers is not historically accurate. Of course, neither is the black and white version. Perhaps the trouble is that viewers of the black and white image know that’s not what that past looked like, but viewers of the coloured image are easily tricked into believing that is history as it was.

Some may go as far as to say such retouching is rewriting of history, and indeed, sometimes it appears so. Take this recent example:

Cambodia has called on US media group Vice to withdraw an article that featured newly-colourised photographs of victims of the Khmer Rouge, saying the images are an insult to the dead because some had been altered to add smiles.

Source

Which is a very valid complaint. It appears the model was over-fit, likely trained on mostly smiling faces. It thus altered the faces of the victims to more closely resemble the training data- by smiling. It is a good example of the pitfalls of AI, especially where applied carelessly.

MyHeritage, which offers a color restoration service based on the same DeOldify model I have used, attempts to make a compromise by watermarking all their retouched images. I think they make a compelling point:

We differentiate colorized photos from those photographed originally in color using a special embossed palette symbol in the bottom left corner of colorized photos. While highly realistic, colorized photos have colors that are simulated by automatic algorithms and these colors may not be identical to the real-life colors of the original image. The palette icon appears on all colorized photos so that users can tell them apart from photos that have real colors. We hope that this responsible practice will be adopted by others who use photo colorization technology. Photos that have undergone color restoration do not have an icon because those colors are authentic.

In my case, my family knew that I had artificially colourised our photos, and they could tell the colours were not wholly accurate. But even with the wrong colours, the photos, and people and scenes within them, were brought back to life. Just as when I was a high-school volunteer in a retirement home, and I was able to transport a senior resident to his childhood home in Dresden via Google Streetview, which he had not visited in 50 years, I was able to use AI to teleport our family to good times decades in the past. Technology is a tool, and I’m thankful I live in an age where magic like this is possible.

Arbitrage as a Shortest Path Problem

Sun, 25 Apr 2021 00:00:00 -0700

An explanation of arbitrage and a look at an efficient algorithm to find riskless instantaneous arbitrage opportunities.

Who doesn’t like to make money?

And what if you could turn the problem of making money into the problem of finding the shortest-path? We can do that in at least one particular way: by exploiting arbitrage opportunities.

What is arbitrage?

Arbitrage is the act of buying or selling things across different markets, or in different forms, to profit from differences in prices. And the people who engage in it? They’re known as arbitrageurs — a fancy title indeed.

Let’s start with an example. Say Paul, Peter, and Bob live in a village, where they barter carrots, potatoes, and lettuce. Bob trades potatoes for carrots, Peter trades lettuce for potatoes, and Paul trades lettuce for carrots.

Furthermore, Bob will trade 2 potatoes for a carrot, Peter will trade 1 lettuce for 2 potatoes, and Paul will trade 2 carrots for 1 lettuce. If we were to treat each individual as a market for their respective goods, what would the exchange rates look like?

Market	Exchange Rate
Bob (potatoes for carrots)	2 potato/carrot
Peter (lettuce for potatoes)	1 lettuce/2 potato = 0.5 lettuce/potato
Paul (carrots for lettuce)	2 carrot/lettuce

Exchange rates for goods in our village.

Do you sense an opportunity?

Being the enterprising individual that you are, you may try to exploit it. Starting with 5 carrots, you approach Bob, and trade your 5 carrots for 10 potatoes, at the rate at which he is willing to trade.

$$ \begin{align} 5 \text{ carrots} \times 2 \space \frac{\text{potatoes}}{\text{carrots}} = 10 \text{ potatoes} \tag{1} \label{eq:arb_example} \end{align} $$

Next, you approach Peter with your potatoes, knowing that he’ll trade you 5 lettuce for them. Then you approach Paul with your 5 lettuce, and he trades 10 carrots for your lettuce.

After a few smart trades, you’ve doubled your carrot wealth. You turned 5 carrots into 10, by exploiting an arbitrage opportunity.

Later on, the villagers may develop more sophisticated markets where Bob, Peter, and Paul aren’t the only traders. Instead this little village might develop a carrot/lettuce market, a lettuce/potato market, and a potato/carrot market, where the going rate for each trade will fluctuate based on what people are willing to trade.

But the arbitrage principle remains the same. And the opportunity can be exploited until the traders offering to exchange at those rates run out of carrots, lettuce, and potatoes to trade. The arbitrage opportunity is exploited until the market reaches an equilibrium.

Arbitrage in Modern Times

When you think of modern markets, you probably don’t think of trading carrots, potatoes, and lettuce. If you’re into forex, you’re more likely thinking of trading dollars, pounds, and yen. And in that case, we would be dealing with a dollar/pound market, a pound/yen market, and a yen/dollar market, with many traders acting on each market. From now on, let’s use those currencies as examples of things to trade, but keep in mind the principles can apply to all sorts of trade-able things.

Say at a given time, the exchange rates are as follows:

Market	Exchange Rate
pound (£) / dollar ($)	0.8 pounds/dollar
yen (¥) / pound (£)	100 yen/pound
dollars ($) / yen (¥)	0.013 dollars/yen

An example of currency market exchange rates.

If you learned anything from Bob, Peter, and Paul trading carrots, lettuce, and potatoes, you’d sense an opportunity here.

If you trade $1 for pounds, you’ll end up with £0.8. Trading that for yen, you’ll end up with ¥80. You take your yen to the yen/dollar exchange where you trade it back for dollars… but now you have $1.04!

But you have to act quickly, before another arbitrageur beats you to the punch. These opportunities only exist temporarily, until the liquidity is used up and the rates equalize.

The perceptive among you may notice that we haven’t considered exchange fees in our example. Of course, you’d have to take those into account to calculate if a profitable arbitrage opportunity actually exists.

Acting Quickly

Hopefully you have some intuition to understand why acting fast is paramount. Exchange rates fluctuate quickly, and there is only a limited amount of “thing” available at that exchange rate.

While we’ve worked with relatively simple examples here, arbitrage opportunities can span many trades, becoming incredibly complex. Our examples used 3 trades, but what if you needed 10? And in a network of 20 currencies with a market for each pair, how quickly could you find an opportunity?

Using a computer is an obvious answer. But we need an efficient algorithm, lest someone else beat us to the opportunity.

To achieve that, we can leverage a few clever insights in mathematics and computer science.

Markets as a Graph

Graphs are an incredibly important structure that has found its uses in numerous applications. Many social and natural structures can be modeled with graphs, and it turns out that markets are one of them.

In our case, let’s treat each currency as a node. Moving from node to node corresponds to trading one currency for another.

Simplified graph — there should be a distinct edge in each direction.

So moving along an edge, between nodes, should transform the amount of currency by the exchange rate.

That means moving from the dollar node to the pound node corresponds to multiplying by 0.8 pounds/dollar. Let’s assign the exchange rate as the weight of each edge.

Note that the exchange rate in each direction will be approximately the reciprocal of each other. That means if the rate to convert pounds to dollars is 0.8 pounds/dollar, the rate in the other direction will be 1/(0.8 pounds/dollar) = 1.25 dollars/pound. The consequence for us is that we need to be careful to treat buying and selling on each market as distinct, directed edges, with different weights.

The reason that the exchange rates in both directions are only approximately reciprocal is due to small differences in the prices to buy and sell currencies, known as the buy-sell spread. For example, if at a given moment you can buy pounds at 0.8 pounds/dollar (the current price somebody will sell to you), but can sell dollars for pounds at 0.82 pounds/dollar (or 1.22 dollars/pound, and the current price somebody will buy from you), your graph model will look like this (excluding the other exchange rates for simplicity):

A series of trades can be modeled by moving along edges in this graph, and the result of the trades is computed by multiplying the edge weights as you move along them.

Seeing the Opportunity

Now that we have a working model, what are we looking for in our graph that corresponds to an arbitrage opportunity?

To determine whether a series of trades is profitable, we need a consistent metric of profitability. In other words, if we begin our series of trades in dollars, then we’ll need to end it in dollars, too. And by comparing the amount of dollars we ended up with to the amount we started with, we’ll know if it was profitable or not.

In our graph, that means that our series of trades must end at the same node from which it started. In our case, we started at the dollar node, and ended in the dollar node. In graph terminology, we call that a cycle. So we know we’re looking for some sort of cycle- but what kind of cycle makes it profitable?

Notice that if we multiply along the edges of a cycle, we transform the units of the effective exchange rate.

$$ \begin{align} a \space \frac{\cancel{£}}{$} \times b \space \frac{¥}{\cancel{£}} = ab \space \frac{¥}{$} \tag{2} \label{eq:units_of_exchange_rate} \end{align} $$

However, when we return to our starting node, the quantity becomes unit-less. It transforms from a rate of exchange, to a ratio of return! Traversing a cycle on our graph and computing the product of exchange rates along the way corresponds to calculating the ratio of return we would get after completing the series of trades.

$$ \begin{align} a \space \frac{\cancel{£}}{\cancel{$}} \times b \space \frac{\cancel{¥}}{\cancel{£}} \times c \space \frac{\cancel{$}}{\cancel{¥}} = abc \space \text{[dimensionless]} \tag{3} \label{eq:unitless_exchange} \end{align} $$

If the market is perfectly efficient, our return ratio, $abc$, will be 1, because the exchange rates have equalized. If the product of weights is greater than 1, say 1.02, then our arbitrage opportunity would have made us a 2% return.

Therefore, generalizing to an arbitrary number of trades, an arbitrage opportunity corresponds to the following inequality:

$$ \begin{align} \prod_i^n{e_i} = e_ie_2...e_n > 1 \tag{4} \label{eq:arbitrage_return} \end{align} $$

where $e_i$ corresponds to the $i^{th}$ exchange rate, for each trade $i$, over n trades.

So what we need is an algorithm that will find a cycle on the graph of markets, where the product of edge weights is greater than 1. You might be able to invent an algorithm to do that - but in computer science, as in life in general, it’s useful to reduce problems to ones you already know how to solve.

The Bellman-Ford Algorithm

The problem of finding shortest paths is a common and fundamental problem in computer science, which can be applied to many different scenarios. An obvious one, by drawing a correspondence between a graph and a map, is that of finding the shortest route on a map. But with some cleverness, many other kinds of problems can be transformed into a shortest-path problem, as well. What I’m going to prove to you is that the problem of finding arbitrage opportunities is one such problem.

First, let’s establish what the shortest path problem is. Given two nodes in a graph, $s$ and $t$, the shortest path is that path which minimizes the sum of edge weights. In other words, we move along the path from $s$ to $t$, adding up edge weights along the way, the path with the minimum sum is the shortest path — the path with the smallest cost.

Next, it will be helpful to understand that there are different classes of shortest-path problems. In the obvious example — like the shortest route on a map — edge weights must be positive. There’s no way, barring a time machine, that driving down a road will reduce your travel time. In a graph with only positive edge weights, Dijkstra’s famous algorithm will compute the shortest path to all nodes in the graph.

However, there is no reason a graph cannot have negative edge weights. In that case, moving along that edge reduces the total cost of the path. But, if you have a cycle which has a negative weight, then you can keep traversing that cycle forever — every time, lowering your overall cost of the path — and your shortest path will have a cost approaching $-\infty$. In that case, it would be very useful for our shortest-path algorithm to have a mechanism to identify negative weight cycles. Otherwise the shortest path would get stuck circling the negative weight cycle, forever.

The Bellman-Ford algorithm is exactly that algorithm. A more general version of Dijkstra’s shortest-path algorithm, it can handle negative weights. To do so, it detects negative weight cycles — cycles in a graph along which adding up the weights produces a negative value.

But how does an algorithm which can find cycles where the sum of edges is less than 0 help us, when we need an algorithm that can detect cycles where the product of edges is greater than 1?

Log to the Rescue

The next insight is that a product can be turned into a sum by applying the logarithmic function, thanks to the identity:

$$ \begin{align} \log{ab} = \log{a} + \log{b} \tag{5} \label{eq:log_product_identity} \end{align} $$

Thereby we can transform our problem of finding a cycle with a product greater than 1, to a problem of finding a cycle with a sum greater than 0! We do that by taking the log of each exchange rate, and using that as the weight of each edge.

Let’s show that by taking the log of both sides of our inequality. First, taking the log of the left-hand side transforms the problem of computing a product into computing a sum:

$$ \begin{align} \log{\prod_i^n{e_i}} = \log{e_ie_2...e_n} = \log{e_1} + ... + \log{e_n} = \sum_i^n{\log{e_i}} \tag{6} \end{align} $$

The log of the right side just transforms the 1 to a 0:

$$ \begin{align} \sum_i^n{\log{e_i}} > \log{1} \rightarrow \sum_i^n{\log{e_i}} > 0 \tag{7} \end{align} $$

We’re close, but not quite there. The final step, to reduce our problem to one that we can solve with this known algorithm, is to multiply each edge weight by -1. This turns the problem of finding a positive weight cycle, into finding a negative one:

$$ \begin{align} \sum_i^n{-\log{e_i}} < 0 \tag{8} \end{align} $$

Which we know the Bellman-Ford algorithm can do! Constructing a graph as specified and executing the Bellman-Ford algorithm on it will quickly and efficiently find arbitrage opportunities for us, because we’ve turned the arbitrage problem into the problem of finding the shortest path — the infinitely shortest path.

We need to find a negative weight cycle, where the weights are the negative logarithm of the exchange rates.

In hindsight, it’s obvious that there should be a correspondence between a negative weight cycle — which lowers the cost of the path every time you traverse it — to an arbitrage opportunity, which makes you a profit every time you traverse it. The key insight is transforming a problem of finding a product greater than 1 into finding a sum less than 0, by applying -log to the edge weights.

Prove It

Let’s run this algorithm on our exchange rates to see if it correctly identifies the arbitrage opportunity. Transforming the exchange rates by -log, we get:

Market	-log(Exchange Rate)
pound (£) / dollar ($)	0.223
yen (¥) / pound (£)	-4.605
dollars ($) / yen (¥)	4.343

Summing over the trades, our equality holds- we found a negative weight cycle!

$$ \begin{align} \sum_i^n{-\log{e_i}} = 0.223 - 4.605 + 4.343 = -0.039 \label{eq:neg_log_exchange_rate_example} \tag{9} \end{align} $$

We can undo the logarithmic operation to restore the product, and calculate the return:

$$ \begin{align} \prod_i^n{e_i} &= \exp{\sum_i^n{-\log{e_i}}} \\ \prod_i^n{e_i} &= \exp(0.039) = 1.04 \tag{10} \end{align} $$

Which is exactly the 4% return we calculated earlier.

In the Real World

Since an arbitrage opportunity corresponds to a negative weight cycle, it seems that we could traverse the cycle forever to make infinite money. Of course, that is not the case.

The liquidity — the volume available before the price changes significantly- available for any arbitrage opportunity is limited, and is quickly exploited by algorithmic traders pushing the boundaries of computing technology and the laws of physics to beat each other.

That being said, I hope you found this exercise in applying graph theory and a well known shortest path algorithm to solving a problem in the finance domain — and making money — as interesting as I always have.