मैंने प्रशिक्षण उद्देश्य के लिए, पायथन में एक रैखिक प्रतिगमन लागू किया। समस्या यह है कि लागत घटने के बजाय बढ़ती ही जा रही है। डेटा के लिए मैं Airfoil सेल्फ-शोर डेटा सेट का उपयोग करता हूं। डेटा यहां पाया जा सकता है

मैं निम्नानुसार डेटा आयात करता हूं:

import pandas as pd

def features():

    features = pd.read_csv("data/airfoil_self_noise/airfoil_self_noise.dat.txt", sep="\t", header=None)

    X = features.iloc[:, 0:5]
    Y = features.iloc[:, 5]

    return X.values, Y.values.reshape(Y.shape[0], 1)

रैखिक प्रतिगमन के लिए मेरा कोड निम्नलिखित है:

import numpy as np
import random

class linearRegression():

    def __init__(self, learning_rate=0.01, max_iter=20):
        """
        Initialize the hyperparameters of the linear regression.

        :param learning_rate: the learning rate
        :param max_iter: the max numer of iteration to perform
        """

        self.lr = learning_rate
        self.max_iter = max_iter
        self.m = None
        self.weights = None
        self.bias = None

    def fit(self, X, Y):
        """
        Run gradient descent algorithm

        :param X: the inputs
        :param Y: the outputs
        :return:
        """

        self.m = X.shape[0]
        self.weights = np.random.normal(0, 0.1, (X.shape[1], 1))
        self.bias = random.normalvariate(0, 0.1)

        for iter in range(0, self.max_iter):

            A = self.__forward(X)
            dw, db = self.__backward(A, X, Y)

            J = (1/(2 * self.m)) * np.sum(np.power((A - Y), 2))

            print("at iteration %s cost is %s" % (iter, J))

            self.weights = self.weights - self.lr * dw
            self.bias = self.bias - self.lr * db

    def predict(self, X):
        """
        Make prediction on the inputs

        :param X: the inputs
        :return:
        """

        Y_pred = self.__forward(X)

        return Y_pred

    def __forward(self, X):
        """
        Compute the linear function on the inputs

        :param X: the inputs
        :return:
            A: the activation
        """

        A = np.dot(X, self.weights) + self.bias

        return A

    def __backward(self, A, X, Y):
        """

        :param A: the activation
        :param X: the inputs
        :param Y: the outputs
        :return:
            dw: the gradient for the weights
            db: the gradient for the bias
        """

        dw = (1 / self.m) * np.dot(X.T, (A - Y))
        db = (1 / self.m) * np.sum(A - Y)

        return dw, db

फिर मैं लीनियर रिग्रेशन क्लास को फॉलो के रूप में इंस्टेंट करता हूं:

X, Y = features()
model = linearRegression()
X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.33, random_state=42)
model.fit(X_train, y_train)

मैंने यह पता लगाने की कोशिश की कि लागत क्यों बढ़ रही है लेकिन अभी तक मुझे यह पता नहीं चल पाया है कि क्यों। अगर कोई मुझे सही दिशा में इंगित कर सकता है तो इसकी सराहना की जाएगी।

14
Vetouz 30 अगस्त 2018, 12:32
3
पूरा कोड पोस्ट करें जहां आप क्लास इंस्टेंस बनाते हैं और फंक्शन्स को कॉल करते हैं। दूसरों को त्रुटि/समस्या को पुन: उत्पन्न करने दें
 – 
Sheldore
30 अगस्त 2018, 12:40
2
मैंने अपनी पोस्ट संपादित की
 – 
Vetouz
30 अगस्त 2018, 13:19
जब आप अपने डेटा पर अन्य पैकेजों का उपयोग करते हैं तो आपको किस प्रकार के परिणाम प्राप्त होते हैं? जब आप हाथ से कुछ पुनरावृत्ति करते हैं तो आपको क्या मिलता है?
 – 
Mohammad Athar
4 सितंबर 2018, 16:27
यह शायद आपका डेटा है। जब मैं features() में लाइन को X = features.iloc[:, 1:2] में बदलता हूं (पहले चार कॉलम का उपयोग करने के बजाय) तो आपकी लागत घटने लगती है। यहां तक ​​​​कि जब मैं स्केलेर का उपयोग करता हूं, तब भी मुझे मूल डेटा के साथ .6 से बेहतर स्कोर नहीं मिल सकता है। एक कृत्रिम डेटासेट बनाने का प्रयास करें जिसे आप जानते हैं कि रैखिक प्रतिगमन के साथ अच्छी तरह से होगा- देखें कि आपको किस प्रकार के परिणाम मिलते हैं
 – 
Mohammad Athar
4 सितंबर 2018, 16:54

3 जवाब

आम तौर पर यदि आपने बड़ी सीखने की दर को चुना है तो आपको इसी तरह की समस्या हो सकती है। मैंने आपके कोड की जांच करने की कोशिश की है और मेरी टिप्पणियां हैं:

  • आपका लागत फलन J ठीक लगता है।
  • लेकिन आपके पीछे के कार्य में आप अपने वास्तविक परिणामों को अपने अनुमानों से घटाते हैं। ऐसा करने से आप नकारात्मक भार प्राप्त कर सकते हैं और चूंकि आप अपनी सीखने की दर के गुणन को घटा रहे हैं और वजन और ग्रेडिएंट से अपनी दर को घटा रहे हैं, तो आप अंत में बढ़े हुए लागत फ़ंक्शन परिणाम प्राप्त कर रहे हैं।
5
ozata 4 सितंबर 2018, 16:12

आपकी सीखने की दर बहुत बहुत अधिक है। जब मैं 0.01 के बजाय 1e-7 की सीखने की दर को छोड़कर आपके कोड को असंशोधित चलाता हूं, तो मुझे विश्वसनीय रूप से घटती लागत मिलती है।

3
Ingo 5 सितंबर 2018, 06:03

आम तौर पर, लागत बढ़ने पर सीखने की दर बहुत अधिक होती है।

0
tlm 11 सितंबर 2018, 13:01