Erregresio lineal sinplearen ekuazioa ebaztea

Artikuluak erregresio zuzen sinple (parekatuta) baten ekuazio matematikoa zehazteko hainbat modu aztertzen ditu.

Hemen aztertutako ekuazioa ebazteko metodo guztiak karratu txikienen metodoan oinarritzen dira. Adierazi ditzagun metodoak honela:

• Soluzio analitikoa
• Jaitsiera Gradientea
• Gradiente estokastikoa jaitsiera

Lerro zuzen baten ekuazioa ebazteko metodo bakoitzerako, artikuluak hainbat funtzio eskaintzen ditu, batez ere liburutegia erabili gabe idazten direnetan banatzen direnak. Zenbakia eta kalkuluetarako erabiltzen direnak Zenbakia. Uste da erabilera trebea Zenbakia informatika kostuak murriztuko ditu.

Artikuluan emandako kode guztia hizkuntzan idatzita dago 2.7. pitonoa batera Jupyter Notebook. Iturburu-kodea eta lagin-datuen fitxategia bertan argitaratzen da Github

Artikulua hasiberriei eta dagoeneko pixkanaka adimen artifizialaren oso atal zabal baten azterketa menperatzen hasi direnei zuzenduta dago: ikaskuntza automatikoa.

Materiala ilustratzeko, oso adibide sinple bat erabiltzen dugu.

Baldintza adibide

Mendekotasuna ezaugarritzen duten bost balio ditugu Y tik X (1. zk. taula):

1. taula "Adibidezko baldintzak"

Balioak direla suposatuko dugu urteko hilabetea da, eta - hilabete honetako diru-sarrerak. Alegia, diru-sarrerak urteko hilabetearen araberakoak dira, eta - diru-sarreren araberako seinale bakarra.

Adibidea horrela da, bai diru-sarreren urteko hilabetearekiko baldintzapeko mendekotasunaren ikuspuntutik, bai balio kopuruaren ikuspegitik - oso gutxi daude. Hala ere, sinplifikazio horrek ahalbidetuko du, esaten den bezala, hasiberriek bereganatzen duten materiala ez beti errazki azaltzea. Eta, gainera, zenbakien sinpletasunak aukera emango die adibidea paperean ebatzi nahi dutenei lan kostu handirik gabe.

Demagun adibidean emandako menpekotasuna nahiko ondo hurbil daitekeela formako erregresio-lerro sinple (parekatuta) baten ekuazio matematikoaren bidez:

non diru-sarrerak jaso diren hilabetea da, - hilabeteari dagozkion diru-sarrerak, и estimatutako zuzenaren erregresio-koefizienteak dira.

Kontuan izan koefizientea sarritan estimatutako zuzenaren malda edo desnibela deritzo; zenbaterainokoa den adierazten du aldatzen denean .

Jakina, adibideko gure zeregina ekuazioan halako koefizienteak hautatzea da и , zeinetan gure kalkulatutako diru-sarreren balioen desbideratzeak hilean egiazko erantzunetatik, hau da. laginean aurkeztutako balioak minimoak izango dira.

Karratu txikienen metodoa

Karratu txikienen metodoaren arabera, desbideratzea karratuz kalkulatu behar da. Teknika honek desbideraketak elkarrekiko baliogabetzea saihesteko aukera ematen du, kontrako zeinuak badituzte. Adibidez, kasu batean bada, desbideratzea da +5 (gehi bost), eta bestean -5 (bost ken), orduan desbideraketen baturak elkarri baliogabetuko du eta 0 (zero) izango da. Posible da desbideratzea ez karratu, baizik eta moduluaren propietatea erabiltzea eta orduan desbideratze guztiak positiboak izango dira eta metatuko dira. Ez dugu puntu honetan zehatz-mehatz luzatuko, baizik eta adieraziko dugu kalkuluen erosotasunerako, ohikoa dela desbideratzea koadratzea.

Hona hemen desbideratze karratuen (erroreak) batura txikiena zehaztuko dugun formularen itxura:

non egiazko erantzunen hurbilketaren funtzioa da (hau da, guk kalkulatutako diru-sarrerak),

benetako erantzunak dira (laginean emandako diru-sarrerak),

laginaren indizea da (desbideratzea zehazten den hilabetearen zenbakia)

Bereiz ditzagun funtzioa, defini ditzagun ekuazio diferentzial partzialak eta egon gaitezen soluzio analitikora pasatzeko. Baina lehenik eta behin, egin dezagun txango labur bat diferentziazioa zer den eta gogora dezagun deribatuaren esanahi geometrikoa.

Bereiztea

Diferentziazioa funtzio baten deribatua aurkitzeko eragiketa da.

Zertarako erabiltzen da deribatua? Funtzio baten deribatuak funtzioaren aldaketa-abiadura ezaugarritzen du eta bere norabidea adierazten digu. Puntu jakin batean deribatua positiboa bada, funtzioa handitu egiten da; bestela, funtzioa txikiagotu egiten da. Eta deribatu absolutuaren balioa zenbat eta handiagoa izan, orduan eta handiagoa izango da funtzioen balioen aldaketa-tasa, baita funtzio grafikoaren malda handiagoa ere.

Esate baterako, koordenatu sistema kartesiar baten baldintzetan, M(0,0) puntuan deribatuaren balioa berdina da. + 25 esan nahi du puntu jakin batean, balioa desplazatzen denean eskuinera ohiko unitate batek, balioa 25 unitate konbentzional handitzen da. Grafikoan balioen igoera nahiko handia dirudi puntu jakin batetik.

Beste adibide bat. Balio deribatua berdina da -0,1 esan nahi du lekuz aldatzean unitate konbentzional bakoitzeko, balioa 0,1 unitate konbentzionalean bakarrik murrizten da. Aldi berean, funtzioaren grafikoan, ia nabaritzen den beheranzko malda bat beha dezakegu. Mendi batekin analogia bat eginez, oso poliki-poliki mendi batetik aldapa leun bat jaisten ari bagina bezala da, aurreko adibidean ez bezala, non gailur malkartsuak igo behar izan genituen :)

Horrela, funtzioa desberdindu ondoren probabilitatearen arabera и , 1. ordenako ekuazio diferentzial partzialak definitzen ditugu. Ekuazioak zehaztu ondoren, bi ekuazioko sistema bat jasoko dugu, koefizienteen balio horiek hautatzeko gai izango garen ebatziz. и , horretarako dagozkien deribatuen balioak puntu jakinetan oso-oso txikian aldatzen dira, eta soluzio analitiko baten kasuan ez dira batere aldatzen. Beste era batera esanda, aurkitutako koefizienteetan errore-funtzioa minimo batera iritsiko da, puntu horietan deribatu partzialen balioak zero berdinak izango baitira.

Beraz, diferentziazio arauen arabera, 1. ordenako deribatu partzialeko ekuazioa koefizientearekiko forma hartuko du:

1. ordenako deribatu partzialeko ekuazioari dagokionez forma hartuko du:

Ondorioz, soluzio analitiko nahiko sinplea duen ekuazio-sistema bat jaso dugu:

hasi{ekuazioa*}
hasi{kasuak}
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
amaiera {kasuak}
amaiera{ekuazioa*}

Ekuazioa ebatzi aurretik, aurrekargatu dezagun, egiaztatu karga zuzena dela eta formateatu datuak.

Datuak kargatzea eta formateatzea

Kontuan izan behar da, soluzio analitikorako, eta, ondoren, gradiente eta gradiente estokastikorako jaitsierarako, kodea bi aldaeratan erabiliko dugula: liburutegia erabiliz. Zenbakia eta erabili gabe, orduan datuen formatu egokia beharko dugu (ikus kodea).

Datuak kargatzeko eta prozesatzeko kodea

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

Bistaratzea

Orain, lehenik eta behin, datuak kargatu ondoren, bigarrenik, kargaren zuzentasuna egiaztatu eta azkenik datuak formateatu ondoren, lehenengo bistaratzea egingo dugu. Horretarako erabili ohi den metodoa da bikoteka liburutegia Itsasoa. Gure adibidean, kopuru mugatuak direnez, ez du balio liburutegia erabiltzeak Itsasoa. Ohiko liburutegia erabiliko dugu matplotlib eta begiratu besterik ez dago sakabanaketa.

Dispertsio grafikoaren kodea

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 zk. grafikoa "Diru-sarreren mendekotasuna urteko hilabetearekiko"

Soluzio analitikoa

Erabili ditzagun tresna ohikoenak python eta ebatzi ekuazio-sistema:

hasi{ekuazioa*}
hasi{kasuak}
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
amaiera {kasuak}
amaiera{ekuazioa*}

Cramer-en arauaren arabera determinatzaile orokorra aurkituko dugu, baita determinanteak ere eta , ondoren, determinantea zatituz determinatzaile orokorrari - aurkitu koefizientea , era berean koefizientea aurkituko dugu .

Soluzio-kode analitikoa

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

Hona hemen lortu duguna:

Beraz, koefizienteen balioak aurkitu dira, desbideratze karratuen batura ezarri da. Marraz dezagun sakabanatze histograman lerro zuzen bat aurkitutako koefizienteen arabera.

Erregresio-lerroaren kodea

# определим функцию для формирования массива рассчетных значений выручки
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. grafikoa "Erantzun zuzenak eta kalkulatuak"

Hilabete bakoitzeko desbideratze grafikoa ikus dezakezu. Gure kasuan, ez dugu hortik balio praktiko esanguratsurik aterako, baina erregresio linealaren ekuazio sinpleak urteko hilabetearekiko diru-sarreren menpekotasuna zein ondo bereizten duen jakiteko gure jakinmina asetuko dugu.

Desbideratze-taularen kodea

# определим функцию для формирования массива отклонений в процентах
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. grafikoa "Desbideratzeak, %"

Ez da perfektua, baina gure zeregina bete dugu.

Idatzi dezagun funtzio bat, koefizienteak zehazteko и liburutegia erabiltzen du Zenbakia, zehatzago, bi funtzio idatziko ditugu: bata matrize pseudo-inbertsoa erabiliz (praktikan ez da gomendagarria, prozesua konputazionalki konplexua eta ezegonkorra baita), bestea matrize-ekuazioa erabiliz.

Soluzio analitikoa (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

Konpara dezagun koefizienteak zehazten emandako denbora и , aurkeztutako 3 metodoen arabera.

Kalkulu-denbora kalkulatzeko kodea

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)

Datu kopuru txiki batekin, "norberak idatzitako" funtzio bat ateratzen da aurrera, Cramer-en metodoa erabiliz koefizienteak aurkitzen dituena.

Orain koefizienteak aurkitzeko beste modu batzuetara joan zaitezke и .

Jaitsiera Gradientea

Lehenik eta behin, defini dezagun zer den gradiente bat. Besterik gabe, gradientea funtzio baten hazkunde maximoaren norabidea adierazten duen segmentua da. Mendi bat igotzearen analogiaz, desnibelaren aurpegiak mendiaren gailurrerako igoerarik gogorrena dagoen tokian dago. Adibidea mendiarekin garatuz, gogoratzen dugu, hain zuzen ere, behealdera ahalik eta azkarren heltzeko jeitsierarik gogorrena behar dugula, hau da, minimora -funtzioa handitzen edo gutxitzen ez den tokira-. Une honetan deribatua zeroren berdina izango da. Beraz, ez dugu gradienterik behar, antigradiente bat baizik. Antigradientea aurkitzeko gradientearekin biderkatu besterik ez duzu behar -1 (bat ken).

Errepara dezagun funtzio batek hainbat minimo izan ditzakeela, eta haietako batean beherago proposatzen den algoritmoa erabiliz, ezingo dugu aurkitu beste minimo bat aurkitu, aurkitutakoa baino txikiagoa izan daitekeena. Lasai gaitezen, hau ez da guretzat mehatxu bat! Gure kasuan minimo bakar batekin ari gara, gure funtzioa grafikoan parabola erregular bat dago. Eta gure eskolako matematika-ikastarotik denok ondo jakin behar dugunez, paraboltak minimo bakarra du.

Gradiente bat zergatik behar genuen jakin ondoren, eta baita gradientea segmentu bat dela, hau da, koefiziente berdinak dituen koordenatuak dituen bektore bat ere. и desnibela ezar dezakegu.

Hasi aurretik, jaitsiera algoritmoari buruzko esaldi batzuk irakurtzea proposatzen dizut:

• Modu sasi-ausazko batean zehazten ditugu koefizienteen koordenatuak и . Gure adibidean, zerotik gertu dauden koefizienteak definituko ditugu. Hau ohiko praktika da, baina kasu bakoitzak bere praktika izan dezake.
• Koordenatutik kendu puntuan 1. ordenako deribatu partzialaren balioa . Beraz, deribatua positiboa bada, funtzioa handitzen da. Hortaz, deribatuaren balioa kenduz gero, hazkundearen kontrako noranzkoan mugituko gara, hau da, beheranzko noranzkoan. Deribatua negatiboa bada, orduan puntu honetan funtzioa txikiagotu egiten da eta deribatuaren balioa kenduz beherantz noranzkoan mugitzen gara.
• Koordenatuarekin antzeko eragiketa bat egiten dugu : kendu puntuan deribatu partzialaren balioa .
• Gutxienekoaren gainetik salto egin eta espazio sakonera hegan egiteko, beharrezkoa da pausoaren tamaina jaitsieraren norabidean ezarri. Oro har, artikulu oso bat idatz dezakezu urratsa behar bezala ezarri eta jaitsiera prozesuan nola aldatu jakiteko kostu konputazionalak murrizteko. Baina orain zeregin apur bat ezberdina dugu aurretik, eta urratsaren tamaina ezarriko dugu “poke” metodo zientifikoa erabiliz edo, hizkera arruntean esaten den bezala, enpirikoki.
• Emandako koordenatuetatik gaudenean и Deribatuen balioak kendu, koordenatu berriak lortuko ditugu и . Hurrengo urratsa (kenketa) egiten dugu, dagoeneko kalkulatutako koordenatuetatik. Eta horrela zikloa behin eta berriro hasten da, behar den konbergentzia lortu arte.

Denak! Orain prest gaude Mariana Lubakiko haitzarterik sakonenaren bila joateko. Has gaitezen.

Desnibela jaisteko kodea

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

Mariana Lubakiaren hondoraino murgildu ginen eta han koefiziente-balio berdinak aurkitu genituen и , hau da, hain zuzen, espero zena.

Egin dezagun beste murgiltze bat, oraingoan bakarrik, gure itsaso sakoneko ibilgailua beste teknologia batzuekin beteko da, liburutegi batekin alegia. Zenbakia.

Gradienteen jaitsieraren kodea (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

Koefizienteen balioak и aldaezina.

Ikus dezagun nola aldatu den errorea gradienteen jaitsieran, hau da, pauso bakoitzean desbideratze karratuen batura nola aldatzen den.

Desbideratze karratuen batuketak irudikatzeko kodea

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. zk. grafikoa "Desbideratze karratuen batura gradientea jaistean"

Grafikoan ikusten dugu urrats bakoitzarekin errorea gutxitzen dela, eta iterazio kopuru jakin baten ondoren lerro ia horizontal bat ikusten dugu.

Azkenik, kalkula dezagun kodea exekutatzeko denboraren aldea:

Gradienteen jaitsiera kalkulatzeko denbora zehazteko kodea

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)

Agian zerbait gaizki egiten ari gara, baina berriro liburutegia erabiltzen ez duen "etxean idatzitako" funtzio soil bat da Zenbakia Liburutegia erabiliz funtzio baten kalkulu-denbora gainditzen du Zenbakia.

Baina ez gaude geldirik, erregresio linealaren ekuazio sinplea ebazteko beste modu zirraragarri bat aztertzera goaz. Ezagutu gaitzazu!

Gradiente estokastikoa jaitsiera

Gradiente estokastikoaren jaitsieraren funtzionamendu-printzipioa azkar ulertzeko, hobe da gradienteen jaitsiera arruntarekiko dituen desberdintasunak zehaztea. Guk, gradiente-jaitsieraren kasuan, deribatuen ekuazioetan и ezaugarri guztien balioen batuketak eta laginean eskuragarri dauden benetako erantzunak erabili zituen (hau da, guztien batuketak и ). Gradiente estokastikoko jaitsieran, ez ditugu laginean dauden balio guztiak erabiliko, baizik eta sasi-ausaz hautatu laginaren indizea deritzona eta erabili bere balioak.

Adibidez, indizea 3. zenbakia (hiru) dela zehazten bada, balioak hartuko ditugu и , ondoren balioak ekuazio deribatuetan ordezkatzen ditugu eta koordenatu berriak zehaztuko ditugu. Ondoren, koordenatuak zehaztu ondoren, berriro sasi-ausaz zehazten dugu laginaren indizea, indizeari dagozkion balioak ekuazio diferentzial partzialetan ordezkatzen ditugu eta koordenatuak modu berri batean zehazten ditugu. и etab. konbergentzia berde bihurtu arte. Lehen begiratuan, agian ez dirudi honek batere funtziona dezakeenik, baina bai. Egia da nabarmentzekoa dela errorea ez dela gutxitzen urrats bakoitzean, baina zalantzarik gabe badago joera bat.

Zein abantaila ditu gradiente estokastikoaren jaitsierak ohikoaren aldean? Gure laginaren tamaina oso handia bada eta hamarnaka mila baliotan neurtuta badago, orduan askoz errazagoa da, esate baterako, horietako mila ausazko bat prozesatzea, lagin osoa baino. Hona hemen gradiente estokastikoa jaitsiera jokoan. Gure kasuan, noski, ez dugu alde handirik nabarituko.

Ikus dezagun kodea.

Gradiente estokastikoaren jaitsiera kodea

# определим функцию стох.град.шага
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])

Koefizienteei arretaz begiratzen diegu eta "Nola izan daiteke hau?" galdera egiten ari gara. Beste koefiziente-balio batzuk lortu ditugu и . Agian gradiente estokastikoen jaitsierak parametro optimoagoak aurkitu ditu ekuaziorako? Zoritxarrez ez. Nahikoa da desbideratze karratuen batura ikustea eta koefizienteen balio berriekin errorea handiagoa dela ikustea. Ez dugu etsitzeko presarik. Eraiki dezagun errore-aldaketaren grafikoa.

Gradiente estokastikoko jaitsieran desbideratze karratuen batura irudikatzeko kodea

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. grafikoa "Gradiente estokastikoen jaitsieran desbideratze karratuen batura"

Ordutegiari erreparatuta, dena kokatzen da eta orain dena konponduko dugu.

Orduan, zer gertatu zen? Honako hau gertatu zen. Hilabete bat ausaz hautatzen dugunean, orduan hautatutako hilabeterako da gure algoritmoak diru-sarrerak kalkulatzeko errorea murriztea bilatzen duena. Ondoren, beste hilabete bat hautatzen dugu eta kalkulua errepikatzen dugu, baina aukeratutako bigarren hilabeterako errorea murrizten dugu. Orain gogoratu lehen bi hilabeteak erregresio lineal sinplearen ekuazio lerrotik nabarmen desbideratzen direla. Horrek esan nahi du bi hilabete horietako edozein hautatzen denean, horietako bakoitzaren errorea murriztuz, gure algoritmoak lagin osoaren errorea larri handitzen duela. Beraz, zer egin? Erantzuna erraza da: jaitsiera urratsa murriztu behar duzu. Azken finean, jaitsiera urratsa murriztuz gero, erroreak gora eta behera "jauzi egitea" ere geldituko da. Edo hobeto esanda, "jauziaren" errorea ez da geldituko, baina ez du hain azkar egingo :) Ikus dezagun.

SGD gehikuntza txikiagoekin exekutatzeko kodea

# запустим функцию, уменьшив шаг в 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. grafikoa "Gradiente estokastikoen jaitsieran desbideratze karratuen batura (80 mila urrats)"

Koefizienteak hobetu egin dira, baina oraindik ez dira idealak. Hipotetikoki, hau modu honetan zuzendu daiteke. Adibidez, azken 1000 iterazioetan gutxieneko errorea egin den koefizienteen balioak hautatzen ditugu. Egia da, horretarako koefizienteen balioak berak ere idatzi beharko ditugu. Ez dugu hau egingo, ordutegiari erreparatuko diogu. Leuna dirudi eta akatsa uniformeki murrizten dela dirudi. Egia esan, hau ez da egia. Ikus ditzagun lehen 1000 iterazioei eta konparatu ditzagun azkenekin.

SGD diagramaren kodea (lehen 1000 urratsak)

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. grafikoa "SGD desbideratze karratuen batura (lehen 1000 urrats)"

8. grafikoa "SGD desbideratze karratuen batura (azken 1000 urrats)"

Jaitsieraren hasieran bertan, akatsen beherakada nahiko uniformea ​​eta aldapatsua ikusten dugu. Azken iterazioetan, ikusten dugu errorea 1,475 balioaren inguruan eta une batzuetan balio optimo hori berdintzen duela, baina gero oraindik gora egiten duela... Berriro diot, idatz ditzakezula balioak. koefizienteak и , eta, ondoren, hautatu errorea gutxienekoa duten horiek. Hala ere, arazo larriagoa izan genuen: 80 mila urrats eman behar izan genituen (ikus kodea) balioak optimoetatik gertu izateko. Eta horrek dagoeneko kontraesanean dago gradiente estokastikoaren jaitsierarekin konputazio-denbora aurrezteko ideia gradientearen jaitsierarekin alderatuta. Zer zuzendu eta hobetu daiteke? Ez da zaila ohartzea lehenengo iterazioetan konfiantzaz jaisten ari garela eta, hortaz, urrats handi bat utzi beharko genukeela lehenengo iterazioetan eta pausoa murriztea aurrera goazen heinean. Artikulu honetan ez dugu hau egingo - luzeegia da jada. Nahi dutenek beren kabuz pentsa dezakete nola egin, ez da zaila :)

Orain egin dezagun gradiente estokastikoa liburutegia erabiliz Zenbakia (eta ez gaitezen estropezu egin lehenago identifikatu ditugun harriekin)

Gradiente estokastikoaren jaitsierarako kodea (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

Balioak erabili gabe jaistean ia berdinak izan dira Zenbakia. Hala ere, hau logikoa da.

Ikus dezagun zenbat denbora behar izan dugun gradiente estokastikoen jaitsierek.

SGD kalkulatzeko denbora zehazteko kodea (80 mila urrats)

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)

Basoan zenbat eta gehiago sartu, orduan eta ilunagoak dira hodeiak: berriro ere, “norberak idatzitako” formulak erakusten du emaitzarik onena. Horrek guztiak iradokitzen du liburutegia erabiltzeko modu are sotilagoak izan behar direla Zenbakia, konputazio-eragiketak benetan bizkortzen dituena. Artikulu honetan ez dugu haiei buruz ikasiko. Zure aisialdian zer pentsatua egongo da :)

Laburpena dugu

Laburbildu baino lehen, ziurrenik gure irakurle maiteari sortu zitzaion galdera bati erantzun nahi nioke. Zer dela eta, hain zuzen ere, halako “tortura” jaitsierekin, zergatik ibili behar dugu mendian gora eta behera (gehienetan behera) lurzoru preziatua aurkitzeko, esku artean hain gailu indartsu eta sinple bat badugu, irtenbide analitiko baten forma, berehala telegarraiatzen gaitu Leku egokira?

Galdera honen erantzuna azalean dago. Orain oso adibide sinple bat ikusi dugu, zeinetan benetako erantzuna dagoen zeinu baten araberakoa da . Bizitzan ez duzu sarritan ikusten, beraz, pentsa dezagun 2, 30, 50 edo gehiago seinale ditugula. Gehi ditzagun milaka, edo baita hamarnaka milaka balio atributu bakoitzeko. Kasu honetan, baliteke soluzio analitikoak probari eustea eta huts egitea. Aldi berean, desnibelaren jaitsierak eta bere aldaerek poliki-poliki baina ziurtasunez helburura hurbilduko gaituzte: funtzioaren minimora. Eta ez kezkatu abiaduraz - ziurrenik urratsen luzera (hau da, abiadura) ezarri eta erregulatzeko aukera emango diguten moduak aztertuko ditugu.

Eta orain benetako laburpen laburra.

Lehenik eta behin, espero dut artikuluan aurkezten den materialak "datuen zientzialariei" hasten lagunduko diela erregresio linealaren ekuazio sinpleak (eta ez bakarrik) nola ebazten ulertzen.

Bigarrenik, ekuazioa ebazteko hainbat modu aztertu ditugu. Orain, egoeraren arabera, arazoa konpontzeko egokiena dena aukeratu dezakegu.

Hirugarrenik, ezarpen gehigarrien indarra ikusi genuen, hau da, gradientearen jaitsieraren pausoaren luzera. Parametro hau ezin da alde batera utzi. Goian esan bezala, kalkuluen kostua murrizteko, pausoen luzera aldatu behar da jaitsieran zehar.

Laugarrenik, gure kasuan, “etxean idatzitako” funtzioek kalkuluetarako denbora emaitzarik onenak erakutsi zituzten. Hau seguruenik liburutegiaren gaitasunen erabilera profesionalik ez izateagatik gertatu da Zenbakia. Baina dena dela, hurrengo ondorioak berak iradokitzen du. Alde batetik, batzuetan merezi du ezarritako iritziak zalantzan jartzea, eta, bestetik, ez du beti merezi dena konplikatzeak -aitzitik, batzuetan arazo bat konpontzeko modu sinpleago bat eraginkorragoa da-. Eta gure helburua erregresio lineal ekuazio sinple bat ebazteko hiru ikuspegi aztertzea zenez, “auto-idatzitako” funtzioen erabilera nahikoa zen guretzat.

Literatura (edo horrelako zerbait)

1. Erregresio lineala

http://statistica.ru/theory/osnovy-lineynoy-regressii/

2. Karratu txikienen metodoa

mathprofi.ru/metod_naimenshih_kvadratov.html

3. Deribatua

www.mathprofi.ru/chastnye_proizvodnye_primery.html

4. Gradientea

mathprofi.ru/proizvodnaja_po_napravleniju_i_gradient.html

5. Jaitsiera desnibela

habr.com/eu/post/471458

habr.com/eu/post/307312

artemarakcheev.com//2017-12-31/linear_regression

6. NumPy liburutegia

docs.scipy.org/doc/numpy-1.10.1/reference/generated/numpy.linalg.solve.html

docs.scipy.org/doc/numpy-1.10.0/reference/generated/numpy.linalg.pinv.html

pythonworld.ru/numpy/2.html

Iturria: www.habr.com