सभी चुनौतियाँ
आसान 0 हल किए गए 0% स्वीकृति

लॉजिस्टिक रिग्रेशन से अनुमान

वेटेड योग को sigmoid से गुज़ारकर और थ्रेशोल्ड से तुलना करके सैंपल को 0 या 1 में वर्गीकृत करें।

आप क्या सीखेंगे

  • भारित योग को प्रायिकता में बदलना
  • निर्णय सीमा से वर्गीकृत करना
  • बाइनरी क्लासिफ़ायर समझना

समस्या

लॉजिस्टिक रिग्रेशन हाँ/ना वाले सवालों के लिए एक लीनियर मॉडल है। हर सैंपल के लिए यह एक प्रायिकता निकालता है और उसे क्लास में बदलता है:

  1. z = x₁×w₁ + … + xₙ×wₙ + bias
  2. p = 1 / (1 + e^(-z))
  3. अगर p ≥ threshold तो क्लास = 1, नहीं तो 0

logistic_predict(samples, weights, bias, threshold) लागू करें।

इनपुट

samples: हर सैंपल के लिए n फ़ीचर की एक पंक्ति।

weights: n वेट।

bias: बायस।

threshold: क्लास 1 का अनुमान लगाने के लिए ज़रूरी प्रायिकता (0 और 1 के बीच, सिरों को छोड़कर)।

आउटपुट

हर सैंपल की अनुमानित क्लास (0 या 1) क्रम से लौटाएँ।

सीमाएँ

1 ≤ सैंपल ≤ 1,000, 1 ≤ n ≤ 50

-100 ≤ हर फ़ीचर, वेट और बायस ≤ 100

0 < threshold < 1

उदाहरण

उदाहरण 1
इनपुट:
samples = [
    [2.0, 1.0],
    [0.0, 0.0],
    [-1.0, -3.0]
]
weights = [1.5, -0.5]
bias = -1.0
threshold = 0.5

अपेक्षित आउटपुट:
expected = [1, 0, 0]
इनपुट:
std::vector<std::vector<double>> samples = {
    {2.0, 1.0},
    {0.0, 0.0},
    {-1.0, -3.0}
};
std::vector<double> weights = {1.5, -0.5};
double bias = -1.0;
double threshold = 0.5;

अपेक्षित आउटपुट:
std::vector<long long> expected = {1, 0, 0};
इनपुट:
double[][] samples = new double[][] {
    new double[] {2.0, 1.0},
    new double[] {0.0, 0.0},
    new double[] {-1.0, -3.0}
};
double[] weights = new double[] {1.5, -0.5};
double bias = -1.0;
double threshold = 0.5;

अपेक्षित आउटपुट:
long[] expected = new long[] {1, 0, 0};

व्याख्या

सैंपल 1: z = 3 - 0.5 - 1 = 1.5, p ≈ 0.818 → 1। सैंपल 2: z = -1, p ≈ 0.269 → 0। सैंपल 3: z = -1.5 + 1.5 - 1 = -1, p ≈ 0.269 → 0। परिणाम: [1, 0, 0]।

उदाहरण 2
इनपुट:
samples = [
    [1.0],
    [2.0],
    [3.0]
]
weights = [1.0]
bias = -2.0
threshold = 0.7

अपेक्षित आउटपुट:
expected = [0, 0, 1]
इनपुट:
std::vector<std::vector<double>> samples = {
    {1.0},
    {2.0},
    {3.0}
};
std::vector<double> weights = {1.0};
double bias = -2.0;
double threshold = 0.7;

अपेक्षित आउटपुट:
std::vector<long long> expected = {0, 0, 1};
इनपुट:
double[][] samples = new double[][] {
    new double[] {1.0},
    new double[] {2.0},
    new double[] {3.0}
};
double[] weights = new double[] {1.0};
double bias = -2.0;
double threshold = 0.7;

अपेक्षित आउटपुट:
long[] expected = new long[] {0, 0, 1};

व्याख्या

प्रायिकताएँ σ(-1) ≈ 0.269, σ(0) = 0.5 और σ(1) ≈ 0.731 हैं। केवल आखिरी 0.7 के थ्रेशोल्ड तक पहुँचती है, इसलिए परिणाम [0, 0, 1] है।

कैसे हल करें

पहले खुद कोशिश करें, फिर एक-एक करके संकेत खोलें।

संकेत 1

हर sample के लिए, पहले features, weights और bias से linear score निकालें।

संकेत 2

उस score को sigmoid से probability में बदलें, फिर उसे threshold से compare करें।

संकेत 3

बहुत बड़े positive या negative scores sigmoid को saturate कर सकते हैं, लेकिन class decision फिर भी threshold से ही आता है।

अपेक्षित जटिलता

समय O(m × n), अतिरिक्त स्थान O(1)

संदर्भ

यह चुनौती CodeUtility के लिए अनुकूलित की गई है। ऊपर दिए गए स्टेटमेंट और सीमाओं का पालन करें।

हर कोडर का सबसे अच्छा पास हुआ समाधान। तेज़, कम मेमोरी वाले और बेहतर रेटिंग वाले समाधान ऊपर रहते हैं।

अभी कोई पास हुआ समाधान नहीं है। इसे हल करें और पहला स्थान पाएँ।

दूसरों से सीखें

समुदाय समाधान

अभी तक कोई प्रकाशित समाधान नहीं। पहला साझा करने के लिए इस चुनौती को हल करें।