ጽሑፉ የቀላል (ጥንድ) ሪግሬሽን መስመርን የሂሳብ ስሌት ለመወሰን በርካታ መንገዶችን ያብራራል።
እዚህ የተብራራውን እኩልታ የመፍታት ሁሉም ዘዴዎች በትንሹ ካሬዎች ዘዴ ላይ የተመሰረቱ ናቸው. ዘዴዎቹን እንደሚከተለው እንጥቀስ-
- ትንታኔያዊ መፍትሄ
- ቀስ በቀስ መውረድ
- ስቶካስቲክ ቅልመት ቁልቁለት
ለእያንዳንዱ ቀጥተኛ መስመር እኩልታ የመፍታት ዘዴ, ጽሑፉ የተለያዩ ተግባራትን ያቀርባል, እነዚህም በዋናነት ቤተ-መጽሐፍቱን ሳይጠቀሙ በተጻፉት ይከፈላሉ. ቁ እና ለስሌቶች የሚጠቀሙት ቁ. በብቃት መጠቀሙ ይታመናል ቁ የኮምፒዩተር ወጪዎችን ይቀንሳል.
በአንቀጹ ውስጥ የተሰጡት ሁሉም ኮድ የተፃፉት በቋንቋ ነው። Python 2.7 በመጠቀም Jupyter Notebook. የምንጭ ኮድ እና ፋይል ከናሙና ውሂብ ጋር ተለጠፈ
ጽሑፉ የበለጠ ያተኮረው ለጀማሪዎች እና ቀድሞውንም ቀስ በቀስ በአርቴፊሻል ኢንተለጀንስ ውስጥ በጣም ሰፊ የሆነውን ክፍል ማጥናት ለጀመሩት - የማሽን መማሪያ ነው።
ትምህርቱን በምሳሌ ለማስረዳት በጣም ቀላል የሆነ ምሳሌ እንጠቀማለን።
ሁኔታዎች ምሳሌ
ጥገኝነትን የሚያሳዩ አምስት እሴቶች አሉን። Y от X (ሠንጠረዥ ቁጥር 1)
ሠንጠረዥ ቁጥር 1 "ምሳሌ ሁኔታዎች"
እሴቶቹን እንገምታለን የዓመቱ ወር ነው, እና - በዚህ ወር ገቢ. በሌላ አነጋገር ገቢ በዓመቱ ወር ላይ የተመሰረተ ነው, እና - ገቢው የተመካበት ብቸኛው ምልክት.
ምሳሌው እንዲሁ ነው ፣ በዓመቱ ወር ላይ ካለው የገቢ ሁኔታዊ ጥገኛ አንፃር ፣ እና ከእሴቶች ብዛት አንፃር - ከእነሱ ውስጥ በጣም ጥቂት ናቸው። ይሁን እንጂ እንዲህ ዓይነቱ ማቅለል ጀማሪዎች የሚዋሃዱትን ቁሳቁስ ሁልጊዜ በቀላል ሳይሆን ለማብራራት እንደሚሉት ቀላል ያደርገዋል። እንዲሁም የቁጥሮች ቀላልነት ጉልህ የሆነ የጉልበት ወጪዎች ሳይኖሩበት ምሳሌውን በወረቀት ላይ ለመፍታት ለሚፈልጉ ሰዎች ይፈቅዳል.
በምሳሌው ላይ የተጠቀሰው ጥገኝነት በቅጹ ቀላል (የተጣመሩ) ሪግሬሽን መስመር የሂሳብ ቀመር በጥሩ ሁኔታ ሊጠጋ እንደሚችል እናስብ።
የት ገቢው የተገኘበት ወር ነው - ከወሩ ጋር የሚዛመድ ገቢ; и የተገመተው መስመር ሪግሬሽን ኮፊሸን ናቸው.
የ Coefficient መሆኑን ልብ ይበሉ ብዙውን ጊዜ የተገመተውን መስመር ተዳፋት ወይም ቀስ በቀስ ይባላል; ይህም በ መጠን ይወክላል ሲቀየር .
በግልጽ ለማየት እንደሚቻለው, በምሳሌው ውስጥ የእኛ ተግባራችን እንደዚህ ያሉ ጥምርታዎችን በቀመር ውስጥ መምረጥ ነው и የተሰሉ የገቢ እሴቶቻችን ከእውነተኛ መልሶች በወር ልዩነቶች ፣ ማለትም። በናሙና ውስጥ የቀረቡት እሴቶች አነስተኛ ይሆናሉ።
ቢያንስ ካሬ ዘዴ
በትንሹ የካሬዎች ዘዴ መሰረት, ዳይሬሽኑን በማጣመር ማስላት አለበት. ይህ ዘዴ ተቃራኒ ምልክቶች ካላቸው ልዩነቶችን በጋራ መሰረዝን ለማስወገድ ያስችልዎታል። ለምሳሌ, በአንድ ጉዳይ ላይ ከሆነ, መዛባት ነው +5 (በተጨማሪ አምስት) እና በሌላ ውስጥ -5 (አምስት ሲቀነስ)፣ ከዚያ የልዩነቱ ድምር እርስ በርስ ይሰረዛሉ እና 0 (ዜሮ) ይሆናሉ። ማፈንገጡን ካሬ ማድረግ አይቻልም, ነገር ግን የሞጁሉን ንብረት መጠቀም እና ከዚያ ሁሉም ልዩነቶች አዎንታዊ ይሆናሉ እና ይከማቻሉ. በዚህ ነጥብ ላይ በዝርዝር አንቀመጥም ፣ ግን በቀላሉ ለስሌቶች ምቾት ፣ መዛባትን ማመጣጠን የተለመደ መሆኑን እንጠቁማለን።
ትንሹን የካሬ መዛባት (ስህተቶችን) የምንወስንበት ቀመሩ ይህን ይመስላል።
የት የእውነተኛ መልሶች መጠጋጋት ተግባር ነው (ይህም ያሰላነው ገቢ)
ትክክለኛዎቹ መልሶች ናቸው (በናሙና ውስጥ የቀረበው ገቢ)
የናሙና መረጃ ጠቋሚ ነው (ልዩነቱ የሚወሰንበት ወር ቁጥር)
ተግባሩን እንለይ፣ ከፊል ልዩነት እኩልታዎችን እንገልፃለን እና ወደ የትንታኔ መፍትሄ ለመሄድ ዝግጁ እንሁን። በመጀመሪያ ግን ልዩነት ምን እንደሆነ አጭር ጉብኝት እናድርግ እና የመነጩን ጂኦሜትሪክ ትርጉም እናስታውስ።
ልዩነት
ልዩነት የአንድ ተግባር ተወላጅ የማግኘት ተግባር ነው።
ተዋጽኦው ለምን ጥቅም ላይ ይውላል? የአንድ ተግባር ተወላጅ የተግባሩን ለውጥ መጠን ያሳያል እና አቅጣጫውን ይነግረናል። በተሰጠው ነጥብ ላይ ያለው ተዋጽኦ አዎንታዊ ከሆነ, ተግባሩ ይጨምራል, አለበለዚያ, ተግባሩ ይቀንሳል. እና የፍፁም መነሻው ዋጋ በጨመረ መጠን የተግባር እሴቶቹ የመቀየር መጠን ከፍ ያለ ሲሆን እንዲሁም የተግባር ግራፍ ቁልቁል ቁልቁል ይሆናል።
ለምሳሌ፣ በካርቴሲያን መጋጠሚያ ስርዓት ሁኔታዎች፣ የመነጩ ዋጋ በ M(0,0) ነጥብ ላይ እኩል ነው። + 25 በተሰጠው ነጥብ ላይ, እሴቱ ሲቀየር ማለት ነው ወደ ቀኝ በተለመደው አሃድ, እሴት በ 25 የተለመዱ ክፍሎች ይጨምራል. በግራፉ ላይ በትክክል ከፍ ያለ የእሴቶች ጭማሪ ይመስላል ከተሰጠው ነጥብ.
ሌላ ምሳሌ። የመነጩ ዋጋ እኩል ነው። -0,1 ሲፈናቀል ማለት ነው። በአንድ የተለመደ ክፍል, ዋጋ በ 0,1 የተለመደ ክፍል ብቻ ይቀንሳል. በተመሳሳይ ጊዜ፣ በተግባሩ ግራፍ ላይ፣ በቀላሉ የማይታይ የቁልቁለት ቁልቁለትን መመልከት እንችላለን። ከተራራው ጋር ተመሳሳይነት መሳል፣ ከቀደመው ምሳሌ በተለየ መልኩ በጣም ቀስ ብሎ ወደ ተራራ ላይ ረጋ ያለ ቁልቁል የምንወርድ ያህል ነው፣ በጣም ቁልቁል መውጣት ነበረብን :)
ስለዚህ, ተግባሩን ከተለየ በኋላ በአጋጣሚ и , 1 ኛ ቅደም ተከተል ከፊል ልዩነት እኩልታዎችን እንገልጻለን. እኩልታዎችን ከወሰንን በኋላ የሁለት እኩልታዎች ስርዓት እንቀበላለን ፣ በመፍታት እነዚህን የቁጥር እሴቶችን መምረጥ እንችላለን ። и , በተሰጡት ነጥቦች ላይ ያሉት ተጓዳኝ ተዋጽኦዎች ዋጋዎች በጣም በጣም ትንሽ በሆነ መጠን ይለወጣሉ, እና በትንታኔው መፍትሄ ላይ ምንም ለውጥ አያመጣም. በሌላ አገላለጽ ፣ በእነዚህ ነጥቦች ላይ የከፊል ተዋጽኦዎች እሴቶች ከዜሮ ጋር እኩል ስለሚሆኑ በተገኙት ጥምርታዎች ላይ ያለው የስህተት ተግባር በትንሹ ይደርሳል።
ስለዚህ ፣ በልዩነት ህጎች መሠረት ፣ የ 1 ኛ ቅደም ተከተል ከፊል ተዋጽኦ እኩልታ ከቁጥር ጋር በተያያዘ። ቅጹን ይወስዳል፡-
1ኛ ቅደም ተከተል ከፊል ተዋጽኦ እኩልታ ጋር በተያያዘ ቅጹን ይወስዳል፡-
በውጤቱም፣ ቀላል የሆነ የትንታኔ መፍትሄ ያለው የእኩልታዎች ስርዓት አግኝተናል፡-
ጀምር{equation*}
ጀምር{ጉዳይ}
ና + 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
መጨረሻ{ጉዳይ}
መጨረሻ{equation*}
እኩልታውን ከመፍታታችን በፊት አስቀድመን እንጫን፣ መጫኑ ትክክል መሆኑን እንፈትሽ እና መረጃውን እንቅረፅ።
ውሂብን በመጫን እና በመቅረጽ ላይ
ለትንታኔው መፍትሄ እና በመቀጠልም ለግራዲየንት እና ስቶካስቲክ ቅልጥፍና ቁልቁል ፣ ኮዱን በሁለት ልዩነቶች እንደምንጠቀም ልብ ሊባል ይገባል። ቁ እና ሳንጠቀምበት, ከዚያም ተገቢውን የውሂብ ቅርጸት ያስፈልገናል (ኮዱን ይመልከቱ).
የውሂብ ጭነት እና ሂደት ኮድ
# импортируем все нужные нам библиотеки
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 '********************************************'ምስላዊ
አሁን ፣ በመጀመሪያ ፣ ውሂቡን ከጫንን በኋላ ፣ ሁለተኛ ፣ የመጫኑን ትክክለኛነት ካረጋገጥን እና በመጨረሻም መረጃውን ቅርጸት ካደረግን በኋላ የመጀመሪያውን ምስላዊነት እናከናውናለን። ብዙውን ጊዜ ለዚህ ጥቅም ላይ የዋለው ዘዴ ነው ጥንድ ሴራ ቤተመፃህፍት የባህር ዳርቻ. በእኛ ምሳሌ, በተወሰኑ ቁጥሮች ምክንያት, ቤተ-መጽሐፍትን መጠቀም ምንም ፋይዳ የለውም የባህር ዳርቻ. መደበኛውን ቤተ-መጽሐፍት እንጠቀማለን ማትፕሎትሊብ እና የተበታተነውን ቦታ ብቻ ይመልከቱ.
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()ገበታ ቁጥር 1 "የገቢው ጥገኝነት በዓመቱ ወር"
ትንታኔያዊ መፍትሄ
በ ውስጥ በጣም የተለመዱ መሳሪያዎችን እንጠቀም ጭረት እና የእኩልታዎችን ስርዓት መፍታት;
ጀምር{equation*}
ጀምር{ጉዳይ}
ና + 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
መጨረሻ{ጉዳይ}
መጨረሻ{equation*}
እንደ ክሬመር ደንብ አጠቃላይ ወሳኙን እና እንዲሁም ወሳኙን በ እና በ , ከዚያ በኋላ, ወሳኙን በ ወደ አጠቃላይ መወሰኛ - ኮፊሸን ይፈልጉ , በተመሳሳይ መልኩ Coefficient ን እናገኛለን .
የትንታኔ መፍትሔ ኮድ
# определим функцию для расчета коэффициентов 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)
በትንሽ የውሂብ መጠን, "በራስ የተጻፈ" ተግባር ወደፊት ይወጣል, ይህም የ Cramer ዘዴን በመጠቀም ጥምርታዎችን ያገኛል.
አሁን ቅንጅቶችን ለማግኘት ወደ ሌሎች መንገዶች መሄድ ትችላለህ и .
ቀስ በቀስ መውረድ
በመጀመሪያ፣ ቅልመት ምን እንደሆነ እንገልፃለን። በቀላል አነጋገር፣ ቅልመት የአንድ ተግባር ከፍተኛ የእድገት አቅጣጫን የሚያመለክት ክፍል ነው። ቅልመት ፊቶች ወደ ተራራው ጫፍ ላይ ቁልቁል የሚወጡበት ተራራ ላይ ከመውጣት ጋር በማመሳሰል ነው። ምሳሌውን ከተራራው ጋር በማዳበር ፣እኛ እንደምናስታውሰው በእውነቱ በተቻለ ፍጥነት ወደ ቆላማው ቦታ ለመድረስ በጣም ቁልቁል መውረድ እንደሚያስፈልገን ማለትም ዝቅተኛው - ተግባሩ የማይጨምርበት ወይም የማይቀንስበት ቦታ። በዚህ ጊዜ ተዋጽኦው ከዜሮ ጋር እኩል ይሆናል. ስለዚህ፣ አንቲግራዲየንት እንጂ ቅልመት አንፈልግም። አንቲግራዲየንትን ለማግኘት ቅልመትን በዚ ማባዛት ብቻ ያስፈልግዎታል -1 (አንድ ሲቀነስ)።
አንድ ተግባር ብዙ ሚኒማ ሊኖረው እንደሚችል ልብ እንበል እና ከዚህ በታች የቀረበውን ስልተ ቀመር ተጠቅመን ወደ አንዱ ወርደን ከተገኘው ያነሰ ሊሆን የሚችል ሌላ ዝቅተኛ ማግኘት አንችልም። ዘና እንበል ይህ ለእኛ ስጋት አይደለም! በእኛ ሁኔታ ከተግባራችን ጀምሮ ከአንድ አነስተኛ ጋር እየተገናኘን ነው። በግራፉ ላይ መደበኛ ፓራቦላ ነው. እና ሁላችንም ከትምህርት ቤታችን የሂሳብ ትምህርት በሚገባ ማወቅ እንዳለብን፣ ፓራቦላ ያለው ዝቅተኛው አንድ ብቻ ነው።
ቅልመት ለምን እንደሚያስፈልገን ካወቅን በኋላ፣ እና ደግሞ ቅልመት ክፍል ነው፣ ማለትም፣ የተሰጡ መጋጠሚያዎች ያሉት ቬክተር፣ እነሱም በትክክል ተመሳሳይ መጋጠሚያዎች ናቸው። и ቀስ በቀስ መውረድን መተግበር እንችላለን።
ከመጀመሬ በፊት ስለ መውረጃ ስልተ ቀመር ጥቂት ዓረፍተ ነገሮችን እንዲያነቡ ሀሳብ አቀርባለሁ።
- የቅንጅቶችን መጋጠሚያዎች በሃሰት-ዘፈቀደ መንገድ እንወስናለን። и . በምሳሌአችን፣ ከዜሮ አጠገብ ያሉ ውህደቶችን እንገልፃለን። ይህ የተለመደ አሰራር ነው, ነገር ግን እያንዳንዱ ጉዳይ የራሱ አሠራር ሊኖረው ይችላል.
- ከማስተባበር በነጥቡ ላይ የ 1 ኛ ቅደም ተከተል ከፊል ተዋጽኦን ዋጋ ይቀንሱ . ስለዚህ, ተዋጽኦው አዎንታዊ ከሆነ, ከዚያም ተግባሩ ይጨምራል. ስለዚህ የመነጩን ዋጋ በመቀነስ በተቃራኒው የእድገት አቅጣጫ ማለትም ወደ መውረድ አቅጣጫ እንሄዳለን. ተዋጽኦው አሉታዊ ከሆነ, በዚህ ነጥብ ላይ ያለው ተግባር ይቀንሳል እና የመነጩን ዋጋ በመቀነስ ወደ መውረድ አቅጣጫ እንሄዳለን.
- ከመጋጠሚያው ጋር ተመሳሳይ ቀዶ ጥገና እናደርጋለን : ነጥብ ላይ ያለውን ከፊል ተዋጽኦ ያለውን ዋጋ መቀነስ .
- ከዝቅተኛው በላይ ለመዝለል እና ወደ ጥልቅ ቦታ ላለመብረር, የእርምጃውን መጠን ወደ መውረድ አቅጣጫ ማዘጋጀት አስፈላጊ ነው. በአጠቃላይ ፣ ደረጃውን እንዴት በትክክል ማቀናበር እንደሚቻል እና በሂደቱ ውስጥ የሂሳብ ወጪዎችን ለመቀነስ እንዴት እንደሚቀይሩት አንድ ሙሉ ጽሑፍ መጻፍ ይችላሉ። አሁን ግን ትንሽ ለየት ያለ ስራ ከፊታችን አለን እና የእርምጃውን መጠን በሳይንሳዊ ዘዴ "poke" በመጠቀም ወይም በተለመደው ቋንቋ እንደሚናገሩት, በተጨባጭ እናስቀምጣለን.
- ከተሰጡት መጋጠሚያዎች አንድ ጊዜ и የመነሻዎቹን ዋጋዎች ቀንስ ፣ አዲስ መጋጠሚያዎችን እናገኛለን и . የሚቀጥለውን ደረጃ (መቀነስ) እንወስዳለን, ቀድሞውኑ ከተሰሉት መጋጠሚያዎች. እና ስለዚህ ዑደቱ እንደገና እና እንደገና ይጀምራል, አስፈላጊው ውህደት እስኪሳካ ድረስ.
ሁሉም! አሁን የማሪያና ትሬንች ጥልቅ የሆነ ገደል ለመፈለግ ዝግጁ ነን። እንጀምር.
ቀስ በቀስ የመውረድ ኮድ
# напишем функцию градиентного спуска без использования библиотеки 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
Coefficient እሴቶች и የማይለወጥ.
ስህተቱ በደረጃ ቁልቁል ወቅት እንዴት እንደተለወጠ፣ ማለትም፣ የካሬ መዛባት ድምር በእያንዳንዱ እርምጃ እንዴት እንደተቀየረ እንይ።
የካሬ መዛባት ድምርን ለማቀድ ኮድ
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)
ምናልባት የሆነ ስህተት እየሰራን ነው፣ ግን እንደገና ቤተ-መጽሐፍቱን የማይጠቀም ቀላል “በቤት የተጻፈ” ተግባር ነው። ቁ ቤተ-መጽሐፍትን በመጠቀም የአንድ ተግባር ስሌት ጊዜን ይበልጣል ቁ.
እኛ ግን ዝም ብለን አንቆምም ፣ ነገር ግን ቀላል መስመራዊ ሪግሬሽን እኩልታን ለመፍታት ሌላ አስደሳች መንገድ ወደ ማጥናት እንሄዳለን። መገናኘት!
ስቶካስቲክ ቅልመት ቁልቁለት
የ stochastic gradient ውረድ አሰራርን መርህ በፍጥነት ለመረዳት ከተራ ቀስ በቀስ መውረድ ያለውን ልዩነት መወሰን የተሻለ ነው። እኛ፣ ቀስ በቀስ መውረድን በተመለከተ፣ በተዋጽኦዎች እኩልታዎች ውስጥ и በናሙና ውስጥ የሚገኙትን የሁሉም ባህሪዎች እና እውነተኛ መልሶች ድምርን ተጠቅሟል (ይህም የሁሉም ድምር)። и ). በስቶካስቲክ ቅልመት ቁልቁል፣ በናሙና ውስጥ ያሉትን ሁሉንም እሴቶች አንጠቀምም፣ ይልቁንስ፣ የውሸት-ነሲብ የሚባለውን የናሙና ኢንዴክስ ይምረጡ እና እሴቶቹን ይጠቀሙ።
ለምሳሌ, ጠቋሚው ቁጥር 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 እና በ XNUMX ዋጋ ዙሪያ እንደሚሄድ እና አንዳንድ ጊዜ እንኳን ከዚህ ጥሩ እሴት ጋር እኩል እንደሆነ እናያለን ፣ ግን አሁንም ከፍ ይላል… እደግማለሁ ፣ የእሴቶቹን እሴቶች መፃፍ ይችላሉ ። አሃዞች и , እና ከዚያ ስህተቱ አነስተኛ የሆኑትን ይምረጡ. ሆኖም ፣ የበለጠ ከባድ ችግር አጋጥሞናል-እሴቶችን ወደ ምርጥ ቅርብ ለማድረግ 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. የመስመራዊ መመለሻ
2. ቢያንስ የካሬዎች ዘዴ
3. የመነጨ
4. ቀስ በቀስ
5. ቀስ በቀስ መውረድ
6. NumPy ቤተ መጻሕፍት
ምንጭ: hab.com