अगर आपको यह मूल्यवान लगता है तो मुझे बताएं और मैं आगे बढ़ता रहूंगा!

अध्याय 1 - रैखिक मॉडल

सबसे सरल लेकिन शक्तिशाली अवधारणाओं में से एक रैखिक मॉडल है।

एमएल में, हमारा प्राथमिक लक्ष्य डेटा के आधार पर भविष्यवाणियां करना है। रैखिक मॉडल मशीन लर्निंग के "हैलो वर्ल्ड" की तरह है - यह सीधा है लेकिन अधिक जटिल मॉडल को समझने की नींव बनाता है।

आइए घर की कीमतों की भविष्यवाणी करने के लिए एक मॉडल बनाएं। इस उदाहरण में, आउटपुट अपेक्षित "घर ​​की कीमत" है, और आपका इनपुट "वर्गफुट", "num_bedrooms" आदि जैसी चीजें होंगी...

def prediction(sqft, num_bedrooms, num_baths):
    weight_1, weight_2, weight_3 = .0, .0, .0  
    home_price = weight_1*sqft, weight_2*num_bedrooms, weight_3*num_baths
    return home_price

आपको प्रत्येक इनपुट के लिए एक "वजन" दिखाई देगा। ये वज़न ही भविष्यवाणी के पीछे का जादू पैदा करते हैं। यह उदाहरण उबाऊ है क्योंकि वज़न शून्य होने के कारण इसका आउटपुट हमेशा शून्य होगा।

तो आइए जानें कि हम ये वज़न कैसे पता कर सकते हैं।

वज़न ढूँढना

वजन ज्ञात करने की प्रक्रिया को मॉडल को "प्रशिक्षण" कहा जाता है।

• सबसे पहले, हमें ज्ञात सुविधाओं (इनपुट) और कीमतों (आउटपुट) वाले घरों का एक डेटासेट चाहिए। उदाहरण के लिए:

data = [
    {"sqft": 1000, "bedrooms": 2, "baths": 1, "price": 200000},
    {"sqft": 1500, "bedrooms": 3, "baths": 2, "price": 300000},
    # ... more data points ...
]

• इससे पहले कि हम अपना वजन अपडेट करने का कोई तरीका बनाएं, हमें यह जानना होगा कि हमारी भविष्यवाणियां कितनी सही हैं। हम अपनी भविष्यवाणी और वास्तविक मूल्य के बीच अंतर की गणना कर सकते हैं।

home_price = prediction(1000, 2, 1) # our weights are currently zero, so this is zero
actual_value = 200000

error = home_price - actual_value # 0 - 200000 we are way off. 
# let's square this value so we aren't dealing with negatives
error = home_price**2

अब हमारे पास यह जानने का एक तरीका है कि हम एक डेटा बिंदु के लिए कितने ऑफ (त्रुटि) हैं, हम सभी डेटा बिंदुओं पर औसत त्रुटि की गणना कर सकते हैं। इसे सामान्यतः माध्य वर्ग त्रुटि कहा जाता है।

• अंत में, वज़न को इस तरह से अपडेट करें जिससे माध्य वर्ग त्रुटि कम हो जाए।

बेशक, हम यादृच्छिक संख्याएं चुन सकते हैं और जैसे-जैसे आगे बढ़ेंगे, सर्वोत्तम मूल्य बचाते रहेंगे- लेकिन यह अक्षम है। तो आइए एक अलग विधि का पता लगाएं: ग्रेडिएंट डिसेंट।

ढतला हुआ वंश

ग्रेडिएंट डिसेंट एक अनुकूलन एल्गोरिदम है जिसका उपयोग हमारे मॉडल के लिए सर्वोत्तम वजन खोजने के लिए किया जाता है।

ग्रेडिएंट एक वेक्टर है जो हमें बताता है कि जब हम प्रत्येक वजन में छोटे बदलाव करते हैं तो त्रुटि कैसे बदलती है।

साइडबार अंतर्ज्ञान
एक पहाड़ी परिदृश्य पर खड़े होने की कल्पना करें, और आपका लक्ष्य निम्नतम बिंदु (न्यूनतम त्रुटि) तक पहुंचना है। ढाल एक कम्पास की तरह है जो हमेशा सबसे तीव्र चढ़ाई की ओर इशारा करती है। ढाल की दिशा के विपरीत जाकर, हम निम्नतम बिंदु की ओर कदम बढ़ा रहे हैं।

यह ऐसे काम करता है:

1. यादृच्छिक भार (या शून्य) से प्रारंभ करें।
2. वर्तमान वजन के लिए त्रुटि की गणना करें।
3. प्रत्येक वजन के लिए त्रुटि की ढाल (ढलान) की गणना करें।
4. त्रुटि को कम करने वाली दिशा में एक छोटा कदम बढ़ाकर वजन को अपडेट करें।
5. चरण 2-4 तब तक दोहराएँ जब तक त्रुटि काफ़ी कम होना बंद न हो जाए।

हम प्रत्येक त्रुटि के लिए ग्रेडिएंट की गणना कैसे करते हैं?

ग्रेडिएंट की गणना करने का एक तरीका वजन में छोटे बदलाव करना है, देखें कि इसका हमारी त्रुटि पर क्या प्रभाव पड़ा, और देखें कि हमें वहां से कहां जाना चाहिए।

def calculate_gradient(weight, data, feature_index, step_size=1e-5):
    original_error = calculate_mean_squared_error(weight, data)

    # Slightly increase the weight
    weight[feature_index]  = step_size
    new_error = calculate_mean_squared_error(weight, data)

    # Calculate the slope
    gradient = (new_error - original_error) / step_size

    # Reset the weight
    weight[feature_index] -= step_size

    return gradient

चरण-दर-चरण विश्लेषण

• इनपुट पैरामीटर्स:

  • वजन: हमारे मॉडल के लिए वजन का वर्तमान सेट।
  • डेटा: घर की सुविधाओं और कीमतों का हमारा डेटासेट।
  • फीचर_इंडेक्स: जिस वजन के लिए हम ग्रेडिएंट की गणना कर रहे हैं (वर्गफुट के लिए 0, शयनकक्ष के लिए 1, स्नान के लिए 2)।
  • चरण_आकार: एक छोटा मान जिसका उपयोग हम वजन को थोड़ा बदलने के लिए करते हैं (डिफ़ॉल्ट 1e-5 या 0.00001 है)।

• मूल त्रुटि की गणना करें:
  
  

   original_error = calculate_mean_squared_error(weight, data)

हम पहले अपने वर्तमान भार के साथ माध्य वर्ग त्रुटि की गणना करते हैं। इससे हमें अपना शुरुआती बिंदु मिलता है।

• वजन थोड़ा बढ़ाएं:

   weight[feature_index]  = step_size

हम थोड़ी मात्रा में वजन बढ़ाते हैं (चरण_आकार)। यह हमें यह देखने की अनुमति देता है कि वजन में एक छोटा सा परिवर्तन हमारी त्रुटि को कैसे प्रभावित करता है।

• नई त्रुटि की गणना करें:

   new_error = calculate_mean_squared_error(weight, data)

हम थोड़े बढ़े हुए वजन के साथ फिर से माध्य वर्ग त्रुटि की गणना करते हैं।

• ढलान (ढाल) की गणना करें:

   gradient = (new_error - original_error) / step_size

यह महत्वपूर्ण कदम है। हम पूछ रहे हैं: "जब हमने वजन थोड़ा बढ़ाया तो त्रुटि में कितना बदलाव आया?"

• यदि नया_त्रुटि> मूल_त्रुटि है, तो ग्रेडिएंट सकारात्मक है, जिसका अर्थ है कि इस वजन को बढ़ाने से त्रुटि बढ़ जाती है।
• यदि नया_त्रुटि

• परिमाण हमें बताता है कि इस भार में परिवर्तन के प्रति त्रुटि कितनी संवेदनशील है।

  • वजन रीसेट करें:

   weight[feature_index] -= step_size

हमने वजन को उसके मूल मूल्य पर वापस रख दिया क्योंकि हम परीक्षण कर रहे थे कि अगर हमने इसे बदल दिया तो क्या होगा।

• ग्रेडिएंट लौटाएं:

   return gradient

हम इस वजन के लिए परिकलित ग्रेडिएंट लौटाते हैं।

इसे "संख्यात्मक ग्रेडिएंट गणना" या "परिमित अंतर विधि" कहा जाता है। हम विश्लेषणात्मक रूप से गणना करने के बजाय ग्रेडिएंट का अनुमान लगा रहे हैं।

आइये वज़न अपडेट करें

अब जब हमारे पास अपने ग्रेडिएंट हैं, तो हम ग्रेडिएंट को घटाकर अपने वजन को ग्रेडिएंट की विपरीत दिशा में बढ़ा सकते हैं।

weights[i] -= gradients[i]

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

learning_rate = 0.00001
weights[i] -= learning_rate*gradients[i]

और इसलिए यहां बताया गया है कि हम इसे सभी भारों के लिए कैसे करते हैं:

def gradient_descent(data, learning_rate=0.00001, num_iterations=1000):
    weights = [0, 0, 0]  # Start with zero weights

    for _ in range(num_iterations):
        gradients = [
            calculate_gradient(weights, data, 0), # sqft
            calculate_gradient(weights, data, 1), # bedrooms
            calculate_gradient(weights, data, 2)  # bathrooms
        ]

        # Update each weight
        for i in range(3):
            weights[i] -= learning_rate * gradients[i]

        if _ % 100 == 0:
            error = calculate_mean_squared_error(weights, data)
            print(f"Iteration {_}, Error: {error}, Weights: {weights}")

    return weights

आखिरकार, हमें अपना वजन मिल गया!

मॉडल की व्याख्या

एक बार जब हमारे पास प्रशिक्षित वजन हो, तो हम उनका उपयोग अपने मॉडल की व्याख्या करने के लिए कर सकते हैं:

• 'वर्ग फुट' का वजन प्रति वर्ग फुट मूल्य वृद्धि को दर्शाता है।
• 'बेडरूम' का वजन प्रति अतिरिक्त बेडरूम की कीमत में वृद्धि दर्शाता है।
• 'स्नान' का वजन प्रति अतिरिक्त बाथरूम की कीमत में वृद्धि दर्शाता है।

उदाहरण के लिए, यदि हमारा प्रशिक्षित वजन [100, 10000, 15000] है, तो इसका मतलब है:

• प्रत्येक वर्ग फुट घर की कीमत में $100 जोड़ता है।
• प्रत्येक शयनकक्ष घर की कीमत में $10,000 जोड़ता है।
• प्रत्येक बाथरूम घर की कीमत में $15,000 जोड़ता है।

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