Hedge funds are among the most computationally demanding environments
I know of.
They have infrastructure requirements like huge databases,
significant network connectivity, low latency and
high bandwidth connectivity, real-time processing, and so on.
I want to show you as an example, the typical kinds of computing
that goes on inside a hedge fund to motivate you for this class.
In other words, this isn't exactly the way all hedge funds work, but
this is just to give you a taste for how many hedge funds work.
And you'll see, I think, that computing and
computational capabilities are core here.
So we're going to work backwards from the market
back towards the sort of back office of the hedge fund.
The way things work are we have certain portfolio that is which stocks
we have and whether we're in positive or negative positions with regard to them.
The trading algorithm here is central.
It's interacting with the market, observing the live portfolio.
And what it's trying to do is to get this live portfolio
to match some target portfolio.
So somewhere further back inside the hedge fund
we've decided what this target portfolio ought to look like.
In other words,
how many shares of Apple, how many shares of Delta Airlines we should have,
and so on, and this trading algorithm is trying to get us there.
So it's comparing target with live.
And then to move this portfolio towards that target, it's issuing orders.
So it sends order like buy 200 shares of Apple to the market.
Those orders get executed or not, and that updates the live portfolio.
Now one reason this kind of trading algorithm is important
is you don't want to execute everything at once.
In other words, suppose we wanted to take a very,
very large position in Apple.
If we were just to send an order, hey, buy me 10 million shares of Apple,
that would affect us detrimentally in the sense that the price for
Apple would probably rise.
And we would not get a good execution.
So this training algorithm takes those sorts of things into consideration as
it moves our live portfolio to be more close to the target portfolio.
In fact, sometimes it takes days to enter a particular position.
So this doesn't necessarily happen all at once.
And there's many, many different types of trading algorithms that have
been invented to solve these problems.
Now let's step one step back into the computing of the hedgefund, and
look at how we arrive at this target portfolio.
Here's that target portfolio, and here is some of the data and
computing that could go into computing that target portfolio.
So from somewhere, machine learning perhaps, we have a forecast
of what stock prices are going to be at some time into the future.
And that can of course drive what our target portfolio ought to be for today.
In other words, if we're forecasting that BAC is going to go up,
this might represent that we think it's going to go up 5%.
We might want to increase our holdings in that.
If we think that Apple, for instance,
is going to go down, we might want to decrease our holdings.
So this forecast informs this algorithm called a Portfolio Optimizer.
That works to balance the risks and rewards for
a balanced portfolio that considers volatility and
correlation between different stocks and so on.
We're going to talk a lot about portfolio optimization later in this
course.
Some other considerations that go into Portfolio Optimizer are historical data,
open, high, low, close, and volume.
We can look at that historical data to inform how stocks are correlated or
uncorrelated to one another, and
also of critical importance is our current portfolio.
It may be the case that if we're holding something, we don't
want to exit it immediately because we'd be penalized by rapidly selling it.
So this optimizer takes all this information into account
to get to the target portfolio
that our trading algorithm is working to drive us towards.
Now one more stop along our road here at the computing infrastructure of a hedge
fund is to look at how do we come up with this N-day forecast.
By N, N might be five days or ten days or whatever.
So here's this N-day forecast, and we've got some kind of forecasting algorithm.
This is very often in the form of a model, in fact,
a machine learning based model.
And creating these sorts of forecasting algorithms using machine learning
is the focus of the last mini-course in this group of mini-courses.
Anyhow, how do we get to this forecast?
Well, we've usually got some sort of proprietary information,
again, historical data, and
our forecaster crunches all that data to build a model and create a forecast.
So, bringing it all together, that's the computing in a hedge fund.
And we've also spent some time talking about what might motivate you
as a hedge fund manager.
That's it for this lesson.
I'll talk to you again soon.