Jak zamienić Quantstrat „for loop” na mclapply [zrównoleglony]?

Aug 16 2020

Chciałbym zrównoleglać quantstrat. Mój kod nie jest dokładnie taki, ale to pokazuje problem. Uważam, że problem polega na tym, że env .blotter jest zainicjowany na adres pamięci wskaźnika i nie mogę zainicjować tablicy / macierzy new.env ().

Chciałbym zamienić pętlę for na mclapply, aby móc uruchomić wiele strategii applyStrategies z różnymi datami / symbolami (pokazane są tylko różne symbole). Moim końcowym celem jest klaster beowulf (makeCluster) i planuję uruchomić je równolegle, używając do 252 dni handlowych (okno ruchome) z różnymi symbolami na iterację (ale nie potrzebuję tego wszystkiego. Po prostu pytam, czy istnieje sposób pracy z przypisywaniem portfela i późniejszego obiektu pamięci .blotter w taki sposób, że mogę użyć mclapply)

#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)

}
)

Ale generowany jest błąd Błąd w get (symbol, envir = envir): nie znaleziono obiektu 'QQQ'

W szczególności problem polega na tym, że instrument FinancialInstrument :::. Instrument wskazuje na adres pamięci, który nie jest aktualizowany przez moje hermetyzowane wywołania zmiennych (ciąg znaków)

Odpowiedzi

3 BrianG.Peterson Aug 17 2020 at 20:37

apply.paramsetin quantstratjuż używa foreachkonstrukcji do zrównoleglenia wykonywania applyStrategy.

apply.paramset musi wykonać sporo pracy, aby upewnić się, że środowiska są dostępne dla pracowników do wykonania pracy oraz zebrać odpowiednie wyniki i odesłać ich z powrotem do procesu telefonicznego.

Najprostszą rzeczą do zrobienia byłoby prawdopodobnie użycie apply.paramset. Ustaw parametry dat i symboli i pozwól, aby funkcja działała normalnie.

Alternatywnie proponuję przyjrzeć się krokom wymaganym do użycia foreachkonstrukcji równoległej w programie, apply.paramsetaby zmodyfikować ją w swoim sugerowanym przypadku.

Zauważ również, że twoje pytanie dotyczy korzystania z klastra Beowulf i mclapply. To nie zadziała. mclapplydziała tylko w jednym miejscu w pamięci. Klastry Beowulf zwykle nie współużytkują pojedynczej pamięci i przestrzeni procesowej. Zwykle dystrybuują zadania za pośrednictwem bibliotek równoległych, takich jak MPI. apply.paramsetmoże już rozpowszechniać w klastrze Beowulf przy użyciu doMPIzaplecza do foreach. To jeden z powodów, dla których użyliśmy foreach: mnogość różnych równoległych backendów, które są dostępne. doMCBackend dla foreachfaktycznie korzysta mclapplyza kulisami.