It artikel besprekt ferskate manieren om de wiskundige fergeliking fan in ienfâldige (paarde) regressionline te bepalen.
Alle metoaden foar it oplossen fan 'e fergeliking dy't hjir besprutsen binne binne basearre op' e metoade fan 'e minste kwadraten. Litte wy de metoaden as folgjend oantsjutte:
- Analytyske oplossing
- Gradient Descent
- Stochastic gradient ôfstamming
Foar elke metoade foar it oplossen fan de fergeliking fan in rjochte line biedt it artikel ferskate funksjes, dy't benammen binne ferdield yn dyjingen dy't skreaun binne sûnder de bibleteek te brûken numpy en dyjingen dy't brûke foar berekkeningen numpy. It wurdt leaud dat betûft gebrûk numpy sil ferminderje computing kosten.
Alle koade jûn yn it artikel is skreaun yn 'e taal python 2.7 mei help fan Jupyter Notebook. De boarnekoade en bestân mei foarbyldgegevens wurde pleatst op
It artikel is mear rjochte op sawol begjinners as dyjingen dy't al stadichoan begûn te behearskjen de stúdzje fan in hiel brede seksje yn keunstmjittige yntelliginsje - masine learen.
Om it materiaal te yllustrearjen brûke wy in heul ienfâldich foarbyld.
Foarbyld betingsten
Wy hawwe fiif wearden dy't ôfhinklikens karakterisearje Y от X (Tabel nr. 1):
Tabel nr. 1 "Foarbyld betingsten"
Wy sille oannimme dat de wearden is de moanne fan it jier, en - ynkomsten dizze moanne. Mei oare wurden, ynkomsten hinget ôf fan de moanne fan it jier, en - it ienige teken wêrfan ynkomsten hinget.
It foarbyld is sa-sa, sawol út it eachpunt fan 'e betingsten ôfhinklikens fan ynkomsten op' e moanne fan it jier, en út it eachpunt fan it oantal wearden - d'r binne heul pear fan har. Lykwols, sa'n ferienfâldiging sil meitsje it mooglik, sa't se sizze, te ferklearjen, net altyd maklik, it materiaal dat begjinners assimilearje. En ek de ienfâld fan 'e sifers sil tastean dyjingen dy't wolle oplosse it foarbyld op papier sûnder signifikante arbeidskosten.
Lit ús oannimme dat de ôfhinklikens jûn yn it foarbyld frij goed kin wurde benadere troch de wiskundige fergeliking fan in ienfâldige (paarde) regressionline fan 'e foarm:
wêr is de moanne wêryn de ynkomsten ûntfongen binne, - ynkomsten dy't oerienkomme mei de moanne, и binne de regressionkoeffisienten fan 'e skatte line.
Tink derom dat de koeffizient faak neamd de helling of helling fan 'e skatte line; stiet foar it bedrach dêr't de as it feroaret .
Fansels is ús taak yn it foarbyld om sokke koeffizienten yn 'e fergeliking te selektearjen и , wêrby't de ôfwikingen fan ús berekkene ynkomsten wearden per moanne fan 'e wiere antwurden, d.w.s. wearden presintearre yn 'e stekproef sille minimaal wêze.
Minste fjouwerkante metoade
Neffens de minste kwadraten metoade moat de ôfwiking berekkene wurde troch it kwadraatsjen. Dizze technyk kinne jo foar te kommen ûnderlinge annulering fan ôfwikingen as se hawwe tsjinoerstelde tekens. Bygelyks, as yn ien gefal, de ôfwiking is +5 (plus fiif), en yn 'e oare -5 (minus fiif), dan sil de som fan de ôfwikingen inoar ôfbrekke en bedraacht 0 (nul). It is mooglik om de ôfwiking net kwadraat te meitsjen, mar it eigenskip fan 'e modulus te brûken en dan sille alle ôfwikingen posityf wêze en sammelje. Wy sille net dwaen op dit punt yn detail, mar gewoan oanjaan dat foar it gemak fan berekkeningen, is it gewoanlik om kwadraat de ôfwiking.
Dit is hoe't de formule derút sjocht wêrmei't wy de minste som fan kwadraten ôfwikingen (flaters) sille bepale:
wêr is in funksje fan approximaasje fan wiere antwurden (dat is de ynkomsten dy't wy berekkene hawwe),
binne de wiere antwurden (ynkomsten levere yn 'e stekproef),
is de stekproefyndeks (nûmer fan 'e moanne wêryn de ôfwiking wurdt bepaald)
Litte wy de funksje ûnderskiede, de parsjele differinsjaalfergelikingen definiearje, en ree wêze om troch te gean nei de analytyske oplossing. Mar earst litte wy in koarte ekskurzje nimme oer wat differinsjaasje is en de geometryske betsjutting fan 'e derivative ûnthâlde.
Differinsjaasje
Differinsjaasje is de operaasje fan it finen fan de derivative fan in funksje.
Wêr wurdt de derivative foar brûkt? De derivative fan in funksje karakterisearret de snelheid fan feroaring fan 'e funksje en fertelt ús de rjochting. As de derivative op in bepaald punt posityf is, dan nimt de funksje ta; oars nimt de funksje ôf. En hoe grutter de wearde fan 'e absolute derivative, hoe heger de snelheid fan feroaring fan' e funksjewearden, en hoe steiler de helling fan 'e funksjegrafyk.
Bygelyks, ûnder de betingsten fan in Cartesysk koördinatesysteem is de wearde fan 'e derivative op it punt M(0,0) gelyk oan + 25 betsjut dat op in bepaald punt, as de wearde wurdt ferskood nei rjochts troch in konvinsjonele ienheid, wearde nimt ta mei 25 konvinsjonele ienheden. Op de grafyk liket it op in frij steile stiging fan wearden fan in bepaald punt.
In oar foarbyld. De derivative wearde is gelyk -0,1 betsjut dat doe't ferpleatst per ien konvinsjonele ienheid, wearde nimt ôf mei mar 0,1 konvinsjonele ienheid. Tagelyk kinne wy op 'e grafyk fan' e funksje in amper merkbere delslach observearje. Troch in analogy mei in berch te tekenjen, is it as komme wy hiel stadich ôf in sêfte helling fan in berch, yn tsjinstelling ta it foarige foarbyld, wêr't wy tige steile toppen moasten beklimme :)
Sa, nei differinsjaasje fan de funksje troch odds и , wy definiearje 1e oarder parsjele differinsjaalfergelikingen. Nei it fêststellen fan de fergelikingen krije wy in systeem fan twa fergelikingen, troch op te lossen dy't wy sokke wearden fan 'e koeffizienten kinne selektearje и , wêrfoar't de wearden fan 'e oerienkommende derivaten op bepaalde punten in heul, heul lyts bedrach feroarje, en yn' t gefal fan in analytyske oplossing hielendal net feroarje. Mei oare wurden, de flaterfunksje op 'e fûne koeffizienten sil in minimum berikke, om't de wearden fan' e parsjele derivaten op dizze punten gelyk wêze oan nul.
Dus, neffens de regels fan differinsjaasje, de parsjele derivative fergeliking fan 'e 1e folchoarder mei respekt foar de koeffizient sil de foarm oannimme:
1e oarder parsjele derivative fergeliking mei respekt foar sil de foarm oannimme:
As gefolch hawwe wy in systeem fan fergelikingen krigen dat in frij ienfâldige analytyske oplossing hat:
begjinne {fergeliking*}
begjinne {gefallen}
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
ein {gefallen}
ein{fergeliking*}
Foardat jo de fergeliking oplosse, litte wy foarlade, kontrolearje dat it laden korrekt is en de gegevens opmaak.
Laden en opmaak fan gegevens
Dêrby moat opmurken wurde dat fanwege it feit dat foar de analytyske oplossing, en dêrnei foar gradient en stochastic gradient ôfstamming, wy sille brûke de koade yn twa fariaasjes: mei help fan de bibleteek numpy en sûnder it te brûken, dan sille wy passende gegevensopmaak nedich hawwe (sjoch koade).
Gegevens laden en ferwurkjen koade
# импортируем все нужные нам библиотеки
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 '********************************************'Fisualisaasje
No, nei't wy earst de gegevens hawwe laden, ten twadde, de krektens fan 'e laden kontrolearre en de gegevens úteinlik opmakke hawwe, sille wy de earste fisualisaasje útfiere. De metoade faak brûkt foar dit is pearplot biblioteken seaborn. Yn ús foarbyld hat it, fanwegen de beheinde oantallen, gjin punt om de bibleteek te brûken seaborn. Wy sille gebrûk meitsje fan de reguliere bibleteek matplotlib en sjoch mar nei it scatterplot.
Scatterplot koade
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()Chart No. 1 "Afhanklikheid fan ynkomsten op 'e moanne fan it jier"
Analytyske oplossing
Litte wy de meast foarkommende ark brûke yn python en oplosse it systeem fan fergelikingen:
begjinne {fergeliking*}
begjinne {gefallen}
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
ein {gefallen}
ein{fergeliking*}
Neffens Cramer syn regel wy sille fine de algemiene determinant, likegoed as determinanten troch en troch , wêrnei't it dielen fan de determinant troch nei de algemiene determinant - fyn de koeffizient , likegoed fine wy de koeffizient .
Analytyske oplossing koade
# определим функцию для расчета коэффициентов 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)Hjir is wat wy krigen:
Dat, de wearden fan 'e koeffizienten binne fûn, de som fan' e kwadratede ôfwikingen is fêststeld. Litte wy in rjochte line tekenje op it ferspriedingshistogram yn oerienstimming mei de fûne koeffizienten.
Regression line koade
# определим функцию для формирования массива рассчетных значений выручки
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()Chart No. 2 "Korrekte en berekkene antwurden"
Jo kinne de deviation grafyk foar elke moanne sjen. Yn ús gefal sille wy der gjin wichtige praktyske wearde oan ûntliene, mar wy sille ús nijsgjirrigens befredigje oer hoe goed de ienfâldige lineêre regressionfergeliking de ôfhinklikens fan ynkomsten op 'e moanne fan it jier karakterisearret.
Ofwiking chart koade
# определим функцию для формирования массива отклонений в процентах
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()Grafyk nûmer 3 "Ofwikingen, %"
Net perfekt, mar wy hawwe ús taak foltôge.
Litte wy in funksje skriuwe dy't, om de koeffizienten te bepalen и brûkt de bibleteek numpy, krekter, wy sille skriuwe twa funksjes: ien mei help fan in pseudoinverse matrix (net oan te rieden yn 'e praktyk, sûnt it proses is computationally kompleks en ynstabyl), de oare mei help fan in matrix fergeliking.
Analytyske oplossingskoade (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_npLitte wy de tiid fergelykje dy't bestege oan it bepalen fan de koeffizienten и , yn oerienstimming mei de 3 presintearre metoaden.
Koade foar it berekkenjen fan berekkeningstiid
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)
Mei in lytse hoemannichte gegevens komt in "sels skreaune" funksje foarút, dy't de koeffizienten fynt mei de metoade fan Cramer.
No kinne jo trochgean nei oare manieren om koeffizienten te finen и .
Gradient Descent
Lit ús earst definiearje wat in gradient is. Simpelwei is de gradient in segmint dat de rjochting fan maksimale groei fan in funksje oanjout. Troch analogy mei it beklimmen fan in berch, wêr't de hellingsgesichten is wêr't de steilste klim nei de top fan 'e berch is. Untwikkeljen fan it foarbyld mei de berch, wy betinke dat wy yn feite de steilste delgong nedich binne om sa gau mooglik it leechlân te berikken, dat is it minimum - it plak dêr't de funksje net ferheget of fermindert. Op dit punt sil de derivative gelyk wêze oan nul. Dêrom hawwe wy gjin gradient nedich, mar in antygradient. Om de antygradient te finen moatte jo gewoan de gradient fermannichfâldigje mei -1 (minus ien).
Lit ús omtinken jaan oan it feit dat in funksje ferskate minima kin hawwe, en nei't wy yn ien fan har delkommen binne mei it hjirûnder foarstelde algoritme, kinne wy net in oar minimum fine, dat leger kin wêze as de fûn. Lit ús ûntspanne, dit is gjin bedriging foar ús! Yn ús gefal hawwe wy te krijen mei ien minimum, sûnt ús funksje op 'e grafyk is in gewoane parabool. En sa't wy allegearre moatte witte hiel goed út ús skoalle wiskunde kursus, in parabool hat mar ien minimum.
Neidat wy fûnen út wêrom't wy nedich in gradient, en ek dat de gradient is in segmint, dat is, in fektor mei opjûne koördinaten, dy't krekt deselde koeffizienten и wy kinne gradient ôfstamming ymplementearje.
Foardat jo begjinne, stel ik foar om mar in pear sinnen te lêzen oer it ôfstammingsalgoritme:
- Wy bepale op in pseudo-willekeurige manier de koördinaten fan de koeffizienten и . Yn ús foarbyld sille wy koeffizienten tichtby nul bepale. Dit is in gewoane praktyk, mar elk gefal kin syn eigen praktyk hawwe.
- Fan koördinaat subtract de wearde fan 'e 1e folchoarder parsjele derivative op it punt . Dus, as de derivative posityf is, dan nimt de funksje ta. Dêrom, troch it subtrahearjen fan 'e wearde fan' e derivative, sille wy yn 'e tsjinoerstelde rjochting fan groei bewegen, dat is yn' e rjochting fan komôf. As de derivative negatyf is, dan nimt de funksje op dit punt ôf en troch de wearde fan 'e derivative ôf te lûken geane wy yn 'e rjochting fan ôfkomst.
- Wy fiere in ferlykbere operaasje mei de koördinaat : subtract de wearde fan de parsjele derivative op it punt .
- Om net oer it minimum te springen en yn djippe romte te fleanen, is it nedich om de stapgrutte yn te stellen yn 'e rjochting fan komôf. Yn 't algemien kinne jo in folslein artikel skriuwe oer hoe't jo de stap goed kinne ynstelle en hoe't jo it kinne feroarje tidens it ôfstammingsproses om berekkeningskosten te ferminderjen. Mar no hawwe wy in wat oare taak foar ús, en wy sille de stapgrutte fêststelle mei de wittenskiplike metoade fan "poke" of, sa't se yn 'e gewoane taal sizze, empirysk.
- Sadree't wy binne út de opjûne koördinaten и subtrahearje de wearden fan 'e derivaten, wy krije nije koördinaten и . Wy nimme de folgjende stap (subtraksje), al út 'e berekkene koördinaten. En sa begjint de syklus hieltyd wer, oant de fereaske konverginsje is berikt.
Alle! No binne wy ree om te gean op syk nei de djipste kloof fan de Mariana Trench. Litte wy begjinne.
Koade foar gradient ôfstamming
# напишем функцию градиентного спуска без использования библиотеки 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
Wy dûken nei de boaiem fan 'e Mariana Trench en dêr fûnen wy allegear deselde koeffizientwearden и , dat is krekt wat te ferwachtsjen wie.
Litte wy noch in dûk nimme, allinich dizze kear sil ús djipseeauto fol wurde mei oare technologyen, nammentlik in biblioteek numpy.
Koade foar gradient ôfstamming (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
Koëffisjint wearden и ûnferoarlik.
Litte wy sjen nei hoe't de flater feroare yn gradient ôfstamming, dat is, hoe't de som fan kwadraten ôfwikingen feroare mei elke stap.
Koade foar plotting sommen fan kwadraat ôfwikingen
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()Grafyk No.
Op 'e grafyk sjogge wy dat by elke stap de flater ôfnimt, en nei in bepaald oantal werhellingen sjogge wy in hast horizontale line.
Litte wy úteinlik it ferskil yn 'e útfieringstiid fan koade skatte:
Koade om de berekkeningstiid fan gradient ôfstamming te bepalen
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)
Miskien dogge wy wat ferkeard, mar wer is it in ienfâldige "hûs-skreaune" funksje dy't de bibleteek net brûkt numpy prestearret de berekkening tiid fan in funksje mei help fan de bibleteek numpy.
Mar wy steane net stil, mar geane nei it bestudearjen fan in oare spannende manier om de ienfâldige lineêre regressionfergeliking op te lossen. Moetsje!
Stochastic gradient ôfstamming
Om fluch begripe it prinsipe fan wurking fan stochastic gradient ôfstamming, is it better om te bepalen syn ferskillen fan gewoane gradient ôfstamming. Wy, yn it gefal fan gradient ôfstamming, yn 'e fergelikingen fan derivatives fan и brûkte de sommen fan 'e wearden fan alle funksjes en wiere antwurden beskikber yn' e stekproef (dat is de sommen fan alle и ). Yn stochastyske gradientôfstamming sille wy net alle wearden brûke dy't oanwêzich binne yn 'e stekproef, mar ynstee, selektearje pseudo-willekeurich de saneamde sample-yndeks en brûk syn wearden.
Bygelyks, as de yndeks bepaald wurdt as nûmer 3 (trije), dan nimme wy de wearden и , dan ferfange wy de wearden yn 'e derivative fergelikingen en bepale nije koördinaten. Dan, nei it fêststellen fan de koördinaten, bepale wy wer pseudo-willekeurich de stekproef yndeks, ferfange de wearden dy't oerienkomme mei de yndeks yn de parsjele differinsjaalfergelikingen, en bepale de koördinaten op in nije manier и ensfh. oant de konverginsje grien wurdt. Op it earste each liket it miskien net dat dit hielendal kin wurkje, mar it docht. It is wier dat it de muoite wurdich op te merken dat de flater net mei elke stap ôfnimt, mar d'r is grif in oanstriid.
Wat binne de foardielen fan stochastic gradient ôfstamming boppe konvinsjonele ien? As ús stekproef grutte is hiel grut en mjitten yn tsientûzenen wearden, dan is it folle makliker te ferwurkjen, sizze, in willekeurige tûzen fan harren, ynstee fan de hiele stekproef. Dit is wêr't stochastyske gradientôfstamming yn spiel komt. Yn ús gefal sille wy fansels net folle ferskil fernimme.
Litte wy nei de koade sjen.
Koade foar stochastic gradient ôfstamming
# определим функцию стох.град.шага
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])
Wy sjogge soarchfâldich nei de koeffizienten en fange ússels de fraach "Hoe kin dit?" Wy krigen oare koeffizientwearden и . Miskien hat stochastic gradient ôfstamming mear optimale parameters fûn foar de fergeliking? Spitigernôch Nee. It is genôch om te sjen nei de som fan kwadraten ôfwikingen en sjen dat mei nije wearden fan de koeffizienten, de flater is grutter. Wy hawwe gjin haast om te wanhopich. Litte wy in grafyk bouwe fan 'e flaterferoaring.
Koade foar it plotjen fan de som fan kwadraten ôfwikingen yn stochastic gradient ôfstamming
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()Grafyk nr. 5 "Som fan kwadraten ôfwikingen tidens stochastyske gradient ôfstamming"
Sjoen nei it skema falt alles op syn plak en no sille wy alles reparearje.
Dus wat barde der? It folgjende barde. As wy willekeurich in moanne selektearje, dan is it foar de selekteare moanne dat ús algoritme besiket de flater te ferminderjen by it berekkenjen fan ynkomsten. Dan selektearje wy in oare moanne en werhelje de berekkening, mar wy ferminderje de flater foar de twadde selektearre moanne. Tink derom dat de earste twa moannen signifikant ôfwike fan 'e line fan' e ienfâldige lineêre regressionfergeliking. Dit betsjut dat as ien fan dizze twa moannen selektearre is, troch de flater fan elk fan har te ferminderjen, ús algoritme de flater foar de heule stekproef serieus fergruttet. Dus wat te dwaan? It antwurd is ienfâldich: jo moatte de delgongstap ferminderje. Ommers, troch it ferminderjen fan de delgong stap, sil de flater ek stopje "springen" op en del. Of leaver, de "springende" flater sil net stopje, mar it sil it net sa fluch dwaan :) Litte wy kontrolearje.
Koade om SGD út te fieren mei lytsere ynkommens
# запустим функцию, уменьшив шаг в 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()
Grafyk nr. 6 "Som fan kwadraten ôfwikingen tidens stochastyske gradient ôfstamming (80 tûzen stappen)"
De koeffizienten binne ferbettere, mar binne noch altyd net ideaal. Hypotetysk kin dit op dizze manier korrizjearre wurde. Wy selektearje, bygelyks, yn 'e lêste 1000 iteraasjes de wearden fan' e koeffizienten wêrmei't de minimale flater makke is. Wier, hjirfoar sille wy ek de wearden fan 'e koeffizienten sels moatte opskriuwe. Wy sille dit net dwaan, mar leaver omtinken jaan oan it skema. It sjocht der glêd út en de flater liket evenredich ôf te nimmen. Eins is dit net wier. Litte wy nei de earste 1000 iteraasjes sjen en fergelykje mei de lêste.
Koade foar SGD-diagram (earste 1000 stappen)
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()Grafyk nr. 7 "Som fan kwadraatdeviaasjes SGD (earste 1000 stappen)"
Grafyk nûmer 8 "Som fan kwadraatdeviaasjes SGD (lêste 1000 stappen)"
Oan it begjin fan 'e delgong observearje wy in frij unifoarme en steile ôfname fan flaters. Yn 'e lêste iteraasjes sjogge wy dat de flater om en om de wearde fan 1,475 giet en op guon mominten sels dizze optimale wearde is, mar dan giet it noch omheech ... Ik werhelje, jo kinne de wearden fan 'e opskriuwe koeffizienten и , en selektearje dan dyjingen wêrfoar't de flater minimaal is. Wy hienen lykwols in serieuzer probleem: wy moasten 80 tûzen stappen nimme (sjoch koade) om wearden ticht by optimaal te krijen. En dit is al yn tsjinspraak mei it idee om berekkeningstiid te besparjen mei stochastyske gradientôfstamming relatyf oan gradientôfstamming. Wat kin korrizjearre en ferbettere wurde? It is net dreech om te merken dat wy yn 'e earste iteraasjes mei fertrouwen nei ûnderen geane en dêrom moatte wy in grutte stap yn' e earste iteraasjes litte en de stap ferminderje as wy foarút geane. Wy sille dit net dwaan yn dit artikel - it is al te lang. Dejingen dy't wolle, kinne sels tinke hoe't se dit dwaan, it is net dreech :)
Litte wy no stochastyske gradientôfstamming útfiere mei de bibleteek numpy (en lit ús net stroffelje oer de stiennen dy't wy earder identifisearre hawwe)
Koade foar 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
De wearden die bliken hast itselde te wêzen as by it delgean sûnder gebrûk numpy. Dit is lykwols logysk.
Litte wy útfine hoe lang stochastyske gradientôfdalingen ús namen.
Koade foar it bepalen fan SGD-berekkeningstiid (80 tûzen stappen)
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)
Hoe fierder it bosk yn, hoe tsjusterder de wolken: wer lit de "sels skreaune" formule it bêste resultaat sjen. Dit alles suggerearret dat d'r noch subtilere manieren wêze moatte om de bibleteek te brûken numpy, dy't berekkeningsoperaasjes echt fersnelle. Yn dit artikel sille wy net leare oer harren. D'r sil wat wêze om oer te tinken yn jo frije tiid :)
Wy binne gearfetsje
Foardat ik gearfette, wol ik in fraach beäntwurdzje dy't nei alle gedachten ûntstie fan ús leave lêzer. Wêrom, yn feite, sa'n "marteling" mei ôfkomsten, wêrom moatte wy de berch op en del rinne (meast del) om it dierbere leechlân te finen, as wy sa'n krêftich en ienfâldich apparaat yn ús hannen hawwe, yn 'e foarm fan in analytyske oplossing, dy't ús direkt teleportearret nei Rjochts plak?
It antwurd op dizze fraach leit oan it oerflak. No hawwe wy sjoen nei in hiel ienfâldich foarbyld, dêr't it wiere antwurd is hinget ôf fan ien teken . Jo sjogge dit net faak yn it libben, dus lit ús yntinke dat wy 2, 30, 50 of mear tekens hawwe. Litte wy tûzenen, of sels tsientûzenen wearden tafoegje foar elk attribút. Yn dit gefal kin de analytyske oplossing de test net ferneare en mislearje. Op syn beurt, gradient ôfstamming en syn fariaasjes sille stadich mar wis bringe ús tichter by it doel - it minimum fan de funksje. En meitsje jo gjin soargen oer snelheid - wy sille wierskynlik sjen nei manieren wêrmei't wy de staplingte (dat is, snelheid) kinne ynstelle en regelje.
En no de eigentlike koarte gearfetting.
As earste hoopje ik dat it materiaal presintearre yn it artikel sil helpe begjinnende "gegevenswittenskippers" te begripen hoe't jo ienfâldige (en net allinich) lineêre regressionfergelikingen kinne oplosse.
Twadder hawwe wy ferskate manieren sjoen om de fergeliking op te lossen. No, ôfhinklik fan 'e situaasje, kinne wy dejinge kieze dy't it bêste is om it probleem op te lossen.
Tredde seagen wy de krêft fan ekstra ynstellingen, nammentlik de lingte fan 'e gradient ôfstamming. Dizze parameter kin net negearre wurde. Lykas hjirboppe oanjûn, om de kosten fan berekkeningen te ferminderjen, moat de staplingte wurde feroare tidens de delgong.
Fjirde, yn ús gefal, "thús-skreaun" funksjes lieten de bêste tiid resultaten foar berekkeningen. Dit komt wierskynlik troch net it meast profesjonele gebrûk fan 'e mooglikheden fan' e bibleteek numpy. Mar hoe dan ek, de folgjende konklúzje suggerearret himsels. Oan 'e iene kant is it soms it wurdich om fêststelde mieningen te freegjen, en oan' e oare kant is it net altyd de muoite wurdich om alles te komplisearjen - krekt oarsom, soms is in ienfâldiger manier om in probleem op te lossen effektiver. En om't ús doel wie om trije oanpakken te analysearjen foar it oplossen fan in ienfâldige lineêre regressionfergeliking, wie it gebrûk fan "selsskreaune" funksjes foar ús genôch.
Literatuer (of sokssawat)
1. Lineêre regression
2. De minste kwadraten metoade
3. Derivaat
4. Gradient
5. Gradient ôfstamming
6. NumPy bibleteek
Boarne: www.habr.com