डेटासेट

Question

में लगभग बराबर अंक विलय करना मैं एक एल्गोरिदम खोज रहा हूं जो जल्दी से एक छोटी (< 30 तत्व) सरणी के माध्यम से चला सकता है और लगभग बराबर अंक मर्ज कर सकता है। यह शायद कुछ प्रकार के विभाजन एल्गोरिदम होने का अंत हो जाएगा।

संदर्भ निम्नानुसार है: मैं डेटासेट में सबसे ऊंची चोटियों की तलाश में हूं। मैंने पहले ही J-SEG के एक आयामी कार्यान्वयन का उपयोग करके ड्रॉस से सबसे ऊंचे अधिकतम सीमाओं को अलग कर दिया है, लेकिन कहीं भी जहां डेटासेट "फ्लैट" है, मैं पठार के साथ हर तत्व के लिए एक बिंदु वापस प्राप्त करता हूं। मुझे पठार के केंद्र में इन बिंदुओं को एक बिंदु पर अनुकूली रूप से मर्ज करने में सक्षम होना चाहिए। (यह भी मैं कितने समूहों होगा पता नहीं है का मतलब है।)

नमूना डाटासेट 1 (नमूना/कृत्रिम इनपुट) इनपुट:

97 54686024814922.8 
118 406406320535.935 
148 24095826539423.7 
152 1625624905272.95 
160 1625625128029.81 
166 1625625152145.47 
176 1625625104745.48 
179 1625625127365.09 
183 1625625152208.44 
190 1625624974205.81 
194 21068100428092.9 
247 54686024895222.1 

आदर्श आउटपुट:

97 54686024814922.8 
118 406406320535.935 
148 24095826539423.7 
159 1625625061816.08 


182 1625625089631.21 



194 21068100428092.9 
247 54686024895222.1 

नमूना डाटासेट 2 (रियल इनपुट): इनपुट:

2 196412376940671 
123 206108518197124 
135 194488685387149 
148 178463949513298 
154 192912098976702 
156 195042451997727 
161 195221254214493 
168 204760073508681 
172 189240741651297 
182 191554457423846 
187 215014126955355 
201 202294866774063 

आइडिया एल उत्पादन:

2 196412376940671 
123 206108518197124 
135 194488685387149 
148 178463949513298 
157 194391935062974 


168 204760073508681 
172 189240741651297 
182 191554457423846 
187 215014126955355 
201 202294866774063 

नमूना डेटासेट 3 (रियल इनपुट) इनपुट:

2 299777367852602 
26 263467434856928 
35 293412234811901 
83 242768805551742 
104 226333969841383 
107 227548774800053 
178 229173574175201 
181 229224441416751 
204 244334414017228 
206 245258151638118 
239 198782930497571 

आदर्श उत्पादन:

2  299777367852602 
26  263467434856928 (May be merged 
35  293412234811901 depending on parameters) 
83  242768805551742 
105.5 226941372320718 

179.5 229199007795976 

205  244796282827673 

239  198782930497571 

(। अधिक जानकारी के में संपादित करेंगे के रूप में आवश्यक)

Answer 1

मुझे यकीन नहीं है कि यह वही है जो आप चाहते हैं, लेकिन अभी तक कोई अन्य उत्तर पोस्ट नहीं किया गया है इसलिए क्या हम जाते हैं

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

इसके अतिरिक्त समान मूल्य हमेशा वर्तमान स्थित पठार के औसत के मुकाबले तुलना की जाती है। एक बार पठार को समाप्त करने के बाद पता चला है कि यह एक्स को एक साथ जोड़ता है और मध्य तक पहुंचने के लिए 2 से विभाजित होता है और फिर औसत वाई मान लेता है और इसे अंतिम डेटा बिंदु के रूप में जोड़ता है।

अच्छे नमूना डेटा तक पहुंच के बिना मुझे बस इतना ही खराब डेटा जेनरेटर बनाना है। लेकिन मेरे परीक्षण मूल्यों में 1% के भीतर आम तौर पर मेरे डेटा बिंदुओं में से लगभग आधा समाप्त हो गया।

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

namespace PointCondenser 
{ 
    public static class Extensions 
    { 
     static public bool AlmostEqual<T>(this T value, T value2, T epsilon) 
     { 
      return (Math.Abs((dynamic)value - value2) < epsilon); 
     } 
    } 

    public struct Point 
    { 
     public Point(double x, double y) 
     { 
      X = x; 
      Y = y; 
     } 

     public override string ToString() 
     { 
      return string.Format("{0}\t{1}", X, Y); 
     } 

     public double X; 
     public double Y; 
    } 
    class Program 
    { 
     static public Point RandomYPoint(int i) 
     { 
      var r = new Random(); 

      var r2 = new Random(i); 

      var variance = r2.NextDouble()/100; 

      return new Point(i, Math.Abs(r.NextDouble() - variance) * 100); 
     } 

     static public IEnumerable<Point> SmoothPoints(IEnumerable<Point> points, double percent) 
     { 
      if (percent <= 0 || percent >= 1) 
       throw new ArgumentOutOfRangeException("percent", "Percentage outside of logical bounds"); 

      var final = new List<Point>(); 

      var apoints = points.ToArray(); 

      var largestDifference = apoints.Max(x => x.Y) - apoints.Min(x => x.Y); 
      var epsilon = largestDifference * percent; 

      var currentPlateau = new List<Point> { apoints[0] }; 

      for (var i = 1; i < apoints.Length; ++i) 
      { 
       var point = apoints[i]; 
       if (point.Y.AlmostEqual(currentPlateau.Average(x => x.Y), epsilon)) 
        currentPlateau.Add(point); 
       else 
       { 
        var x = (currentPlateau[0].X + currentPlateau[currentPlateau.Count - 1].X)/2.0; 
        var y = currentPlateau.Average(z => z.Y); 

        currentPlateau.Clear(); 
        currentPlateau.Add(point); 

        final.Add(new Point(x, y)); 
       } 
      } 

      return final; 
     } 

     static void Main(string[] args) 
     { 
      var r = new Random(); 
      var points = new List<Point>(); 


      for (var i = 0; i < 100; ++i) 
      { 
       for (var n = 0; n < r.Next(1, 5); ++n) 
       { 
        var p = RandomYPoint(points.Count); 
        points.Add(p); 
        Console.WriteLine(p); 
       } 
       Thread.Sleep(r.Next(10, 250)); 
      } 

      Console.Write("\n\n Condensed \n\n"); 


      var newPoints = SmoothPoints(points, .01); 

      foreach (var p in newPoints) 
       Console.WriteLine(p); 
     } 
    } 
} 

Answer 2

पैरामीटर के बिना क्लस्टरिंग के लिए एक और दृष्टिकोण निकटतम डेटा बिंदुओं को मर्ज करना है। प्रत्येक पास में आपको दो डेटा बिंदुओं के बीच सबसे छोटा अंतर मिलेगा और फिर उस अंतर के साथ जोड़े को मर्ज करें।

परिणामस्वरूप प्रत्येक पास ग्रैन्युलरिटी कम हो जाएगी। हालांकि सबसे छोटा अंतर ढूंढना तब तक महंगा हो सकता है जब तक आप तुलना की गई विशेषता के आधार पर डेटा पॉइंट्स को सॉर्ट नहीं किया जाता।

Answer 3

पीछे की ओर, मैं रैखिक प्रतिगमन के साथ भी ऐसा कर सकता था: यदि ढलान शून्य के करीब है, और अगली बिंदु पर ढलान पठार पर पिछले बिंदुओं की औसत ढलान के समान है, तो अगला बिंदु पंजीकृत करें विलय और जारी रखें।