સરળ રેખીય રીગ્રેશનનું સમીકરણ ઉકેલવું

લેખ સરળ (જોડી) રીગ્રેસન રેખાના ગાણિતિક સમીકરણને નિર્ધારિત કરવાની ઘણી રીતોની ચર્ચા કરે છે.

અહીં ચર્ચા કરેલ સમીકરણને ઉકેલવાની તમામ પદ્ધતિઓ ઓછામાં ઓછા ચોરસ પદ્ધતિ પર આધારિત છે. ચાલો નીચે પ્રમાણે પદ્ધતિઓનો ઉલ્લેખ કરીએ:

• વિશ્લેષણાત્મક ઉકેલ
• ગ્રેડિયન્ટ ડિસેન્ટ
• સ્ટોકેસ્ટિક ગ્રેડિયન્ટ વંશ

સીધી રેખાના સમીકરણને ઉકેલવાની દરેક પદ્ધતિ માટે, લેખ વિવિધ કાર્યો પૂરા પાડે છે, જે મુખ્યત્વે પુસ્તકાલયનો ઉપયોગ કર્યા વિના લખેલા કાર્યોમાં વિભાજિત થાય છે. નમી અને જે ગણતરી માટે ઉપયોગ કરે છે નમી. એવું માનવામાં આવે છે કે કુશળ ઉપયોગ નમી કમ્પ્યુટિંગ ખર્ચ ઘટાડશે.

લેખમાં આપેલ તમામ કોડ ભાષામાં લખેલા છે અજગર 2.7 ઉપયોગ કરીને જ્યુપીટર નોટબુક. સ્રોત કોડ અને નમૂના ડેટા સાથેની ફાઇલ પર પોસ્ટ કરવામાં આવી છે ગીથબ

આ લેખ નવા નિશાળીયા અને જેઓ ધીમે ધીમે આર્ટિફિશિયલ ઈન્ટેલિજન્સ - મશીન લર્નિંગના ખૂબ જ વ્યાપક વિભાગના અભ્યાસમાં નિપુણતા મેળવવાનું શરૂ કરી ચૂક્યા છે તેઓ બંને માટે વધુ લક્ષ્યાંકિત છે.

સામગ્રીને સમજાવવા માટે, અમે એક ખૂબ જ સરળ ઉદાહરણનો ઉપયોગ કરીએ છીએ.

ઉદાહરણ શરતો

આપણી પાસે પાંચ મૂલ્યો છે જે પરાધીનતાને દર્શાવે છે Y થી X (કોષ્ટક નં. 1):

કોષ્ટક નંબર 1 "ઉદાહરણ શરતો"

અમે ધારીશું કે મૂલ્યો વર્ષનો મહિનો છે, અને - આ મહિને આવક. બીજા શબ્દોમાં કહીએ તો, આવક વર્ષના મહિના પર આધાર રાખે છે, અને - એકમાત્ર નિશાની જેના પર આવક આધાર રાખે છે.

ઉદાહરણ એટલું જ છે, વર્ષના મહિના પર આવકની શરતી નિર્ભરતાના દૃષ્ટિકોણથી અને મૂલ્યોની સંખ્યાના દૃષ્ટિકોણથી - તેમાંથી ઘણા ઓછા છે. જો કે, આવા સરળીકરણ તે શક્ય બનાવશે, જેમ કે તેઓ કહે છે, સમજાવવા માટે, હંમેશા સરળતા સાથે નહીં, તે સામગ્રી કે જે નવા નિશાળીયા આત્મસાત કરે છે. અને સંખ્યાઓની સરળતા પણ જેઓ નોંધપાત્ર શ્રમ ખર્ચ વિના કાગળ પર ઉદાહરણ ઉકેલવા માંગે છે તેમને મંજૂરી આપશે.

ચાલો ધારીએ કે ઉદાહરણમાં આપેલ અવલંબન ફોર્મની સરળ (જોડી) રીગ્રેસન લાઇનના ગાણિતિક સમીકરણ દ્વારા ખૂબ સારી રીતે અંદાજિત કરી શકાય છે:

જ્યાં તે મહિનો છે જેમાં આવક પ્રાપ્ત થઈ હતી, - મહિનાને અનુરૂપ આવક, и અંદાજિત રેખાના રીગ્રેસન ગુણાંક છે.

નોંધ કરો કે ગુણાંક ઘણીવાર અંદાજિત રેખાનો ઢાળ અથવા ઢાળ કહેવામાં આવે છે; તે રકમ રજૂ કરે છે જેના દ્વારા જ્યારે તે બદલાય છે .

દેખીતી રીતે, ઉદાહરણમાં અમારું કાર્ય સમીકરણમાં આવા ગુણાંક પસંદ કરવાનું છે и , જેના પર સાચા જવાબોમાંથી મહિના પ્રમાણે અમારી ગણતરી કરેલ આવક મૂલ્યોના વિચલનો, એટલે કે. નમૂનામાં પ્રસ્તુત મૂલ્યો ન્યૂનતમ હશે.

ઓછામાં ઓછી ચોરસ પદ્ધતિ

ન્યૂનતમ ચોરસ પદ્ધતિ અનુસાર, વિચલનની ગણતરી તેને વર્ગીકરણ કરીને કરવી જોઈએ. આ તકનીક તમને વિચલનોના પરસ્પર રદને ટાળવા માટે પરવાનગી આપે છે જો તેમની પાસે વિરોધી ચિહ્નો હોય. ઉદાહરણ તરીકે, જો એક કિસ્સામાં, વિચલન છે +5 (વત્તા પાંચ), અને બીજામાં -5 (માઈનસ પાંચ), પછી વિચલનોનો સરવાળો એકબીજાને રદ કરશે અને તેની રકમ 0 (શૂન્ય) થશે. વિચલનનું વર્ગીકરણ ન કરવું શક્ય છે, પરંતુ મોડ્યુલસની મિલકતનો ઉપયોગ કરવો અને પછી તમામ વિચલનો હકારાત્મક હશે અને એકઠા થશે. અમે આ મુદ્દા પર વિગતવાર ધ્યાન આપીશું નહીં, પરંતુ ફક્ત એટલું જ સૂચવીશું કે ગણતરીઓની સુવિધા માટે, વિચલનને વર્ગીકૃત કરવાનો રિવાજ છે.

આ ફોર્મ્યુલા જેવો દેખાય છે જેની સાથે આપણે વર્ગ વિચલનો (ભૂલો) નો ઓછામાં ઓછો સરવાળો નક્કી કરીશું:

જ્યાં સાચા જવાબોના અંદાજનું કાર્ય છે (એટલે ​​કે, અમે જે આવકની ગણતરી કરી છે),

સાચા જવાબો છે (નમૂનામાં આપેલી આવક),

નમૂના અનુક્રમણિકા છે (મહિનાની સંખ્યા જેમાં વિચલન નક્કી કરવામાં આવે છે)

ચાલો ફંક્શનને અલગ કરીએ, આંશિક વિભેદક સમીકરણોને વ્યાખ્યાયિત કરીએ અને વિશ્લેષણાત્મક ઉકેલ તરફ આગળ વધવા માટે તૈયાર થઈએ. પરંતુ પ્રથમ, ચાલો ભિન્નતા શું છે તે વિશે ટૂંકું પ્રવાસ લઈએ અને વ્યુત્પન્નનો ભૌમિતિક અર્થ યાદ રાખીએ.

ભિન્નતા

ભિન્નતા એ કાર્યનું વ્યુત્પન્ન શોધવાનું કાર્ય છે.

વ્યુત્પન્ન શેના માટે વપરાય છે? ફંક્શનનું ડેરિવેટિવ ફંક્શનના ફેરફારના દરને દર્શાવે છે અને તેની દિશા જણાવે છે. જો આપેલ બિંદુ પર વ્યુત્પન્ન હકારાત્મક હોય, તો કાર્ય વધે છે; અન્યથા, કાર્ય ઘટે છે. અને નિરપેક્ષ વ્યુત્પન્નનું મૂલ્ય જેટલું વધારે છે, ફંક્શન મૂલ્યોના ફેરફારનો દર જેટલો ઊંચો છે, તેમજ ફંક્શન ગ્રાફનો ઢોળાવ વધારે છે.

ઉદાહરણ તરીકે, કાર્ટેશિયન કોઓર્ડિનેટ સિસ્ટમની શરતો હેઠળ, બિંદુ M(0,0) પર વ્યુત્પન્નનું મૂલ્ય બરાબર છે + 25 મતલબ કે આપેલ બિંદુએ, જ્યારે મૂલ્ય સ્થાનાંતરિત થાય છે પરંપરાગત એકમ દ્વારા જમણી બાજુએ, મૂલ્ય 25 પરંપરાગત એકમો દ્વારા વધે છે. ગ્રાફ પર તે મૂલ્યોમાં એકદમ બેહદ વૃદ્ધિ જેવું લાગે છે આપેલ બિંદુ પરથી.

બીજું ઉદાહરણ. વ્યુત્પન્ન મૂલ્ય સમાન છે -0,1 મતલબ કે જ્યારે વિસ્થાપિત થાય છે એક પરંપરાગત એકમ દીઠ, મૂલ્ય માત્ર 0,1 પરંપરાગત એકમથી ઘટે છે. તે જ સમયે, ફંક્શનના ગ્રાફ પર, આપણે ભાગ્યે જ નોંધનીય નીચે તરફના ઢોળાવને અવલોકન કરી શકીએ છીએ. પર્વત સાથે સામ્યતા દોરતા, એવું લાગે છે કે આપણે ખૂબ જ ધીમે ધીમે પર્વત પરથી હળવા ઢોળાવ પર ઉતરી રહ્યા છીએ, અગાઉના ઉદાહરણથી વિપરીત, જ્યાં અમારે ખૂબ જ ઢાળવાળી શિખરો પર ચઢવાનું હતું :)

આમ, કાર્યને અલગ કર્યા પછી મતભેદ દ્વારા и , અમે 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