बड़े सहसंयोजक मैट्रिक्स की समानांतर गणना

Question

हम से लेकर आकारों के साथ गणना सहप्रसरण मैट्रिक्स की जरूरत को । हमारे पास GPU और क्लस्टर तक पहुंच है, हमें आश्चर्य है कि इन संगणनाओं को तेज करने के लिए सबसे अच्छा समानांतर दृष्टिकोण क्या है।$10000\times10000$$100000\times100000$

Comments

क्या आप अपने सहसंयोजक मैट्रिक्स के लिए विशिष्टताओं की अपेक्षा करते हैं? उदाहरण के लिए, "0 के निकट" सहसंबंधों की बड़ी संख्या?

— Dr_Sam

नहीं, हम अभी कुछ भी उम्मीद नहीं कर सकते हैं

— मार्ग

आपका k क्या है? यही है, प्रत्येक डेटा वेक्टर कब तक है। क्या वे शून्य-मतलब पहले से ही हैं?

— मैक्स हचिंसन

नहीं, वे शून्य-मीन नहीं हैं, वे जो भी मूल्य ले सकते हैं

— मार्ग

@ प्रवाह: '' क्लिनिकल डेटा '' appl8ication है, लेकिन उपयोग नहीं। मेरा प्रश्न था: मान लीजिए कि आपके पास सहसंयोजक मैट्रिक्स है, तो आप इसके साथ क्या करने जा रहे हैं (गणितीय दृष्टिकोण से)? मेरे द्वारा पूछे जाने का कारण यह है कि अंत में हमेशा इससे बहुत कम गणना की जाती है, और यदि इसे ध्यान में रखा जाए तो आमतौर पर पूर्ण सहसंयोजक मैट्रिक्स की गणना करने से बचते हुए चीजों को बहुत तेजी से बढ़ाया जा सकता है, जबकि अभी भी वांछित परिणाम प्राप्त कर सकते हैं।

— अर्नोल्ड न्यूमैयर

Answer 1

पहली बात यह है कि आप BLAS का उपयोग करके ऐसा कर सकते हैं। यदि आप डेटा मैट्रिक्स है$X = [x_1 x_2 x_3 ...] \in \mathbb{R}^{m\times n}$ (से प्रत्येक $x$एक माप के अनुरूप एक कॉलम वेक्टर है; पंक्तियाँ ट्रायल हैं), फिर आप कोविर्सिअस को इस प्रकार लिख सकते हैं:

$$C_{ij} = E[x_i,x_j] - E[x_i] E[x_j] = \frac{1}{n} \sum_k x_{ik} x_{jk} - \frac{1}{n^2} \left(\sum_k x_{ik} \right) \left(\sum_k x_{jk}\right)$$ हम इसे इस प्रकार लिख सकते हैं: $$C = \frac{1}{n} X^T X - \frac{1}{n^2} (1^T X)^T (1^T X)$$ कहाँ पे $(1^T)$ सभी तत्वों 1 के साथ पंक्ति-वेक्टर है $(1^T X)$ कॉलम रकम का एक पंक्ति वेक्टर है $X$। यह पूरी तरह से BLAS के रूप में लिखा जा सकता है, जहां$X^T X$या तो एक है GEMM या, बेहतर अभी तक, एक SYRK / Herk और आप प्राप्त कर सकते हैं$(1^T X) = b$एक GEMV के साथ ,$b^T b$GEMM या SYRK / HERK के साथ, और SCAL के साथ पूर्ववर्ती ।

आपका डेटा और परिणाम मैट्रिसेस लगभग 64GB हो सकता है, इसलिए आप एक नोड या एक नोड के GPU के लायक नहीं होंगे। एक गैर-GPU क्लस्टर के लिए, आप PBLAS को देखना चाहते हैं , जो स्केलपैक की तरह महसूस करता है। जीपीयू के लिए, बहु-नोड लाइब्रेरी अभी तक वहां नहीं हैं। मैग्मा में अंतर्निहित समानांतर BLAS कार्यान्वयन के कुछ प्रकार हैं, लेकिन यह उपयोगकर्ता के अनुकूल नहीं हो सकता है। मुझे नहीं लगता कि CULA मल्टी-नोड अभी तक नहीं करता है, लेकिन इसकी नज़र रखने के लिए कुछ है। CUBLAS एकल-नोड है।

मेरा यह भी सुझाव है कि आप अपने आप को समानांतर रूप से लागू करने पर दृढ़ता से विचार करें, खासकर यदि आप MPI से परिचित हैं और इसे मौजूदा कोड-बेस में हुक करना है। इस तरह, आप आसानी से सीपीयू और जीपीएल बीएलएएस के बीच स्विच कर सकते हैं और शुरू कर सकते हैं और डेटा के साथ समाप्त कर सकते हैं। आपको कुछ MPI_ALLREDUCE कॉल से अधिक की आवश्यकता नहीं होनी चाहिए ।

Comments

आपके विश्लेषण और प्रासंगिक BLAS कार्यों की सूची के लिए धन्यवाद। आपके उत्तर को पढ़ने के बाद मैंने सिलाब (www.scilab.org) के विकास संस्करण में सहसंयोजक मैट्रिक्स की गणना में तेजी लाने और अनुकूलन करने के लिए इनका उपयोग किया है।

— स्टीफन मोटलेट

हालांकि, चेतावनी दी जाती है कि कोवरियन के कंप्यूटिंग के इस तरीके का उपयोग करना जब विनाशकारी रद्द करने के अधीन है $E[x_i,x_j]$ इसके करीब है $E[x_i] E[x_j]$, उदाहरण के लिए en.wikipedia.org/wiki/…

— Stéphane Mottelet

Answer 2

मैंने CUBlas और Cuda Thrust के साथ @Max Hutchinson द्वारा दिए गए फार्मूले को लागू किया और ऑनलाइन सह विचरण गणना उपकरणों के साथ तुलना की। ऐसा लगता है कि मेरा अच्छा परिणाम है। नीचे दिया गया कोड QDA Bayes के लिए योजनाबद्ध है। इसलिए दिए गए मैट्रिक्स में एक से अधिक वर्ग हो सकते हैं। तो कई सह प्रसरण matrices की गणना की जाती है। मुझे उम्मीद है कि यह किसी के लिए उपयोगी होगा।

//! Calculates one or more than one coVarianceMatrix given data.
//  There can be many classes since many covariance matrixes.
/*!
    \param inMatrix This vector contains matrix data in major storage. 
    Forexample if inMatrix=[1 2 3 4 5 6] and trialSizes=[2] this means matrix we will work on a matrix like :
        |1 4 |
        |2 5 |
        |3 6 | -> 2 Trials, 3 Features. Columns contains feature rows contains trials (samples)
    \param trialSizes There can be many classes since many covariance matrixes. Samples from all classes will be given with inMatrix.
    But we need to know how many trials(samples) we have for each class. 
    For example if inMatrix=[1 2 3 4 5 6 7 8 9 10 11 12] and trialSizes=[2,2] 
    this means matrix we will work on a matrix like :
        |1 4 |  |7 10 |
        |2 5 |  |8 11 |
        |3 6 |  |9 12 |  --> Total number of trials(samples which is total rowCount) 2 + 2 = 4 , 
                             So colSize = inMatrix.size()/4 = 3(feature vector size)
                         --> There is two element in trialSize vec so each vector has to samples
*/
void multiQDACovianceCalculator(std::vector<float>& inMatrix, std::vector<int>& trialSizes)
{
    cublasHandle_t handle; // CUBLAS context
    int classCount = trialSizes.size();
    int rowSize = std::accumulate(trialSizes.begin(), trialSizes.end(), 0);
    int dimensionSize = inMatrix.size() / rowSize;
    float alpha = 1.0f;
    float beta = 0.0f; // bet =1

    thrust::device_vector<float> d_cov1(dimensionSize * dimensionSize);
    thrust::device_vector<float> d_cov2(dimensionSize * dimensionSize);
    thrust::device_vector<float> d_covResult(dimensionSize * dimensionSize);

    thrust::device_vector<float> d_wholeMatrix(inMatrix);
    thrust::device_vector<float> d_meansVec(dimensionSize); // rowVec of means of trials
    float *meanVecPtr = thrust::raw_pointer_cast(d_meansVec.data());
    float *device2DMatrixPtr = thrust::raw_pointer_cast(d_wholeMatrix.data());
    auto maxTrialNumber = *std::max_element(trialSizes.begin(), trialSizes.end());
    thrust::device_vector<float> deviceVector(maxTrialNumber, 1.0f);

    cublasCreate(&handle);
    // Inside of for loop  one covariance matrix calculated each time
    for (int i = 0; i < trialSizes.size(); i++)
    {
        // X*transpose(X) / N
        alpha = 1.0f / trialSizes[i];
        cublasSgemm(handle, CUBLAS_OP_N, CUBLAS_OP_T, dimensionSize, dimensionSize, trialSizes[i], &alpha,
            device2DMatrixPtr, dimensionSize, device2DMatrixPtr, dimensionSize, &beta,
            thrust::raw_pointer_cast(d_cov1.data()), dimensionSize);

        // Mean vector of each column
        alpha = 1.0f;
        cublasSgemv(handle, CUBLAS_OP_N, dimensionSize, trialSizes[i], &alpha, device2DMatrixPtr,
            dimensionSize, thrust::raw_pointer_cast(deviceVector.data()), 1, &beta, meanVecPtr, 1);

        // MeanVec * transpose(MeanVec) / N*N
        alpha = 1.0f / (trialSizes[i] * trialSizes[i]);
        cublasSgemm(handle, CUBLAS_OP_T, CUBLAS_OP_N, dimensionSize, dimensionSize, 1, &alpha,
            meanVecPtr, 1, meanVecPtr, 1, &beta,
            thrust::raw_pointer_cast(d_cov2.data()), dimensionSize);

        alpha = 1.0f;
        beta = -1.0f;
        //  (X*transpose(X) / N) -  (MeanVec * transpose(MeanVec) / N*N)
        cublasSgeam(handle, CUBLAS_OP_N, CUBLAS_OP_N, dimensionSize, dimensionSize, &alpha,
            thrust::raw_pointer_cast(d_cov1.data()), dimensionSize, &beta, thrust::raw_pointer_cast(d_cov2.data()), 
            dimensionSize, thrust::raw_pointer_cast(d_covResult.data()), dimensionSize);

        // Go to other class and calculate its covarianceMatrix
        device2DMatrixPtr += trialSizes[i] * dimensionSize;
    }
    printVector(d_covResult);
    cublasDestroy(handle);
}