0 और 1 के बीच की संख्या के रूप में एक अबाधित चर का प्रतिनिधित्व कैसे करें

Question

मैं 0 और 1. के बीच की संख्या के रूप में एक चर का प्रतिनिधित्व करना चाहता हूं। चर एक गैर-नकारात्मक पूर्णांक है जिसमें कोई अंतर्निहित बाध्य नहीं है। मैं 0 से 0 पर मैप करता हूं लेकिन मैं 0 और 1 के बीच 1 या नंबर पर क्या मैप कर सकता हूं?

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

Comments

क्योंकि कोई भी nondecinating फ़ंक्शन ट्रिक करेगा, आपके पास बहुत अधिक लचीलापन है। लेकिन आवेदन के आधार पर कुछ विधियां दूसरों की तुलना में बेहतर होंगी। ऐसी पुन: अभिव्यक्ति की तलाश में आपका उद्देश्य क्या है? $[0, \infty) \to [0, 1]$

— whuber

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

— स्पेंसर

@ स्पेंसर वास्तव में आप सामग्री और "प्रासंगिकता" को कैसे माप रहे हैं? जैसे, मनमाना तराजू पर, जैसे कि मायने रखता है, अनुपात, विचारों की आवृत्तियों, अन्य सामग्री के साथ संबंध, आदि आदि विभिन्न प्रकार के माप विभिन्न प्रकार के पुन: भावों से लाभान्वित होते हैं।

— whuber

मैं उन्हें मनमाने पैमाने पर माप रहा हूं। सामग्री कितनी पुरानी है। कितने "अंक" सामग्री का एक टुकड़ा प्राप्त होता है। सामग्री के क्षेत्र में स्व-रिपोर्ट की गई "रुचि"।

— स्पेंसर

आपके द्वारा उपयोग किए जा सकने वाले सरलतम परिवर्तनों में से एक है अपने डेटा को क्वांटाइल स्कोर में बदलना।

— charles.y.zheng

Answer 1

ऐसा करने के लिए एक बहुत ही सामान्य चाल है (जैसे, कनेक्शनवादी मॉडलिंग में) हाइपरबोलिक स्पर्शरेखा तन को 'स्क्वैशिंग फ़ंक्शन' के रूप में उपयोग करना है । यह स्वचालित रूप से -1 और 1. के बीच के अंतराल में सभी नंबरों को फिट करता है जो आपके मामले में सीमा को प्रतिबंधित करता है। 0 से 1. में rऔर matlabआप इसे प्राप्त करते हैं tanh()।

एक और स्क्वाशिंग फंक्शन लॉजिस्टिक फंक्शन (नाम के लिए साइमन का धन्यवाद) है, जो द्वारा प्रदान किया , जो 0 से 1 तक (0 मैप की गई सीमा को सीमित करता है। 5)। इसलिए आपको अपने डेटा को 0 और 1 के बीच के अंतराल में फिट करने के लिए परिणाम को 2 से गुणा करना होगा और 1 को घटाना होगा।$f(x) = 1 / (1 + e ^{-x} )$

यहाँ कुछ सरल आर कोड है जो दोनों फ़ंक्शन (लाल रंग में तन, नीले रंग में लॉजिस्टिक) प्लॉट करता है ताकि आप देख सकें कि दोनों स्क्वैश कैसे हैं:

x <- seq(0,20,0.001)
plot(x,tanh(x),pch=".", col="red", ylab="y")
points(x,(1 / (1 + exp(-x)))*2-1, pch=".",col="blue")

Comments

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

— रसेल गैलप

Answer 2

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

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

Comments

$[0, 1]$

mad()rank()ecdf()ecdf(x)$p$$p$$x$$1/n$$x$$1$

— कार्ल ओवे हफथममर

Answer 3

कोई भी सिग्मोइड फ़ंक्शन काम करेगा:

• लॉजिस्टिक फ़ंक्शन का शीर्ष आधा (2 से गुणा करें, 1 घटाएं)
• त्रुटि फ़ंक्शन
• टैन, जैसा कि हेनरिक द्वारा सुझाया गया है।

Comments

erf एक बहुत ही उपयोगी कार्य नहीं है, बशर्ते आप इसे इसके व्युत्पन्न के लिए उपयोग नहीं करना चाहते।

मैंने कुछ छोटे मोड़ के साथ एक साधारण लॉजिस्टिक फ़ंक्शन का उपयोग किया: (1 / (1 + java.lang.Math.exp (-1 * (कारक * i))) - 0.5) * 2. मैंने 0.05 का एक कारक चुना मैं 0 और कुछ सौ के बीच के लिए अच्छी तरह से काम करने लगता है।

— जिल्स वैन गुरप सिप

1.0 / (1.0 + exp (-1.69897 * * (x- माध्य (x)) / sd (x)) pnorm का एक निकट सन्निकटन है

— क्रिस

Answer 4

हेनरिक और साइमन बायरन के अच्छे सुझावों के अलावा, आप f (x) = x / (x + 1) का उपयोग कर सकते हैं। तुलना के माध्यम से, लॉजिस्टिक फ़ंक्शन एक्स को बड़ा होने पर मतभेदों को बढ़ा देगा। अर्थात्, f (x) और f (x + 1) के बीच का अंतर f (x) = x / (x + 1) के साथ लॉजिस्टिक फ़ंक्शन के साथ बड़ा होगा। आप उस प्रभाव को चाह सकते हैं या नहीं भी।

Answer 5

मेरी पिछली पोस्ट में 0 और 1 के बीच रैंक करने की एक विधि है। क्लासिफायर इनपुट सहसंबंध पर सलाह

हालाँकि, मैंने जो रैंकिंग का उपयोग किया है, वह Tmin / Tmax नमूना मिनट / अधिकतम का उपयोग करता है, लेकिन आप जनसंख्या मिनट / अधिकतम अधिक उपयुक्त पा सकते हैं। इसके अलावा z स्कोर देखें

Answer 6

Pnorm का सुझाव देने वाले अन्य उत्तरों में जोड़ने के लिए ...

मापदंडों के चयन के लिए एक संभावित इष्टतम विधि के लिए मैं pnorm के लिए यह अनुमान लगाता हूं।

1.0/(1.0+exp(-1.69897*(x-mean(x))/sd(x)))

यह अनिवार्य रूप से सॉफ्टमैक्स सामान्यीकरण है।

एक चुटकी में संदर्भ Pnorm

Answer 7

इसे लागू करने के दो तरीके हैं जो मैं आमतौर पर उपयोग करता हूं। मैं हमेशा रियलटाइम डेटा के साथ काम कर रहा हूं, इसलिए यह निरंतर इनपुट मानता है। यहाँ कुछ छद्म कोड है:

एक ट्रेन करने योग्य मिनीमैक्स का उपयोग करना:

define function peak:
    // keeps the highest value it has received

define function trough:
    // keeps the lowest value it has received

define function calibrate:
    // toggles whether peak() and trough() are receiving values or not

define function scale:
    // maps input range [trough.value() to peak.value()] to [0.0 to 1.0]

इस फ़ंक्शन के लिए आवश्यक है कि आप या तो प्रारंभिक प्रशिक्षण चरण (उपयोग करके calibrate()) या आप कुछ अंतरालों पर या कुछ शर्तों के अनुसार पुन: प्रशिक्षण करें। उदाहरण के लिए, एक फंक्शन की कल्पना करें:

define function outBounds (val, thresh):
    if val > (thresh*peak.value()) || val < (trough.value() / thresh):
        calibrate()

शिखर और गर्त आमतौर पर मान प्राप्त नहीं कर रहे हैं, लेकिन यदि outBounds()ऐसा मान प्राप्त होता है जो वर्तमान शिखर से 1.5 गुना से अधिक है या 1.5 से विभाजित वर्तमान कुंड से कम है, तो calibrate()उसे कहा जाता है जो फ़ंक्शन को स्वचालित रूप से पुन: अंशांकित करने की अनुमति देता है।

एक ऐतिहासिक minmax का उपयोग करना:

var arrayLength = 1000
var histArray[arrayLength]

define historyArray(f):
    histArray.pushFront(f) //adds f to the beginning of the array

define max(array):
    // finds maximum element in histArray[]
    return max

define min(array):
    // finds minimum element in histArray[]
    return min

define function scale:
    // maps input range [min(histArray) to max(histArray)] to [0.0 to 1.0]

main()
historyArray(histArray)
scale(min(histArray), max(histArray), histArray[0])
// histArray[0] is the current element

Comments

यह सभी मैक्स / MSP / Jitter में [चरम] और [गर्त] वस्तुओं के साथ पहले उदाहरण के लिए और दूसरे उदाहरण के लिए [jit.3m] के साथ लागू किया जा सकता है।

— छत पर

Answer 8

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