एक गाऊसी गिरी की गणना प्रभावी ढंग से सुन्न में कैसे करें [बंद]

Question

मेरे पास एम कॉलम और एन पंक्तियों के साथ एक सुस्पष्ट सरणी है , कॉलम आयाम और पंक्तियों के डेटापॉइंट हैं।

अब मुझे डेटा बिंदुओं के प्रत्येक संयोजन के लिए कर्नेल मानों की गणना करने की आवश्यकता है।

एक रैखिक कर्नेल $K(\mathbf{x}_i,\mathbf{x}_j) = \langle \mathbf{x}_i,\mathbf{x}_j \rangle$ मैं बस कर सकता हूँdot(X,X.T)

मैं गॉसियन कर्नेल K (\ mathbf {x} _i, \ mathbf {x} _j) = \ exp {- \ frac {\ _ \ _ \ _ \ _ \ _bbb {{}}-\ mathbf {x} _j के लिए सभी मूल्यों की प्रभावी रूप से गणना कैसे कर सकता हूं। $K(\mathbf{x}_i,\mathbf{x}_j) = \exp{-\frac{\|\mathbf{x}_i-\mathbf{x}_j\|_2^2}{s^2}}$किसी दिए गए s के साथ \ | _2 ^ 2} {s ^ 2}} ?

Comments

यदि आप गणना में दो वृद्धि के कारक के बारे में बहुत अधिक परवाह नहीं करते हैं, तो आप हमेशा और फिर जहां, निश्चित रूप से, एक है की वें तत्व । यह शायद है नहीं सबसे संख्यानुसार स्थिर है, हालांकि, या तो। $\newcommand{\m}{\mathbf} \m S = \m X \m X^T$$K(\m x_i, \m x_j ) = \exp( - (S_{ii} + S_{jj} - 2 S_{ij})/s^2 )$$S_{ij}$$(i,j)$$\m S$

— कार्डिनल

(वर्षों बाद) बड़ी विरल सरणियों के लिए, sklearn.metrics.pairwise.pairwise_distances.html देखें ।

— डेसीस

Answer 1

मुझे लगता है कि मुख्य समस्या जोड़ीदार दूरी को कुशलता से प्राप्त करना है। एक बार आपके पास यह है कि बाकी तत्व बुद्धिमान है।

ऐसा करने के लिए, आप शायद scipy का उपयोग करना चाहते हैं। फ़ंक्शन scipy.spatial.distance.pdistवह करता है जो आपको चाहिए, और scipy.spatial.distance.squareformसंभवतः आपके जीवन को आसान बना देगा।

इसलिए यदि आप कर्नेल मैट्रिक्स चाहते हैं तो आप करें

from scipy.spatial.distance import pdist, squareform
  # this is an NxD matrix, where N is number of items and D its dimensionalites
X = loaddata() 
pairwise_dists = squareform(pdist(X, 'euclidean'))
K = scip.exp(-pairwise_dists ** 2 / s ** 2)

प्रलेखन यहाँ पाया जा सकता है । 

Comments

मुझे ऐसा लगता है कि बेयरज के उत्तर के लिए सूत्र को फिट करने के लिए कुछ छोटे संशोधनों की आवश्यकता है, अगर किसी और को इसकी आवश्यकता है:K = scipy.exp(-pairwise_dists**2 / s**2)

— च्लोए

यदि कोई उत्सुक है, तो इसके द्वारा उपयोग किया जाने वाला एल्गोरिथ्म pdistबहुत सरल है: यह सिर्फ एक सी-कार्यान्वित लूप है जो सीधे स्पष्ट तरीके से दूरी की गणना करता है , यहां किया जा रहा लूपिंग ; जो भी कंपाइलर स्वचालित रूप से पूरा कर सकता है, उसके आगे कोई फैंसी वेक्टराइजेशन या कुछ भी नहीं।

— डगल

Answer 2

बायरज के उत्तर के लिए एक छोटे से परिशिष्ट के रूप में, स्कैपी का pdistकार्य सीधे रूप से स्क्वेरेड यूक्लिडियन मानदंडों की गणना कर सकता है pdist(X, 'sqeuclidean')। पूर्ण कोड को तब और अधिक कुशलता से लिखा जा सकता है

from scipy.spatial.distance import pdist, squareform
  # this is an NxD matrix, where N is number of items and D its dimensionalites
X = loaddata() 
pairwise_sq_dists = squareform(pdist(X, 'sqeuclidean'))
K = scip.exp(-pairwise_sq_dists / s**2)

Comments

या बस pairwise_sq_dists = cdist(X, X, 'sqeuclidean')जो वही देता है।

— user1721713

Answer 3

आप हाथ से वर्गाकार रूप भी लिख सकते हैं:

import numpy as np
def vectorized_RBF_kernel(X, sigma):
    # % This is equivalent to computing the kernel on every pair of examples
    X2 = np.sum(np.multiply(X, X), 1) # sum colums of the matrix
    K0 = X2 + X2.T - 2 * X * X.T
    K = np.power(np.exp(-1.0 / sigma**2), K0)
    return K

PS लेकिन यह 30% धीमा काम करता है

Comments

यह, जो कि टिप्पणियों में कार्डिनल द्वारा सुझाई गई विधि है, इनहेलर ऑपरेशंस का उपयोग करके थोड़ा सा उगाया जा सकता है। यह आपके लिए एक कॉल के साथ कितना डरावना-सीखता है । einsumX2

— डगल

Answer 4

def my_kernel(X,Y):
    K = np.zeros((X.shape[0],Y.shape[0]))
    for i,x in enumerate(X):
        for j,y in enumerate(Y):
            K[i,j] = np.exp(-1*np.linalg.norm(x-y)**2)
    return K

clf=SVR(kernel=my_kernel)

जो के बराबर है

clf=SVR(kernel="rbf",gamma=1)

आप उपरोक्त कोड नोट से आरबीएफ को प्रभावी ढंग से गणना कर सकते हैं कि गामा मूल्य 1 है, क्योंकि यह एक निरंतर है जो आपके द्वारा अनुरोधित एक समान है।

Comments

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

— सिल्वरफिश

यह अन्य उत्तरों की तुलना में बहुत धीमा होगा क्योंकि यह वेक्टराइजेशन के बजाय पायथन लूप्स का उपयोग करता है।

— डगल

Answer 5

मुझे लगता है कि इससे मदद मिलेगी:

def GaussianKernel(v1, v2, sigma):
    return exp(-norm(v1-v2, 2)**2/(2.*sigma**2))

Comments

साइट पर आपका स्वागत है @ कर्नेल। आप $ संकेतों के बीच अभिव्यक्ति और सिंटैक्स की तरह लेटेक्स का उपयोग करके गणित को प्रदर्शित कर सकते हैं। और आप 4 स्थानों द्वारा लाइनों को इंडेंट करके कोड (सिंटैक्स हाइलाइटिंग के साथ) प्रदर्शित कर सकते हैं। दिशानिर्देशों को प्रारूपित करने के लिए मार्कडाउन संपादन सहायता देखें, और अधिक सामान्य लोगों के लिए faq ।

— एंटोनी वर्नेट

क्या यह सिर्फ गूंज नहीं है जो प्रश्न में है?

— whuber