Intraday Usecases for US Stockmarket

[omniv0x]

Adding to the discussion on discord I would like to describe my ideas for a bot that basically trades like an intraday trader focussing on

• gapping stocks
• unusual volume
• momentum
• high of day breakouts
• volatility halts

Scanning

At the heart of any of these strategies lies a dynamic selection of stocks based on some sort of scanning logic. I think the scanning part it self does not have to be a feature of the framework, but it would be great to be able to hook into the selection of stocks traded dynamically. It would probably best if this selection included some sort of signal, as depending on what scanner the stock came up on, a user might want to run a different strategy or parameter-set.
As I side note: Im working on a stock scanner in python right now. It scans the entire market periodically and saves data from polygon. In the future this should serve me with the ability to "replay" the market for each trading day and provide the necesarry data to backtest. Id be willing to port this to AVRO and share it with community

What would be the approach to feeding a selection of symbol/signal pairs to roboquant? Is it even possible to change to set of symbols while the bot is running?

(No) Indicators

From what Ive understood so far entry and exit signals in roboquant rely on some sort of indicator logic. I have to dive deeper into ta4j as I think it might be possible to reference "pure price action" with it.
Reading into the ta4j strategy code it uses a "series" argument which i think might be suitable.

How do you reference price data in roboquant? For example, getting extrema from the previous 10 1min bars? Or even just referencing the current price is beyond me right now, as the examples mosty show some current indicator value.

MultiTimeframe Analysis / Execution

This is something I have really struggeled with while testing different frameworks. When trading live manually I would compare different timeframes to gain a better understanding of the price action. In detail you might want to study these charts:

• daily to get some key support/resistance levels, quantify gapping behavior
• use a lower timeframe to quantify pullbacks and pivots
  or perform any other sort of analysis, basically accepting more or less noise the higher/lower you go.

The execution however should always be triggered by tick level price data - otherwise one can never catch a breakout.
Enabling a strategy to reference certain intervals of priceaction indepently of the timeframe would unlock great potential as you could:

• calculate support/resistance points
• identify multicandle patterns (like wedges, flags, channels etc.)
• you can also calculate some "velocity" based signals like volume rate of change etc.

I think archieving this relies heavily on the user as it would be necesarry to have all of the candle data ready. Of course some aggregation feature would help alot in this scenario. Getting back to the fact that the stock selection is limited by the scanner I am currently defaulting to downloading 3 months of data in daily resolution, the last week in hourly resolution and the trading day itself in tick resolution. I think you could also add a minute resolution for some sort of period to easily be able to aggregate these bars into any timeframe.

From what Ive understood so far, roboquant can handle multiple feeds already. I think thats a great basis to start from to archieve this feature, as a user could just pass multiple feeds, correct?

Some more detail on entry logic based on price action

If not using an indicator to generate signals one pretty much always relies on the price break through some sort of predefined level i.e. support/resistance, channels, pivot points etc. Identifying those algorithmically means defining some sort of lookback period and granularity. So to identify a pivot high you would look at the last x candles and pick the high point where y candles to left, aswell as z candles to the right are lower.

Conclusion

I hope this can give anybody reading some trading ideas and maybe we can figure out solutions for this together.
If somebody with a better understanding of roboquant could point me in some general directions I would be happy to share my solutions/findings with the community, possibly to be referenced in the documentation.

[jbaron]

I'll try to provide some answers and pointers per topic, but please feel free to correct me if I misunderstood it. So this reply covers the scanning part as I understood it:

Scanning

It is possible to have different strategies for different assets. Right now the out of the box provided asset filters are "static", but they could be made dynamic. Small (dummy) example with two different strategies for different stocks:

import org.roboquant.common.AssetFilter
import org.roboquant.strategies.CombinedStrategy
import org.roboquant.strategies.EMAStrategy
import org.roboquant.strategies.filter


val strategy = CombinedStrategy(

    EMAStrategy.PERIODS_12_26.filter(
        AssetFilter.includeSymbols("TSLA", "AAPL")
    ),

    EMAStrategy.PERIODS_5_15.filter(
        AssetFilter.includeSymbols("IBM", "MSFT", "GOOG")
    )

)

I use EMAStrategy variations as an example, but of course these strategies could be anything. And if I understood your use-case correctly, something like the following could work:

// This class represents the scanner you referred to
class Scanner(val symbols: Array<String>, val signal: String)

val scanners = listOf<Scanner>()
val strategies = mutableListOf<Strategy>()

for (x in scanners) {
    when(x.signal) {
        "a" -> strategies.add(EMAStrategy.PERIODS_12_26.filter(AssetFilter.includeSymbols(*x.symbols)))
        "b" -> strategies.add(EMAStrategy.PERIODS_5_15.filter(AssetFilter.includeSymbols(*x.symbols)))
    }
}

val strategy = CombinedStrategy(strategies)

[omniv0x]

Thanks for this idea, I think it should serve well in a live scenario, backtesting this will be a bit tricky. I might ignore this in the beginning and only test on data that was available premarket open, so I dont have to worry about having stocks available that wouldve come up later. For proper backtesting the scanner events have to be intime with the rest..Ill work on this once I better understand roboquant.

[jbaron]

(No) Indicators

Roboquant is event driven. That means that your strategy will just get the prices (or any other piece of information) at each moment in time they become available. This is true for both back-testing as well as live trading.

class MyStrategy : Strategy {
    override fun generate(event: Event): List<Signal> {
        print(event.time)
        for ((asset, action) in event.prices) {
            val price = action.getPrice()
            print("$asset $price")
        }
        TODO()
    }

}

However this is not convenient for many strategies since they need historic series of prices to work (f.e the last 10 prices for a stock). So there are some helper classes you can extend that make your life easier:

class MyStrategy2 : HistoricPriceStrategy(10, priceType = "CLOSE") {

    override fun generateRating(data: DoubleArray): Rating? {
        return if (data.last() == data.max()) 
            Rating.BUY
        else if (data.last() == data.min())
            Rating.SELL
        else 
            null
    }
    
}

And to make it even more convenient, roboquant also comes with bindings for two popular technical analysis/indicator frameworks, Ta4J and TaLib. TaLib is the much faster one of the two, while Ta4J is a more flexible.

val shortTerm = 30
val longTerm = 50
val myStrategy3 = TaLibStrategy(longTerm)

myStrategy3.buy {
    sma(it.close, shortTerm) > sma(it.close, longTerm)
}

myStrategy3.buy {
    sma(it.close, shortTerm) < sma(it.close, longTerm)
}

So you can see there are different ways to access prices in a strategy, depending on your needs.

[jbaron]

Ahh, I think I understand now. You want to use candle-stick (aka PriceBar) data to determine support/resistance lines and tick data (aka TradePrice) to create signals when for example a price passes a resistance line.

[omniv0x]

Yes, exactly. Sorry for the prior confusion. The support/resistance is a simple example on how one could be enabled to do analysis on multiple timeframes.
Cant wrap my head around this in the context of roboquant is from my understanding you would need two strategies and also two feeds?
Thanks again for your time on this - I really appreciate it. If you have a buymeacoffee link or something similiar Id be happy to give back.

[jbaron]

This isn't super hard to do (but if you are new to Kotlin and roboquant API documentation is still missing, not that obvious ;)

This is an example for creating a BUY signal when a simple resistance level is broken. The feed in this example is assumed to contain both price-bars and trade-prices.

class MyStrategy5 : Strategy {

    private val history = PriceBarSeries(50)
    
    private fun determineBreak(ticks: List<TradePrice>) : List<Asset> {
        val result = mutableListOf<Asset>()
        for (tick in ticks) {
            val priceBars = history[tick.asset]
            if (priceBars != null && priceBars.isFull()) {
                val resistenceLevel = priceBars.high.max()
                if (tick.price > resistenceLevel) result.add(tick.asset)
            }
        }
        return result
    }

    override fun generate(event: Event): List<Signal> {
        history.addAll(event) // Will automatically filter PriceBar actions

        val ticks = event.actions.filterIsInstance<TradePrice>()
        val assets = determineBreak(ticks)

        return assets.map { Signal(it, Rating.BUY) }
    }

}

[omniv0x]

I took the last two weeks to get a better grip on kotlin and so far it going great. This also allowed me to learn more about roboquant. If you would allow me to pick this topic up:
Am I right that it is assumed that a feed only contains priceBar records of a single resolution? (i.e. only daily ohlcv or only hourly ohlcv etc.)
From what I understand we look at each records -> priceAction -> priceBar. So if the feed would contain multiple resolutions that would end in mixed results.

Picking up on the multi-timeframe analysis part: A user might want to draw conclusions from a variety of resolutions.
I am thinking about three ways to tackle this - would do you think is the best approach?

Buffering:
Only use the lowest resolution required and aggregate them in series: For example only feed 1min data and instanciate a series of 5 priceBars, mapping the earliest open, the latest close and the min/max of the lows and highs to obtain a 5min bar.

Extending priceBar
Basically just keep a string record as a column for the resolution i.e. "1min"

Extending the feed
I really like the idea of only keeping a single avro file but maybe it would make sense to label each feed so you can, combine feeds, and reference data from a specific feed in a strategy.

Looking forward to your thoughts.

[jbaron]

A feed can contain mixed resolutions, and even a single event can have mixed resolutions (although if you use the convenience methods event.prices there is only one PriceAction per asset).

The following gives back all the price bars:

val allPriceBars = event.actions.filterIsInstance<PriceBar>()

What is missing however, is a way to easy differentiate them. So how to tell which is the 1-min and which is the 1-hour resolution for example. Best you can do today is looking at high-low (larger timeframes have higher spread), but that is of course not ideal.

Regarding possible solutions (my first thoughts):

• Buffering: perhaps a nice feature to add to PriceBarSeries, but for example if you would subscribe to multiple live-feeds of different resolutions this wouldn't help.

• Extending PriceBar: seems the right place to put this info. Have to check performance impact. Main reason why I didn't put it yet was the slightly more complicated serialisation of PriceActions (as used by Avro for example).

• Extending feed: at strategy level you only have events and I would like to avoid putting in knowledge from which feed they came from. The main reason is that when moving from back-test to live-trading, there are as few changes as possible.

P.S currently you can already combine feeds if you like, the only thing is your strategy is unaware where the actions are coming from.

[omniv0x]

Thank you very much for the time you took to explain these concepts.
Ive been carefully reading everything and will have to do some further reading in the code to fully understand whats going on (as well getting up there in kotlin, which im new to 😄).