python - पायथन और numpy का उपयोग कर ढाल वंश




machine-learning linear-regression (3)

नीचे आप रैखिक प्रतिगमन समस्या के लिए ढाल वंश के कार्यान्वयन को पा सकते हैं।

सबसे पहले, आप XT * (X * w - y) / N जैसे ढाल की गणना करते हैं और साथ ही इस ढाल के साथ अपने वर्तमान थेटा को अपडेट करते हैं।

  • एक्स: फीचर मैट्रिक्स
  • वाई: लक्ष्य मूल्य
  • डब्ल्यू: वजन / मूल्य
  • एन: प्रशिक्षण सेट का आकार

पाइथन कोड यहां दिया गया है:

import pandas as pd
import numpy as np
from matplotlib import pyplot as plt
import random

def generateSample(N, variance=100):
    X = np.matrix(range(N)).T + 1
    Y = np.matrix([random.random() * variance + i * 10 + 900 for i in range(len(X))]).T
    return X, Y

def fitModel_gradient(x, y):
    N = len(x)
    w = np.zeros((x.shape[1], 1))
    eta = 0.0001

    maxIteration = 100000
    for i in range(maxIteration):
        error = x * w - y
        gradient = x.T * error / N
        w = w - eta * gradient
    return w

def plotModel(x, y, w):
    plt.plot(x[:,1], y, "x")
    plt.plot(x[:,1], x * w, "r-")
    plt.show()

def test(N, variance, modelFunction):
    X, Y = generateSample(N, variance)
    X = np.hstack([np.matrix(np.ones(len(X))).T, X])
    w = modelFunction(X, Y)
    plotModel(X, Y, w)


test(50, 600, fitModel_gradient)
test(50, 1000, fitModel_gradient)
test(100, 200, fitModel_gradient)

def gradient(X_norm,y,theta,alpha,m,n,num_it):
    temp=np.array(np.zeros_like(theta,float))
    for i in range(0,num_it):
        h=np.dot(X_norm,theta)
        #temp[j]=theta[j]-(alpha/m)*(  np.sum( (h-y)*X_norm[:,j][np.newaxis,:] )  )
        temp[0]=theta[0]-(alpha/m)*(np.sum(h-y))
        temp[1]=theta[1]-(alpha/m)*(np.sum((h-y)*X_norm[:,1]))
        theta=temp
    return theta



X_norm,mean,std=featureScale(X)
#length of X (number of rows)
m=len(X)
X_norm=np.array([np.ones(m),X_norm])
n,m=np.shape(X_norm)
num_it=1500
alpha=0.01
theta=np.zeros(n,float)[:,np.newaxis]
X_norm=X_norm.transpose()
theta=gradient(X_norm,y,theta,alpha,m,n,num_it)
print theta

उपरोक्त कोड से मेरा 100.2 61.09 100.2 100.2 , लेकिन यह matlab में 100.2 61.09 होना चाहिए जो सही है।


पायथन में @ थॉमस-जंगलब्लूट कार्यान्वयन के बाद, मैंने ऑक्टेव के लिए भी ऐसा ही किया। अगर आपको कुछ गड़बड़ मिलती है तो कृपया मुझे बताएं और मैं + अपडेट ठीक कर दूंगा।

डेटा निम्न पंक्तियों के साथ एक txt फ़ाइल से आता है:

1 10 1000
2 20 2500
3 25 3500
4 40 5500
5 60 6200

सुविधाओं [शयनकक्षों की संख्या] [mts2] और अंतिम कॉलम [किराया मूल्य] के लिए एक बहुत ही मोटा नमूना के रूप में इसके बारे में सोचें जो हम भविष्यवाणी करना चाहते हैं।

ऑक्टेव कार्यान्वयन यहां दिया गया है:

%
% Linear Regression with multiple variables
%

% Alpha for learning curve
alphaNum = 0.0005;

% Number of features
n = 2;

% Number of iterations for Gradient Descent algorithm
iterations = 10000

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% No need to update after here
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

DATA = load('CHANGE_WITH_DATA_FILE_PATH');

% Initial theta values
theta = ones(n + 1, 1);

% Number of training samples
m = length(DATA(:, 1));

% X with one mor column (x0 filled with '1's)
X = ones(m, 1);
for i = 1:n
  X = [X, DATA(:,i)];
endfor

% Expected data must go always in the last column  
y = DATA(:, n + 1)

function gradientDescent(x, y, theta, alphaNum, iterations)
  iterations = [];
  costs = [];

  m = length(y);

  for iteration = 1:10000
    hypothesis = x * theta;

    loss = hypothesis - y;

    % J(theta)    
    cost = sum(loss.^2) / (2 * m);

    % Save for the graphic to see if the algorithm did work
    iterations = [iterations, iteration];
    costs = [costs, cost];

    gradient = (x' * loss) / m; % /m is for the average

    theta = theta - (alphaNum * gradient);
  endfor    

  % Show final theta values
  display(theta)

  % Show J(theta) graphic evolution to check it worked, tendency must be zero
  plot(iterations, costs);

endfunction

% Execute gradient descent
gradientDescent(X, y, theta, alphaNum, iterations);

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

  1. परिकल्पना एच = एक्स * थेटा की गणना करें
  2. हानि = एच - वाई और शायद वर्ग की लागत (हानि ^ 2) / 2 मीटर की गणना करें
  3. ढाल = एक्स '* हानि / एम की गणना करें
  4. पैरामीटर theta = theta - अल्फा * ढाल अद्यतन करें

आपके मामले में, मुझे लगता है कि आपने n साथ m उलझन में है। यहां m आपके प्रशिक्षण सेट में उदाहरणों की संख्या को दर्शाता है, न कि सुविधाओं की संख्या।

आइए आपके कोड की भिन्नता देखें:

import numpy as np
import random

# m denotes the number of examples here, not the number of features
def gradientDescent(x, y, theta, alpha, m, numIterations):
    xTrans = x.transpose()
    for i in range(0, numIterations):
        hypothesis = np.dot(x, theta)
        loss = hypothesis - y
        # avg cost per example (the 2 in 2*m doesn't really matter here.
        # But to be consistent with the gradient, I include it)
        cost = np.sum(loss ** 2) / (2 * m)
        print("Iteration %d | Cost: %f" % (i, cost))
        # avg gradient per example
        gradient = np.dot(xTrans, loss) / m
        # update
        theta = theta - alpha * gradient
    return theta


def genData(numPoints, bias, variance):
    x = np.zeros(shape=(numPoints, 2))
    y = np.zeros(shape=numPoints)
    # basically a straight line
    for i in range(0, numPoints):
        # bias feature
        x[i][0] = 1
        x[i][1] = i
        # our target variable
        y[i] = (i + bias) + random.uniform(0, 1) * variance
    return x, y

# gen 100 points with a bias of 25 and 10 variance as a bit of noise
x, y = genData(100, 25, 10)
m, n = np.shape(x)
numIterations= 100000
alpha = 0.0005
theta = np.ones(n)
theta = gradientDescent(x, y, theta, alpha, m, numIterations)
print(theta)

सबसे पहले मैं एक छोटा यादृच्छिक डेटासेट बनाता हूं जो इस तरह दिखना चाहिए:

जैसा कि आप देख सकते हैं मैंने जेनरेटेड रिग्रेशन लाइन और सूत्र भी जोड़ा है जिसे एक्सेल द्वारा गणना की गई थी।

आपको ढाल वंश का उपयोग करके प्रतिगमन के अंतर्ज्ञान के बारे में परवाह करने की आवश्यकता है। जैसे ही आप अपने डेटा एक्स पर एक पूर्ण बैच पास करते हैं, आपको प्रत्येक उदाहरण के एम-लॉस को एक वज़न अपडेट में कम करने की आवश्यकता होती है। इस मामले में, यह ग्रेडियेंट्स पर योग का औसत है, इस प्रकार m द्वारा विभाजन।

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

यदि आप मेरा उदाहरण चलाते हैं, तो वापस लौटाए गए थे:

Iteration 99997 | Cost: 47883.706462
Iteration 99998 | Cost: 47883.706462
Iteration 99999 | Cost: 47883.706462
[ 29.25567368   1.01108458]

जो वास्तव में समीकरण के करीब है जो एक्सेल (y = x + 30) द्वारा गणना की गई थी। ध्यान दें कि जब हमने पहले कॉलम में पूर्वाग्रह पारित किया था, तो पहला थाटा मान पूर्वाग्रह भार को दर्शाता है।





gradient-descent