sorting 5 सितारा रेटिंग द्वारा क्रमबद्ध करने का एक बेहतर तरीका क्या है?




statistics user-experience (8)

मैं 5 सितारा सिस्टम का उपयोग कर ग्राहक रेटिंग द्वारा उत्पादों का एक गुच्छा सॉर्ट करने की कोशिश कर रहा हूं। जिस साइट पर मैं इसे स्थापित कर रहा हूं, उसके पास बहुत सारी रेटिंग नहीं है और नए उत्पादों को जोड़ना जारी रखता है, इसलिए आमतौर पर कम संख्या में रेटिंग वाले कुछ उत्पाद होंगे।

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

एक ऐसे उत्पाद का उदाहरण लें जिसमें 3x 5 स्टार रेटिंग्स उस उत्पाद से बेहतर दिखाई दें जिसमें 100x 5 स्टार रेटिंग और 2x 2 स्टार रेटिंग हों।

क्या दूसरा उत्पाद अधिक नहीं दिखाना चाहिए क्योंकि रेटिंग की बड़ी संख्या के कारण यह सांख्यिकीय रूप से अधिक भरोसेमंद है?


एक विकल्प माइक्रोसॉफ्ट की ट्रूस्किल प्रणाली की तरह कुछ है, जहां स्कोर mean - 3*stddev द्वारा दिया जाता mean - 3*stddev , जहां स्थिरांक को tweaked किया जा सकता है।


http://www.evanmiller.org/ranking-items-with-star-ratings.html 5-सितारा रेटिंग रैंकिंग के लिए बेयसियन दृष्टिकोण http://www.evanmiller.org/ranking-items-with-star-ratings.html है:

कहा पे

  • nk स्टार रेटिंग की संख्या है,
  • sk सितारों के "मूल्य" (अंक में) है,
  • N वोटों की कुल संख्या है
  • के सितारों की अधिकतम संख्या (जैसे के = 5, 5-सितारा रेटिंग सिस्टम में)
  • z_alpha/2 एक सामान्य वितरण का 1 - alpha/2 मात्रा है। यदि आप 95% आत्मविश्वास चाहते हैं (Bayesian पश्चवर्ती वितरण के आधार पर) कि वास्तविक प्रकार मानदंड कम से कम गणना के प्रकार मानदंड के रूप में बड़ा है, z_alpha/2 = 1.65 चुनें।

पायथन में, सॉर्टिंग मानदंड की गणना की जा सकती है

def starsort(ns):
    """
    http://www.evanmiller.org/ranking-items-with-star-ratings.html
    """
    N = sum(ns)
    K = len(ns)
    s = list(range(K,0,-1))
    s2 = [sk**2 for sk in s]
    z = 1.65
    def f(s, ns):
        N = sum(ns)
        K = len(ns)
        return sum(sk*(nk+1) for sk, nk in zip(s,ns)) / (N+K)
    fsns = f(s, ns)
    return fsns - z*math.sqrt((f(s2, ns)- fsns**2)/(N+K+1))

उदाहरण के लिए, यदि किसी आइटम में 60 पांच-सितारे हैं, 80 चार-सितारे, 75 तीन-सितारे, 20 दो-सितारे और 25 एक-सितारे हैं, तो इसकी समग्र स्टार रेटिंग लगभग 3.4 होगी:

x = (60, 80, 75, 20, 25)
starsort(x)
# 3.3686975120774694

और आप 5-सितारा रेटिंग की सूची को सॉर्ट कर सकते हैं

sorted([(60, 80, 75, 20, 25), (10,0,0,0,0), (5,0,0,0,0)], key=starsort, reverse=True)
# [(10, 0, 0, 0, 0), (60, 80, 75, 20, 25), (5, 0, 0, 0, 0)]

यह प्रभाव दिखाता है कि समग्र रेटिंग मूल्य पर अधिक रेटिंग हो सकती है।

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

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

आईएमडीबी फॉर्मूला के विपरीत, यह सूत्र सभी वस्तुओं में औसत स्कोर पर निर्भर नहीं है, न ही कृत्रिम न्यूनतम संख्या में कटऑफ मूल्य।

इसके अलावा, यह सूत्र पूर्ण आवृत्ति वितरण का उपयोग करता है - न केवल सितारों की औसत संख्या और वोटों की संख्या। और यह समझ में आता है कि इसे दस 5-सितारों वाले दस आइटमों और दस 1-सितारों के साथ एक अनिश्चितता के रूप में माना जाना चाहिए (और इसलिए जितना अधिक मूल्यांकन नहीं किया गया) बीस 3-सितारा रेटिंग वाले आइटम:

In [78]: starsort((10,0,0,0,10))
Out[78]: 2.386028063783418

In [79]: starsort((0,0,20,0,0))
Out[79]: 2.795342687927806

आईएमडीबी फॉर्मूला इसे ध्यान में नहीं लेता है।


जाहिर है, रेटिंग की कम संख्या इस समस्या को एक सांख्यिकीय विकलांगता पर रखती है। कभी कम नहीं ...

कुल रेटिंग की गुणवत्ता में सुधार करने के लिए एक महत्वपूर्ण तत्व "रटर को रेट करना" है, यानि प्रत्येक विशेष "रटर" की आपूर्ति (दूसरों के सापेक्ष) रेटिंग के टैब रखने के लिए। यह एकत्रीकरण प्रक्रिया के दौरान अपने वोट वजन की अनुमति देता है।

एक और समाधान, अधिक से अधिक सामना करने के लिए, अंत उपयोगकर्ताओं को अंतर्निहित वस्तु के लिए वोटों (या एक सीमा संकेत) के साथ अंत उपयोगकर्ताओं को आपूर्ति करना है।


खैर, यह निर्भर करता है कि आप इसे कितना जटिल बनाना चाहते हैं, आप रेटिंग के अतिरिक्त रेटिंग कर सकते हैं कि व्यक्ति ने कितनी रेटिंग बनाई है, और ये रेटिंग क्या हैं। अगर व्यक्ति ने केवल एक रेटिंग बनाई है, तो यह एक शिल रेटिंग हो सकती है, और कम के लिए गिनती हो सकती है। या यदि व्यक्ति ने श्रेणी में कई चीजें रेट की हैं, लेकिन श्रेणी बी में कुछ हैं, और 5 सितारों में से 1.3 की औसत रेटिंग है, तो ऐसा लगता है कि इस उपयोगकर्ता के निम्न औसत स्कोर से श्रेणी को कृत्रिम रूप से कम किया जा सकता है, और समायोजित किया जाना चाहिए।

लेकिन इसे जटिल बनाने के लिए पर्याप्त है। आइए इसे सरल बनाएं।

मान लें कि हम किसी विशेष आइटम के लिए केवल दो मानों, समीक्षा गणना और औसत रेटिंग के साथ काम कर रहे हैं, यह मुझे "विश्वसनीयता" मान के रूप में समीक्षा गणना को देखने के लिए समझ में आता है। लेकिन हम सिर्फ कम समीक्षा गणना आइटमों के लिए स्कोर नहीं लेना चाहते हैं: एक एकल स्टार रेटिंग शायद 5 सितारा रेटिंग के रूप में अविश्वसनीय है। तो हम जो करना चाहते हैं वह शायद मध्य की ओर औसत है: 3।

तो, मूल रूप से, मैं एक्स * औसतरेटिंग + वाई * 3 = रेटिंग-हम-चाहते हैं जैसे समीकरण की सोच रहा हूं। इस मूल्य को सही करने के लिए हमें एक्स + वाई को बराबर 1 की आवश्यकता है। इसके अलावा हमें मूल्य में वृद्धि करने के लिए एक्स की आवश्यकता है क्योंकि समीक्षा गणना बढ़ जाती है ... 0 की समीक्षा गिनती के साथ, x 0 होना चाहिए (हमें " 3 "), और एक अनंत समीक्षा गिनती एक्स के साथ 1 होना चाहिए (जो समीकरण = औसत रेटिंग बनाता है)।

तो एक्स और वाई समीकरण क्या हैं? एक्स समीकरण के लिए आश्रित चर को असम्बद्ध रूप से 1 तक पहुंचना चाहिए क्योंकि स्वतंत्र परिवर्तनीय अनंतता तक पहुंचता है। समीकरणों का एक अच्छा सेट कुछ ऐसा है: वाई = 1 / (कारक ^ रेटिंगकाउंट) और (इस तथ्य का उपयोग करना कि एक्स 1-वाई के बराबर होना चाहिए) एक्स = 1 - (1 / (कारक ^ रेटिंगकाउंट)

फिर हम उस सीमा को फिट करने के लिए "कारक" समायोजित कर सकते हैं जिसे हम ढूंढ रहे हैं।

मैंने कुछ कारकों को आजमाने के लिए इस सरल सी # प्रोग्राम का उपयोग किया:

        // We can adjust this factor to adjust our curve.
        double factor = 1.5;  

        // Here's some sample data
        double RatingAverage1 = 5;
        double RatingCount1 = 1;

        double RatingAverage2 = 4.5;
        double RatingCount2 = 5;

        double RatingAverage3 = 3.5;
        double RatingCount3 = 50000; // 50000 is not infinite, but it's probably plenty to closely simulate it.

        // Do the calculations
        double modfactor = Math.Pow(factor, RatingCount1);
        double modRating1 = (3 / modfactor)
            + (RatingAverage1 * (1 - 1 / modfactor));

        double modfactor2 = Math.Pow(factor, RatingCount2);
        double modRating2 = (3 / modfactor2)
            + (RatingAverage2 * (1 - 1 / modfactor2));

        double modfactor3 = Math.Pow(factor, RatingCount3);
        double modRating3 = (3 / modfactor3)
            + (RatingAverage3 * (1 - 1 / modfactor3));

        Console.WriteLine(String.Format("RatingAverage: {0}, RatingCount: {1}, Adjusted Rating: {2:0.00}", 
            RatingAverage1, RatingCount1, modRating1));
        Console.WriteLine(String.Format("RatingAverage: {0}, RatingCount: {1}, Adjusted Rating: {2:0.00}",
            RatingAverage2, RatingCount2, modRating2));
        Console.WriteLine(String.Format("RatingAverage: {0}, RatingCount: {1}, Adjusted Rating: {2:0.00}",
            RatingAverage3, RatingCount3, modRating3));

        // Hold up for the user to read the data.
        Console.ReadLine();

तो आप इसे कॉपी करने में परेशान नहीं करते हैं, यह इस आउटपुट को देता है:

RatingAverage: 5, RatingCount: 1, Adjusted Rating: 3.67
RatingAverage: 4.5, RatingCount: 5, Adjusted Rating: 4.30
RatingAverage: 3.5, RatingCount: 50000, Adjusted Rating: 3.50

ऐसा कुछ? आप वांछित वज़न प्राप्त करने के लिए आवश्यक रूप से "कारक" मान को समायोजित कर सकते हैं।


उनकी शीर्ष 250 फिल्मों की सूची के लिए आईएमडीबी बेयसियन अनुमान का उपयोग करता है। मतदाताओं की संख्या को ध्यान में रखना एक अच्छा तरीका है।

here :

शीर्ष रेटेड 250 टाइटल की गणना के लिए सूत्र एक वास्तविक Bayesian अनुमान देता है:

भारित रेटिंग (डब्ल्यूआर) = (वी ÷ (वी + एम)) × आर + (एम ÷ (वी + एम)) × सी

कहा पे:

* R = average for the movie (mean) = (Rating)
* v = number of votes for the movie = (votes)
* m = minimum votes required to be listed in the Top 250 (currently 1300)
* C = the mean vote across the whole report (currently 6.8)

शीर्ष 250 के लिए, नियमित मतदाताओं से केवल वोट माना जाता है।


आप अंकगणितीय median बजाय median द्वारा क्रमबद्ध कर सकते हैं। इस मामले में दोनों उदाहरणों में 5 का औसत होता है, इसलिए दोनों को एक सॉर्टिंग एल्गोरिदम में वही वज़न होता है।

आप एक ही प्रभाव के लिए एक mode का उपयोग कर सकते हैं, लेकिन औसत शायद एक बेहतर विचार है।

यदि आप 100 5-सितारा रेटिंग के साथ उत्पाद को अतिरिक्त वजन असाइन करना चाहते हैं, तो आप शायद किसी भी प्रकार के भारित मोड के साथ जाना चाहेंगे, उसी मध्यस्थ के साथ रेटिंग के लिए अधिक वजन दे सकते हैं, लेकिन अधिक समग्र वोटों के साथ।


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


थोड़ी देर के लिए देखने के बाद, मैं Bayesian प्रणाली का चयन करें। अगर कोई रूबी का उपयोग कर रहा है, तो इसके लिए यहां एक मणि है:

https://github.com/wbotelhos/rating







bayesian