सभी चुनौतियाँ
आसान 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
इनपुट:
bias = -1.0
samples = [
    [2.0, 1.0],
    [0.0, 0.0],
    [-1.0, -3.0]
]
weights = [1.5, -0.5]
threshold = 0.5

अपेक्षित आउटपुट:
expected = [1, 0, 0]
इनपुट:
double bias = -1.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 threshold = 0.5;

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

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

अपेक्षित आउटपुट:
std::vector<long long> expected = {0, 0, 1};
इनपुट:
double bias = -2.0;
double[][] samples = new double[][] {
    new double[] {1.0},
    new double[] {2.0},
    new double[] {3.0}
};
double[] weights = new double[] {1.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] है।

संदर्भ

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

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

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

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