Artikel ngabahas sababaraha cara pikeun nangtukeun persamaan matematik garis regression basajan (dipasangkeun).
Sadaya metodeu pikeun ngarengsekeun persamaan anu dibahas di dieu dumasar kana metode kuadrat pangleutikna. Hayu urang nunjukkeun métode saperti kieu:
- Solusi analitik
- Gradién turunan
- turunan gradién stokastik
Pikeun unggal metodeu pikeun ngarengsekeun persamaan garis lempeng, tulisan éta nyayogikeun sababaraha fungsi, anu utamina dibagi kana anu ditulis tanpa nganggo perpustakaan. Numpy jeung nu dipaké pikeun itungan Numpy. Hal ieu dipercaya yén pamakéan skillful Numpy bakal ngurangan biaya komputasi.
Sadaya kode anu dipasihkeun dina tulisan ditulis dina basa python 2.7 ngagunakeun Notebook Jupyter. Kodeu sumber sareng file sareng data sampel dipasang dina
Tulisan éta langkung ditujukeun pikeun pamula sareng anu parantos laun-laun ngawasa diajar bagian anu lega pisan dina intelijen buatan - learning machine.
Pikeun ngagambarkeun bahan, kami nganggo conto anu saderhana pisan.
Conto kaayaan
Kami ngagaduhan lima nilai anu dicirikeun gumantungna Y от X (Tabel No. 1):
Méja No. 1 "Conto kaayaan"
Urang bakal nganggap yén nilai nyaéta bulan taun, jeung - panghasilan bulan ieu. Dina basa sejen, sharing gumantung kana bulan taun, sarta - hijina tanda on nu panghasilan gumantung.
Contona kitu-kitu, boh tina sudut pandang gumantungna kondisional tina pendapatan dina bulan taun, sareng tina sudut pandang jumlah nilai - saeutik pisan di antarana. Nanging, nyederhanakeun sapertos kitu bakal ngamungkinkeun, sakumaha anu aranjeunna nyarios, ngajelaskeun, henteu salawasna gampang, bahan anu diasimilasi para pemula. Sarta ogé kesederhanaan tina angka bakal ngidinan jalma anu hayang ngajawab conto dina kertas tanpa waragad kuli signifikan.
Hayu urang nganggap yén kagumantungan anu dipasihkeun dina conto tiasa dideukeutan lumayan ku persamaan matematika tina garis régrési sederhana (dipasangkeun) tina bentuk:
di mana nyaéta bulan dimana pendapatan ditampi, - panghasilan pakait sareng bulan, и nyaéta koefisien régrési tina garis estimasi.
Catet yén koefisien mindeng disebut lamping atawa gradién tina garis estimasi; ngagambarkeun jumlah ku nu lamun robah .
Jelas, tugas urang dina conto nyaéta pikeun milih koefisien sapertos dina persamaan и , di mana panyimpangan tina nilai panghasilan urang diitung ku bulan tina jawaban anu leres, i.e. nilai dibere dina sampel bakal minimal.
Métode kuadrat pangsaeutikna
Numutkeun métode kuadrat pangleutikna, simpangan kudu diitung ku squaring eta. Téhnik ieu ngamungkinkeun anjeun pikeun nyingkahan silih pembatalan panyimpangan upami aranjeunna gaduh tanda anu sabalikna. Contona, upami dina hiji kasus, simpangan téh +5 (tambah lima), jeung lianna -5 (dikurangan lima), mangka jumlah simpangan bakal ngabolaykeun silih kaluar sarta jumlahna 0 (nol). Ieu mungkin teu kuadrat simpangan, tapi ngagunakeun sipat modulus lajeng sagala simpangan bakal positif sarta bakal ngumpulkeun. Urang moal Huni on titik ieu di jéntré, tapi ngan saukur nunjukkeun yén pikeun genah itungan, geus biasa kuadrat simpangan.
Ieu mangrupikeun rumus anu urang bakal nangtukeun jumlah pangsaeutikna tina simpangan kuadrat (kasalahan):
di mana nyaéta fungsi perkiraan jawaban anu leres (nyaéta, pendapatan anu urang diitung),
nyaéta jawaban anu leres (panghasilan anu disayogikeun dina conto),
nyaéta indéks sampel (jumlah bulan dimana simpangan ditangtukeun)
Hayu urang ngabedakeun fungsi, nangtukeun persamaan diferensial parsial, sarta siap pikeun ngaléngkah ka solusi analitik. Tapi ke heula, hayu urang nyandak hiji piknik pondok ngeunaan naon diferensiasi sarta inget harti geometric turunan.
Diferensiasi
Diferensiasi nyaéta operasi manggihan turunan tina hiji fungsi.
Naon turunan dipaké pikeun? Turunan tina hiji fungsi dicirikeun laju robah fungsi sarta ngabejaan urang arah na. Lamun turunan dina titik nu tangtu positip, mangka fungsi naek; lamun henteu, fungsi nurun. Jeung nu leuwih gede nilai turunan mutlak, nu leuwih luhur laju robah tina nilai fungsi, kitu ogé steeper lamping grafik fungsi.
Contona, dina kaayaan sistem koordinat Cartésian, nilai turunan dina titik M(0,0) sarua jeung + 25 hartina dina titik tinangtu, nalika nilai ieu bergeser ka katuhu ku unit konvensional, nilai ngaronjat ku 25 unit konvensional. Dina grafik eta Sigana naékna cukup lungkawing dina nilai ti titik nu tangtu.
conto sejen. Nilai turunan sarua -0,1 hartina lamun digusur per hiji unit konvensional, nilai turun ku ukur 0,1 unit konvensional. Dina waktu nu sarua, dina grafik fungsi, urang bisa niténan lamping handap bieu noticeable. Ngagambar analogi sareng gunung, saolah-olah urang laun-laun turun lamping anu lemah lembut tina gunung, teu sapertos conto sateuacana, dimana urang kedah naék puncak anu lungkawing :)
Ku kituna, sanggeus diferensiasi fungsi ku odds и , urang nangtukeun 1st urutan persamaan diferensial parsial. Saatos nangtukeun persamaan, urang bakal nampi sistem dua persamaan, ku ngarengsekeun anu urang bakal tiasa milih nilai-nilai sapertos koefisien. и , dimana nilai turunan anu aya dina titik anu dipasihkeun robih ku jumlah anu sakedik pisan, sareng dina kasus solusi analitis henteu robih pisan. Dina basa sejen, fungsi kasalahan dina koefisien kapanggih bakal ngahontal minimum, sabab nilai tina turunan parsial dina titik ieu bakal sarua jeung nol.
Ku kituna, nurutkeun aturan diferensiasi, persamaan turunan parsial tina orde 1 ngeunaan koefisien. bakal nyandak bentuk:
Orde 1 persamaan turunan parsial ngeunaan bakal nyandak bentuk:
Hasilna, kami nampi sistem persamaan anu ngagaduhan solusi analitik anu saderhana:
dimimitian{persamaan*}
dimimitian {kasus}
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
tungtung {kasus}
tungtung {persamaan*}
Sateuacan ngarengsekeun persamaan, hayu urang preload, pariksa yen loading bener, sarta pormat data.
Ngamuat sareng pormat data
Ieu kudu dicatet yén alatan kanyataan yén pikeun solusi analitik, sarta salajengna pikeun gradién jeung turunan gradient stokastik, urang bakal ngagunakeun kode dina dua variasi: ngagunakeun perpustakaan. Numpy sareng tanpa nganggo éta, maka urang peryogi pormat data anu pas (tingali kode).
Data loading jeung kode processing
# импортируем все нужные нам библиотеки
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 '********************************************'Visualisasi
Ayeuna, sanggeus kami geus, firstly, dimuat data, Bréh, pariksa correctness of loading sarta tungtungna formatna data, urang bakal ngalaksanakeun visualisasi munggaran. Métode anu sering dianggo pikeun ieu nyaéta papasangan perpustakaan Laut laut. Dina conto urang, kusabab jumlah kawates, teu aya gunana ngagunakeun perpustakaan Laut laut. Urang bakal ngagunakeun perpustakaan biasa matplotlib sarta ngan kasampak di scatterplot.
Kodeu 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()Bagan No. 1 "Gumantungan panghasilan dina bulan dina sataun"
Solusi analitik
Hayu urang nganggo alat anu paling umum dina python jeung ngajawab sistem persamaan:
dimimitian{persamaan*}
dimimitian {kasus}
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
tungtung {kasus}
tungtung {persamaan*}
Numutkeun aturan Cramer urang bakal manggihan determinant umum, kitu ogé determinants ku sareng ku , sanggeus éta, ngabagi determinant ku ka determinan umum - manggihan koefisien , Sarupa oge urang manggihan koefisien .
Kode solusi analitik
# определим функцию для расчета коэффициентов 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)Ieu naon anu urang kéngingkeun:
Janten, nilai-nilai koefisien parantos kapanggih, jumlah simpangan kuadrat parantos didamel. Hayu urang ngagambar garis lempeng dina histogram scattering luyu jeung koefisien kapanggih.
Kodeu garis regression
# определим функцию для формирования массива рассчетных значений выручки
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()Bagan No. 2 "Jawaban anu leres sareng diitung"
Anjeun tiasa ningali grafik simpangan unggal bulan. Dina hal urang, urang moal diturunkeun sagala nilai praktis signifikan ti dinya, tapi urang bakal nyugemakeun rasa panasaran urang ngeunaan kumaha ogé persamaan régrési linier basajan characterizes gumantungna sharing dina bulan taun.
Kode grafik simpangan
# определим функцию для формирования массива отклонений в процентах
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()Bagan No. 3 "Panyimpangan, %"
Teu sampurna, tapi urang réngsé tugas urang.
Hayu urang nulis fungsi éta, pikeun nangtukeun koefisien и ngagunakeun perpustakaan Numpy, leuwih tepatna, urang bakal nulis dua fungsi: hiji ngagunakeun matriks pseudoinverse (teu dianjurkeun dina prakna, sabab prosés komputasi rumit sarta teu stabil), nu séjén ngagunakeun persamaan matrix.
Kode Solusi Analitik (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_npHayu urang ngabandingkeun waktos spent dina nangtukeun koefisien и , luyu jeung 3 métode dibere.
Kode keur ngitung waktu itungan
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)
Kalawan jumlah leutik data, hiji fungsi "tulisan sorangan" kaluar payun, nu manggihan koefisien ngagunakeun métode Cramer urang.
Ayeuna anjeun bisa ngaléngkah ka cara séjén pikeun manggihan koefisien и .
Gradién turunan
Kahiji, hayu urang ngartikeun naon gradién. Kantun nempatkeun, gradién nyaéta bagéan anu nuduhkeun arah tumuwuhna maksimum hiji fungsi. Sacara analogi jeung naek gunung, dimana beungeut gradién mangrupa tempat nanjak paling lungkawing ka puncak gunung. Ngembangkeun conto sareng gunung, urang émut yén saleresna urang peryogi turunan anu paling luhur pikeun ngahontal dataran rendah gancang-gancang, nyaéta, minimum - tempat dimana fungsina henteu ningkat atanapi turun. Dina titik ieu turunan bakal sarua jeung nol. Ku alatan éta, urang teu kudu gradién, tapi hiji antigradient. Pikeun mendakan antigradién anjeun ngan ukur kedah ngalikeun gradién ku -1 (minus hiji).
Hayu urang nengetan kanyataan yén hiji fungsi bisa mibanda sababaraha minima, sarta sanggeus turun kana salah sahijina ngagunakeun algoritma diusulkeun handap, urang moal bisa manggihan minimum sejen, nu bisa jadi leuwih handap hiji kapanggih. Hayu urang santai, ieu sanés ancaman pikeun urang! Bisi kami urang kaayaan minimum tunggal, saprak fungsi urang dina grafik nyaéta parabola biasa. Sareng sakumaha urang sadayana kedah terang pisan tina kursus matematika sakola urang, parabola ngan ukur aya hiji minimum.
Saatos urang mendakan naha urang peryogi gradién, sareng ogé yén gradién mangrupikeun ruas, nyaéta, vektor kalayan koordinat anu dipasihkeun, anu sami-sami koefisien. и urang tiasa nerapkeun turunan gradién.
Sateuacan ngamimitian, kuring nyarankeun maca ngan sababaraha kalimat ngeunaan algoritma turunan:
- Urang nangtukeun ku cara pseudo-acak koordinat tina koefisien и . Dina conto urang, urang bakal nangtukeun koefisien deukeut enol. Ieu mangrupikeun prakték umum, tapi unggal kasus tiasa gaduh prakték sorangan.
- Ti koordinat ngurangan nilai turunan parsial orde 1 dina titik . Janten, upami turunanna positip, fungsina ningkat. Ku alatan éta, ku subtracting nilai turunan, urang bakal mindahkeun dina arah nu lalawanan tumuwuhna, nyaeta, dina arah turunan. Lamun turunan négatip, fungsi dina titik ieu turun sarta ku subtracting nilai turunan urang pindah ka arah turunan.
- Kami ngalaksanakeun operasi anu sami sareng koordinat : ngurangan nilai turunan parsial dina titik .
- Dina raraga teu luncat leuwih minimum jeung ngapung ka jero rohangan, perlu pikeun ngeset ukuran hambalan dina arah turunan. Sacara umum, anjeun tiasa nyerat sadayana tulisan ngeunaan kumaha nyetél léngkah anu leres sareng kumaha cara ngarobih nalika prosés turunan supados ngirangan biaya komputasi. Tapi ayeuna urang boga tugas rada béda dihareupeun urang, sarta kami bakal ngadegkeun ukuran hambalan ngagunakeun métode ilmiah "poke" atawa, sakumaha aranjeunna nyebutkeun dina parlance umum, émpiris.
- Sakali kami ti koordinat dibikeun и ngurangan nilai turunan, urang meunang koordinat anyar и . Kami nyandak léngkah salajengna (pangurangan), parantos tina koordinat anu diitung. Kituna siklus dimimitian deui jeung deui, nepi ka konvergénsi diperlukeun kahontal.
Sadayana! Ayeuna kami siap pikeun milarian jurang anu paling jero tina Palung Mariana. Hayu urang ngamimitian.
Kode pikeun turunan gradién
# напишем функцию градиентного спуска без использования библиотеки 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
Urang teuleum ka handapeun Palung Mariana sareng di dinya urang mendakan nilai koefisien anu sami и , anu persis naon anu dipiharep.
Hayu urang teuleum deui, ngan waktos ieu, kendaraan laut jero urang bakal dieusi ku téknologi sanés, nyaéta perpustakaan. Numpy.
Kode pikeun turunan gradién (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
nilai koefisien и teu bisa dirobah.
Hayu urang tingali kumaha kasalahan robah salila turunan gradién, nyaeta, kumaha jumlah simpangan kuadrat robah unggal hambalan.
Kode pikeun ngarencanakeun jumlah simpangan kuadrat
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()Grafik No. 4 "Jumlah simpangan kuadrat salami turunan gradién"
Dina grafik urang nempo yén kalawan unggal hambalan kasalahan nurun, sarta sanggeus sababaraha iterations urang nitenan hiji garis ampir horizontal.
Tungtungna, hayu urang estimasi bédana dina waktu palaksanaan kode:
Kode pikeun nangtukeun waktu itungan turunan gradién
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)
Panginten urang ngalakukeun anu salah, tapi deui éta mangrupikeun fungsi "tulisan bumi" anu sederhana anu henteu nganggo perpustakaan. Numpy outperforms waktu itungan hiji fungsi ngagunakeun perpustakaan Numpy.
Tapi urang teu nangtung kénéh, tapi nuju nuju diajar cara seru séjén pikeun ngajawab persamaan régrési linier basajan. Papanggih kami!
turunan gradién stokastik
Pikeun gancang ngartos prinsip operasi turunan gradién stokastik, langkung saé pikeun nangtukeun bédana tina turunan gradién biasa. Kami, dina kasus turunan gradién, dina persamaan turunan tina и ngagunakeun jumlah nilai sadaya fitur sareng jawaban leres anu aya dina sampel (nyaéta, jumlah sadaya и ). Dina turunan gradién stokastik, urang moal nganggo sadaya nilai anu aya dina sampel, tapi gantina, pilih pseudo-acak anu disebut indéks sampel sareng nganggo nilaina.
Contona, lamun indéks ditangtukeun jadi angka 3 (tilu), lajeng urang nyokot nilai и , teras urang ngagantikeun nilai-nilai kana persamaan turunan sareng nangtukeun koordinat anyar. Lajeng, sanggeus nangtukeun koordinat, urang deui pseudo-acak nangtukeun indéks sampel, ngagantikeun nilai pakait jeung indéks kana persamaan diferensial parsial, sarta nangtukeun koordinat dina cara anyar. и jsb. nepi ka konvergénsi robah jadi héjo. Dina glance kahiji, éta sigana henteu sigana sapertos ieu tiasa dianggo pisan, tapi éta. Memang bener eta sia noting yén kasalahan teu ngurangan kalawan unggal hambalan, tapi pasti aya kacenderungan.
Naon kaunggulan turunan gradién stokastik dibandingkeun anu konvensional? Lamun ukuran sampel urang kacida gedéna tur diukur dina puluhan rébu nilai, mangka loba gampang pikeun ngolah, sebutkeun, sarébu acak di antarana, tinimbang sakabéh sampel. Ieu dimana turunan gradient stokastik asalna kana antrian. Dina kasus urang, tangtosna, urang moal aya bewara loba bédana.
Hayu urang nempo kode.
Kode pikeun turunan gradién stokastik
# определим функцию стох.град.шага
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])
Urang ningali sacara saksama dina koefisien sareng naroskeun diri naroskeun patarosan "Kumaha ieu tiasa?" Kami ngagaduhan nilai koefisien anu sanés и . Panginten turunan gradién stokastik parantos mendakan parameter anu langkung optimal pikeun persamaan? Hanjakal henteu. Cukup pikeun ningali jumlah simpangan kuadrat sareng ningali yén kalayan nilai-nilai anyar koefisien, kasalahanna langkung ageung. Urang teu puguh asa. Hayu urang ngawangun grafik ngeunaan parobahan kasalahan.
Kode pikeun ngarencanakeun jumlah simpangan kuadrat dina turunan gradién stokastik
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()Grafik No. 5 "Jumlah simpangan kuadrat salami turunan gradién stokastik"
Ningali jadwalna, sadayana janten tempatna sareng ayeuna urang bakal ngalereskeun sadayana.
Jadi naon anu lumangsung? Di handap ieu kajadian. Nalika kami sacara acak milih sabulan, maka éta pikeun bulan anu dipilih yén algoritma kami narékahan pikeun ngirangan kasalahan dina ngitung pendapatan. Teras pilih bulan anu sanés sareng malikan deui itungan, tapi urang ngirangan kasalahan pikeun bulan anu dipilih kadua. Ayeuna émut yén dua bulan kahiji nyimpang sacara signifikan tina garis persamaan régrési liniér basajan. Ieu ngandung harti yén nalika salah sahiji dua bulan ieu dipilih, ku cara ngurangan kasalahan unggal sahijina, algoritma urang serius ngaronjatkeun kasalahan pikeun sakabéh sampel. Janten naon anu kedah dilakukeun? Jawabanna basajan: anjeun kedah ngirangan léngkah turunan. Barina ogé, ku ngurangan hambalan turunan, kasalahan ogé bakal eureun "luncat" luhur jeung ka handap. Atawa rada, kasalahan "luncat" moal eureun, tapi moal ngalakukeun eta jadi gancang :) Hayu urang pariksa.
Kodeu ngajalankeun SGD kalawan increments leutik
# запустим функцию, уменьшив шаг в 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()
Grafik No. 6 "Jumlah simpangan kuadrat salami turunan gradién stokastik (80 rébu léngkah)"
Koefisien parantos ningkat, tapi tetep henteu idéal. Hypothetically, ieu bisa dilereskeun ku cara kieu. Urang milih, contona, dina 1000 iterations panungtungan nilai koefisien nu kasalahan minimum dijieun. Leres, pikeun ieu urang ogé kedah nyerat nilai-nilai koefisien sorangan. Kami moal ngalakukeun ieu, tapi nengetan jadwal. Sigana lancar sareng kasalahan sigana ngirangan sacara rata. Sabenerna ieu teu bener. Hayu urang tingali 1000 iterasi munggaran sareng bandingkeun sareng anu terakhir.
Kodeu pikeun bagan SGD (1000 léngkah munggaran)
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()Grafik No. 7 "Jumlah simpangan kuadrat SGD (1000 léngkah munggaran)"
Grafik No. 8 "Jumlah kuadrat simpangan SGD (1000 léngkah panungtungan)"
Dina awal turunna, urang niténan panurunan cukup seragam jeung lungkawing dina kasalahan. Dina iterations panungtungan, urang nempo yén kasalahan mana sabudeureun tur sabudeureun nilai 1,475 sarta dina sababaraha moments malah sarua jeung nilai optimal ieu, tapi lajeng eta tetep naek ... Kuring ngulang, anjeun bisa nulis handap nilai tina koefisien и , teras pilih anu kasalahanna minimal. Nanging, urang ngagaduhan masalah anu langkung serius: urang kedah nyandak 80 rébu léngkah (tingali kode) pikeun ngahontal nilai anu optimal. Sareng ieu parantos bertentangan sareng ideu pikeun ngahémat waktos komputasi sareng turunan gradién stokastik relatif ka turunan gradién. Naon anu tiasa dilereskeun sareng ningkat? Henteu hese pikeun perhatikeun yén dina iterasi munggaran urang yakin turun sareng, janten, urang kedah ngantunkeun léngkah anu ageung dina iterasi munggaran sareng ngirangan léngkah nalika urang maju. Kami moal ngalakukeun ieu dina tulisan ieu - éta parantos panjang teuing. Anu hayang bisa mikir sorangan kumaha carana ngalakukeun ieu, teu hese :)
Ayeuna hayu urang ngalakukeun turunan gradién stokastik nganggo perpustakaan Numpy (sareng hayu urang titajong kana batu-batu anu urang kenalkeun sateuacana)
Kodeu pikeun turunan Stokastik Gradién (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
Nilai-nilaina tétéla ampir sami sareng nalika turun tanpa nganggo Numpy. Sanajan kitu, ieu logis.
Hayu urang terang sabaraha lila turunan gradién stokastik nyandak urang.
Kode pikeun nangtukeun waktos itungan SGD (80 rébu léngkah)
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)
The salajengna ka leuweung, nu darker awan: deui, rumus "tinulis sorangan" nembongkeun hasil pangalusna. Sadaya ieu nunjukkeun yén kedah aya cara anu langkung halus pikeun ngagunakeun perpustakaan Numpy, nu bener-bener nyepetkeun operasi komputasi. Dina artikel ieu kami moal diajar ngeunaan aranjeunna. Bakal aya anu dipikirkeun dina waktos luang anjeun :)
Nyimpulkeun
Sateuacan nyimpulkeun, kuring hoyong ngajawab patarosan anu paling dipikaresep timbul ti pamaca anu dipikacinta. Kunaon, kanyataanna, "siksaan" sapertos kitu sareng turunan, naha urang kedah leumpang naék-turun gunung (lolobana turun) pikeun mendakan dataran rendah anu berharga, upami urang gaduh alat anu kuat sareng saderhana dina panangan urang. bentuk hiji solusi analitik, nu instan teleports kami ka tempat katuhu?
Jawaban kana patarosan ieu perenahna dina beungeut cai. Ayeuna urang geus nempo conto basajan pisan, nu jawaban nu bener gumantung kana hiji tanda . Anjeun teu ningali ieu mindeng dina kahirupan, jadi hayu urang ngabayangkeun yen urang boga 2, 30, 50 atawa leuwih tanda. Hayu urang tambahkeun kana ieu rébuan, atanapi malah puluhan rébu nilai pikeun tiap atribut. Dina hal ieu, leyuran analitik bisa jadi teu tahan tes jeung gagal. Sabalikna, turunan gradién sareng variasina lalaunan tapi pasti bakal ngadeukeutkeun urang ka tujuan - minimum fungsina. Entong hariwang ngeunaan kagancangan - sigana urang bakal ningali cara anu bakal ngamungkinkeun urang nyetél sareng ngatur panjang léngkah (nyaéta, laju).
Tur ayeuna kasimpulan ringkes sabenerna.
Firstly, abdi miharep yén bahan dibere dina artikel bakal mantuan dimimitian "élmuwan data" dina pamahaman cara ngajawab basajan (teu ngan) persamaan regression linier.
Kadua, urang nempo sababaraha cara pikeun ngajawab persamaan. Ayeuna, gumantung kana kaayaan, urang tiasa milih anu paling cocog pikeun ngarengsekeun masalah.
Katilu, urang ningal kakawasaan setélan tambahan, nyaéta panjang léngkah turunan gradién. Parameter ieu teu tiasa diabaikan. Sakumaha didadarkeun di luhur, dina raraga ngurangan biaya itungan, panjang hambalan kudu dirobah salila turunan.
Kaopat, dina kasus urang, fungsi "ditulis di bumi" nunjukkeun hasil waktos pangsaéna pikeun itungan. Ieu meureun alatan teu paling profésional pamakéan kamampuhan perpustakaan urang Numpy. Tapi kumaha waé, kacindekan di handap ieu nunjukkeun sorangan. Di hiji sisi, sakapeung sia questioning pamadegan ngadegkeun, sarta di sisi séjén, teu salawasna patut complicating sagalana - sabalikna, kadang cara basajan pikeun ngarengsekeun hiji masalah leuwih éféktif. Sarta saprak tujuan urang éta pikeun nganalisis tilu pendekatan pikeun ngarengsekeun hiji persamaan regression linier basajan, pamakéan "tinulis sorangan" fungsi éta cukup keur urang.
Sastra (atanapi sapertos kitu)
1. régrési liniér
2. métode kuadrat pangsaeutikna
3. Turunan
4. Gradién
5. turunan gradién
6. perpustakaan NumPy
sumber: www.habr.com