Quantstrat 'for loop'u mclapply [parallelized] ile nasıl değiştiririm?

Aug 16 2020

Quantstrat'ı paralelleştirmek istiyorum. Kodum tam olarak böyle değil, ancak bu sorunu gösteriyor. Blotter env'nin bir işaretçi bellek adresine başlatıldığına inandığım ve new.env () dizisini / matrisini başlatamıyorum.

Yapmak istediğim şey, for döngüsünü bir mclapply ile değiştirmektir, böylece değişen tarihlere / sembollere sahip birden fazla applyStrategies çalıştırabilirim (burada yalnızca değişen semboller gösterilmektedir). Nihai hedefim bir beowulf kümesi (makeCluster) ve bunları yineleme başına değişen sembollerle 252 işlem gününe kadar (kayan pencere) kullanarak paralel olarak çalıştırmayı planlıyorum (ancak bunların hepsine ihtiyacım yok. portföy ve sonraki .blotter bellek nesnesini mclapply'yi kullanabileceğim bir şekilde atamanın yolu)

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

}
)

Ancak bir hata atıldı Get (sembol, envir = envir) hatası: 'QQQ' nesnesi bulunamadı

Özellikle sorun, FinancialInstrument :::. Enstrüman, kapsüllenmiş değişken çağrılarımla (simge dizgisi) güncellenmeyen bir bellek adresini işaret ediyor

Yanıtlar

3 BrianG.Peterson Aug 17 2020 at 20:37

apply.paramsetin quantstratzaten foreachyürütmeyi paralelleştirmek için bir yapı kullanıyor applyStrategy.

apply.paramset İşi yapacak işçilerde ortamların mevcut olduğundan emin olmak ve onları arama sürecine geri göndermek için uygun sonuçları toplamak için makul miktarda çalışma yapması gerekir.

Yapmanız gereken en basit şey muhtemelen kullanmak olacaktır apply.paramset. Tarihlerinizi ve sembollerinizin parametrelerini yapın ve işlevin normal şekilde çalışmasını sağlayın.

Alternatif olarak, önerilen duruma göre değiştirmek için paralel bir foreachyapıyı kullanmak için gereken adımlara bakmanızı öneririm apply.paramset.

Ayrıca sorunuzun bir Beowulf kümesi ve mclapply. Bu işe yaramayacak. mclapplyyalnızca tek bir bellek alanında çalışır. Beowulf kümeleri normalde tek bir belleği ve işlem alanını paylaşmaz. Genellikle işleri MPI gibi paralel kitaplıklar aracılığıyla dağıtırlar. apply.paramsetbir doMPIarka uç kullanarak bir Beowulf kümesinde zaten dağıtılabilir foreach. Bu, kullanmamızın nedenlerinden biri foreach: mevcut olan çok sayıda farklı paralel arka uç. Arka doMCuç foreachaslında mclapplyperde arkasında kullanır .

1 thistleknot Aug 19 2020 at 20:43

Bunun kodla paralel olduğuna inanıyorum. Göstergelerin yanı sıra sembollerin yerini değiştirdim, ancak farklı semboller ve tarihler kullanmanın mantığı burada.