Hồi quy logistic giảm dần độ dốc python

Độ dốc gốc là một thuật toán tối ưu hóa hoạt động bằng cách tìm kiếm hiệu quả không gian tham số, phần chặn($\theta_0$) và độ dốc($\theta_1$) cho hồi quy tuyến tính, theo quy tắc sau

\[\begin{aligned} \theta. = \theta -\alpha \frac{\delta}{\delta \theta}J(\theta). \end{căn} \]

Lưu ý rằng chúng tôi đã sử dụng '$. =$' để chỉ định hoặc cập nhật

\(J(\theta)\) được gọi là hàm chi phí và \(\alpha\) là tốc độ học tập, một tham số miễn phí. Trong hướng dẫn này, chúng ta sẽ sử dụng hàm chi phí bình phương nhỏ nhất được định nghĩa như sau

\[\begin{aligned} J(\theta) = \frac{1}{2m}\sum_{i=1}^m (h_\theta(x^{(i)})-y^{(i)

trong đó \(m\) là tổng số ví dụ huấn luyện và $h_\theta(x^{(i)})$ là hàm giả thiết được định nghĩa như sau

\[\begin{aligned} h_\theta(x^{(i)}) = \theta_0 + \theta_1 x^{(i)} \end{aligned} \]

trong đó siêu tập lệnh $(i)$ được sử dụng để biểu thị mẫu $i^{th}$ (chúng tôi sẽ lưu các chỉ số con cho chỉ mục vào một tính năng khi chúng tôi xử lý nhiều tính năng)

Chúng ta cần đạo hàm cho cả $\theta_0$ và $\theta_1$

\[\begin{aligned} \frac{\partial}{\partial \theta_0}J(\theta_0, \theta_1) = \frac{1}{m} \sum_{i=1}^m (h_\theta(

Hồi quy logistic giảm dần độ dốc python

Đoạn mã sau chạy cho đến khi nó hội tụ hoặc đạt đến số lần lặp tối đa. Chúng tôi nhận được $\theta_0$ và $\theta_1$ là đầu ra của nó

import numpy as np
import random
import sklearn
from sklearn.datasets.samples_generator import make_regression 
import pylab
from scipy import stats

def gradient_descent(alpha, x, y, ep=0.0001, max_iter=10000):
    converged = False
    iter = 0
    m = x.shape[0] # number of samples

    # initial theta
    t0 = np.random.random(x.shape[1])
    t1 = np.random.random(x.shape[1])

    # total error, J(theta)
    J = sum([(t0 + t1*x[i] - y[i])**2 for i in range(m)])

    # Iterate Loop
    while not converged:
        # for each training sample, compute the gradient (d/d_theta j(theta))
        grad0 = 1.0/m * sum([(t0 + t1*x[i] - y[i]) for i in range(m)]) 
        grad1 = 1.0/m * sum([(t0 + t1*x[i] - y[i])*x[i] for i in range(m)])

        # update the theta_temp
        temp0 = t0 - alpha * grad0
        temp1 = t1 - alpha * grad1
    
        # update theta
        t0 = temp0
        t1 = temp1

        # mean squared error
        e = sum( [ (t0 + t1*x[i] - y[i])**2 for i in range(m)] ) 

        if abs(J-e) <= ep:
            print 'Converged, iterations: ', iter, '!!!'
            converged = True
    
        J = e   # update error 
        iter += 1  # update iter
    
        if iter == max_iter:
            print 'Max interactions exceeded!'
            converged = True

    return t0,t1

if __name__ == '__main__':

    x, y = make_regression(n_samples=100, n_features=1, n_informative=1, 
                        random_state=0, noise=35) 
    print 'x.shape = %s y.shape = %s' %(x.shape, y.shape)
 
    alpha = 0.01 # learning rate
    ep = 0.01 # convergence criteria

    # call gredient decent, and get intercept(=theta0) and slope(=theta1)
    theta0, theta1 = gradient_descent(alpha, x, y, ep, max_iter=1000)
    print ('theta0 = %s theta1 = %s') %(theta0, theta1) 

    # check with scipy linear regression 
    slope, intercept, r_value, p_value, slope_std_error = stats.linregress(x[:,0], y)
    print ('intercept = %s slope = %s') %(intercept, slope) 

    # plot
    for i in range(x.shape[0]):
        y_predict = theta0 + theta1*x 

    pylab.plot(x,y,'o')
    pylab.plot(x,y_predict,'k-')
    pylab.show()
    print "Done!"

đầu ra

x.shape = (100, 1) y.shape = (100,)
Converged, iterations:  641 !!!
theta0 = [-2.81943944] theta1 = [ 43.1387759]
intercept = -2.84963639461 slope = 43.2042438802

Đường hồi quy trong hình trên xác nhận rằng chúng tôi đã nhận được kết quả đúng từ thuật toán Gradient Descent của mình. Ngoài ra, số liệu thống kê của sciPy. linregress đảm bảo (giá trị chặn và độ dốc) tính chính xác của kết quả của chúng tôi (theta0 và theta1)

Chúng ta cần cẩn thận một chút khi cập nhật $\theta_0$ và $\theta_1$. Đầu tiên, chúng tôi tính toán $\theta_0$ và $\theta_1$ tạm thời với $\theta_0$ và $\theta_1$ cũ, sau đó chúng tôi nhận được $\theta_0$ và $\theta_1$ mới từ $temp0$ và $temp1$

\[\begin{aligned} temp0. = \theta_0 -\alpha \frac{\partial}{\partial \theta_0}J(\theta_0, \theta_1) \end{aligned} \] \[\begin{aligned} temp1. = \theta_1 -\alpha \frac{\partial}{\partial \theta_1}J(\theta_0, \theta_1) \end{aligned} \] \[\begin{aligned} \theta_0. = temp0 \end{aligned} \] \[\begin{aligned} \theta_1. = nhiệt độ1. \end{căn} \]

Đoạn mã sau gần giống như đoạn mã chúng ta đã sử dụng trong phần trước nhưng đơn giản hơn vì nó sử dụng numPy tốt hơn. Nó chạy cho đến khi đạt đến số lần lặp tối đa. Chúng tôi nhận được $\theta_0$ và $\theta_1$ là đầu ra của nó

import numpy as np
import random
from sklearn.datasets.samples_generator import make_regression 
import pylab
from scipy import stats

def gradient_descent_2(alpha, x, y, numIterations):
    m = x.shape[0] # number of samples
    theta = np.ones(2)
    x_transpose = x.transpose()
    for iter in range(0, numIterations):
        hypothesis = np.dot(x, theta)
        loss = hypothesis - y
        J = np.sum(loss ** 2) / (2 * m)  # cost
        print "iter %s | J: %.3f" % (iter, J)      
        gradient = np.dot(x_transpose, loss) / m         
        theta = theta - alpha * gradient  # update
    return theta

if __name__ == '__main__':

    x, y = make_regression(n_samples=100, n_features=1, n_informative=1, 
                        random_state=0, noise=35) 
    m, n = np.shape(x)
    x = np.c_[ np.ones(m), x] # insert column
    alpha = 0.01 # learning rate
    theta = gradient_descent_2(alpha, x, y, 1000)

    # plot
    for i in range(x.shape[1]):
        y_predict = theta[0] + theta[1]*x 
    pylab.plot(x[:,1],y,'o')
    pylab.plot(x,y_predict,'k-')
    pylab.show()
    print "Done!"

đầu ra

iter 0 | J: 1604.873
iter 1 | J: 1586.636
iter 2 | J: 1568.768
iter 3 | J: 1551.261
...
iter 997 | J: 699.300
iter 998 | J: 699.300
iter 999 | J: 699.300
theta = [ -2.84837957  43.20234847]

Hồi quy logistic giảm dần độ dốc python

Chúng tôi cũng có thể muốn xem cách sử dụng giảm độ dốc hàng loạt cho bộ dữ liệu Iris nổi tiếng. Mạng Nơ-ron một lớp - Nơ-ron tuyến tính thích ứng sử dụng chức năng kích hoạt (nhận dạng) tuyến tính với phương pháp gradient hàng loạt

Chúng ta có thể sử dụng độ dốc gốc cho hồi quy logistic không?

Đáng ngạc nhiên là quy tắc cập nhật lại giống với quy tắc được rút ra bằng cách sử dụng tổng các lỗi bình phương trong hồi quy tuyến tính. Do đó, chúng ta cũng có thể sử dụng cùng một công thức giảm độ dốc cho hồi quy logistic .

Hồi quy logistic Sklearn có sử dụng độ dốc gốc không?

Mô hình hồi quy tuyến tính hội tụ đến giải pháp tối ưu bằng cách sử dụng Gradient Descent. Tuy nhiên, Hồi quy tuyến tính sklearn không sử dụng độ dốc giảm dần .

Hồi quy logistic có sử dụng độ dốc giảm dần hoặc tăng dần không?

3. Tốc độ giảm dần . Giảm độ dốc là một quy trình lặp đi lặp lại qua đó chúng tôi tối ưu hóa các tham số của mô hình máy học. Nó đặc biệt được sử dụng trong các mạng thần kinh, mà còn trong hồi quy logistic và các máy vectơ hỗ trợ.

Python triển khai hồi quy logistic từ đầu như thế nào?

nhập gấu trúc dưới dạng pd nhập numpy dưới dạng np nhập matplotlib. pyplot như plt từ cốt truyện. nhập ngoại tuyến download_plotlyjs, init_notebook_mode, cốt truyện, iplot nhập sơ đồ dưới dạng py nhập sơ đồ. graph_objs khi bắt đầu nhập thời gian init_notebook_mode(connected=True)
def sigmoid(X, trọng số). z = np. .
mất chắc chắn (h, y). trả lại (-y * np