आरसीपी धीमी के साथ आर उद्देश्य समारोह का अनुकूलन, क्यों?


16

मैं वर्तमान में एक बायेसियन पद्धति पर काम कर रहा हूं जिसमें प्रति चलना एक बहुराष्ट्रीय लॉगिट मॉडल के अनुकूलन के कई चरणों की आवश्यकता है। मैं उन आशाओं को पूरा करने के लिए आशा () का उपयोग कर रहा हूं, और आर। प्रोफाइलिंग में लिखे गए एक उद्देश्य समारोह में पता चला है कि आशा () मुख्य अड़चन है।

चारों ओर खुदाई करने के बाद, मुझे यह प्रश्न मिला, जिसमें वे सुझाव देते हैं कि इस उद्देश्य को पूरा करने के साथ Rcppप्रक्रिया को गति दे सकते हैं। मैंने सुझाव का पालन किया और अपने उद्देश्य समारोह को फिर से शुरू किया Rcpp, लेकिन यह धीमा (लगभग दो गुना धीमा!) हो गया।

यह मेरा पहली बार था Rcpp(या C ++ से संबंधित कुछ भी) और मैं कोड को वेक्टर करने का एक तरीका नहीं खोज पा रहा था। किसी भी विचार यह कैसे तेजी से बनाने के लिए?

Tl; dr: Rcpp में फ़ंक्शन का वर्तमान कार्यान्वयन वेक्टराइज़्ड R जितना तेज़ नहीं है; इसे कैसे तेज किया जाए?

एक प्रतिलिपि प्रस्तुत करने योग्य उदाहरण :

1) में Rऔर Rcppएक इंटरसेप्ट केवल बहुराष्ट्रीय मॉडल की लॉग-सम्भावना को परिभाषित करें

library(Rcpp)
library(microbenchmark)

llmnl_int <- function(beta, Obs, n_cat) {
  n_Obs     <- length(Obs)
  Xint      <- matrix(c(0, beta), byrow = T, ncol = n_cat, nrow = n_Obs)
  ind       <- cbind(c(1:n_Obs), Obs)
  Xby       <- Xint[ind]
  Xint      <- exp(Xint)
  iota      <- c(rep(1, (n_cat)))
  denom     <- log(Xint %*% iota)
  return(sum(Xby - denom))
}

cppFunction('double llmnl_int_C(NumericVector beta, NumericVector Obs, int n_cat) {

    int n_Obs = Obs.size();

    NumericVector betas = (beta.size()+1);
    for (int i = 1; i < n_cat; i++) {
        betas[i] = beta[i-1];
    };

    NumericVector Xby = (n_Obs);
    NumericMatrix Xint(n_Obs, n_cat);
    NumericVector denom = (n_Obs);
    for (int i = 0; i < Xby.size(); i++) {
        Xint(i,_) = betas;
        Xby[i] = Xint(i,Obs[i]-1.0);
        Xint(i,_) = exp(Xint(i,_));
        denom[i] = log(sum(Xint(i,_)));
    };

    return sum(Xby - denom);
}')

2) उनकी दक्षता की तुलना करें:

## Draw sample from a multinomial distribution
set.seed(2020)
mnl_sample <- t(rmultinom(n = 1000,size = 1,prob = c(0.3, 0.4, 0.2, 0.1)))
mnl_sample <- apply(mnl_sample,1,function(r) which(r == 1))

## Benchmarking
microbenchmark("llmml_int" = llmnl_int(beta = c(4,2,1), Obs = mnl_sample, n_cat = 4),
               "llmml_int_C" = llmnl_int_C(beta = c(4,2,1), Obs = mnl_sample, n_cat = 4),
               times = 100)
## Results
# Unit: microseconds
#         expr     min       lq     mean   median       uq     max neval
#    llmnl_int  76.809  78.6615  81.9677  79.7485  82.8495 124.295   100
#  llmnl_int_C 155.405 157.7790 161.7677 159.2200 161.5805 201.655   100

3) अब उन्हें अंदर बुला रहे हैं optim:

## Benchmarking with optim
microbenchmark("llmnl_int" = optim(c(4,2,1), llmnl_int, Obs = mnl_sample, n_cat = 4, method = "BFGS", hessian = T, control = list(fnscale = -1)),
               "llmnl_int_C" = optim(c(4,2,1), llmnl_int_C, Obs = mnl_sample, n_cat = 4, method = "BFGS", hessian = T, control = list(fnscale = -1)),
               times = 100)
## Results
# Unit: milliseconds
#         expr      min       lq     mean   median       uq      max neval
#    llmnl_int 12.49163 13.26338 15.74517 14.12413 18.35461 26.58235   100
#  llmnl_int_C 25.57419 25.97413 28.05984 26.34231 30.44012 37.13442   100

मुझे कुछ आश्चर्य हुआ कि आर में वेक्टरकृत कार्यान्वयन तेजी से हुआ। Rcpp में एक अधिक कुशल संस्करण को लागू करना (RcppArmadillo के साथ कहते हैं?) किसी भी लाभ का उत्पादन कर सकता है? क्या C ++ ऑप्टिमाइज़र का उपयोग करके Rcpp में सबकुछ फिर से बनाना बेहतर है?

पुनश्च: पहली बार Stackoverflow में पोस्टिंग!

जवाबों:


9

सामान्य तौर पर यदि आप वेक्टरकृत कार्यों का उपयोग करने में सक्षम हैं, तो आप इसे (लगभग) आरसीपी में अपने कोड को सीधे चलाने के रूप में तेज़ पाएंगे। ऐसा इसलिए है क्योंकि आर में कई वेक्टरकृत कार्य (बेस आर में लगभग सभी वेक्टर किए गए कार्य) सी, सीपीपी या फोरट्रान में लिखे गए हैं और जैसे कि लाभ प्राप्त करने के लिए बहुत कम है।

उस ने कहा, आपके Rऔर Rcppकोड दोनों में लाभ होगा । अनुकूलन सावधानीपूर्वक कोड का अध्ययन करने, और अनावश्यक चरणों (स्मृति असाइनमेंट, रकम आदि) को हटाने से आता है।

Rcppकोड अनुकूलन के साथ शुरू करते हैं ।

आपके मामले में मुख्य अनुकूलन अनावश्यक मैट्रिक्स और वेक्टर गणना को दूर करना है। कोड सार है

  1. शिफ्ट बीटा
  2. समाप्ति राशि के योग की गणना करें (शिफ्ट बीटा) [लॉग-सम-एक्सप]
  3. स्थानांतरित बीटा के लिए एक सूचकांक के रूप में अवलोकन का उपयोग करें और सभी संभावनाओं पर योग करें
  4. लॉग-सम-ऍक्स्प को प्रतिस्थापित करें

इस अवलोकन का उपयोग करके हम आपके कोड को 2-छोरों के लिए कम कर सकते हैं। ध्यान दें कि sumबस एक और लूप के लिए है (अधिक या कम for(i = 0; i < max; i++){ sum += x }:) ताकि रकम से बचने से लोग कोड को आगे बढ़ा सकें (ज्यादातर स्थितियों में यह अनावश्यक अनुकूलन है!)। इसके अतिरिक्त आपका इनपुट Obsएक पूर्णांक वेक्टर है, और हम तत्वों को IntegerVectorकास्टिंग से बचने के लिए प्रकार का उपयोग करके कोड को और अधिक अनुकूलित कर सकते हैं (क्रेडिट राल्फ स्टबनर के जवाब में)।doubleinteger

cppFunction('double llmnl_int_C_v2(NumericVector beta, IntegerVector Obs, int n_cat)
 {

    int n_Obs = Obs.size();

    NumericVector betas = (beta.size()+1);
    //1: shift beta
    for (int i = 1; i < n_cat; i++) {
        betas[i] = beta[i-1];
    };
    //2: Calculate log sum only once:
    double expBetas_log_sum = log(sum(exp(betas)));
    // pre allocate sum
    double ll_sum = 0;

    //3: Use n_Obs, to avoid calling Xby.size() every time 
    for (int i = 0; i < n_Obs; i++) {
        ll_sum += betas(Obs[i] - 1.0) ;
    };
    //4: Use that we know denom is the same for all I:
    ll_sum = ll_sum - expBetas_log_sum * n_Obs;
    return ll_sum;
}')

ध्यान दें कि मैंने कुछ मेमोरी आवंटन हटा दिए हैं और फॉर-लूप में अनावश्यक गणना हटा दी है। इसके अलावा मैंने उपयोग किया है जो denomसभी पुनरावृत्तियों के लिए समान है और बस अंतिम परिणाम के लिए गुणा किया जाता है।

हम आपके आर-कोड में समान अनुकूलन कर सकते हैं, जिसका परिणाम निम्न कार्य में है:

llmnl_int_R_v2 <- function(beta, Obs, n_cat) {
    n_Obs <- length(Obs)
    betas <- c(0, beta)
    #note: denom = log(sum(exp(betas)))
    sum(betas[Obs]) - log(sum(exp(betas))) * n_Obs
}

ध्यान दें कि फ़ंक्शन की जटिलता को बहुत कम कर दिया गया है ताकि यह दूसरों के पढ़ने के लिए सरल हो सके। बस यह सुनिश्चित करने के लिए कि मैंने कोड में गड़बड़ नहीं की है, चलो जाँचते हैं कि वे उसी परिणाम को लौटाते हैं:

set.seed(2020)
mnl_sample <- t(rmultinom(n = 1000,size = 1,prob = c(0.3, 0.4, 0.2, 0.1)))
mnl_sample <- apply(mnl_sample,1,function(r) which(r == 1))

beta = c(4,2,1)
Obs = mnl_sample 
n_cat = 4
xr <- llmnl_int(beta = beta, Obs = mnl_sample, n_cat = n_cat)
xr2 <- llmnl_int_R_v2(beta = beta, Obs = mnl_sample, n_cat = n_cat)
xc <- llmnl_int_C(beta = beta, Obs = mnl_sample, n_cat = n_cat)
xc2 <- llmnl_int_C_v2(beta = beta, Obs = mnl_sample, n_cat = n_cat)
all.equal(c(xr, xr2), c(xc, xc2))
TRUE

खैर यह राहत की बात है।

प्रदर्शन:

मैं प्रदर्शन को दर्शाने के लिए माइक्रोबेनमार्क का उपयोग करूँगा। अनुकूलित कार्य तेज़ हैं, इसलिए मैं 1e5कचरा संग्राहक के प्रभाव को कम करने के लिए फ़ंक्शन बार चलाऊंगा

microbenchmark("llmml_int_R" = llmnl_int(beta = beta, Obs = mnl_sample, n_cat = n_cat),
               "llmml_int_C" = llmnl_int_C(beta = beta, Obs = mnl_sample, n_cat = n_cat),
               "llmnl_int_R_v2" = llmnl_int_R_v2(beta = beta, Obs = mnl_sample, n_cat = n_cat),
               "llmml_int_C_v2" = llmnl_int_C_v2(beta = beta, Obs = mnl_sample, n_cat = n_cat),
               times = 1e5)
#Output:
#Unit: microseconds
#           expr     min      lq       mean  median      uq        max neval
#    llmml_int_R 202.701 206.801 288.219673 227.601 334.301  57368.902 1e+05
#    llmml_int_C 250.101 252.802 342.190342 272.001 399.251 112459.601 1e+05
# llmnl_int_R_v2   4.800   5.601   8.930027   6.401   9.702   5232.001 1e+05
# llmml_int_C_v2   5.100   5.801   8.834646   6.700  10.101   7154.901 1e+05

यहां हम पहले जैसा ही परिणाम देखते हैं। अब नए कार्य अपने पहले काउंटर-पुर्जों की तुलना में लगभग 35x तेज़ (R) और 40x तेज़ (Cpp) हैं। दिलचस्प रूप से पर्याप्त अनुकूलित Rफ़ंक्शन मेरे अनुकूलित फ़ंक्शन की तुलना में अभी भी बहुत कम (0.3 एमएस या 4%) तेज है Cpp। यहां मेरा सबसे अच्छा शर्त यह है कि Rcppपैकेज से कुछ ओवरहेड है , और अगर इसे हटा दिया गया तो दोनों समान होंगे या आर।

इसी तरह हम ऑप्टिमाइज़ेशन का उपयोग करके प्रदर्शन की जाँच कर सकते हैं।

microbenchmark("llmnl_int" = optim(beta, llmnl_int, Obs = mnl_sample, 
                                   n_cat = n_cat, method = "BFGS", hessian = F, 
                                   control = list(fnscale = -1)),
               "llmnl_int_C" = optim(beta, llmnl_int_C, Obs = mnl_sample, 
                                     n_cat = n_cat, method = "BFGS", hessian = F, 
                                     control = list(fnscale = -1)),
               "llmnl_int_R_v2" = optim(beta, llmnl_int_R_v2, Obs = mnl_sample, 
                                     n_cat = n_cat, method = "BFGS", hessian = F, 
                                     control = list(fnscale = -1)),
               "llmnl_int_C_v2" = optim(beta, llmnl_int_C_v2, Obs = mnl_sample, 
                                     n_cat = n_cat, method = "BFGS", hessian = F, 
                                     control = list(fnscale = -1)),
               times = 1e3)
#Output:
#Unit: microseconds
#           expr       min        lq      mean    median         uq      max neval
#      llmnl_int 29541.301 53156.801 70304.446 76753.851  83528.101 196415.5  1000
#    llmnl_int_C 36879.501 59981.901 83134.218 92419.551 100208.451 190099.1  1000
# llmnl_int_R_v2   667.802  1253.452  1962.875  1585.101   1984.151  22718.3  1000
# llmnl_int_C_v2   704.401  1248.200  1983.247  1671.151   2033.401  11540.3  1000

एक बार फिर परिणाम वही है।

निष्कर्ष:

एक संक्षिप्त निष्कर्ष के रूप में यह ध्यान देने योग्य है कि यह एक उदाहरण है, जहां आपके कोड को Rcpp में परिवर्तित करना वास्तव में परेशानी के लायक नहीं है। यह हमेशा मामला नहीं होता है, लेकिन अक्सर यह आपके फ़ंक्शन पर दूसरा नज़र डालने के लायक है, यह देखने के लिए कि क्या आपके कोड के क्षेत्र हैं, जहां अनावश्यक गणना की जाती है। विशेष रूप से उन स्थितियों में जहां कोई बिल्डिन वेक्टराइज्ड फ़ंक्शन का उपयोग करता है, यह अक्सर कोड को आरसीपी में बदलने के लिए समय के लायक नहीं होता है। अधिक बार कोई एक महान सुधार देख सकता है यदि कोई for-loopsउस कोड का उपयोग करता है जिसे कैंट-फॉर-लूप को हटाने के लिए आसानी से वेक्टर किया जा सकता है।


1
आप कुछ जातियों को हटाने के Obsरूप में IntegerVectorमान सकते हैं।
राल्फ स्टनर

अपने उत्तर में यह ध्यान देने के लिए धन्यवाद देने से पहले आपको इसे शामिल करना था। यह बस मेरे द्वारा पारित किया गया। मैंने अपने उत्तर @RalfStubner में आपको इसके लिए श्रेय दिया है। :-)
ओलिवर

2
जैसा कि आपने इस खिलौना उदाहरण (इंटरसेप्ट-ओनली mnl मॉडल) पर ध्यान दिया है कि रेखीय भविष्यवक्ता ( beta) टिप्पणियों पर स्थिर रहते हैं Obs। अगर हमारे पास समय के हिसाब से भविष्यवाणियां होती हैं तो डिजाइन मैट्रिक्स के मूल्य के आधार पर denomप्रत्येक के लिए एक अनुमानित गणना Obsआवश्यक हो जाएगी X। कहा जा रहा है, मैं पहले से ही अपने कोड के बाकी हिस्सों में अपने सुझावों को कुछ अच्छे लाभ के साथ लागू कर रहा हूं :)। @RalfStubner, @Oliver और @thc को आपके बहुत ही सुखद जवाब के लिए धन्यवाद! अब मेरी अगली अड़चन पर चलते हुए!
Smildiner

1
मुझे खुशी है कि हम मदद कर सके। अधिक सामान्य मामले में दूसरे के प्रत्येक चरण पर घटते मूल्यवर्ग की गणना करना for-loopजो आपको सबसे बड़ा लाभ देगा। इसके अलावा अधिक सामान्य मामले में मैं model.matrix(...)आपके कार्यों में इनपुट के लिए अपना मैट्रिक्स बनाने का उपयोग करने का सुझाव दूंगा।
ओलिवर

9

आपके C ++ फ़ंक्शन को निम्न टिप्पणियों का उपयोग करके तेज़ी से बनाया जा सकता है। कम से कम पहले आपके R फ़ंक्शन के साथ भी उपयोग किया जा सकता है:

  • जिस तरह से आप गणना करते हैं denom[i]वह हर के लिए समान है i। इसलिए यह समझ में आता है double denomकि इस का उपयोग करें और यह गणना केवल एक बार करें। मैं भी अंत में इस सामान्य शब्द को घटाना कारक हूं।

  • आपकी टिप्पणियों वास्तव में आर पक्ष पर एक पूर्णांक वेक्टर हैं, और आप उन्हें C ++ में पूर्णांक के रूप में भी उपयोग कर रहे हैं। के IntegerVectorसाथ शुरू करने के लिए एक का उपयोग कर कास्टिंग की एक बहुत अनावश्यक बनाता है।

  • आप C ++ में ए NumericVectorका उपयोग करके भी इंडेक्स कर सकते हैं IntegerVector। मुझे यकीन नहीं है कि यह प्रदर्शन में मदद करता है, लेकिन यह कोड को थोड़ा छोटा करता है।

  • कुछ और बदलाव जो प्रदर्शन की तुलना में शैली से अधिक संबंधित हैं।

परिणाम:

double llmnl_int_C(NumericVector beta, IntegerVector Obs, int n_cat) {

    int n_Obs = Obs.size();

    NumericVector betas(beta.size()+1);
    for (int i = 1; i < n_cat; ++i) {
        betas[i] = beta[i-1];
    };

    double denom = log(sum(exp(betas)));
    NumericVector Xby = betas[Obs - 1];

    return sum(Xby) - n_Obs * denom;
}

मेरे लिए यह फ़ंक्शन आपके R फ़ंक्शन की तुलना में लगभग दस गुना तेज है।


आपके उत्तर के लिए धन्यवाद राल्फ, इनपुट प्रकार को हाजिर नहीं किया। मैंने इसे अपने उत्तर में शामिल किया है और साथ ही आपको श्रेय भी दिया है। :-)
ओलिवर

7

मैं राल्फ और ओलिव के उत्तरों पर चार संभावित अनुकूलन के बारे में सोच सकता हूं ।

(आपको उनके जवाब स्वीकार करने चाहिए, लेकिन मैं सिर्फ अपना 2 सेंट जोड़ना चाहता था)।

1) // [[Rcpp::export(rng = false)]]अलग सी ++ फ़ाइल में फ़ंक्शन के लिए एक टिप्पणी हेडर के रूप में उपयोग करें । यह मेरी मशीन पर ~ 80% की गति की ओर जाता है। (यह 4 में से सबसे महत्वपूर्ण सुझाव है)।

2) cmathजब संभव हो तो पसंद करें । (इस मामले में, इससे कोई फर्क नहीं पड़ता)।

3) जब भी संभव हो आवंटन से बचें, जैसे कि betaएक नए वेक्टर में शिफ्ट न करें ।

4) खिंचाव लक्ष्य: SEXPRcpp वैक्टर के बजाय मापदंडों का उपयोग करें । (पाठक को एक अभ्यास के रूप में छोड़ दिया)। Rcpp वैक्टर बहुत पतले रैपर होते हैं, लेकिन वे अभी भी रैपर हैं और एक छोटा ओवरहेड है।

ये सुझाव महत्वपूर्ण नहीं होंगे, यदि इस तथ्य के लिए नहीं कि आप फ़ंक्शन को एक तंग लूप में बुला रहे हैं optim। इसलिए कोई भी ओवरहेड बहुत महत्वपूर्ण है।

बेंच:

microbenchmark("llmnl_int_R_v1" = optim(beta, llmnl_int, Obs = mnl_sample, 
                                      n_cat = n_cat, method = "BFGS", hessian = F, 
                                      control = list(fnscale = -1)),
             "llmnl_int_R_v2" = optim(beta, llmnl_int_R_v2, Obs = mnl_sample, 
                                      n_cat = n_cat, method = "BFGS", hessian = F, 
                                      control = list(fnscale = -1)),
             "llmnl_int_C_v2" = optim(beta, llmnl_int_C_v2, Obs = mnl_sample, 
                                      n_cat = n_cat, method = "BFGS", hessian = F, 
                                      control = list(fnscale = -1)),
             "llmnl_int_C_v3" = optim(beta, llmnl_int_C_v3, Obs = mnl_sample, 
                                      n_cat = n_cat, method = "BFGS", hessian = F, 
                                      control = list(fnscale = -1)),
             "llmnl_int_C_v4" = optim(beta, llmnl_int_C_v4, Obs = mnl_sample, 
                                      n_cat = n_cat, method = "BFGS", hessian = F, 
                                      control = list(fnscale = -1)),
             times = 1000)


Unit: microseconds
expr      min         lq       mean     median         uq        max neval cld
llmnl_int_R_v1 9480.780 10662.3530 14126.6399 11359.8460 18505.6280 146823.430  1000   c
llmnl_int_R_v2  697.276   735.7735  1015.8217   768.5735   810.6235  11095.924  1000  b 
llmnl_int_C_v2  997.828  1021.4720  1106.0968  1031.7905  1078.2835  11222.803  1000  b 
llmnl_int_C_v3  284.519   295.7825   328.5890   304.0325   328.2015   9647.417  1000 a  
llmnl_int_C_v4  245.650   256.9760   283.9071   266.3985   299.2090   1156.448  1000 a 

v3 ओलिवर का जवाब है rng=false। v4 में सुझाव # 2 और # 3 शामिल हैं।

कार्यक्रम:

#include <Rcpp.h>
#include <cmath>
using namespace Rcpp;

// [[Rcpp::export(rng = false)]]
double llmnl_int_C_v4(NumericVector beta, IntegerVector Obs, int n_cat) {

  int n_Obs = Obs.size();
  //2: Calculate log sum only once:
  // double expBetas_log_sum = log(sum(exp(betas)));
  double expBetas_log_sum = 1.0; // std::exp(0)
  for (int i = 1; i < n_cat; i++) {
    expBetas_log_sum += std::exp(beta[i-1]);
  };
  expBetas_log_sum = std::log(expBetas_log_sum);

  double ll_sum = 0;
  //3: Use n_Obs, to avoid calling Xby.size() every time 
  for (int i = 0; i < n_Obs; i++) {
    if(Obs[i] == 1L) continue;
    ll_sum += beta[Obs[i]-2L];
  };
  //4: Use that we know denom is the same for all I:
  ll_sum = ll_sum - expBetas_log_sum * n_Obs;
  return ll_sum;
}
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.