बहुत तिरछी, डेटा की गणना: किसी भी सुझाव के बारे में जाने के लिए (परिवर्तन आदि)?

Question

मूल समस्या

यहाँ मेरी मूल समस्या है: मैं एक डेटासेट को क्लस्टर करने की कोशिश कर रहा हूं जिसमें कुछ बहुत ही तिरछे वेरिएबल हैं, जो मायने रखते हैं। चर में कई शून्य होते हैं और इसलिए मेरी क्लस्टरिंग प्रक्रिया के लिए बहुत जानकारीपूर्ण नहीं हैं - जो कि k- साधन एल्गोरिथ्म होने की संभावना है।

ठीक है, आप कहते हैं, बस वर्गमूल, बॉक्स कॉक्स या लघुगणक का उपयोग करके चर को रूपांतरित करें। लेकिन चूंकि मेरे चर श्रेणीबद्ध चर पर आधारित हैं, इसलिए मुझे डर है कि मैं एक चर (श्रेणीगत चर के एक मूल्य के आधार पर) को संभालकर एक पूर्वाग्रह का परिचय दे सकता हूं, जबकि दूसरों को छोड़कर (श्रेणीगत चर के अन्य मूल्यों के आधार पर) वे जिस तरह से हैं ।

आइए कुछ और विस्तार में जाएं।

डेटासेट

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

जिस तरह से मैं करता हूं वह खरीद की संख्या की गणना करके है, जहां आइटम एक निश्चित रंग है। तो एक भी चर के बजाय color, मैं तीन चर के साथ खत्म count_red, count_blue, और count_green।

यहाँ उदाहरण के लिए एक उदाहरण है:

-----------------------------------------------------------
customer | count_red  |    count_blue   | count_green     |
-----------------------------------------------------------
c0       |    12      |        5        |       0         |
-----------------------------------------------------------
c1       |     3      |        4        |       0         |
-----------------------------------------------------------
c2       |     2      |       21        |       0         |
-----------------------------------------------------------
c3       |     4      |        8        |       1         |
-----------------------------------------------------------

वास्तव में, मैं अंत में पूर्ण गणना का उपयोग नहीं करता हूं, मैं अनुपात (प्रति ग्राहक सभी खरीदी गई वस्तुओं के हरे रंग की वस्तुओं का अंश) का उपयोग करता हूं।

-----------------------------------------------------------
customer | count_red  |    count_blue   | count_green     |
-----------------------------------------------------------
c0       |    0.71    |        0.29     |       0.00      |
-----------------------------------------------------------
c1       |    0.43    |        0.57     |       0.00      |
-----------------------------------------------------------
c2       |    0.09    |        0.91     |       0.00      |
-----------------------------------------------------------
c3       |    0.31    |        0.62     |       0.08      |
-----------------------------------------------------------

परिणाम समान है: मेरे रंगों में से एक के लिए, उदाहरण के लिए हरा (कोई भी हरे रंग को पसंद नहीं करता है), मुझे एक बाएं तिरछा चर मिलता है जिसमें कई शून्य होते हैं। नतीजतन, k- साधन इस चर के लिए एक अच्छा विभाजन खोजने में विफल रहता है।

दूसरी ओर, अगर मैं अपने चर (घटाव का मतलब, मानक विचलन से विभाजित) का मानकीकरण करता हूं, तो हरे रंग का चर अपने छोटे से विचरण के कारण "उड़ता है" और अन्य चर की तुलना में बहुत बड़ी रेंज से मान लेता है, जिससे यह अधिक दिखता है वास्तव में यह है की तुलना में k- साधन के लिए महत्वपूर्ण है।

अगला विचार स्के (r) ईव्ड ग्रीन वैरिएबल को बदलना है।

तिरछी चर को बदलना

अगर मैं वर्गमूल को लागू करके हरे रंग के चर को परिवर्तित करता हूं तो यह थोड़ा कम तिरछा दिखता है। (यहां भ्रम को सुनिश्चित करने के लिए हरे रंग के चर को लाल और हरे रंग में चित्रित किया गया है।)

लाल: मूल चर; नीला: वर्गमूल द्वारा रूपांतरित।

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

जमीनी स्तर

दूसरे शब्दों में, क्या मैं एक तरह से रंग हरे को संभालकर क्लस्टरिंग परिणामों को विकृत करता हूं, लेकिन लाल और नीले रंग को बिल्कुल भी नहीं संभाल रहा हूं? अंत में, सभी तीन चर एक साथ होते हैं, तो क्या उन्हें उसी तरह से नहीं संभाला जाना चाहिए?

संपादित करें

स्पष्ट करने के लिए: मुझे पता है कि k- साधन संभवतः गणना-आधारित डेटा के लिए जाने का तरीका नहीं है । मेरा प्रश्न वास्तव में आश्रित चर के उपचार के बारे में है। सही विधि चुनना एक अलग मामला है।

मेरे चर में निहित बाधा वह है

count_red(i) + count_blue(i) + count_green(i) = n(i), n(i)ग्राहक की खरीद की कुल संख्या कहां है i।

(या, समकक्ष, count_red(i) + count_blue(i) + count_green(i) = 1जब रिश्तेदार मायने रखता है।)

यदि मैं अपने चरों को अलग-अलग रूपांतरित करता हूं, तो यह बाधा में तीन शब्दों को अलग-अलग वजन देने से मेल खाती है। यदि मेरा लक्ष्य ग्राहकों के अलग-अलग समूहों को अलग-अलग करना है, तो क्या मुझे इस बाधा का उल्लंघन करने की परवाह है? या "अंत का मतलब उचित है"?

Comments

CV में आपका स्वागत है! अपना पहला प्रश्न इतना स्पष्ट और अच्छी तरह से लिखे जाने के लिए धन्यवाद।

— सिल्वरफिश

मुझे आपके डेटासेट की समझ नहीं थी। चर (विशेषताएँ) हैं count_red, count_blueऔर count_greenडेटा मायने रखता है। सही? पंक्तियाँ फिर क्या हैं - आइटम? और आप आइटम क्लस्टर करने जा रहे हैं?

— ttnphns

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

— 14

आप "ग्राहकों" को क्लस्टर करना चाहते हैं?

— ttnphns

हाँ। मैं समय अंतराल के साथ-साथ फलस्वरूप समूह समय के अंतराल पर समूह खरीद का इरादा रखता हूं, लेकिन अभी के लिए: ग्राहक।

— पैदल सैनिक

Answer 1

@ttnphns ने एक अच्छा जवाब दिया है।

अच्छी तरह से क्लस्टरिंग करना अक्सर आपके डेटा के बारे में बहुत कठिन सोचने के बारे में होता है, तो चलिए कुछ ऐसा करते हैं। मेरे दिमाग में, आपके डेटा का सबसे बुनियादी पहलू यह है कि वे संरचनागत हैं ।

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

नीचे मैं आपके उदाहरण के लिए डेटासेट का उपयोग (आर में) आपकी स्थिति के बारे में बताने के लिए करता हूँ। मैं डेटा में पढ़ता हूं और उन्हें अनुपात अनुपात में परिवर्तित करता हूं, और फिर स्तंभ द्वारा माध्य अनुपात की गणना करता हूं। मैं समायोजित गिनती और नए रोवाइस अनुपात प्राप्त करने के लिए प्रत्येक गणना में वापस साधन जोड़ता हूं। यह प्रत्येक उत्पाद के लिए औसत अनुपात के प्रति प्रत्येक ग्राहक के अनुमानित अनुपात को बताता है। यदि आप एक मजबूत कुहनी चाहते थे, तो आप 15*mean.propsइसके बजाय कई साधन (जैसे ) का उपयोग कर सकते थे।

d = read.table(text="id  red    blue    green
...
c3  4   8   1", header=TRUE)
tab = as.table(as.matrix(d[,-1]))
rownames(tab) = paste0("c", 0:3)
tab
#    red blue green
# c0  12    5     0
# c1   3    4     0
# c2   2   21     0
# c3   4    8     1
props = prop.table(tab, 1)
props
#           red       blue      green
# c0 0.70588235 0.29411765 0.00000000
# c1 0.42857143 0.57142857 0.00000000
# c2 0.08695652 0.91304348 0.00000000
# c3 0.30769231 0.61538462 0.07692308
mean.props = apply(props, 2, FUN=function(x){ weighted.mean(x, rowSums(tab)) })
mean.props
#        red       blue      green 
# 0.35000000 0.63333333 0.01666667 
adj.counts = sweep(tab, 2, mean.props, FUN="+");  adj.counts
#            red        blue       green
# c0 12.35000000  5.63333333  0.01666667
# c1  3.35000000  4.63333333  0.01666667
# c2  2.35000000 21.63333333  0.01666667
# c3  4.35000000  8.63333333  1.01666667
adj.props = prop.table(adj.counts, 1);  adj.props
#             red         blue        green
# c0 0.6861111111 0.3129629630 0.0009259259
# c1 0.4187500000 0.5791666667 0.0020833333
# c2 0.0979166667 0.9013888889 0.0006944444
# c3 0.3107142857 0.6166666667 0.0726190476

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

हम डेटा को देखने के लिए कल्पना कर सकते हैं कि क्या हुआ। क्योंकि ये संरचनात्मक डेटा हैं, हमारे पास वास्तव में केवल जानकारी के दो टुकड़े हैं, और हम इन्हें एक ही स्कैल्पलॉट में प्लॉट कर सकते हैं। लाल और नीली श्रेणियों में अधिकांश जानकारी के साथ, यह कुल्हाड़ियों के रूप में उपयोग करने के लिए समझ में आता है। आप देख सकते हैं कि समायोजित अनुपात (लाल संख्या) को उनके मूल पदों से थोड़ा स्थानांतरित कर दिया गया है।

windows()
  plot(props[,1], props[,2], pch=as.character(0:3),
       xlab="Proportion Red", ylab="Proportion Blue", xlim=c(0,1), ylim=c(0,1))
  points(adj.props[,1], adj.props[,2], pch=as.character(0:3), col="red")

इस बिंदु पर, आपके पास डेटा है और बहुत से लोग उन्हें मानकीकृत करके शुरू करेंगे। फिर से, क्योंकि ये संरचनात्मक डेटा हैं, मैं बिना किसी मानकीकरण के क्लस्टर विश्लेषण चलाऊंगा - ये मान पहले से ही कम हैं और मानकीकरण कुछ संबंधपरक जानकारी को नष्ट कर देगा। वास्तव में, मुझे लगता है कि आपको वास्तव में जानकारी का केवल एक ही आयाम है। (कम से कम नमूना डेटासेट में; आपका वास्तविक डेटासेट अच्छी तरह से अलग हो सकता है।) जब तक कि व्यवसाय की दृष्टि से, आपको लगता है कि ऐसे लोगों को पहचानना महत्वपूर्ण है, जिनके पास हरे रंग के उत्पादों को खरीदने के लिए ग्राहकों की एक अलग क्लस्टर के रूप में पर्याप्त संभावना है, I पहले मुख्य घटक (जो इस डेटासेट में विचरण के 99.5% के लिए खाता है) पर स्कोर निकालता है और बस क्लस्टर करता है।

pc.a.props = prcomp(adj.props[,1:2], center=T, scale=T)
cumsum(pc.a.props$sdev^2)/sum(pc.a.props$sdev^2)
# [1] 0.9946557 1.000000
pc.a.props$x
#           PC1         PC2
# c0 -1.7398975 -0.03897251
# c1 -0.1853614 -0.04803648
# c2  1.6882400 -0.06707115
# c3  0.2370189  0.15408015
library(mclust)
mc = Mclust(pc.a.props$x[,1])
summary(mc)
# ----------------------------------------------------
# Gaussian finite mixture model fitted by EM algorithm 
# ----------------------------------------------------
# 
# Mclust E (univariate, equal variance) model with 3 components:
# 
#  log.likelihood n df       BIC       ICL
#       -2.228357 4  6 -12.77448 -12.77448
# 
# Clustering table:
# 1 2 3 
# 1 2 1 

Comments

+1 क्योंकि आपने माना कि यह कंपोजिटल डेटा है, लेकिन आप केवल कंपोजिशन के लिए स्टैंडर्ड ट्रांसफॉर्मेशन तकनीक का उपयोग क्यों नहीं करेंगे। इस विषम "माध्य समायोजित गणना" विचार के बजाय डेटा? यह मेरे लिए तदर्थ लगता है, क्या इसके लिए कोई विशेष संदर्भ है या कुछ इसी तरह का है? यह एक साधारण केंद्रित लॉग-रेशो ट्रांसफ़ॉर्मेशन से बेहतर क्यों है और फिर ट्रांसफ़ॉर्म किए गए डेटा के पहले पीसी स्कोर को क्लस्ट कर रहा है? (जो किसी भी

— रचनाकार

धन्यवाद, @ usεr11852 > 2 की गिनती, लेकिन परिमित, विकल्प बहुराष्ट्रीय हैं। यह (एक अनुभवजन्य का 1 रूप) बायेसियन विश्लेषण w / एक डिरिचलेट पूर्व (संयुग्म) है। मुझे यकीन है कि अन्य विकल्प संभव हैं। मैं तुरंत नहीं देखता कि अनुपात लेने से w / 0s कैसे काम करेगा, हालाँकि।

— गूँग - मोनिका

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

— us --r11852

ऐसा लगता है कि आप इस विषय के बारे में बहुत कुछ जानते हैं, जैसा कि मैं करता हूं, @ us11r11852। मेरा जवाब वास्तव में सिर्फ स्थिति की प्रकृति के बारे में इन तथ्यों को स्पष्ट करने / मुद्दा उठाने और प्रारंभिक सुझाव देने की कोशिश कर रहा था। अपने स्वयं के (बेहतर सूचित) उत्तर में योगदान क्यों नहीं?

— गंग -

Answer 2

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

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

प्रश्न से उदाहरण डेटा की प्रतिलिपि बनाना:

-----------------------------------------------------------
customer | count_red  |    count_blue   | count_green     |
-----------------------------------------------------------
c0       |    12      |        5        |       0         |
-----------------------------------------------------------
c1       |     3      |        4        |       0         |
-----------------------------------------------------------
c2       |     2      |       21        |       0         |
-----------------------------------------------------------
c3       |     4      |        8        |       1         |
-----------------------------------------------------------

जोड़ी पर विचार करें c0और उनकी आवृत्ति तालिका के लिए ची-स्क्वायर सांख्यिकीय की c1गणना करें । इसका वर्गमूल लें (जैसे आप इसे लेते हैं जब आप सामान्य यूक्लिडियन दूरी की गणना करते हैं)। वह तुम्हारी दूरी है। यदि दूरी 0 के करीब है तो दोनों ग्राहक समान हैं।2x3

यह आपको परेशान कर सकते हैं कि आपकी तालिका में पंक्तियों में रकम अलग है और इसलिए यह ची-वर्ग दूरी जब आप तुलना को प्रभावित करता है c0के साथ c1बनाम c0साथ c2। फिर Ph- वर्ग दूरी की (जड़) की गणना करें : वर्तमान में माना जाने वाली दो पंक्तियों (ग्राहकों) में संयुक्त कुल गणना Phi-sq = Chi-sq/Nकहां Nहै। इस प्रकार, यह सामान्यीकृत दूरी की कुल संख्या के बराबर है।

Here is the matrix of sqrt(Chi-sq) distance between your four customers
 .000   1.275   4.057   2.292
1.275    .000   2.124    .862
4.057   2.124    .000   2.261
2.292    .862   2.261    .000

And here is the matrix of sqrt(Phi-sq) distance 
.000    .260    .641    .418
.260    .000    .388    .193
.641    .388    .000    .377
.418    .193    .377    .000

तो, डेटा के किसी भी दो पंक्तियों के बीच की दूरी (के वर्ग। रूट) है ची-वर्ग या फ़ाई वर्ग आंकड़ा की 2 x pआवृत्ति तालिका ( pडेटा में स्तंभों की संख्या है)। यदि वर्तमान 2 x pतालिका में कोई भी कॉलम पूर्ण शून्य है, तो उस कॉलम को काट दें और शेष नॉनजरो कॉलम के आधार पर दूरी की गणना करें (यह ठीक है और यह उदाहरण के लिए, SPSS तब करता है जब वह दूरी की गणना करता है)। ची-वर्ग की दूरी वास्तव में एक भारित यूक्लिडियन दूरी है।

Comments

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

— पैदल सैनिक

एक ग्राहक तीन रंगों के बीच चयन करता है जब वह एक ही खरीद करता है: तीन रंग वैचारिक रूप से स्वतंत्र "वैरिएबल" नहीं होते हैं। साथ ही आपका डेटा मायने रखता है। यह मेरे लिए तुरंत स्पष्ट हो गया था कि ची-स्क्वायर आधारित उपाय इष्टतम होना चाहिए। अपने अंतिम बिंदु के संबंध में - मैं आपसे वापस पूछ सकता हूं: उन्हें अलग तरह से क्यों माना जाना चाहिए? A ने आपको क्लस्टरिंग कार्य करने के लिए एक समाधान दिया। क्या इसमें कुछ भी है जो आपको पसंद नहीं है या आपको क्या संदेह है?

— ttnphns

मुझे लगता है कि k- साधन (विचरण को कम नहीं करता है!) जाने का तरीका है: k- साधन का उपयोग करता है । आपका डेटा पूर्णांक है, और कई शून्य हैं। क्लस्टर केंद्र पूर्णांक नहीं होंगे, और कुछ शून्य होंगे। वे आपके डेटा बिंदुओं के बिल्कुल विपरीत हैं , वे कैसे प्रतिनिधि हो सकते हैं? नीचे पंक्ति: k- साधनों को फिट करने के लिए अपने डेटा को बदलने के लिए संघर्ष न करें। समस्या को समझें, और अपनी समस्या के लिए एल्गोरिदम को फिट करें, दूसरे तरीके से नहीं। यदि आप अपने डेटा को k- साधन की समस्या के लिए फिट करते हैं, तो यह अभी भी गलत समस्या हो सकती है ...

— है QUIT - Anony-Mousse

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

— ttnphns

अनुचित सामान्यीकरण द्वारा मौलिक गुणों को नष्ट करना आसान है। उदाहरण के लिए, यदि आपका डेटा प्रत्येक पंक्ति में 1 तक है, तो प्रत्येक कॉलम को सामान्य करने से यह संपत्ति नष्ट हो जाएगी। इस तरह के डेटा पर, आपको इसके बजाय उदाहरण के विचलन उपायों (वितरण के लिए दूरी) पर विचार करना चाहिए। डेटा की गिनती पर, चौराहे के उपायों को सेट करें जैसे कि जैकार्ड अधिक जानकारीपूर्ण हो सकता है; लेकिन उन्हें बाइनरी वैक्टर चाहिए। आदि

— है क्विट -