डेटा के दो रुझान हैं; स्वतंत्र ट्रेंडलाइन कैसे निकालें?

Question

मेरे पास डेटा का एक सेट है जो किसी विशेष तरीके से ऑर्डर नहीं किया गया है लेकिन जब स्पष्ट रूप से प्लॉट किया गया है तो दो अलग-अलग रुझान हैं। दो श्रृंखलाओं के बीच स्पष्ट अंतर के कारण एक सरल रेखीय प्रतिगमन वास्तव में यहां पर्याप्त नहीं होगा। क्या दो स्वतंत्र रैखिक ट्रेंडलाइन प्राप्त करने का एक सरल तरीका है?

रिकॉर्ड के लिए मैं पायथन का उपयोग कर रहा हूं और मैं मशीन सीखने सहित प्रोग्रामिंग और डेटा विश्लेषण के साथ काफी सहज हूं, लेकिन यदि आवश्यक हो तो आर पर कूदने के लिए तैयार हूं।

Comments

मेरे पास अब तक का सबसे अच्छा जवाब ग्राफ पेपर पर इसे प्रिंट करना और एक पेंसिल और शासक और कैलकुलेटर का उपयोग करना है ...

— jbbiomed

हो सकता है कि आप जोड़ी-वार ढलान की गणना कर सकते हैं और उन्हें दो "ढलान-समूहों" में समूहित कर सकते हैं। हालाँकि यह विफल होगा यदि आपके पास दो समानांतर रुझान हैं।

— थॉमस जुंगलबुत

मेरे पास इसके साथ कोई व्यक्तिगत अनुभव नहीं है, लेकिन मुझे लगता है कि स्टेटमेंटमॉडल की जाँच के लायक होगा। सांख्यिकीय रूप से, समूह के लिए एक बातचीत के साथ एक रेखीय प्रतिगमन पर्याप्त होगा (जब तक आप कह रहे हैं कि आपके पास कोई डेटा नहीं है, जिस स्थिति में यह थोड़ा बालों वाला है ...)

— मैट पार्कर

दुर्भाग्य से यह प्रभाव डेटा नहीं है, लेकिन डेटा का उपयोग करता है, और दो अलग-अलग प्रणालियों से स्पष्ट रूप से उपयोग एक ही डेटा सेट में मिलाया जाता है। मैं दो उपयोग पैटर्न का वर्णन करने में सक्षम होना चाहता हूं, लेकिन मैं वापस नहीं जा सकता और डेटा को फिर से याद नहीं कर सकता क्योंकि यह एक ग्राहक द्वारा एकत्र की गई जानकारी के 6 साल के मूल्य का प्रतिनिधित्व करता है।

— जुलबी

बस यह सुनिश्चित करने के लिए: आपके ग्राहक के पास कोई अतिरिक्त डेटा नहीं है जो यह इंगित करेगा कि कौन सी जनसंख्या किस माप से आती है? यह 100% डेटा है जो आपके या आपके क्लाइंट के पास है या पा सकते हैं। इसके अलावा, 2012 ऐसा लगता है कि या तो आपका डेटा संग्रह अलग हो गया या आपके या आपके दोनों सिस्टम फर्श से गिर गए। मुझे आश्चर्य होता है कि क्या प्रवृत्ति उस बिंदु तक ज्यादा मायने रखती है।

— वेन

Answer 1

अपनी समस्या को हल करने के लिए, एक अच्छा तरीका एक संभाव्य मॉडल को परिभाषित करना है जो आपके डेटासेट के बारे में मान्यताओं से मेल खाता है। आपके मामले में, आप शायद रेखीय प्रतिगमन मॉडल का मिश्रण चाहते हैं। आप विभिन्न मिश्रण घटकों के साथ विभिन्न डेटा बिंदुओं को जोड़कर एक गाऊसी मिश्रण मॉडल के समान "मिश्रणों का मिश्रण" मॉडल बना सकते हैं।

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

import numpy as np
import matplotlib.pyplot as plt 
import scipy.linalg as lin

#generate some random data
N=100
x=np.random.rand(N,2)
x[:,1]=1

w=np.random.rand(2,2)
y=np.zeros(N)

n=int(np.random.rand()*N)
y[:n]=np.dot(x[:n,:],w[0,:])+np.random.normal(size=n)*.01
y[n:]=np.dot(x[n:,:],w[1,:])+np.random.normal(size=N-n)*.01


rx=np.ones( (100,2) )
r=np.arange(0,1,.01)
rx[:,0]=r

#plot the random dataset
plt.plot(x[:,0],y,'.b')
plt.plot(r,np.dot(rx,w[0,:]),':k',linewidth=2)
plt.plot(r,np.dot(rx,w[1,:]),':k',linewidth=2)

# regularization parameter for the regression weights
lam=.01

def em():
    # mixture weights
    rpi=np.zeros( (2) )+.5

    # expected mixture weights for each data point
    pi=np.zeros( (len(x),2) )+.5

    #the regression weights
    w1=np.random.rand(2)
    w2=np.random.rand(2)

    #precision term for the probability of the data under the regression function 
    eta=100

    for _ in xrange(100):
        if 0:
            plt.plot(r,np.dot(rx,w1),'-r',alpha=.5)
            plt.plot(r,np.dot(rx,w2),'-g',alpha=.5)

        #compute lhood for each data point
        err1=y-np.dot(x,w1)
        err2=y-np.dot(x,w2)
        prbs=np.zeros( (len(y),2) )
        prbs[:,0]=-.5*eta*err1**2
        prbs[:,1]=-.5*eta*err2**2

        #compute expected mixture weights
        pi=np.tile(rpi,(len(x),1))*np.exp(prbs)
        pi/=np.tile(np.sum(pi,1),(2,1)).T

        #max with respect to the mixture probabilities
        rpi=np.sum(pi,0)
        rpi/=np.sum(rpi)

        #max with respect to the regression weights
        pi1x=np.tile(pi[:,0],(2,1)).T*x
        xp1=np.dot(pi1x.T,x)+np.eye(2)*lam/eta
        yp1=np.dot(pi1x.T,y)
        w1=lin.solve(xp1,yp1)

        pi2x=np.tile(pi[:,1],(2,1)).T*x
        xp2=np.dot(pi2x.T,x)+np.eye(2)*lam/eta
        yp2=np.dot(pi[:,1]*y,x)
        w2=lin.solve(xp2,yp2)

        #max wrt the precision term
        eta=np.sum(pi)/np.sum(-prbs/eta*pi)

        #objective function - unstable as the pi's become concentrated on a single component
        obj=np.sum(prbs*pi)-np.sum(pi[pi>1e-50]*np.log(pi[pi>1e-50]))+np.sum(pi*np.log(np.tile(rpi,(len(x),1))))+np.log(eta)*np.sum(pi)
        print obj,eta,rpi,w1,w2

        try:
            if np.isnan(obj): break
            if np.abs(obj-oldobj)<1e-2: break
        except:
            pass

        oldobj=obj

    return w1,w2


#run the em algorithm and plot the solution
rw1,rw2=em()
plt.plot(r,np.dot(rx,rw1),'-r')
plt.plot(r,np.dot(rx,rw2),'-g')

plt.show()

Answer 2

इस थ्रेड में कहीं और, user1149913 महान सलाह (एक संभाव्य मॉडल को परिभाषित करता है) और एक शक्तिशाली दृष्टिकोण (EM अनुमान) के लिए कोड प्रदान करता है। दो मुद्दों पर ध्यान दिया जाना बाकी है:

1. संभाव्यता मॉडल से प्रस्थान का सामना कैसे करें (जो 2011-2012 के आंकड़ों में बहुत स्पष्ट हैं और कम-ढलान वाले बिंदुओं के अपवाद में स्पष्ट हैं)।

2. ईएम एल्गोरिथ्म (या किसी अन्य एल्गोरिथ्म) के लिए अच्छे शुरुआती मूल्यों की पहचान कैसे करें।

# 2 को संबोधित करने के लिए, पर्याप्त परिवर्तन का उपयोग करने पर विचार करें । यह एक फीचर-डिटेक्शन एल्गोरिथ्म है, जो सुविधाओं के रैखिक हिस्सों को खोजने के लिए, कुशलतापूर्वक रेडॉन रूपांतरण के रूप में गणना की जा सकती है ।

$x$$y$$x,y$Hough में परिवर्तन। जब मूल कथानक में सुविधाएँ एक सामान्य रेखा के साथ, या एक से अधिक के पास आती हैं, तो कफ के संग्रह, जो वे हूप ट्रांसफ़ॉर्म में उत्पन्न करते हैं, उस कॉमन लाइन के अनुरूप एक सामान्य चौराहा होता है। होफ ट्रांसफॉर्मेशन में सबसे बड़ी तीव्रता के इन बिंदुओं को पाकर, हम मूल समस्या के अच्छे समाधानों को पढ़ सकते हैं।

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

img = Import["http://i.stack.imgur.com/SkEm3.png"]
i = ColorNegate[Binarize[img]]
crop2 = ImageCrop[ImageCrop[i, {694, 531}, {Left, Bottom}], {565, 467}, {Right, Top}]

(यह और बाकी कोड गणितज्ञ हैं ।)

इस छवि में प्रत्येक बिंदु के लिए, Hough में घटता की एक संकीर्ण श्रृंखला से मेल खाती है, यहाँ दिखाई दे रही है। वे साइन लहरें हैं:

hough2 = Radon[crop2, Method -> "Hough"]  // ImageAdjust

यह नेत्रहीन रूप से उस भावना को प्रकट करता है जिसमें प्रश्न एक लाइन क्लस्टरिंग समस्या है: हूप ट्रांसफ़ॉर्म यह एक बिंदु क्लस्टरिंग समस्या को कम करता है, जिससे हम अपनी पसंद के किसी भी क्लस्टरिंग विधि को लागू कर सकते हैं।

इस मामले में, क्लस्टरिंग इतना स्पष्ट है कि Hough ट्रांसफॉर्म की सरल पोस्ट-प्रोसेसिंग पर्याप्त हो गई है। परिवर्तन में सबसे बड़ी तीव्रता के स्थानों की पहचान करने के लिए, मैंने इसके विपरीत वृद्धि की और लगभग 1% की त्रिज्या में परिवर्तन को धुंधला कर दिया: यह मूल छवि में भूखंड के बिंदुओं के व्यास के बराबर है।

blur = ImageAdjust[Blur[ImageAdjust[hough2, {1, 0}], 8]]

परिणाम थ्रेशहोल्डिंग ने इसे दो छोटे ब्लब्स तक सीमित कर दिया, जिनके केंद्रक यथोचित रूप से सबसे बड़ी तीव्रता के बिंदुओं की पहचान करते हैं: ये अनुमान लगाया लाइनों।

comp = MorphologicalComponents[blur, 0.777]) // Colorize

$0.777$

छवि के बाईं ओर 0 डिग्री (क्षैतिज) की दिशा से मेल खाती है और, जैसा कि हम बाएं से दाएं देखते हैं, वह कोण रैखिक रूप से 180 डिग्री तक बढ़ जाता है। इंटरपोलिंग, मैं गणना करता हूं कि दो बूँदें क्रमशः 19 और 57.1 डिग्री पर केंद्रित हैं। हम ब्लॉब्स के ऊर्ध्वाधर पदों से इंटरसेप्ट्स भी पढ़ सकते हैं। यह जानकारी प्रारंभिक फिट बैठता है:

width = ImageDimensions[blur][[1]];
slopes =  Module[{x, y, z}, ComponentMeasurements[comp, "Centroid"] /. 
          Rule[x_, {y_, z_}] :>  Round[((y - 1/2)/(width - 1))  180., 0.1]
  ]

{19., 57.1}

कुछ इसी अंदाज में, इन ढलानों के अनुरूप इंटरसेप्ट्स की गणना की जा सकती है, जिससे ये फिट होते हैं:

(लाल रेखा पिछली तस्वीर में छोटी गुलाबी बिंदु से मेल खाती है और नीली रेखा बड़ी एक्वा बूँद से मेल खाती है।)

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

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

Comments

चित्र एक हजार शब्द बताते हैं और आपके पास 5 हैं। यह इस प्रश्न के उद्देश्य के लिए बनाए गए एक त्वरित ग्राफ से अविश्वसनीय काम है! कुडोस!

— जुबैलोमेड

किसी छवि में सीधी रेखाओं की पहचान करने के लिए कंप्यूटर विज़न फ़ील्ड में व्यापक रूप से परिवर्तन का उपयोग किया जाता है। इसे आँकड़ों में भी क्यों नहीं इस्तेमाल किया जाना चाहिए? ;)

— लुकास रीस

$x$$y$

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

— लुकास रीस

@RoyalTS कोड स्निपेट में से किसी एक को फिक्स करने की आवश्यकता को इंगित करने के लिए धन्यवाद। जब तक मैंने आपके सुझाए गए परिवर्तन को पाया, तब तक इसे अस्वीकार कर दिया गया था (सही ढंग से, क्योंकि यह काफी सही नहीं था, लेकिन कभी भी इस पर ध्यान नहीं दिया: मैं आभारी हूं कि आपने देखा कि एक त्रुटि थी)। मैंने इसे संदर्भ को हटाकर तय किया rotation, जो मूल रूप से शून्य पर सेट किया गया था और इसलिए कोई फर्क नहीं पड़ा।

— whuber

Answer 3

मुझे यह सवाल दूसरे सवाल से जुड़ा हुआ लगा । मैंने वास्तव में इस तरह की समस्या पर अकादमिक शोध किया। कृपया मेरे उत्तर की जाँच करें "कम से कम वर्गमूल" फिटिंग? अधिक विवरण के लिए कई मिनीमा के साथ एक फिटिंग विधि ।

व्हीबर का हूप ट्रांसफॉर्म आधारित दृष्टिकोण सरल परिदृश्यों के लिए एक बहुत अच्छा समाधान है जैसा आपने दिया था। मैंने अधिक जटिल डेटा वाले परिदृश्यों पर काम किया, जैसे कि:

मेरे सह-लेखक और मैंने इसे "डेटा एसोसिएशन" समस्या बताया। जब आप इसे हल करने का प्रयास करते हैं, तो संभावित डेटा संयोजनों की घातीय राशि के कारण मुख्य समस्या आमतौर पर दहनशील होती है।

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

[अपडेट] OMGP तकनीक का पायथन कार्यान्वयन GPClust लाइब्रेरी में पाया जा सकता है ।

मेरे पास एक और पेपर है जहां हमने एक उत्तल अनुकूलन समस्या प्राप्त करने के लिए समस्या को शांत किया, लेकिन इसे अभी तक प्रकाशन के लिए स्वीकार नहीं किया गया है। यह 2 घटता के लिए विशिष्ट है, इसलिए यह आपके डेटा पर पूरी तरह से काम करेगा। मुझे बताओ की क्या तुम्हारी रूचि है।

Comments

मुझे यह देखकर दुख हुआ कि दो वर्षों में किसी और ने इस मूल और मूल्यवान उत्तर को नहीं उखाड़ा। इस बीच, आपके द्वारा उल्लेखित अंतिम पेपर स्वीकार किया गया है?

— whuber

कागज वास्तव में स्वीकार किया गया है, बस कुछ महीने पहले। आप इसे gtas.unican.es/pub/378 पर डाउनलोड कर सकते हैं । यह वास्तव में एक काफी दुर्लभ समस्या है (जो इसकी लोकप्रियता की कमी की व्याख्या कर सकती है), लेकिन हम अभी भी कुछ दिलचस्प अनुप्रयोगों को खोजने में कामयाब रहे। पेपर के अंत में प्रयोगों पर एक नज़र है यदि आप पसंद करते हैं।

— स्टीवन

Answer 4

user1149913 का एक उत्कृष्ट उत्तर (+1) है, लेकिन यह मुझे दिखता है कि 2011 के अंत में आपका डेटा संग्रह अलग हो गया था, इसलिए आपको अपने डेटा के उस हिस्से को काट देना होगा, और फिर भी कुछ बार अलग-अलग यादृच्छिक तरीके से चीजों को चलाना होगा। आप क्या प्राप्त करते हैं यह देखने के लिए गुणांक शुरू करना।

चीजों को करने का एक सीधा तरीका यह होगा कि आप अपने डेटा को दो सेटों में आँख से अलग करें, फिर आप जिस भी रैखिक मॉडल तकनीक का उपयोग करते हैं, उसका उपयोग करें। आर में, यह lmफ़ंक्शन होगा।

या आँख से दो पंक्तियाँ फिट। R में आप ऐसा करने के ablineलिए उपयोग करेंगे ।

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