Градиентный спуск с использованием python и numpy

Ответ 1

Я думаю, что ваш код слишком сложный, и ему нужна больше структуры, потому что иначе вы будете потеряны во всех уравнениях и операциях. В конце этого регрессия сводится к четырем операциям:

• Вычислить гипотезу h = X * theta​​li >
• Рассчитайте потерю = h - y и, возможно, квадрат стоимости (убыток ^ 2)/2m
• Вычислить градиент = X '* loss/m
• Обновить параметры: theta = theta - alpha * gradient

В вашем случае, я думаю, вы путали m с n. Здесь 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)

Сначала я создаю небольшой случайный набор данных, который должен выглядеть следующим образом:

Как вы можете видеть, я также добавил созданную линию регрессии и формулу, которая была рассчитана с помощью excel.

Вам нужно позаботиться об интуиции регрессии с помощью градиентного спуска. Поскольку вы выполняете полный пакетный контроль над данными X, вам нужно уменьшить m-потери каждого примера до одного обновления веса. В этом случае это среднее значение суммы по градиентам, таким образом, деление на m.

Следующее, что вам нужно позаботиться, - отслеживать конвергенцию и корректировать скорость обучения. В этом случае вы всегда должны отслеживать свои затраты на каждой итерации, возможно, даже заговорить.

Если вы запустите мой пример, возвращаемый тета будет выглядеть так:

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

На самом деле это довольно близко к уравнению, которое было рассчитано с помощью excel (y = x + 30). Обратите внимание, что при прохождении смещения в первый столбец первое значение theta обозначает вес смещения.

Ответ 2

Ниже вы можете найти мою реализацию градиентного спуска для проблемы линейной регрессии.

Сначала вы вычисляете градиент как X.T * (X * w - y) / N и одновременно обновляете текущий тета с помощью этого градиента.

• X: функциональная матрица
• y: целевые значения
• w: вес/значения
• N: размер учебного набора

Вот код python:

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)

Ответ 3

Я знаю, что этот вопрос уже был ответом, но я сделал некоторое обновление функции GD:

  ### COST FUNCTION

def cost(theta,X,y):
     ### Evaluate half MSE (Mean square error)
     error = np.dot(X,theta) - y
     J = np.sum(error ** 2)/(2*m)
     return J

 cost(theta,X,y)



def GD(X,y,theta,alpha):

    cost_histo = [0]
    theta_histo = [0]

    # an arbitrary gradient, to pass the initial while() check
    delta = [np.repeat(1,len(X))]
    # Initial theta
    old_cost = cost(theta,X,y)

    while (np.max(np.abs(delta)) > 1e-6):
        error = np.dot(X,theta) - y
        delta = np.dot(np.transpose(X),error)/len(y)
        trial_theta = theta - alpha * delta
        trial_cost = cost(trial_theta,X,y)
        while (trial_cost >= old_cost):
            trial_theta = (theta +trial_theta)/2
            trial_cost = cost(trial_theta,X,y)
            cost_histo = cost_histo + trial_cost
            theta_histo = theta_histo +  trial_theta
        old_cost = trial_cost
        theta = trial_theta
    Intercept = theta[0] 
    Slope = theta[1]  
    return [Intercept,Slope]

res = GD(X,y,theta,alpha)

Эта функция уменьшает альфа по итерации, делая функцию слишком сходимой, см. Оценка линейной регрессии с градиентным спуском (наискорейшее спуск) для примера в R. Я применяю та же логика, но в Python.