साध्या रेखीय प्रतिगमनाचे समीकरण सोडवणे

लेख एका साध्या (जोडलेल्या) प्रतिगमन रेषेचे गणितीय समीकरण निर्धारित करण्याच्या अनेक मार्गांवर चर्चा करतो.

येथे चर्चा केलेले समीकरण सोडवण्याच्या सर्व पद्धती किमान वर्ग पद्धतीवर आधारित आहेत. चला खालील पद्धती दर्शवूया:

• विश्लेषणात्मक उपाय
• ग्रेडियंट डिसेंट
• स्टोकास्टिक ग्रेडियंट डिसेंट

सरळ रेषेचे समीकरण सोडवण्याच्या प्रत्येक पद्धतीसाठी, लेख विविध फंक्शन्स प्रदान करतो, जे प्रामुख्याने लायब्ररी न वापरता लिहिलेल्यांमध्ये विभागले जातात. सुन्न आणि जे गणनेसाठी वापरतात सुन्न. असा विश्वास आहे की कुशल वापर सुन्न संगणकीय खर्च कमी करेल.

लेखात दिलेले सर्व कोड लिहिलेले आहेत अजगर 2.7 वापरत आहे ज्युपिटर नोटबुक. नमुना डेटासह स्त्रोत कोड आणि फाइल वर पोस्ट केली आहे गिथुब

आर्टिफिशियल इंटेलिजेंस - मशिन लर्निंग या अत्यंत विस्तृत विभागाच्या अभ्यासात हळूहळू प्रभुत्व मिळवू लागलेल्या नवशिक्यांसाठी आणि ज्यांनी हळूहळू प्रावीण्य मिळवायला सुरुवात केली आहे अशा दोघांसाठी हा लेख अधिक आहे.

सामग्री स्पष्ट करण्यासाठी, आम्ही एक अतिशय साधे उदाहरण वापरतो.

उदाहरण परिस्थिती

आमच्याकडे पाच मूल्ये आहेत जी अवलंबित्व दर्शवतात Y पासून X (तक्ता क्र. १):

तक्ता क्रमांक 1 “उदाहरण अटी”

आपण मूल्ये गृहीत धरू वर्षाचा महिना आहे, आणि - या महिन्यात महसूल. दुसऱ्या शब्दांत, महसूल वर्षाच्या महिन्यावर अवलंबून असतो आणि - एकमात्र चिन्ह ज्यावर महसूल अवलंबून आहे.

वर्षाच्या महिन्यावरील कमाईच्या सशर्त अवलंबित्वाच्या दृष्टिकोनातून आणि मूल्यांच्या संख्येच्या दृष्टिकोनातून, उदाहरण असेच आहे - त्यापैकी फारच कमी आहेत. तथापि, अशा सरलीकरणामुळे ते शक्य होईल, जसे ते म्हणतात, नवशिक्या आत्मसात करणारी सामग्री नेहमी सहजतेने नाही हे स्पष्ट करणे. आणि संख्यांची साधेपणा देखील ज्यांना लक्षणीय श्रम खर्चाशिवाय कागदावर उदाहरण सोडवायचे आहे त्यांना अनुमती देईल.

उदाहरणात दिलेले अवलंबित्व फॉर्मच्या साध्या (जोडलेल्या) प्रतिगमन रेषेच्या गणितीय समीकरणाद्वारे अंदाजे चांगले ठरवले जाऊ शकते असे गृहीत धरू या:

जेथे ज्या महिन्यात महसूल प्राप्त झाला तो महिना आहे, - महिन्याशी संबंधित महसूल, и अंदाजित रेषेचे प्रतिगमन गुणांक आहेत.

गुणांक लक्षात घ्या सहसा अंदाजे रेषेचा उतार किंवा ग्रेडियंट म्हणतात; ती रक्कम दर्शवते ज्याद्वारे जेव्हा ते बदलते .

साहजिकच, उदाहरणातील आमचे कार्य समीकरणातील असे गुणांक निवडणे आहे и , ज्यावर खऱ्या उत्तरांपासून महिन्यानुसार आमच्या गणना केलेल्या महसूल मूल्यांचे विचलन, उदा. नमुन्यात सादर केलेली मूल्ये किमान असतील.

किमान चौरस पद्धत

किमान वर्ग पद्धतीनुसार, विचलनाचे वर्गीकरण करून मोजले पाहिजे. हे तंत्र आपल्याला विचलनांचे परस्पर रद्दीकरण टाळण्यास अनुमती देते जर त्यांच्यात विरुद्ध चिन्हे असतील. उदाहरणार्थ, जर एका बाबतीत, विचलन आहे +5 (अधिक पाच), आणि इतर मध्ये -5 (वजा पाच), नंतर विचलनांची बेरीज एकमेकांना रद्द करेल आणि 0 (शून्य) होईल. विचलनाचे वर्गीकरण करणे शक्य नाही, परंतु मॉड्यूलसच्या गुणधर्माचा वापर करणे शक्य आहे आणि नंतर सर्व विचलन सकारात्मक असतील आणि जमा होतील. आम्ही या मुद्द्यावर तपशीलवार विचार करणार नाही, परंतु फक्त असे सूचित करतो की गणनेच्या सोयीसाठी, विचलनाचे वर्गीकरण करण्याची प्रथा आहे.

हे सूत्र असे दिसते ज्याद्वारे आपण वर्ग विचलनाची किमान बेरीज (त्रुटी) निर्धारित करू:

जेथे खऱ्या उत्तरांच्या अंदाजाचे कार्य आहे (म्हणजे, आम्ही गणना केलेली कमाई),

खरी उत्तरे आहेत (नमुन्यात दिलेला महसूल),

नमुना निर्देशांक आहे (ज्या महिन्यातील विचलन निर्धारित केले जाते त्या महिन्याची संख्या)

चला फंक्शन वेगळे करू, आंशिक विभेदक समीकरणे परिभाषित करू आणि विश्लेषणात्मक समाधानाकडे जाण्यासाठी तयार होऊ. परंतु प्रथम, भिन्नता म्हणजे काय याबद्दल एक लहान भ्रमण करूया आणि व्युत्पन्नाचा भौमितीय अर्थ लक्षात ठेवूया.

भेद

भिन्नता म्हणजे फंक्शनचे व्युत्पन्न शोधण्याचे ऑपरेशन.

व्युत्पन्न कशासाठी वापरले जाते? फंक्शनचे व्युत्पन्न फंक्शनच्या बदलाचा दर दर्शविते आणि त्याची दिशा सांगते. जर दिलेल्या बिंदूवर व्युत्पन्न सकारात्मक असेल तर कार्य वाढते अन्यथा, कार्य कमी होते; आणि निरपेक्ष व्युत्पन्नाचे मूल्य जितके जास्त असेल तितका फंक्शन व्हॅल्यूजच्या बदलाचा दर जास्त असेल, तसेच फंक्शन आलेखाचा उतार जास्त असेल.

उदाहरणार्थ, कार्टेशियन कोऑर्डिनेट सिस्टमच्या परिस्थितीनुसार, M(0,0) बिंदूवरील व्युत्पन्नाचे मूल्य + 25 म्हणजे दिलेल्या बिंदूवर, जेव्हा मूल्य स्थलांतरित केले जाते पारंपारिक एककाद्वारे उजवीकडे, मूल्य 25 पारंपारिक युनिट्सने वाढते. आलेखावर ते मूल्यांमध्ये बऱ्यापैकी वाढलेले दिसते दिलेल्या बिंदूपासून.

दुसरे उदाहरण. व्युत्पन्न मूल्य समान आहे -0,1 म्हणजे विस्थापित झाल्यावर प्रति एक पारंपरिक युनिट, मूल्य केवळ 0,1 पारंपारिक युनिटने कमी होते. त्याच वेळी, फंक्शनच्या आलेखावर, आपण कमी लक्षात येण्याजोगा उतार पाहू शकतो. डोंगराशी साधर्म्य रेखाटणे, जणू काही आपण डोंगरावरून हळूवार उतार उतरत आहोत, मागील उदाहरणापेक्षा, जिथे आपल्याला खूप उंच शिखरे चढावी लागली होती :)

अशा प्रकारे, फंक्शन वेगळे केल्यानंतर विषमतेने и , आम्ही 1ली ऑर्डर आंशिक भिन्न समीकरणे परिभाषित करतो. समीकरणे निश्चित केल्यानंतर, आम्हाला दोन समीकरणांची एक प्रणाली प्राप्त होईल, ज्याचे निराकरण करून आम्ही गुणांकांची अशी मूल्ये निवडण्यास सक्षम होऊ. и , ज्यासाठी दिलेल्या बिंदूंवरील संबंधित डेरिव्हेटिव्ह्जची मूल्ये खूप कमी प्रमाणात बदलतात आणि विश्लेषणात्मक समाधानाच्या बाबतीत अजिबात बदलत नाहीत. दुस-या शब्दात, आढळलेल्या गुणांकांवर त्रुटी कार्य किमान पोहोचेल, कारण या बिंदूंवरील आंशिक डेरिव्हेटिव्ह्जची मूल्ये शून्य समान असतील.

तर, भिन्नतेच्या नियमांनुसार, गुणांकाच्या संदर्भात 1ल्या क्रमाचे आंशिक व्युत्पन्न समीकरण फॉर्म घेईल:

संदर्भात प्रथम क्रम आंशिक व्युत्पन्न समीकरण फॉर्म घेईल:

परिणामी, आम्हाला समीकरणांची एक प्रणाली प्राप्त झाली ज्यामध्ये अगदी सोप्या विश्लेषणात्मक समाधान आहे:

सुरुवात{समीकरण*}
सुरुवात{केसेस}
na + bsumlimits_{i=1}^nx_i — sumlimits_{i=1}^ny_i = 0

sumlimits_{i=1}^nx_i(a +bsumlimits_{i=1}^nx_i — sumlimits_{i=1}^ny_i) = 0
शेवट{केस}
शेवट{समीकरण*}

समीकरण सोडवण्यापूर्वी, प्रीलोड करू, लोडिंग बरोबर आहे का ते तपासा आणि डेटा फॉरमॅट करू.

डेटा लोड करणे आणि स्वरूपित करणे

हे लक्षात घेतले पाहिजे की विश्लेषणात्मक सोल्यूशनसाठी आणि नंतर ग्रेडियंट आणि स्टोकास्टिक ग्रेडियंट डिसेंटसाठी, आम्ही कोड दोन भिन्नतेमध्ये वापरू: लायब्ररी वापरणे सुन्न आणि ते न वापरता, आम्हाला योग्य डेटा स्वरूपन आवश्यक असेल (कोड पहा).

डेटा लोडिंग आणि प्रोसेसिंग कोड

# импортируем все нужные нам библиотеки
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import math
import pylab as pl
import random

# графики отобразим в Jupyter
%matplotlib inline

# укажем размер графиков
from pylab import rcParams
rcParams['figure.figsize'] = 12, 6

# отключим предупреждения Anaconda
import warnings
warnings.simplefilter('ignore')

# загрузим значения
table_zero = pd.read_csv('data_example.txt', header=0, sep='t')

# посмотрим информацию о таблице и на саму таблицу
print table_zero.info()
print '********************************************'
print table_zero
print '********************************************'

# подготовим данные без использования NumPy

x_us = []
[x_us.append(float(i)) for i in table_zero['x']]
print x_us
print type(x_us)
print '********************************************'

y_us = []
[y_us.append(float(i)) for i in table_zero['y']]
print y_us
print type(y_us)
print '********************************************'

# подготовим данные с использованием NumPy

x_np = table_zero[['x']].values
print x_np
print type(x_np)
print x_np.shape
print '********************************************'

y_np = table_zero[['y']].values
print y_np
print type(y_np)
print y_np.shape
print '********************************************'

व्हिज्युअलायझेशन

आता, आम्ही प्रथम, डेटा लोड केल्यानंतर, दुसरे म्हणजे, लोडिंगची शुद्धता तपासल्यानंतर आणि शेवटी डेटाचे स्वरूपन केल्यानंतर, आम्ही प्रथम व्हिज्युअलायझेशन पार पाडू. यासाठी अनेकदा वापरलेली पद्धत आहे पेअरप्लॉट ग्रंथालये सीबॉर्न. आमच्या उदाहरणात, मर्यादित संख्येमुळे, लायब्ररी वापरण्यात काही अर्थ नाही सीबॉर्न. आम्ही नियमित लायब्ररी वापरू मॅटप्लोटलिब आणि फक्त स्कॅटरप्लॉट पहा.

स्कॅटरप्लॉट कोड

print 'График №1 "Зависимость выручки от месяца года"'

plt.plot(x_us,y_us,'o',color='green',markersize=16)
plt.xlabel('$Months$', size=16)
plt.ylabel('$Sales$', size=16)
plt.show()

चार्ट क्रमांक 1 "वर्षाच्या महिन्यावर महसुलाचे अवलंबन"

विश्लेषणात्मक उपाय

मध्ये सर्वात सामान्य साधने वापरू अजगर आणि समीकरणांची प्रणाली सोडवा:

सुरुवात{समीकरण*}
सुरुवात{केसेस}
na + bsumlimits_{i=1}^nx_i — sumlimits_{i=1}^ny_i = 0

sumlimits_{i=1}^nx_i(a +bsumlimits_{i=1}^nx_i — sumlimits_{i=1}^ny_i) = 0
शेवट{केस}
शेवट{समीकरण*}

क्रेमरच्या नियमानुसार आम्ही सामान्य निर्धारक, तसेच निर्धारक शोधू आणि द्वारे , ज्यानंतर, निर्धारकाला द्वारे विभाजित करणे सामान्य निर्धारकाकडे - गुणांक शोधा , त्याचप्रमाणे आपल्याला गुणांक सापडतो .

विश्लेषणात्मक समाधान कोड

# определим функцию для расчета коэффициентов a и b по правилу Крамера
def Kramer_method (x,y):
        # сумма значений (все месяца)
    sx = sum(x)
        # сумма истинных ответов (выручка за весь период)
    sy = sum(y)
        # сумма произведения значений на истинные ответы
    list_xy = []
    [list_xy.append(x[i]*y[i]) for i in range(len(x))]
    sxy = sum(list_xy)
        # сумма квадратов значений
    list_x_sq = []
    [list_x_sq.append(x[i]**2) for i in range(len(x))]
    sx_sq = sum(list_x_sq)
        # количество значений
    n = len(x)
        # общий определитель
    det = sx_sq*n - sx*sx
        # определитель по a
    det_a = sx_sq*sy - sx*sxy
        # искомый параметр a
    a = (det_a / det)
        # определитель по b
    det_b = sxy*n - sy*sx
        # искомый параметр b
    b = (det_b / det)
        # контрольные значения (прооверка)
    check1 = (n*b + a*sx - sy)
    check2 = (b*sx + a*sx_sq - sxy)
    return [round(a,4), round(b,4)]

# запустим функцию и запишем правильные ответы
ab_us = Kramer_method(x_us,y_us)
a_us = ab_us[0]
b_us = ab_us[1]
print ' 33[1m' + ' 33[4m' + "Оптимальные значения коэффициентов a и b:"  + ' 33[0m' 
print 'a =', a_us
print 'b =', b_us
print

# определим функцию для подсчета суммы квадратов ошибок
def errors_sq_Kramer_method(answers,x,y):
    list_errors_sq = []
    for i in range(len(x)):
        err = (answers[0] + answers[1]*x[i] - y[i])**2
        list_errors_sq.append(err)
    return sum(list_errors_sq)

# запустим функцию и запишем значение ошибки
error_sq = errors_sq_Kramer_method(ab_us,x_us,y_us)
print ' 33[1m' + ' 33[4m' + "Сумма квадратов отклонений" + ' 33[0m'
print error_sq
print

# замерим время расчета
# print ' 33[1m' + ' 33[4m' + "Время выполнения расчета суммы квадратов отклонений:" + ' 33[0m'
# % timeit error_sq = errors_sq_Kramer_method(ab,x_us,y_us)

आम्हाला काय मिळाले ते येथे आहे:

तर, गुणांकांची मूल्ये सापडली आहेत, वर्ग विचलनांची बेरीज स्थापित केली गेली आहे. सापडलेल्या गुणांकांच्या अनुषंगाने स्कॅटरिंग हिस्टोग्रामवर सरळ रेषा काढू.

रीग्रेशन लाइन कोड

# определим функцию для формирования массива рассчетных значений выручки
def sales_count(ab,x,y):
    line_answers = []
    [line_answers.append(ab[0]+ab[1]*x[i]) for i in range(len(x))]
    return line_answers

# построим графики
print 'Грфик№2 "Правильные и расчетные ответы"'
plt.plot(x_us,y_us,'o',color='green',markersize=16, label = '$True$ $answers$')
plt.plot(x_us, sales_count(ab_us,x_us,y_us), color='red',lw=4,
         label='$Function: a + bx,$ $where$ $a='+str(round(ab_us[0],2))+',$ $b='+str(round(ab_us[1],2))+'$')
plt.xlabel('$Months$', size=16)
plt.ylabel('$Sales$', size=16)
plt.legend(loc=1, prop={'size': 16})
plt.show()

चार्ट क्रमांक 2 “बरोबर आणि मोजणी केलेली उत्तरे”

तुम्ही प्रत्येक महिन्याचा विचलन आलेख पाहू शकता. आमच्या बाबतीत, आम्ही त्यातून कोणतेही महत्त्वपूर्ण व्यावहारिक मूल्य प्राप्त करणार नाही, परंतु साधे रेखीय प्रतिगमन समीकरण वर्षाच्या महिन्यावरील महसुलाचे अवलंबित्व किती चांगले दर्शवते याबद्दल आम्ही आमची उत्सुकता पूर्ण करू.

विचलन चार्ट कोड

# определим функцию для формирования массива отклонений в процентах
def error_per_month(ab,x,y):
    sales_c = sales_count(ab,x,y)
    errors_percent = []
    for i in range(len(x)):
        errors_percent.append(100*(sales_c[i]-y[i])/y[i])
    return errors_percent

# построим график
print 'График№3 "Отклонения по-месячно, %"'
plt.gca().bar(x_us, error_per_month(ab_us,x_us,y_us), color='brown')
plt.xlabel('Months', size=16)
plt.ylabel('Calculation error, %', size=16)
plt.show()

चार्ट क्रमांक 3 “विचलन, %”

परिपूर्ण नाही, परंतु आम्ही आमचे कार्य पूर्ण केले.

गुणांक ठरवण्यासाठी फंक्शन लिहू и लायब्ररी वापरते सुन्न, अधिक तंतोतंत, आम्ही दोन फंक्शन्स लिहू: एक स्यूडोइनव्हर्स मॅट्रिक्स वापरून (प्रक्रिया संगणकीयदृष्ट्या जटिल आणि अस्थिर असल्याने, व्यवहारात शिफारस केलेली नाही), दुसरी मॅट्रिक्स समीकरण वापरून.

विश्लेषणात्मक समाधान कोड (NumPy)

# для начала добавим столбец с не изменяющимся значением в 1. 
# Данный столбец нужен для того, чтобы не обрабатывать отдельно коэффицент a
vector_1 = np.ones((x_np.shape[0],1))
x_np = table_zero[['x']].values # на всякий случай приведем в первичный формат вектор x_np
x_np = np.hstack((vector_1,x_np))

# проверим то, что все сделали правильно
print vector_1[0:3]
print x_np[0:3]
print '***************************************'
print

# напишем функцию, которая определяет значения коэффициентов a и b с использованием псевдообратной матрицы
def pseudoinverse_matrix(X, y):
    # задаем явный формат матрицы признаков
    X = np.matrix(X)
    # определяем транспонированную матрицу
    XT = X.T
    # определяем квадратную матрицу
    XTX = XT*X
    # определяем псевдообратную матрицу
    inv = np.linalg.pinv(XTX)
    # задаем явный формат матрицы ответов
    y = np.matrix(y)
    # находим вектор весов
    return (inv*XT)*y

# запустим функцию
ab_np = pseudoinverse_matrix(x_np, y_np)
print ab_np
print '***************************************'
print

# напишем функцию, которая использует для решения матричное уравнение
def matrix_equation(X,y):
    a = np.dot(X.T, X)
    b = np.dot(X.T, y)
    return np.linalg.solve(a, b)

# запустим функцию
ab_np = matrix_equation(x_np,y_np)
print ab_np

गुणांक ठरवण्यासाठी घालवलेल्या वेळेची तुलना करूया и , 3 सादर केलेल्या पद्धतींनुसार.

गणना वेळ मोजण्यासाठी कोड

print ' 33[1m' + ' 33[4m' + "Время выполнения расчета коэффициентов без использования библиотеки NumPy:" + ' 33[0m'
% timeit ab_us = Kramer_method(x_us,y_us)
print '***************************************'
print
print ' 33[1m' + ' 33[4m' + "Время выполнения расчета коэффициентов с использованием псевдообратной матрицы:" + ' 33[0m'
%timeit ab_np = pseudoinverse_matrix(x_np, y_np)
print '***************************************'
print
print ' 33[1m' + ' 33[4m' + "Время выполнения расчета коэффициентов с использованием матричного уравнения:" + ' 33[0m'
%timeit ab_np = matrix_equation(x_np, y_np)

थोड्या प्रमाणात डेटासह, "स्वयं-लिखित" फंक्शन पुढे येते, जे क्रॅमरची पद्धत वापरून गुणांक शोधते.

आता तुम्ही गुणांक शोधण्यासाठी इतर मार्गांवर जाऊ शकता и .

ग्रेडियंट डिसेंट

प्रथम, ग्रेडियंट म्हणजे काय ते परिभाषित करूया. सोप्या भाषेत सांगायचे तर, ग्रेडियंट हा एक विभाग आहे जो फंक्शनच्या कमाल वाढीची दिशा दर्शवतो. डोंगरावर चढण्याशी साधर्म्य साधून, जेथे ग्रेडियंट चेहर्याचा भाग आहे जेथे पर्वताच्या शिखरावर सर्वात जास्त चढाई आहे. डोंगरासह उदाहरण विकसित करताना, आपल्याला लक्षात येते की शक्य तितक्या लवकर सखल प्रदेशात पोहोचण्यासाठी आपल्याला सर्वात उंच उताराची आवश्यकता आहे, म्हणजे, किमान - जेथे कार्य वाढत किंवा कमी होत नाही. या टप्प्यावर व्युत्पन्न शून्य असेल. म्हणून, आम्हाला ग्रेडियंटची गरज नाही, परंतु अँटीग्रेडियंटची आवश्यकता आहे. अँटीग्रेडियंट शोधण्यासाठी तुम्हाला फक्त ग्रेडियंटने गुणाकार करणे आवश्यक आहे -1 (वजा एक).

आपण या वस्तुस्थितीकडे लक्ष देऊ या की फंक्शनमध्ये अनेक मिनिमम असू शकतात आणि खाली प्रस्तावित अल्गोरिदम वापरून त्यापैकी एकामध्ये उतरल्यानंतर, आपल्याला आणखी एक किमान शोधणे शक्य होणार नाही, जे सापडलेल्यापेक्षा कमी असू शकते. चला आराम करूया, हा आम्हाला धोका नाही! आमच्या बाबतीत आम्ही आमच्या फंक्शनपासून एकच किमान व्यवहार करत आहोत आलेखावर एक नियमित पॅराबोला आहे. आणि आपल्या सर्वांना आपल्या शालेय गणिताच्या अभ्यासक्रमातून चांगले माहित असले पाहिजे, पॅराबोलामध्ये फक्त एक किमान असतो.

आम्हाला ग्रेडियंटची गरज का आहे हे आम्हाला समजल्यानंतर आणि ग्रेडियंट हा एक विभाग आहे, म्हणजे दिलेल्या निर्देशांकांसह वेक्टर, जे तंतोतंत समान गुणांक आहेत и आम्ही ग्रेडियंट डिसेंट लागू करू शकतो.

सुरू करण्यापूर्वी, मी डिसेंट अल्गोरिदमबद्दल फक्त काही वाक्ये वाचण्याचा सल्ला देतो:

• आम्ही गुणांकांचे निर्देशांक छद्म-यादृच्छिक पद्धतीने निर्धारित करतो и . आमच्या उदाहरणात, आम्ही शून्य जवळ गुणांक परिभाषित करू. ही एक सामान्य प्रथा आहे, परंतु प्रत्येक केसची स्वतःची प्रथा असू शकते.
• समन्वयातून बिंदूवर 1ल्या ऑर्डरच्या आंशिक डेरिव्हेटिव्हचे मूल्य वजा करा . तर, जर व्युत्पन्न सकारात्मक असेल तर कार्य वाढते. म्हणून, डेरिव्हेटिव्हचे मूल्य वजा करून, आपण वाढीच्या विरुद्ध दिशेने, म्हणजे, उतरण्याच्या दिशेने जाऊ. जर व्युत्पन्न ऋण असेल, तर या टप्प्यावरचे कार्य कमी होते आणि व्युत्पन्नाचे मूल्य वजा करून आपण उतरत्या दिशेने जाऊ.
• आम्ही समन्वयासह समान ऑपरेशन करतो : बिंदूवरील आंशिक व्युत्पन्नाचे मूल्य वजा करा .
• किमान वर उडी मारणे आणि खोल जागेत उड्डाण न करण्यासाठी, पायरीचा आकार उतरण्याच्या दिशेने सेट करणे आवश्यक आहे. सर्वसाधारणपणे, आपण गणनात्मक खर्च कमी करण्यासाठी पायरी योग्यरित्या कशी सेट करावी आणि उतरण्याच्या प्रक्रियेदरम्यान ते कसे बदलावे याबद्दल संपूर्ण लेख लिहू शकता. परंतु आता आमच्याकडे थोडेसे वेगळे कार्य आहे आणि आम्ही "पोक" च्या वैज्ञानिक पद्धतीचा वापर करून किंवा जसे ते सामान्य भाषेत म्हणतात, अनुभवानुसार पायरी आकार स्थापित करू.
• एकदा आपण दिलेल्या निर्देशांकातून आलो и डेरिव्हेटिव्ह्जची मूल्ये वजा करा, आम्हाला नवीन निर्देशांक मिळतात и . आम्ही गणना केलेल्या निर्देशांकांमधून पुढील चरण (वजाबाकी) घेतो. आणि म्हणून आवश्यक अभिसरण प्राप्त होईपर्यंत चक्र पुन्हा पुन्हा सुरू होते.

सर्व! आता आम्ही मारियाना खंदकाच्या सर्वात खोल घाटाच्या शोधात जाण्यासाठी तयार आहोत. चला सुरू करुया.

ग्रेडियंट डिसेंटसाठी कोड

# напишем функцию градиентного спуска без использования библиотеки NumPy. 
# Функция на вход принимает диапазоны значений x,y, длину шага (по умолчанию=0,1), допустимую погрешность(tolerance)
def gradient_descent_usual(x_us,y_us,l=0.1,tolerance=0.000000000001):
    # сумма значений (все месяца)
    sx = sum(x_us)
    # сумма истинных ответов (выручка за весь период)
    sy = sum(y_us)
    # сумма произведения значений на истинные ответы
    list_xy = []
    [list_xy.append(x_us[i]*y_us[i]) for i in range(len(x_us))]
    sxy = sum(list_xy)
    # сумма квадратов значений
    list_x_sq = []
    [list_x_sq.append(x_us[i]**2) for i in range(len(x_us))]
    sx_sq = sum(list_x_sq)
    # количество значений
    num = len(x_us)
    # начальные значения коэффициентов, определенные псевдослучайным образом
    a = float(random.uniform(-0.5, 0.5))
    b = float(random.uniform(-0.5, 0.5))
    # создаем массив с ошибками, для старта используем значения 1 и 0
    # после завершения спуска стартовые значения удалим
    errors = [1,0]
    # запускаем цикл спуска
    # цикл работает до тех пор, пока отклонение последней ошибки суммы квадратов от предыдущей, не будет меньше tolerance
    while abs(errors[-1]-errors[-2]) > tolerance:
        a_step = a - l*(num*a + b*sx - sy)/num
        b_step = b - l*(a*sx + b*sx_sq - sxy)/num
        a = a_step
        b = b_step
        ab = [a,b]
        errors.append(errors_sq_Kramer_method(ab,x_us,y_us))
    return (ab),(errors[2:])

# запишем массив значений 
list_parametres_gradient_descence = gradient_descent_usual(x_us,y_us,l=0.1,tolerance=0.000000000001)


print ' 33[1m' + ' 33[4m' + "Значения коэффициентов a и b:" + ' 33[0m'
print 'a =', round(list_parametres_gradient_descence[0][0],3)
print 'b =', round(list_parametres_gradient_descence[0][1],3)
print


print ' 33[1m' + ' 33[4m' + "Сумма квадратов отклонений:" + ' 33[0m'
print round(list_parametres_gradient_descence[1][-1],3)
print



print ' 33[1m' + ' 33[4m' + "Количество итераций в градиентном спуске:" + ' 33[0m'
print len(list_parametres_gradient_descence[1])
print

आम्ही मारियाना ट्रेंचच्या अगदी तळाशी डुबकी मारली आणि तिथे आम्हाला सर्व समान गुणांक मूल्ये आढळली и , जे अपेक्षित होते तेच आहे.

चला आणखी एक डुबकी मारूया, फक्त यावेळी, आपले खोल समुद्रातील वाहन इतर तंत्रज्ञानाने भरले जाईल, म्हणजे लायब्ररी. सुन्न.

ग्रेडियंट डिसेंटसाठी कोड (NumPy)

# перед тем определить функцию для градиентного спуска с использованием библиотеки NumPy, 
# напишем функцию определения суммы квадратов отклонений также с использованием NumPy
def error_square_numpy(ab,x_np,y_np):
    y_pred = np.dot(x_np,ab)
    error = y_pred - y_np
    return sum((error)**2)

# напишем функцию градиентного спуска с использованием библиотеки NumPy. 
# Функция на вход принимает диапазоны значений x,y, длину шага (по умолчанию=0,1), допустимую погрешность(tolerance)
def gradient_descent_numpy(x_np,y_np,l=0.1,tolerance=0.000000000001):
    # сумма значений (все месяца)
    sx = float(sum(x_np[:,1]))
    # сумма истинных ответов (выручка за весь период)
    sy = float(sum(y_np))
    # сумма произведения значений на истинные ответы
    sxy = x_np*y_np
    sxy = float(sum(sxy[:,1]))
    # сумма квадратов значений
    sx_sq = float(sum(x_np[:,1]**2))
    # количество значений
    num = float(x_np.shape[0])
    # начальные значения коэффициентов, определенные псевдослучайным образом
    a = float(random.uniform(-0.5, 0.5))
    b = float(random.uniform(-0.5, 0.5))
    # создаем массив с ошибками, для старта используем значения 1 и 0
    # после завершения спуска стартовые значения удалим
    errors = [1,0]
    # запускаем цикл спуска
    # цикл работает до тех пор, пока отклонение последней ошибки суммы квадратов от предыдущей, не будет меньше tolerance
    while abs(errors[-1]-errors[-2]) > tolerance:
        a_step = a - l*(num*a + b*sx - sy)/num
        b_step = b - l*(a*sx + b*sx_sq - sxy)/num
        a = a_step
        b = b_step
        ab = np.array([[a],[b]])
        errors.append(error_square_numpy(ab,x_np,y_np))
    return (ab),(errors[2:])

# запишем массив значений 
list_parametres_gradient_descence = gradient_descent_numpy(x_np,y_np,l=0.1,tolerance=0.000000000001)

print ' 33[1m' + ' 33[4m' + "Значения коэффициентов a и b:" + ' 33[0m'
print 'a =', round(list_parametres_gradient_descence[0][0],3)
print 'b =', round(list_parametres_gradient_descence[0][1],3)
print


print ' 33[1m' + ' 33[4m' + "Сумма квадратов отклонений:" + ' 33[0m'
print round(list_parametres_gradient_descence[1][-1],3)
print

print ' 33[1m' + ' 33[4m' + "Количество итераций в градиентном спуске:" + ' 33[0m'
print len(list_parametres_gradient_descence[1])
print

गुणांक मूल्ये и अपरिवर्तनीय

ग्रेडियंट डिसेंट दरम्यान त्रुटी कशी बदलली ते पाहू, म्हणजेच प्रत्येक पायरीवर वर्ग विचलनाची बेरीज कशी बदलली.

वर्ग विचलनांची बेरीज प्लॉट करण्यासाठी कोड

print 'График№4 "Сумма квадратов отклонений по-шагово"'
plt.plot(range(len(list_parametres_gradient_descence[1])), list_parametres_gradient_descence[1], color='red', lw=3)
plt.xlabel('Steps (Iteration)', size=16)
plt.ylabel('Sum of squared deviations', size=16)
plt.show()

आलेख क्रमांक 4 "ग्रेडियंट डिसेंट दरम्यान स्क्वेअर विचलनांची बेरीज"

आलेखावर आपण पाहतो की प्रत्येक पायरीने त्रुटी कमी होते आणि ठराविक पुनरावृत्तीनंतर आपण जवळजवळ क्षैतिज रेषा पाहतो.

शेवटी, कोडच्या अंमलबजावणीच्या वेळेतील फरकाचा अंदाज घेऊया:

ग्रेडियंट डिसेंट गणना वेळ निर्धारित करण्यासाठी कोड

print ' 33[1m' + ' 33[4m' + "Время выполнения градиентного спуска без использования библиотеки NumPy:" + ' 33[0m'
%timeit list_parametres_gradient_descence = gradient_descent_usual(x_us,y_us,l=0.1,tolerance=0.000000000001)
print '***************************************'
print

print ' 33[1m' + ' 33[4m' + "Время выполнения градиентного спуска с использованием библиотеки NumPy:" + ' 33[0m'
%timeit list_parametres_gradient_descence = gradient_descent_numpy(x_np,y_np,l=0.1,tolerance=0.000000000001)

कदाचित आपण काहीतरी चुकीचे करत आहोत, परंतु पुन्हा हे एक साधे "होम-लिखित" कार्य आहे जे लायब्ररी वापरत नाही सुन्न लायब्ररी वापरून फंक्शनच्या गणना वेळेपेक्षा जास्त कामगिरी करते सुन्न.

परंतु आपण स्थिर नाही आहोत, तर साध्या रेखीय प्रतिगमन समीकरणाचे निराकरण करण्यासाठी आणखी एक रोमांचक मार्गाचा अभ्यास करण्याच्या दिशेने वाटचाल करत आहोत. भेटा!

स्टोकास्टिक ग्रेडियंट डिसेंट

स्टोकास्टिक ग्रेडियंट डिसेंटच्या ऑपरेशनचे सिद्धांत द्रुतपणे समजून घेण्यासाठी, सामान्य ग्रेडियंट वंशापासून त्याचे फरक निर्धारित करणे चांगले आहे. आम्ही, ग्रेडियंट वंशाच्या बाबतीत, च्या व्युत्पन्नांच्या समीकरणांमध्ये и सर्व वैशिष्ट्यांच्या मूल्यांची बेरीज आणि नमुन्यात उपलब्ध असलेली खरी उत्तरे (म्हणजे सर्वांची बेरीज) и ). स्टोकास्टिक ग्रेडियंट डिसेंटमध्ये, आम्ही नमुन्यात उपस्थित असलेली सर्व मूल्ये वापरणार नाही, परंतु त्याऐवजी, स्यूडो-यादृच्छिकपणे तथाकथित नमुना निर्देशांक निवडा आणि त्याची मूल्ये वापरा.

उदाहरणार्थ, जर अनुक्रमणिका क्रमांक 3 (तीन) असल्याचे निश्चित केले असेल तर आपण मूल्ये घेऊ и , नंतर आम्ही व्युत्पन्न समीकरणांमध्ये मूल्ये बदलतो आणि नवीन समन्वय निर्धारित करतो. त्यानंतर, निर्देशांक निश्चित केल्यावर, आम्ही पुन्हा स्यूडो-यादृच्छिकपणे नमुना निर्देशांक निर्धारित करतो, निर्देशांकाशी संबंधित मूल्ये आंशिक भिन्न समीकरणांमध्ये बदलतो आणि नवीन मार्गाने निर्देशांक निर्धारित करतो. и इ. अभिसरण हिरवे होईपर्यंत. पहिल्या दृष्टीक्षेपात, असे वाटत नाही की हे अजिबात कार्य करू शकत नाही, परंतु तसे होते. प्रत्येक पावलाने त्रुटी कमी होत नाही हे लक्षात घेण्यासारखे आहे, परंतु एक प्रवृत्ती नक्कीच आहे.

पारंपारिकपेक्षा स्टोकास्टिक ग्रेडियंट डिसेंटचे काय फायदे आहेत? जर आमचा नमुन्याचा आकार खूप मोठा असेल आणि हजारो मूल्यांमध्ये मोजला गेला असेल, तर संपूर्ण नमुन्यापेक्षा यादृच्छिक हजारांवर प्रक्रिया करणे खूप सोपे आहे. येथेच स्टोकास्टिक ग्रेडियंट डिसेंट लागू होतो. आमच्या बाबतीत, अर्थातच, आम्हाला फारसा फरक जाणवणार नाही.

चला कोड पाहू.

स्टोकास्टिक ग्रेडियंट डिसेंटसाठी कोड

# определим функцию стох.град.шага
def stoch_grad_step_usual(vector_init, x_us, ind, y_us, l):
#     выбираем значение икс, которое соответствует случайному значению параметра ind 
# (см.ф-цию stoch_grad_descent_usual)
    x = x_us[ind]
#     рассчитывыаем значение y (выручку), которая соответствует выбранному значению x
    y_pred = vector_init[0] + vector_init[1]*x_us[ind]
#     вычисляем ошибку расчетной выручки относительно представленной в выборке
    error = y_pred - y_us[ind]
#     определяем первую координату градиента ab
    grad_a = error
#     определяем вторую координату ab
    grad_b = x_us[ind]*error
#     вычисляем новый вектор коэффициентов
    vector_new = [vector_init[0]-l*grad_a, vector_init[1]-l*grad_b]
    return vector_new


# определим функцию стох.град.спуска
def stoch_grad_descent_usual(x_us, y_us, l=0.1, steps = 800):
#     для самого начала работы функции зададим начальные значения коэффициентов
    vector_init = [float(random.uniform(-0.5, 0.5)), float(random.uniform(-0.5, 0.5))]
    errors = []
#     запустим цикл спуска
# цикл расчитан на определенное количество шагов (steps)
    for i in range(steps):
        ind = random.choice(range(len(x_us)))
        new_vector = stoch_grad_step_usual(vector_init, x_us, ind, y_us, l)
        vector_init = new_vector
        errors.append(errors_sq_Kramer_method(vector_init,x_us,y_us))
    return (vector_init),(errors)


# запишем массив значений 
list_parametres_stoch_gradient_descence = stoch_grad_descent_usual(x_us, y_us, l=0.1, steps = 800)

print ' 33[1m' + ' 33[4m' + "Значения коэффициентов a и b:" + ' 33[0m'
print 'a =', round(list_parametres_stoch_gradient_descence[0][0],3)
print 'b =', round(list_parametres_stoch_gradient_descence[0][1],3)
print


print ' 33[1m' + ' 33[4m' + "Сумма квадратов отклонений:" + ' 33[0m'
print round(list_parametres_stoch_gradient_descence[1][-1],3)
print

print ' 33[1m' + ' 33[4m' + "Количество итераций в стохастическом градиентном спуске:" + ' 33[0m'
print len(list_parametres_stoch_gradient_descence[1])

आम्ही गुणांक काळजीपूर्वक पाहतो आणि "हे कसे असू शकते?" हा प्रश्न विचारून स्वतःला पकडतो. आम्हाला इतर गुणांक मूल्ये मिळाली и . कदाचित स्टोकास्टिक ग्रेडियंट डिसेंटला समीकरणासाठी अधिक इष्टतम मापदंड सापडले असतील? दुर्दैवाने नाही. चौरस विचलनांची बेरीज पाहणे आणि गुणांकांच्या नवीन मूल्यांसह त्रुटी अधिक आहे हे पाहणे पुरेसे आहे. आम्हाला निराश होण्याची घाई नाही. चला त्रुटी बदलाचा आलेख तयार करू.

स्टोकास्टिक ग्रेडियंट डिसेंटमध्ये स्क्वेअर विचलनांची बेरीज प्लॉट करण्यासाठी कोड

print 'График №5 "Сумма квадратов отклонений по-шагово"'
plt.plot(range(len(list_parametres_stoch_gradient_descence[1])), list_parametres_stoch_gradient_descence[1], color='red', lw=2)
plt.xlabel('Steps (Iteration)', size=16)
plt.ylabel('Sum of squared deviations', size=16)
plt.show()

आलेख क्रमांक 5 "स्टोकास्टिक ग्रेडियंट डिसेंट दरम्यान स्क्वेअर विचलनांची बेरीज"

वेळापत्रक पाहता, सर्व काही ठिकाणी येते आणि आता आम्ही सर्वकाही ठीक करू.

मग काय झालं? पुढील घडले. जेव्हा आम्ही यादृच्छिकपणे महिना निवडतो, तेव्हा निवडलेल्या महिन्यासाठी आमचा अल्गोरिदम महसूल मोजण्यात त्रुटी कमी करण्याचा प्रयत्न करतो. मग आम्ही दुसरा महिना निवडतो आणि गणना पुन्हा करतो, परंतु आम्ही दुसऱ्या निवडलेल्या महिन्यासाठी त्रुटी कमी करतो. आता लक्षात ठेवा की पहिले दोन महिने साध्या रेखीय प्रतिगमन समीकरणाच्या रेषेपासून लक्षणीयरीत्या विचलित होतात. याचा अर्थ असा की जेव्हा या दोन महिन्यांपैकी कोणताही महिना निवडला जातो, तेव्हा त्या प्रत्येकाची त्रुटी कमी करून, आमचे अल्गोरिदम संपूर्ण नमुन्यासाठी त्रुटी गंभीरपणे वाढवते. मग काय करायचं? उत्तर सोपे आहे: तुम्हाला उतरण्याची पायरी कमी करणे आवश्यक आहे. शेवटी, उतरण्याची पायरी कमी करून, त्रुटी देखील वर आणि खाली "उडी मारणे" थांबवेल. किंवा त्याऐवजी, "उडी मारणे" त्रुटी थांबणार नाही, परंतु ती इतक्या लवकर करणार नाही :) चला तपासूया.

लहान वाढीसह SGD चालविण्यासाठी कोड

# запустим функцию, уменьшив шаг в 100 раз и увеличив количество шагов соответсвующе 
list_parametres_stoch_gradient_descence = stoch_grad_descent_usual(x_us, y_us, l=0.001, steps = 80000)

print ' 33[1m' + ' 33[4m' + "Значения коэффициентов a и b:" + ' 33[0m'
print 'a =', round(list_parametres_stoch_gradient_descence[0][0],3)
print 'b =', round(list_parametres_stoch_gradient_descence[0][1],3)
print


print ' 33[1m' + ' 33[4m' + "Сумма квадратов отклонений:" + ' 33[0m'
print round(list_parametres_stoch_gradient_descence[1][-1],3)
print



print ' 33[1m' + ' 33[4m' + "Количество итераций в стохастическом градиентном спуске:" + ' 33[0m'
print len(list_parametres_stoch_gradient_descence[1])

print 'График №6 "Сумма квадратов отклонений по-шагово"'
plt.plot(range(len(list_parametres_stoch_gradient_descence[1])), list_parametres_stoch_gradient_descence[1], color='red', lw=2)
plt.xlabel('Steps (Iteration)', size=16)
plt.ylabel('Sum of squared deviations', size=16)
plt.show()

आलेख क्रमांक 6 "स्टोकास्टिक ग्रेडियंट डिसेंट (80 हजार पायऱ्या) दरम्यान स्क्वेअर विचलनांची बेरीज"

गुणांक सुधारले आहेत, परंतु अद्याप आदर्श नाहीत. काल्पनिकदृष्ट्या, हे अशा प्रकारे दुरुस्त केले जाऊ शकते. आम्ही, उदाहरणार्थ, शेवटच्या 1000 पुनरावृत्त्यांमध्ये गुणांकांची मूल्ये निवडतो ज्यासह किमान त्रुटी केली गेली होती. खरे आहे, यासाठी आपल्याला स्वतः गुणांकांची मूल्ये देखील लिहावी लागतील. आम्ही हे करणार नाही, उलट वेळापत्रकाकडे लक्ष देऊ. ते गुळगुळीत दिसते आणि त्रुटी समान रीतीने कमी होत असल्याचे दिसते. प्रत्यक्षात हे खरे नाही. चला पहिली 1000 पुनरावृत्ती पाहू आणि त्यांची शेवटची तुलना करू.

SGD चार्टसाठी कोड (पहिल्या 1000 पायऱ्या)

print 'График №7 "Сумма квадратов отклонений по-шагово. Первые 1000 итераций"'
plt.plot(range(len(list_parametres_stoch_gradient_descence[1][:1000])), 
         list_parametres_stoch_gradient_descence[1][:1000], color='red', lw=2)
plt.xlabel('Steps (Iteration)', size=16)
plt.ylabel('Sum of squared deviations', size=16)
plt.show()

print 'График №7 "Сумма квадратов отклонений по-шагово. Последние 1000 итераций"'
plt.plot(range(len(list_parametres_stoch_gradient_descence[1][-1000:])), 
         list_parametres_stoch_gradient_descence[1][-1000:], color='red', lw=2)
plt.xlabel('Steps (Iteration)', size=16)
plt.ylabel('Sum of squared deviations', size=16)
plt.show()

आलेख क्रमांक 7 “वर्ग विचलनाची बेरीज SGD (प्रथम 1000 पायऱ्या)”

आलेख क्रमांक 8 "वर्ग विचलनाची बेरीज SGD (शेवटच्या 1000 पायऱ्या)"

उतरण्याच्या अगदी सुरुवातीस, आम्ही बऱ्यापैकी एकसमान आणि त्रुटीमध्ये तीव्र घट पाहतो. शेवटच्या पुनरावृत्तीमध्ये, आपण पाहतो की त्रुटी 1,475 च्या मूल्याच्या आसपास आणि आसपास जाते आणि काही क्षणी या इष्टतम मूल्याच्या बरोबरीने देखील होते, परंतु तरीही ते वर जाते... मी पुन्हा सांगतो, तुम्ही ची मूल्ये लिहू शकता गुणांक и , आणि नंतर ज्यासाठी त्रुटी कमी आहे ते निवडा. तथापि, आमच्याकडे एक अधिक गंभीर समस्या होती: इष्टतम मूल्यांच्या जवळ जाण्यासाठी आम्हाला 80 हजार पावले उचलावी लागली (कोड पहा). आणि हे आधीच ग्रेडियंट डिसेंटच्या सापेक्ष स्टोकास्टिक ग्रेडियंट डिसेंटसह गणना वेळ वाचवण्याच्या कल्पनेला विरोध करते. काय दुरुस्त आणि सुधारले जाऊ शकते? हे लक्षात घेणे कठीण नाही की पहिल्या पुनरावृत्तीमध्ये आपण आत्मविश्वासाने खाली जात आहोत आणि म्हणूनच, आपण पहिल्या पुनरावृत्तीमध्ये एक मोठी पायरी सोडली पाहिजे आणि पुढे जात असताना पायरी कमी केली पाहिजे. आम्ही या लेखात हे करणार नाही - ते आधीच खूप लांब आहे. ज्यांना इच्छा आहे ते हे कसे करायचे ते स्वत: साठी विचार करू शकतात, हे कठीण नाही :)

आता लायब्ररी वापरून स्टोकास्टिक ग्रेडियंट डिसेंट करू सुन्न (आणि आपण आधी ओळखलेल्या दगडांवर अडखळू नये)

स्टोकास्टिक ग्रेडियंट डिसेंटसाठी कोड (NumPy)

# для начала напишем функцию градиентного шага
def stoch_grad_step_numpy(vector_init, X, ind, y, l):
    x = X[ind]
    y_pred = np.dot(x,vector_init)
    err = y_pred - y[ind]
    grad_a = err
    grad_b = x[1]*err
    return vector_init - l*np.array([grad_a, grad_b])

# определим функцию стохастического градиентного спуска
def stoch_grad_descent_numpy(X, y, l=0.1, steps = 800):
    vector_init = np.array([[np.random.randint(X.shape[0])], [np.random.randint(X.shape[0])]])
    errors = []
    for i in range(steps):
        ind = np.random.randint(X.shape[0])
        new_vector = stoch_grad_step_numpy(vector_init, X, ind, y, l)
        vector_init = new_vector
        errors.append(error_square_numpy(vector_init,X,y))
    return (vector_init), (errors)

# запишем массив значений 
list_parametres_stoch_gradient_descence = stoch_grad_descent_numpy(x_np, y_np, l=0.001, steps = 80000)

print ' 33[1m' + ' 33[4m' + "Значения коэффициентов a и b:" + ' 33[0m'
print 'a =', round(list_parametres_stoch_gradient_descence[0][0],3)
print 'b =', round(list_parametres_stoch_gradient_descence[0][1],3)
print


print ' 33[1m' + ' 33[4m' + "Сумма квадратов отклонений:" + ' 33[0m'
print round(list_parametres_stoch_gradient_descence[1][-1],3)
print



print ' 33[1m' + ' 33[4m' + "Количество итераций в стохастическом градиентном спуске:" + ' 33[0m'
print len(list_parametres_stoch_gradient_descence[1])
print

मूल्ये वापरल्याशिवाय खाली उतरताना जवळजवळ सारखीच निघाली सुन्न. तथापि, हे तार्किक आहे.

स्टोकास्टिक ग्रेडियंट डिसेंट्सने आम्हाला किती वेळ लागला ते शोधूया.

SGD गणना वेळ निश्चित करण्यासाठी कोड (80 हजार पायऱ्या)

print ' 33[1m' + ' 33[4m' +
"Время выполнения стохастического градиентного спуска без использования библиотеки NumPy:"
+ ' 33[0m'
%timeit list_parametres_stoch_gradient_descence = stoch_grad_descent_usual(x_us, y_us, l=0.001, steps = 80000)
print '***************************************'
print

print ' 33[1m' + ' 33[4m' +
"Время выполнения стохастического градиентного спуска с использованием библиотеки NumPy:"
+ ' 33[0m'
%timeit list_parametres_stoch_gradient_descence = stoch_grad_descent_numpy(x_np, y_np, l=0.001, steps = 80000)

जितके पुढे जंगलात जाईल तितके गडद ढग: पुन्हा, "स्वयं-लिखित" सूत्र सर्वोत्तम परिणाम दर्शविते. हे सर्व सूचित करते की लायब्ररी वापरण्याचे आणखी सूक्ष्म मार्ग असले पाहिजेत सुन्न, जे खरोखर गणना ऑपरेशन्स गतिमान करते. या लेखात आपण त्यांच्याबद्दल जाणून घेणार नाही. तुमच्या फावल्या वेळेत विचार करण्यासारखे काहीतरी असेल :)

चला थोडक्यात

सारांश देण्यापूर्वी, मी एका प्रश्नाचे उत्तर देऊ इच्छितो जो बहुधा आमच्या प्रिय वाचकाकडून उद्भवला असेल. खरं तर, उतरत्या लोकांसह असा "छळ" का, जर आपल्या हातात एवढं सामर्थ्यवान आणि साधं यंत्र असेल, तर खजिना असलेला सखल प्रदेश शोधण्यासाठी आपल्याला डोंगरावरून (बहुतेक खाली) चालत जाण्याची गरज का आहे? विश्लेषणात्मक समाधानाचे स्वरूप, जे आम्हाला त्वरित योग्य ठिकाणी पाठवते?

या प्रश्नाचे उत्तर पृष्ठभागावर आहे. आता आपण एक अतिशय साधे उदाहरण पाहिले आहे, ज्यामध्ये खरे उत्तर आहे एका चिन्हावर अवलंबून आहे . आपण आयुष्यात हे सहसा पाहत नाही, म्हणून कल्पना करूया की आपल्याकडे 2, 30, 50 किंवा अधिक चिन्हे आहेत. प्रत्येक गुणधर्मासाठी यामध्ये हजारो किंवा दहापट मूल्ये जोडूया. या प्रकरणात, विश्लेषणात्मक उपाय चाचणीचा सामना करू शकत नाही आणि अयशस्वी होऊ शकतो. या बदल्यात, ग्रेडियंट डिसेंट आणि त्याचे फरक हळूहळू पण निश्चितपणे आपल्याला ध्येयाच्या जवळ आणतील - कार्याच्या किमान. आणि वेगाबद्दल काळजी करू नका - आम्ही कदाचित असे मार्ग पाहू जे आम्हाला पायरीची लांबी (म्हणजे वेग) सेट आणि नियमन करण्यास अनुमती देतील.

आणि आता वास्तविक संक्षिप्त सारांश.

सर्वप्रथम, मला आशा आहे की लेखात सादर केलेली सामग्री "डेटा सायंटिस्ट" ची सुरुवात करण्यास मदत करेल साधी (आणि केवळ नाही) रेखीय प्रतिगमन समीकरणे कशी सोडवायची हे समजण्यास.

दुसरे, आम्ही समीकरण सोडवण्याचे अनेक मार्ग पाहिले. आता, परिस्थितीनुसार, आम्ही समस्येचे निराकरण करण्यासाठी सर्वात योग्य एक निवडू शकतो.

तिसरे, आम्ही अतिरिक्त सेटिंग्जची शक्ती पाहिली, म्हणजे ग्रेडियंट डिसेंट स्टेप लांबी. या पॅरामीटरकडे दुर्लक्ष केले जाऊ शकत नाही. वर नमूद केल्याप्रमाणे, गणनेची किंमत कमी करण्यासाठी, उतरताना पायरीची लांबी बदलली पाहिजे.

चौथे, आमच्या बाबतीत, "होम-लिखित" फंक्शन्सने गणनासाठी सर्वोत्तम वेळ परिणाम दर्शविला. हे कदाचित लायब्ररीच्या क्षमतांचा सर्वाधिक व्यावसायिक वापर न केल्यामुळे आहे सुन्न. परंतु ते जसेच्या तसे असू द्या, पुढील निष्कर्ष स्वतःच सूचित करतो. एकीकडे, काहीवेळा प्रस्थापित मतांवर प्रश्न विचारणे योग्य असते आणि दुसरीकडे, सर्वकाही गुंतागुंतीचे करणे नेहमीच फायदेशीर नसते - त्याउलट, कधीकधी समस्या सोडवण्याचा सोपा मार्ग अधिक प्रभावी असतो. आणि आमचे ध्येय एक साधे रेखीय प्रतिगमन समीकरण सोडवण्यासाठी तीन दृष्टिकोनांचे विश्लेषण करणे हे असल्याने, "स्वयं-लिखित" फंक्शन्सचा वापर आमच्यासाठी पुरेसा होता.

साहित्य (किंवा असे काहीतरी)

1. रेखीय प्रतिगमन

http://statistica.ru/theory/osnovy-lineynoy-regressii/

2. किमान चौरस पद्धत

mathprofi.ru/metod_naimenshih_kvadratov.html

3. व्युत्पन्न

www.mathprofi.ru/chastnye_proizvodnye_primery.html

4. ग्रेडियंट

mathprofi.ru/proizvodnaja_po_napravleniju_i_gradient.html

5. ग्रेडियंट डिसेंट

habr.com/en/post/471458

habr.com/en/post/307312

artemarakcheev.com//2017-12-31/linear_regression

6. NumPy लायब्ररी

docs.scipy.org/doc/numpy-1.10.1/reference/generated/numpy.linalg.solve.html

docs.scipy.org/doc/numpy-1.10.0/reference/generated/numpy.linalg.pinv.html

pythonworld.ru/numpy/2.html

स्त्रोत: www.habr.com