सरल रैखिक प्रतिगमनको समीकरण समाधान गर्दै

लेखले सरल (जोडी) रिग्रेसन रेखाको गणितीय समीकरण निर्धारण गर्न धेरै तरिकाहरू छलफल गर्दछ।

यहाँ छलफल गरिएको समीकरण समाधान गर्ने सबै विधिहरू न्यूनतम वर्ग विधिमा आधारित छन्। निम्नानुसार विधिहरू बुझौं:

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

सीधा रेखाको समीकरण समाधान गर्ने प्रत्येक विधिको लागि, लेखले विभिन्न प्रकार्यहरू प्रदान गर्दछ, जुन मुख्य रूपमा पुस्तकालय प्रयोग नगरी लेखिएकाहरूमा विभाजित हुन्छन्। नम्र र ती जो गणनाको लागि प्रयोग गर्छन् नम्र। कुशलतापूर्वक प्रयोग गर्ने विश्वास गरिन्छ नम्र कम्प्युटिङ लागत घटाउनेछ।

लेखमा दिइएको सबै कोड भाषामा लेखिएको छ अजगर २ प्रयोग गर्दै Jupyter नोटबुक। नमूना डेटाको साथ स्रोत कोड र फाइल पोस्ट गरिएको छ Github

आर्टिफिशियल इन्टेलिजेन्स - मेसिन लर्निङमा धेरै फराकिलो खण्डको अध्ययनमा बिस्तारै मास्टर गर्न थालेकाहरू र शुरुआतीहरू दुवैलाई लेख बढी लक्षित छ।

सामग्री चित्रण गर्न, हामी एक धेरै सरल उदाहरण प्रयोग गर्दछौं।

उदाहरण सर्तहरू

हामीसँग पाँचवटा मानहरू छन् जसले निर्भरतालाई चित्रण गर्छ Y देखि X (तालिका नम्बर १):

तालिका नम्बर १ "उदाहरणका सर्तहरू"

हामी मान्नेछौं कि मानहरू वर्षको महिना हो, र - यो महिना राजस्व। अर्को शब्दमा, राजस्व वर्षको महिनामा निर्भर गर्दछ, र - एक मात्र चिन्ह जसमा राजस्व निर्भर हुन्छ।

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

हामी मानौं कि उदाहरणमा दिइएको निर्भरता फारमको सरल (जोडी गरिएको) प्रतिगमन रेखाको गणितीय समीकरणबाट राम्रोसँग अनुमान गर्न सकिन्छ:

जहाँ राजस्व प्राप्त भएको महिना हो, - महिना अनुरूप राजस्व, и अनुमानित रेखाको प्रतिगमन गुणांकहरू हुन्।

ध्यान दिनुहोस् कि गुणांक प्रायः अनुमानित रेखाको ढलान वा ढाँचा भनिन्छ; जसद्वारा रकम प्रतिनिधित्व गर्दछ जब यो परिवर्तन हुन्छ .

स्पष्ट रूपमा, उदाहरणमा हाम्रो कार्य समीकरणमा त्यस्ता गुणांकहरू चयन गर्नु हो и , जसमा साँचो उत्तरहरूबाट महिनाको आधारमा हाम्रो गणना गरिएको राजस्व मानहरूको विचलन, अर्थात्। नमूनामा प्रस्तुत मानहरू न्यूनतम हुनेछन्।

न्यूनतम वर्ग विधि

न्यूनतम वर्ग विधि अनुसार, विचलनलाई वर्गीकरण गरेर गणना गर्नुपर्छ। यो प्रविधिले तपाईंलाई विचलनहरूको आपसी रद्दीकरणबाट बच्न अनुमति दिन्छ यदि तिनीहरूसँग विपरीत संकेतहरू छन्। उदाहरण को लागी, यदि एक मामला मा, विचलन छ +5 (प्लस पाँच), र अर्कोमा -5 (माइनस पाँच), त्यसपछि विचलनहरूको योगले एकअर्कालाई रद्द गर्नेछ र ० (शून्य) मा परिमाण हुनेछ। तपाईंले विचलन वर्ग गर्नु पर्दैन, तर मोडुलस गुण प्रयोग गर्नुहोस् र त्यसपछि सबै विचलनहरू सकारात्मक हुनेछन् र जम्मा हुनेछन्। हामी यस बिन्दुमा विस्तृत रूपमा बस्ने छैनौं, तर केवल गणनाको सुविधाको लागि, विचलन वर्ग गर्ने चलन छ भनेर संकेत गर्दछ।

यो सूत्र जस्तो देखिन्छ जसको साथ हामी वर्ग विचलन (त्रुटि) को न्यूनतम योगफल निर्धारण गर्नेछौं:

जहाँ साँचो उत्तरहरूको अनुमानित कार्य हो (अर्थात हामीले गणना गरेको राजस्व),

साँचो जवाफहरू हुन् (नमूनामा प्रदान गरिएको राजस्व),

नमूना सूचकांक हो (महिनाको संख्या जसमा विचलन निर्धारण गरिन्छ)

प्रकार्यलाई फरक पारौं, आंशिक विभेदक समीकरणहरू परिभाषित गरौं, र विश्लेषणात्मक समाधानमा जान तयार हुनुहोस्। तर पहिले, भिन्नता के हो भन्ने बारे छोटो भ्रमण गरौं र व्युत्पन्नको ज्यामितीय अर्थ सम्झौं।

भिन्नता

भिन्नता भनेको प्रकार्यको व्युत्पन्न पत्ता लगाउने कार्य हो।

व्युत्पन्न के लागि प्रयोग गरिन्छ? प्रकार्यको व्युत्पन्नले प्रकार्यको परिवर्तनको दरलाई चित्रण गर्छ र हामीलाई यसको दिशा बताउँछ। यदि दिइएको बिन्दुमा व्युत्पन्न सकारात्मक छ भने, प्रकार्य बढ्छ; अन्यथा, प्रकार्य घट्छ। र निरपेक्ष व्युत्पन्नको जति ठूलो मान, प्रकार्य मानहरूको परिवर्तनको उच्च दर, साथै फंक्शन ग्राफको ढलान उति बढी हुन्छ।

उदाहरण को लागी, एक कार्टेसियन समन्वय प्रणाली को शर्तहरु मा, बिन्दु M(0,0) मा व्युत्पन्न को मान बराबर छ। + 25 यसको मतलब दिइएको बिन्दुमा, जब मान सारियो परम्परागत एकाइ, मान द्वारा दायाँ 25 परम्परागत एकाइहरु द्वारा बढ्छ। ग्राफमा यो मानहरूमा एकदमै तीव्र वृद्धि जस्तो देखिन्छ दिइएको बिन्दुबाट।

अर्को उदाहरण। व्युत्पन्न मूल्य बराबर छ -0,1 विस्थापित हुँदा प्रति एक परम्परागत एकाइ, मूल्य केवल 0,1 परम्परागत एकाइले घट्छ। एकै समयमा, प्रकार्यको ग्राफमा, हामी एक मुश्किल देखिने तलको ढलान अवलोकन गर्न सक्छौं। पहाडसँग समानता कोर्दै, यो जस्तो छ कि हामी धेरै बिस्तारै पहाडबाट हल्का ढलान ओर्लिरहेका छौं, अघिल्लो उदाहरणको विपरीत, जहाँ हामीले धेरै ठाडो चुचुराहरू चढ्नुपर्‍यो :)

यसरी, प्रकार्य भिन्नता पछि बाधाहरू द्वारा и , हामी 1st अर्डर आंशिक भिन्न समीकरणहरू परिभाषित गर्छौं। समीकरणहरू निर्धारण गरेपछि, हामीले दुई समीकरणहरूको प्रणाली प्राप्त गर्नेछौं, जसलाई समाधान गरेर हामी गुणांकहरूको त्यस्ता मानहरू चयन गर्न सक्षम हुनेछौं। и , जसको लागि दिइएको बिन्दुहरूमा सम्बन्धित डेरिभेटिभहरूको मानहरू धेरै, धेरै थोरै मात्रामा परिवर्तन हुन्छन्, र विश्लेषणात्मक समाधानको मामलामा कुनै पनि परिवर्तन हुँदैन। अर्को शब्दमा, पाइने गुणांकहरूमा त्रुटि प्रकार्य न्यूनतम पुग्नेछ, किनकि यी बिन्दुहरूमा आंशिक डेरिभेटिभहरूको मानहरू शून्य बराबर हुनेछ।

त्यसोभए, भिन्नताका नियमहरू अनुसार, गुणांकको सन्दर्भमा पहिलो क्रमको आंशिक व्युत्पन्न समीकरण फारम लिनेछ:

पहिलो क्रम आंशिक व्युत्पन्न समीकरण सम्बन्धमा फारम लिनेछ:

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

सुरु{समीकरण*}
सुरु {केस}
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) = ०
अन्त्य {केस}
अन्त्य{समीकरण*}

समीकरण समाधान गर्नु अघि, प्रिलोड गरौं, लोडिङ सही छ कि छैन जाँच गरौं, र डेटा ढाँचा गर्नुहोस्।

डेटा लोड र ढाँचा

यो ध्यान दिनुपर्छ कि विश्लेषणात्मक समाधानको लागि, र पछि ग्रेडियन्ट र स्टोकास्टिक ग्रेडियन्ट डिसेन्टको लागि, हामी कोडलाई दुई भिन्नताहरूमा प्रयोग गर्नेछौं: पुस्तकालय प्रयोग गरेर। नम्र र यसलाई प्रयोग नगरीकन, तब हामीलाई उपयुक्त डाटा ढाँचा चाहिन्छ (कोड हेर्नुहोस्)।

डाटा लोडिङ र प्रोसेसिङ कोड

# импортируем все нужные нам библиотеки
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 '********************************************'

दृश्य

अब, हामीले पहिले, डाटा लोड गरेपछि, दोस्रो, लोडिङको शुद्धता जाँच गरेपछि र अन्तमा डाटा ढाँचा गरेपछि, हामी पहिलो भिजुअलाइजेशन गर्नेछौं। यसका लागि अक्सर प्रयोग गरिने विधि हो pairplot पुस्तकालयहरु समुद्री। हाम्रो उदाहरणमा, सीमित संख्याको कारणले, त्यहाँ पुस्तकालय प्रयोग गर्न कुनै मतलब छैन समुद्री। हामी नियमित पुस्तकालय प्रयोग गर्नेछौं matplotlib र केवल scatterplot हेर्नुहोस्।

स्क्याटरप्लट कोड

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()

चार्ट नम्बर १ "वर्षको महिनामा राजस्वको निर्भरता"

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

मा सबैभन्दा सामान्य उपकरणहरू प्रयोग गरौं अजगर र समीकरण प्रणाली हल गर्नुहोस्:

सुरु{समीकरण*}
सुरु {केस}
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) = ०
अन्त्य {केस}
अन्त्य{समीकरण*}

Cramer को नियम अनुसार हामीले सामान्य निर्धारक, साथै निर्धारकहरू फेला पार्नेछौं र द्वारा , जस पछि, द्वारा निर्धारक विभाजित गर्दै सामान्य निर्धारकमा - गुणांक फेला पार्नुहोस् , त्यसै गरी हामी गुणांक फेला पार्छौं .

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

# определим функцию для расчета коэффициентов 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()

चार्ट नम्बर २ "सही र गणना गरिएका उत्तरहरू"

तपाइँ प्रत्येक महिनाको लागि विचलन ग्राफ हेर्न सक्नुहुन्छ। हाम्रो मामलामा, हामी यसबाट कुनै महत्त्वपूर्ण व्यावहारिक मूल्य प्राप्त गर्दैनौं, तर हामी हाम्रो जिज्ञासालाई सन्तुष्ट गर्नेछौं कि साधारण रैखिक प्रतिगमन समीकरणले वर्षको महिनामा राजस्वको निर्भरतालाई कत्तिको राम्रोसँग चित्रण गर्दछ।

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

# определим функцию для формирования массива отклонений в процентах
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()

चार्ट नम्बर ३ "विचलन,%"

पूर्ण छैन, तर हामीले हाम्रो कार्य पूरा गर्यौं।

गुणांक निर्धारण गर्न एउटा प्रकार्य लेखौं и पुस्तकालय प्रयोग गर्दछ नम्र, अझ स्पष्ट रूपमा, हामी दुई प्रकार्यहरू लेख्नेछौं: एउटा स्यूडोइन्भर्स म्याट्रिक्स प्रयोग गरेर (प्रक्रियामा सिफारिस गरिएको छैन, किनकि प्रक्रिया कम्प्युटेसनली जटिल र अस्थिर छ), अर्को म्याट्रिक्स समीकरण प्रयोग गरेर।

विश्लेषणात्मक समाधान कोड (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 (माइनस एक)।

हामी यस तथ्यमा ध्यान दिऔं कि एक प्रकार्यमा धेरै मिनिमा हुन सक्छ, र तल प्रस्तावित एल्गोरिदम प्रयोग गरेर ती मध्ये एउटामा झर्दा, हामी अर्को न्यूनतम फेला पार्न सक्षम हुने छैनौं, जुन फेला परेको भन्दा कम हुन सक्छ। आराम गरौं, यो हाम्रो लागि खतरा होइन! हाम्रो मामला मा हामी एकल न्यूनतम संग व्यवहार गर्दैछौं, हाम्रो प्रकार्य देखि ग्राफ मा एक नियमित parabola छ। र हामी सबैलाई हाम्रो स्कूलको गणित पाठ्यक्रमबाट राम्ररी थाहा हुनुपर्दछ, एक प्याराबोलामा एउटा मात्र न्यूनतम हुन्छ।

हामीले ढाँचा किन चाहिन्छ भनेर पत्ता लगाएपछि, र यो पनि कि ग्रेडियन्ट एक खण्ड हो, त्यो हो, दिइएको निर्देशांकहरू भएको भेक्टर, जुन ठीक समान गुणांकहरू हुन्। и हामी ग्रेडियन्ट डिसेन्ट लागू गर्न सक्छौं।

सुरु गर्नु अघि, म वंश एल्गोरिथ्मको बारेमा केही वाक्यहरू पढ्न सुझाव दिन्छु:

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

सबै! अब हामी मारियाना ट्रेन्चको सबैभन्दा गहिरो खाडलको खोजीमा जान तयार छौं। सुरु गरौं।

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

# напишем функцию градиентного спуска без использования библиотеки 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()

ग्राफ नम्बर ४ "ग्रेडियन्ट डिसेन्टको समयमा वर्ग विचलनको योग"

ग्राफमा हामी देख्छौं कि प्रत्येक चरणको साथ त्रुटि घट्छ, र निश्चित संख्याको पुनरावृत्ति पछि हामी लगभग तेर्सो रेखा देख्छौं।

अन्तमा, कोड कार्यान्वयन समय मा भिन्नता अनुमान गरौं:

ग्रेडियन्ट डिसेन्ट गणना समय निर्धारण गर्न कोड

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()

ग्राफ नम्बर ५ "स्टोकास्टिक ग्रेडियन्ट डिसेन्टको समयमा वर्ग विचलनको योग"

तालिका हेर्दा, सबै कुरा ठाउँमा खस्छ र अब हामी सबै ठीक गर्नेछौं।

त्यसोभए के भयो? निम्न कुरा भयो। जब हामी अनियमित रूपमा एक महिना चयन गर्छौं, तब यो चयन गरिएको महिनाको लागि हो जुन हाम्रो एल्गोरिदमले राजस्व गणनामा त्रुटि कम गर्न खोज्छ। त्यसपछि हामी अर्को महिना चयन गर्छौं र गणना दोहोर्याउँछौं, तर हामी दोस्रो चयन गरिएको महिनाको लागि त्रुटि घटाउँछौं। अब याद गर्नुहोस् कि पहिलो दुई महिना सरल रैखिक प्रतिगमन समीकरणको रेखाबाट महत्त्वपूर्ण रूपमा विचलित हुन्छ। यसको मतलब यो हो कि जब यी दुई महिनाहरू मध्ये कुनै पनि चयन गरिन्छ, तिनीहरूमध्ये प्रत्येकको त्रुटि घटाएर, हाम्रो एल्गोरिदमले सम्पूर्ण नमूनाको लागि त्रुटिलाई गम्भीर रूपमा बढाउँछ। त्यसोभए के गर्ने? जवाफ सरल छ: तपाईंले वंश चरण कम गर्न आवश्यक छ। आखिर, वंश चरण घटाएर, त्रुटिले माथि र तल "जम्पिङ" पनि रोक्नेछ। वा बरु, "जम्पिङ" त्रुटि रोकिनेछैन, तर यसले यति चाँडो गर्दैन :) जाँच गरौं।

सानो वृद्धि संग 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()

ग्राफ नम्बर ६ "स्टोकास्टिक ग्रेडियन्ट डिसेन्ट (८० हजार पाइला) को समयमा वर्ग विचलनको योग"

गुणांक सुधार भएको छ, तर अझै पनि आदर्श छैन। काल्पनिक रूपमा, यो यस तरिकाले सच्याउन सकिन्छ। हामी चयन गर्छौं, उदाहरणका लागि, अन्तिम 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()

ग्राफ नम्बर ७ "वर्ग विचलनको योगफल SGD (पहिलो १००० चरणहरू)"

ग्राफ नम्बर ८ "वर्ग विचलनको योगफल SGD (अन्तिम १००० चरणहरू)"

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

अब लाइब्रेरी प्रयोग गरेर स्टोकास्टिक ग्रेडियन्ट डिसेन्ट प्रदर्शन गरौं नम्र (र हामीले पहिले पहिचान गरेका ढुङ्गाहरूमा ठेस नपाऔं)

Stochastic Gradient Descent को लागि कोड (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