Como substituo Quantstrat 'for loop' por mclaply [paralelizado]?

Aug 16 2020

Eu gostaria de paralelizar quantstrat. Meu código não é exatamente assim, mas isso mostra o problema. O problema que acredito é que o .blotter env é inicializado em um endereço de memória de ponteiro e não consigo inicializar uma matriz/array de new.env().

O que eu gostaria de fazer é substituir o loop for por um mclaply para que eu possa executar vários applyStrategies com datas/símbolos variados (somente símbolos variados são mostrados aqui). Meu objetivo final é um cluster beowulf (makeCluster) e pretendo executá-los em paralelo usando até 252 dias de negociação (janela contínua) com símbolos variados por iteração (mas não preciso de tudo isso. Estou simplesmente perguntando se há um maneira de trabalhar com a atribuição de portfólio e o objeto de memória .blotter subsequente de forma que eu possa usar o mclaply)

#Load quantstrat in your R environment.

rm(list = ls())

local()

library(quantstrat) 
library(parallel)

# The search command lists all attached packages.
search()

symbolstring1 <- c('QQQ','GOOG')
#symbolstring <- c('QQQ','GOOG')

#for(i in 1:length(symbolstring1))
  mlapply(symbolstring1, function(symbolstring)
{
  #local()
  #i=2
  #symbolstring=as.character(symbolstring1[i])
  
  .blotter <- new.env()
  .strategy <- new.env()
  
  try(rm.strat(strategyName),silent=TRUE)
  try(rm(envir=FinancialInstrument:::.instrument),silent=TRUE)
  for (name in ls(FinancialInstrument:::.instrument)){rm_instruments(name,keep.currencies = FALSE)}
  print(symbolstring)

currency('USD')

stock(symbolstring,currency='USD',multiplier=1)

# Currency and trading instrument objects stored in the 
# .instrument environment

print("FI")
ls(envir=FinancialInstrument:::.instrument)

# blotter functions used for instrument initialization 
# quantstrat creates a private storage area called .strategy

ls(all=T)

# The initDate should be lower than the startDate. The initDate will be used later while initializing the strategy.

initDate <- '2010-01-01'

startDate <- '2011-01-01'

endDate <- '2019-08-10'

init_equity <- 50000

# Set UTC TIME

Sys.setenv(TZ="UTC")

getSymbols(symbolstring,from=startDate,to=endDate,adjust=TRUE,src='yahoo')

# Define names for portfolio, account and strategy. 

#portfolioName <- accountName <- strategyName <- "FirstPortfolio"
portfolioName <- accountName <- strategyName <- paste0("FirstPortfolio",symbolstring)

print(portfolioName)
# The function rm.strat removes any strategy, portfolio, account, or order book object with the given name. This is important

#rm.strat(strategyName)

print("port")
initPortf(name = portfolioName,
          symbols = symbolstring,
          initDate = initDate)

initAcct(name = accountName,
         portfolios = portfolioName,
         initDate = initDate,
         initEq = init_equity)

initOrders(portfolio = portfolioName,
           symbols = symbolstring,
           initDate = initDate)



# name: the string name of the strategy

# assets: optional list of assets to apply the strategy to.  

# Normally these are defined in the portfolio object

# contstrains: optional portfolio constraints

# store: can be True or False. If True store the strategy in the environment. Default is False
print("strat")
strategy(strategyName, store = TRUE)

ls(all=T)

# .blotter holds the portfolio and account object 

ls(.blotter)

# .strategy holds the orderbook and strategy object

print(ls(.strategy))

print("ind")
add.indicator(strategy = strategyName, 
              name = "EMA", 
              arguments = list(x = quote(Cl(mktdata)), 
                               n = 10), label = "nFast")

add.indicator(strategy = strategyName, 
              name = "EMA", 
              arguments = list(x = quote(Cl(mktdata)), 
                               n = 30), 
              label = "nSlow")

# Add long signal when the fast EMA crosses over slow EMA.

print("sig")
add.signal(strategy = strategyName,
           name="sigCrossover",
           arguments = list(columns = c("nFast", "nSlow"),
                            relationship = "gte"),
           label = "longSignal")

# Add short signal when the fast EMA goes below slow EMA.

add.signal(strategy = strategyName, 
           name = "sigCrossover",
           arguments = list(columns = c("nFast", "nSlow"),
                            relationship = "lt"),
           label = "shortSignal")

# go long when 10-period EMA (nFast) >= 30-period EMA (nSlow)

print("rul")
add.rule(strategyName,
         name= "ruleSignal",
         arguments=list(sigcol="longSignal",
                        sigval=TRUE,
                        orderqty=100,
                        ordertype="market",
                        orderside="long",
                        replace = TRUE, 
                        TxnFees = -10),
         type="enter",
         label="EnterLong") 

# go short when 10-period EMA (nFast) < 30-period EMA (nSlow)

add.rule(strategyName, 
         name = "ruleSignal", 
         arguments = list(sigcol = "shortSignal", 
                          sigval = TRUE, 
                          orderside = "short", 
                          ordertype = "market", 
                          orderqty = -100, 
                          TxnFees = -10,                     
                          replace = TRUE), 
         type = "enter", 
         label = "EnterShort")

# Close long positions when the shortSignal column is True

add.rule(strategyName, 
         name = "ruleSignal", 
         arguments = list(sigcol = "shortSignal", 
                          sigval = TRUE, 
                          orderside = "long", 
                          ordertype = "market", 
                          orderqty = "all", 
                          TxnFees = -10, 
                          replace = TRUE), 
         type = "exit", 
         label = "ExitLong")

# Close Short positions when the longSignal column is True

add.rule(strategyName, 
         name = "ruleSignal", 
         arguments = list(sigcol = "longSignal", 
                          sigval = TRUE, 
                          orderside = "short", 
                          ordertype = "market", 
                          orderqty = "all", 
                          TxnFees = -10, 
                          replace = TRUE), 
         type = "exit", 
         label = "ExitShort")

print("summary")
summary(getStrategy(strategyName))

# Summary results are produced below

print("results")
results <- applyStrategy(strategy= strategyName, portfolios = portfolioName,symbols=symbolstring)

# The applyStrategy() outputs all transactions(from the oldest to recent transactions)that the strategy sends. The first few rows of the applyStrategy() output are shown below

getTxns(Portfolio=portfolioName, Symbol=symbolstring)

mktdata

updatePortf(portfolioName)

dateRange <- time(getPortfolio(portfolioName)$summary)[-1]

updateAcct(portfolioName,dateRange)

updateEndEq(accountName)

print(plot(tail(getAccount(portfolioName)$summary$End.Eq,-1), main = "Portfolio Equity"))

#cleanup
for (name in symbolstring) rm(list = name)
#rm(.blotter)
rm(.stoploss)
rm(.txnfees)
#rm(.strategy)
rm(symbols)

}
)

Mas um erro é lançado Erro em get(symbol, envir = envir): objeto 'QQQ' não encontrado

Especificamente, o problema é FinancialInstrument:::.instrument está apontando para um endereço de memória que não é atualizado com minhas chamadas de variáveis encapsuladas (symbolstring)

Respostas

3 BrianG.Peterson Aug 17 2020 at 20:37

apply.paramsetin quantstratjá usa uma foreachconstrução para paralelizar a execução de applyStrategy.

apply.paramsetprecisa fazer uma boa quantidade de trabalho para garantir que os ambientes estejam disponíveis nos trabalhadores para fazer o trabalho e coletar os resultados adequados para enviá-los de volta ao processo de chamada.

A coisa mais simples para você fazer provavelmente seria usar apply.paramset. Faça seus parâmetros de datas e símbolos e execute a função normalmente.

Como alternativa, sugiro que você observe as etapas necessárias para usar uma foreachconstrução paralela apply.paramsetpara modificá-la para o caso sugerido.

Observe também que sua pergunta é sobre o uso de um cluster Beowulf e mclapply. Isso não vai funcionar. mclapplysó funciona em um único espaço de memória. Os clusters Beowulf normalmente não compartilham uma única memória e espaço de processo. Eles normalmente distribuem tarefas por meio de bibliotecas paralelas, como MPI. apply.paramsetjá poderia distribuir em um cluster Beowulf usando um doMPIback-end para foreach. Essa é uma das razões pelas quais usamos foreach: a multiplicidade de diferentes back-ends paralelos disponíveis. O doMCback-end para foreachrealmente usa mclapplynos bastidores.

1 thistleknot Aug 19 2020 at 20:43

Eu acredito que isso paraleliza o código. Troquei os indicadores e também os símbolos, mas a lógica de usar símbolos e datas diferentes está aí