Kutatua mlinganyo rahisi wa urejeshaji wa mstari

Nakala hiyo inajadili njia kadhaa za kuamua usawa wa hesabu wa laini rahisi (iliyooanishwa).

Mbinu zote za kusuluhisha mlinganyo unaojadiliwa hapa zinatokana na mbinu ya angalau miraba. Wacha tuonyeshe mbinu kama ifuatavyo:

• Ufumbuzi wa uchambuzi
• Kushuka kwa Gradient
• Kushuka kwa gradient ya Stochastic

Kwa kila njia ya kutatua equation ya mstari wa moja kwa moja, makala hutoa kazi mbalimbali, ambazo zimegawanywa hasa katika zile zilizoandikwa bila kutumia maktaba. Nambari ya Pili na zile zinazotumika kwa mahesabu Nambari ya Pili. Inaaminika kuwa matumizi ya ustadi Nambari ya Pili itapunguza gharama za kompyuta.

Nambari zote zilizotolewa katika kifungu zimeandikwa kwa lugha chatu 2.7 kutumia Jupyter Daftari. Msimbo wa chanzo na faili iliyo na sampuli ya data huchapishwa Github

Nakala hiyo inalenga zaidi kwa Kompyuta na wale ambao tayari wameanza kusoma kwa uangalifu sehemu pana sana katika akili ya bandia - kujifunza kwa mashine.

Ili kufafanua nyenzo, tunatumia mfano rahisi sana.

Masharti ya mfano

Tuna maadili matano ambayo ni sifa ya utegemezi Y kutoka X (Jedwali Na. 1):

Jedwali Na. 1 "Masharti ya Mfano"

Tutafikiri kwamba maadili ni mwezi wa mwaka, na - mapato ya mwezi huu. Kwa maneno mengine, mapato inategemea mwezi wa mwaka, na - ishara pekee ambayo mapato inategemea.

Mfano ni hivyo, wote kutoka kwa mtazamo wa utegemezi wa masharti ya mapato kwa mwezi wa mwaka, na kutoka kwa mtazamo wa idadi ya maadili - kuna wachache sana. Walakini, kurahisisha kama hiyo itafanya iwezekanavyo, kama wanasema, kuelezea, sio kila wakati kwa urahisi, nyenzo ambazo waanzilishi huchukua. Na pia unyenyekevu wa nambari itawawezesha wale wanaotaka kutatua mfano kwenye karatasi bila gharama kubwa za kazi.

Wacha tufikirie kuwa utegemezi uliotolewa katika mfano unaweza kukadiriwa vizuri na hesabu ya hesabu ya laini rahisi (iliyooanishwa) ya fomu:

ambapo ni mwezi ambao mapato yalipokelewa, - mapato yanayolingana na mwezi, и ni hesabu za kirejeshi za mstari uliokadiriwa.

Kumbuka kwamba mgawo mara nyingi huitwa mteremko au gradient ya mstari unaokadiriwa; inawakilisha kiasi ambacho inapobadilika .

Kwa wazi, kazi yetu katika mfano ni kuchagua coefficients vile katika equation и , ambapo kupotoka kwa maadili yetu ya mapato yaliyohesabiwa kwa mwezi kutoka kwa majibu ya kweli, i.e. maadili yaliyowasilishwa kwenye sampuli yatakuwa ndogo.

Njia ya angalau mraba

Kulingana na njia ya angalau mraba, kupotoka kunapaswa kuhesabiwa kwa kuipiga. Mbinu hii hukuruhusu kuzuia kufutwa kwa kupotoka ikiwa wana ishara tofauti. Kwa mfano, ikiwa katika kesi moja, kupotoka ni +5 (pamoja na tano), na katika nyingine -5 (ondoa tano), basi jumla ya mikengeuko itaghairi kila mmoja na kufikia 0 (sifuri). Inawezekana si mraba kupotoka, lakini kutumia mali ya moduli na kisha kupotoka wote itakuwa chanya na kujilimbikiza. Hatutakaa juu ya hatua hii kwa undani, lakini onyesha tu kwamba kwa urahisi wa mahesabu, ni kawaida kuweka mraba kupotoka.

Hivi ndivyo fomula inavyoonekana ambayo tutaamua jumla ndogo ya mikengeuko ya mraba (makosa):

ambapo ni kazi ya kukadiria majibu ya kweli (yaani, mapato tuliyohesabu),

ni majibu ya kweli (mapato yaliyotolewa kwenye sampuli),

ni sampuli ya fahirisi (idadi ya mwezi ambayo mkengeuko umebainishwa)

Wacha tutofautishe kazi, tufafanue milinganyo ya sehemu, na tuwe tayari kuendelea na suluhisho la uchanganuzi. Lakini kwanza, hebu tuchukue safari fupi kuhusu upambanuzi ni nini na tukumbuke maana ya kijiometri ya derivative.

Utofautishaji

Utofautishaji ni utendakazi wa kutafuta derivative ya chaguo za kukokotoa.

Derivative inatumika kwa ajili gani? Derivative ya chaguo la kukokotoa ina sifa ya kiwango cha mabadiliko ya kazi na inatuambia mwelekeo wake. Ikiwa derivative katika hatua fulani ni chanya, basi kazi huongezeka; vinginevyo, kazi hupungua. Na thamani kubwa ya derivative kamili, kiwango cha juu cha mabadiliko ya maadili ya kazi, pamoja na mteremko wa grafu ya kazi.

Kwa mfano, chini ya masharti ya mfumo wa kuratibu wa Cartesian, thamani ya derivative katika hatua M(0,0) ni sawa na + 25 ina maana kwamba katika hatua fulani, wakati thamani ni kubadilishwa kulia kwa kitengo cha kawaida, thamani huongezeka kwa vitengo 25 vya kawaida. Kwenye grafu inaonekana kama ongezeko kubwa la maadili kutoka kwa hatua fulani.

Mfano mwingine. Thamani ya derivative ni sawa -0,1 ina maana kwamba wakati wa kuhamishwa kwa kitengo kimoja cha kawaida, thamani hupungua kwa kitengo cha kawaida cha 0,1 pekee. Wakati huo huo, kwenye grafu ya kazi, tunaweza kuona mteremko wa chini unaoonekana. Kuchora mlinganisho na mlima, ni kana kwamba tunashuka polepole sana kwenye mteremko mzuri kutoka kwa mlima, tofauti na mfano uliopita, ambapo tulilazimika kupanda vilele vikali sana :)

Hivyo, baada ya kutofautisha kazi kwa tabia mbaya и , tunafafanua milinganyo ya sehemu ya mpangilio wa 1. Baada ya kuamua hesabu, tutapokea mfumo wa hesabu mbili, kwa kutatua ambayo tutaweza kuchagua maadili kama haya ya coefficients. и , ambayo maadili ya derivatives sambamba katika pointi fulani hubadilika kwa kiasi kidogo sana, na katika kesi ya ufumbuzi wa uchambuzi haubadilika kabisa. Kwa maneno mengine, kazi ya hitilafu kwenye coefficients iliyopatikana itafikia kiwango cha chini, kwani maadili ya derivatives ya sehemu katika pointi hizi itakuwa sawa na sifuri.

Kwa hivyo, kulingana na sheria za kutofautisha, equation ya derivative ya sehemu ya agizo la 1 kwa heshima na mgawo. itachukua fomu:

Agizo la 1 mlinganyo wa sehemu ya derivative kwa heshima na itachukua fomu:

Kama matokeo, tulipokea mfumo wa milinganyo ambao una suluhisho rahisi la uchanganuzi:

anza{equation*}
anza{kesi}
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
mwisho{kesi}
mwisho{equation*}

Kabla ya kusuluhisha mlinganyo, wacha tupakie mapema, angalia ikiwa upakiaji ni sahihi, na umbizo la data.

Inapakia na kupangilia data

Ikumbukwe kwamba kwa sababu ya ukweli kwamba kwa suluhisho la uchambuzi, na baadaye kwa asili ya gradient na stochastic, tutatumia nambari katika tofauti mbili: kwa kutumia maktaba. Nambari ya Pili na bila kuitumia, basi tutahitaji umbizo sahihi la data (tazama msimbo).

Upakiaji na msimbo wa usindikaji wa data

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

Visualization

Sasa, baada ya sisi, kwanza, kupakia data, pili, kuangalia usahihi wa upakiaji na hatimaye kupangilia data, tutafanya taswira ya kwanza. Njia inayotumiwa mara nyingi kwa hii ni kiwanja maktaba Mzaliwa wa kwanza. Katika mfano wetu, kwa sababu ya idadi ndogo, hakuna maana katika kutumia maktaba Mzaliwa wa kwanza. Tutatumia maktaba ya kawaida matplotlib na angalia tu eneo la kutawanyika.

Msimbo wa 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()

Chati Na. 1 "Utegemezi wa mapato kwa mwezi wa mwaka"

Ufumbuzi wa uchambuzi

Wacha tutumie zana zinazojulikana zaidi python na kutatua mfumo wa equations:

anza{equation*}
anza{kesi}
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
mwisho{kesi}
mwisho{equation*}

Kulingana na sheria ya Cramer tutapata kiambishi cha jumla, na vile vile vibainishi kwa na kwa , baada ya hapo, kugawanya kiangazi kwa kwa kiambishi cha jumla - pata mgawo , vile vile tunapata mgawo .

Nambari ya suluhisho la uchambuzi

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

Hivi ndivyo tulivyopata:

Kwa hivyo, maadili ya coefficients yamepatikana, jumla ya kupotoka kwa mraba imeanzishwa. Hebu tuchore mstari wa moja kwa moja kwenye histogram ya kueneza kwa mujibu wa coefficients zilizopatikana.

Regression line code

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

Chati Na. 2 “Majibu Sahihi na yaliyokokotolewa”

Unaweza kuangalia grafu ya kupotoka kwa kila mwezi. Kwa upande wetu, hatutapata thamani yoyote muhimu ya kiutendaji kutoka kwayo, lakini tutakidhi udadisi wetu kuhusu jinsi mlinganyo rahisi wa urejeshaji wa mstari unaonyesha utegemezi wa mapato kwa mwezi wa mwaka.

Msimbo wa chati ya kupotoka

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

Chati Na. 3 “Mikengeuko, %”

Sio kamili, lakini tulikamilisha kazi yetu.

Hebu tuandike kazi ambayo, ili kuamua coefficients и hutumia maktaba Nambari ya Pili, kwa usahihi zaidi, tutaandika kazi mbili: moja kwa kutumia matrix ya pseudoinverse (haipendekezi katika mazoezi, kwa kuwa mchakato huo ni mgumu wa computationally na usio imara), mwingine kwa kutumia equation ya matrix.

Msimbo wa Suluhisho la Uchanganuzi (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

Hebu tulinganishe muda uliotumika katika kuamua coefficients и , kwa mujibu wa mbinu 3 zilizowasilishwa.

Msimbo wa kuhesabu wakati wa kuhesabu

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)

Kwa kiasi kidogo cha data, kazi ya "kujiandika" inatoka mbele, ambayo hupata coefficients kwa kutumia njia ya Cramer.

Sasa unaweza kuendelea na njia zingine za kupata coefficients и .

Kushuka kwa Gradient

Kwanza, hebu tufafanue gradient ni nini. Kwa ufupi, gradient ni sehemu inayoonyesha mwelekeo wa ukuaji wa juu wa kazi. Kwa mlinganisho na kupanda mlima, ambapo gradient inakabiliwa ndipo mahali palipo na mwinuko mkubwa zaidi wa kupanda mlima. Kuendeleza mfano na mlima, tunakumbuka kwamba kwa kweli tunahitaji asili ya mwinuko zaidi ili kufikia nyanda za chini haraka iwezekanavyo, yaani, kiwango cha chini - mahali ambapo kazi haizidi au kupungua. Katika hatua hii derivative itakuwa sawa na sifuri. Kwa hiyo, hatuhitaji gradient, lakini antigradient. Ili kupata antigradient unahitaji tu kuzidisha upinde rangi kwa -1 (ondoa moja).

Wacha tuzingatie ukweli kwamba kazi inaweza kuwa na minima kadhaa, na baada ya kushuka kwenye moja yao kwa kutumia algorithm iliyopendekezwa hapa chini, hatutaweza kupata kiwango kingine cha chini, ambacho kinaweza kuwa chini kuliko ile iliyopatikana. Wacha tupumzike, hii sio tishio kwetu! Kwa upande wetu tunashughulika na kiwango cha chini kimoja, tangu kazi yetu kwenye grafu ni parabola ya kawaida. Na kama sote tunapaswa kujua vyema kutoka kwa kozi yetu ya hisabati ya shule, parabola ina kiwango cha chini kimoja tu.

Baada ya kujua ni kwanini tulihitaji gradient, na pia kwamba gradient ni sehemu, ambayo ni, vekta iliyo na viwianishi vilivyopewa, ambavyo ni coefficients sawa. и tunaweza kutekeleza kushuka kwa gradient.

Kabla ya kuanza, ninapendekeza kusoma sentensi chache tu juu ya algorithm ya asili:

• Tunaamua kwa namna ya pseudo-random viwianishi vya coefficients и . Katika mfano wetu, tutaamua coefficients karibu na sifuri. Hii ni mazoezi ya kawaida, lakini kila kesi inaweza kuwa na mazoezi yake mwenyewe.
• Kutoka kwa kuratibu toa thamani ya agizo la 1 sehemu ya derivative katika uhakika . Kwa hivyo, ikiwa derivative ni chanya, basi kazi huongezeka. Kwa hiyo, kwa kuondoa thamani ya derivative, tutahamia kinyume cha ukuaji, yaani, katika mwelekeo wa asili. Ikiwa derivative ni hasi, basi kazi katika hatua hii inapungua na kwa kupunguza thamani ya derivative tunahamia kwenye mwelekeo wa kushuka.
• Tunafanya operesheni sawa na kuratibu : toa thamani ya sehemu ya derivative katika uhakika .
• Ili sio kuruka juu ya kiwango cha chini na kuruka kwenye nafasi ya kina, ni muhimu kuweka ukubwa wa hatua katika mwelekeo wa asili. Kwa ujumla, unaweza kuandika makala nzima kuhusu jinsi ya kuweka hatua kwa usahihi na jinsi ya kuibadilisha wakati wa mchakato wa kushuka ili kupunguza gharama za computational. Lakini sasa tuna kazi tofauti kidogo mbele yetu, na tutaanzisha saizi ya hatua kwa kutumia njia ya kisayansi ya "poke" au, kama wanasema kwa lugha ya kawaida, kwa nguvu.
• Mara tu tunapotoka kwa kuratibu zilizopewa и toa maadili ya derivatives, tunapata kuratibu mpya и . Tunachukua hatua inayofuata (kutoa), tayari kutoka kwa kuratibu zilizohesabiwa. Na hivyo mzunguko huanza tena na tena, mpaka muunganisho unaohitajika unapatikana.

Wote! Sasa tuko tayari kwenda kutafuta kijito chenye kina kirefu zaidi cha Mariana Trench. Tuanze.

Msimbo wa kushuka kwa gradient

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

Tulipiga mbizi hadi chini kabisa ya Mariana Trench na hapo tukapata thamani zote zile zile za mgawo и , ambayo ndiyo hasa ilitarajiwa.

Wacha tupige mbizi nyingine, wakati huu tu, gari letu la bahari kuu litajazwa na teknolojia zingine, yaani maktaba. Nambari ya Pili.

Msimbo wa kushuka kwa daraja (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

Thamani za mgawo и isiyobadilika.

Wacha tuangalie jinsi kosa lilibadilika wakati wa kushuka kwa upinde rangi, ambayo ni, jinsi jumla ya mikengeuko ya mraba ilibadilika kwa kila hatua.

Msimbo wa kupanga hesabu za mikengeuko ya mraba

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()

Grafu Na. 4 "Jumla ya mikengeuko ya mraba wakati wa kushuka kwa upinde rangi"

Kwenye grafu tunaona kwamba kwa kila hatua kosa hupungua, na baada ya idadi fulani ya marudio tunaona mstari wa karibu wa usawa.

Mwishowe, wacha tukadirie tofauti katika wakati wa utekelezaji wa nambari:

Msimbo wa kubainisha muda wa ukokotoaji wa mteremko wa daraja

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)

Labda tunafanya kitu kibaya, lakini tena ni kazi rahisi ya "iliyoandikwa nyumbani" ambayo haitumii maktaba. Nambari ya Pili hufaulu kuliko muda wa hesabu wa chaguo za kukokotoa kwa kutumia maktaba Nambari ya Pili.

Lakini hatujasimama tuli, lakini tunasonga mbele kuelekea kusoma njia nyingine ya kusisimua ya kutatua mlingano rahisi wa rejista ya mstari. Kutana!

Kushuka kwa gradient ya Stochastic

Ili kuelewa haraka kanuni ya uendeshaji wa asili ya gradient ya stochastic, ni bora kuamua tofauti zake kutoka kwa asili ya kawaida ya gradient. Sisi, kwa upande wa ukoo wa gradient, katika milinganyo ya derivatives ya и ilitumia jumla ya maadili ya vipengele vyote na majibu ya kweli yanayopatikana kwenye sampuli (yaani, jumla ya yote. и ) Katika asili ya gradient ya stochastic, hatutatumia maadili yote yaliyopo kwenye sampuli, lakini badala yake, chagua kwa nasibu kinachojulikana index index na kutumia maadili yake.

Kwa mfano, ikiwa index imedhamiriwa kuwa nambari 3 (tatu), basi tunachukua maadili и , kisha tunabadilisha thamani katika milinganyo ya derivative na kuamua viwianishi vipya. Kisha, baada ya kuamua kuratibu, tunaamua tena kwa bahati nasibu faharisi ya sampuli, kubadilisha maadili yanayolingana na faharisi katika hesabu za tofauti za sehemu, na kuamua kuratibu kwa njia mpya. и na kadhalika. mpaka muunganiko unageuka kijani. Kwa mtazamo wa kwanza, inaweza kuonekana kuwa hii inaweza kufanya kazi hata kidogo, lakini inafanya kazi. Ni kweli kwamba inafaa kuzingatia kwamba kosa halipunguzi kwa kila hatua, lakini hakika kuna mwelekeo.

Je, ni faida gani za kushuka kwa gradient ya stochastic kuliko ile ya kawaida? Ikiwa saizi yetu ya sampuli ni kubwa sana na inapimwa katika makumi ya maelfu ya thamani, basi ni rahisi zaidi kuchakata, tuseme, elfu moja kati yao, badala ya sampuli nzima. Hapa ndipo asili ya stochastic gradient inahusika. Kwa upande wetu, bila shaka, hatutaona tofauti nyingi.

Hebu tuangalie kanuni.

Msimbo wa kushuka kwa gradient ya stochastic

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

Tunaangalia kwa uangalifu coefficients na tunajikuta tukiuliza swali "Hii inawezaje kuwa?" Tulipata maadili mengine ya mgawo и . Labda asili ya gradient ya stochastic imepata vigezo bora zaidi vya equation? Kwa bahati mbaya hapana. Inatosha kuangalia jumla ya kupotoka kwa mraba na kuona kwamba kwa maadili mapya ya coefficients, kosa ni kubwa zaidi. Hatuna haraka ya kukata tamaa. Wacha tujenge grafu ya mabadiliko ya makosa.

Msimbo wa kupanga jumla ya mikengeuko ya mraba katika asili ya gradient ya stochastiki

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()

Grafu Na. 5 "Jumla ya mikengeuko ya mraba wakati wa kushuka kwa daraja la stochastiki"

Kuangalia ratiba, kila kitu kinaanguka mahali na sasa tutarekebisha kila kitu.

Basi nini kilitokea? Ifuatayo ilitokea. Tunapochagua mwezi kwa nasibu, basi ni kwa mwezi uliochaguliwa ambapo kanuni yetu inatafuta kupunguza hitilafu katika kuhesabu mapato. Kisha tunachagua mwezi mwingine na kurudia hesabu, lakini tunapunguza kosa kwa mwezi wa pili uliochaguliwa. Sasa kumbuka kwamba miezi miwili ya kwanza inapotoka kwa kiasi kikubwa kutoka kwa mstari wa mlinganyo rahisi wa rejista wa mstari. Hii ina maana kwamba wakati wowote wa miezi hii miwili imechaguliwa, kwa kupunguza makosa ya kila mmoja wao, algorithm yetu huongeza kwa uzito makosa kwa sampuli nzima. Basi nini cha kufanya? Jibu ni rahisi: unahitaji kupunguza hatua ya kushuka. Baada ya yote, kwa kupunguza hatua ya kushuka, kosa pia litaacha "kuruka" juu na chini. Au tuseme, hitilafu ya "kuruka" haitaacha, lakini haitafanya haraka sana :) Hebu tuchunguze.

Msimbo wa kuendesha SGD na nyongeza ndogo

# запустим функцию, уменьшив шаг в 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()

Grafu Na. 6 "Jumla ya mikengeuko ya mraba wakati wa kushuka kwa gradient ya stochastic (hatua elfu 80)"

Coefficients imeboreshwa, lakini bado sio bora. Hypothetically, hii inaweza kusahihishwa kwa njia hii. Tunachagua, kwa mfano, katika marudio 1000 ya mwisho maadili ya coefficients ambayo kosa la chini lilifanywa. Kweli, kwa hili tutalazimika pia kuandika maadili ya coefficients wenyewe. Hatutafanya hivi, lakini badala yake makini na ratiba. Inaonekana laini na kosa linaonekana kupungua sawasawa. Kwa kweli hii si kweli. Wacha tuangalie marudio 1000 ya kwanza na tuyalinganishe na ya mwisho.

Msimbo wa chati ya SGD (hatua 1000 za kwanza)

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()

Grafu Na. 7 "Jumla ya mikengeuko ya mraba SGD (hatua 1000 za kwanza)"

Grafu Na. 8 "Jumla ya mikengeuko ya mraba SGD (hatua 1000 za mwisho)"

Mwanzoni mwa asili, tunaona upungufu wa usawa na mwinuko wa makosa. Katika marudio ya mwisho, tunaona kwamba kosa linazunguka na kuzunguka thamani ya 1,475 na wakati fulani hata ni sawa na thamani hii bora, lakini bado inaongezeka ... narudia, unaweza kuandika maadili ya mgawo и , na kisha uchague zile ambazo kosa ni ndogo. Walakini, tulikuwa na shida kubwa zaidi: tulilazimika kuchukua hatua elfu 80 (tazama nambari) kupata maadili karibu na bora. Na hii tayari inapingana na wazo la kuokoa wakati wa hesabu na asili ya gradient ya stochastic inayohusiana na asili ya gradient. Ni nini kinachoweza kusahihishwa na kuboreshwa? Sio ngumu kugundua kuwa katika marudio ya kwanza tunashuka kwa ujasiri na, kwa hivyo, tunapaswa kuacha hatua kubwa katika marudio ya kwanza na kupunguza hatua tunaposonga mbele. Hatutafanya hivyo katika makala hii - tayari ni ndefu sana. Wale wanaotaka wanaweza kufikiria wenyewe jinsi ya kufanya hivyo, sio ngumu :)

Sasa wacha tutekeleze mteremko wa upinde wa mvua wa stochastiki kwa kutumia maktaba Nambari ya Pili (na tusijikwae juu ya mawe tuliyoainisha hapo awali)

Msimbo wa Kushuka kwa Gradient ya Stochastic (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

Thamani ziligeuka kuwa karibu sawa na wakati wa kushuka bila kutumia Nambari ya Pili. Hata hivyo, hii ni mantiki.

Wacha tujue ni muda gani kushuka kwa gradient ya stochastic kulichukua sisi.

Nambari ya kuamua wakati wa kuhesabu SGD (hatua elfu 80)

print ' 33[1m' + ' 33[4m' +
"Время выполнения стохастического градиентного спуска без использования библиотеки NumPy:"
+ ' 33[0m'
%timeit list_parametres_stoch_gradient_descence = stoch_grad_descent_usual(x_us, y_us, l=0.001, steps = 80000)
print '***************************************'
print

print ' 33[1m' + ' 33[4m' +
"Время выполнения стохастического градиентного спуска с использованием библиотеки NumPy:"
+ ' 33[0m'
%timeit list_parametres_stoch_gradient_descence = stoch_grad_descent_numpy(x_np, y_np, l=0.001, steps = 80000)

Zaidi ndani ya msitu, mawingu nyeusi zaidi: tena, formula "iliyojiandikisha" inaonyesha matokeo bora. Haya yote yanapendekeza kwamba lazima kuwe na njia za hila zaidi za kutumia maktaba Nambari ya Pili, ambayo huharakisha shughuli za hesabu. Katika makala hii hatutajifunza juu yao. Kutakuwa na kitu cha kufikiria wakati wako wa ziada :)

Muhtasari

Kabla ya kufanya muhtasari, ningependa kujibu swali ambalo huenda likazuka kutoka kwa msomaji wetu mpendwa. Kwa nini, kwa kweli, "mateso" kama haya na asili, kwa nini tunahitaji kutembea juu na chini ya mlima (haswa chini) ili kupata eneo la chini la hazina, ikiwa tunayo kifaa chenye nguvu na rahisi mikononi mwetu. aina ya suluhu la uchanganuzi, ambalo hutusafirisha mara moja hadi mahali Pazuri?

Jibu la swali hili liko juu ya uso. Sasa tumeangalia mfano rahisi sana, ambao jibu la kweli ni inategemea ishara moja . Huwezi kuona hili mara nyingi katika maisha, basi hebu fikiria kwamba tuna 2, 30, 50 au zaidi ishara. Wacha tuongeze kwa hii maelfu, au hata makumi ya maelfu ya maadili kwa kila sifa. Katika kesi hii, suluhisho la uchambuzi haliwezi kuhimili mtihani na kushindwa. Kwa upande mwingine, kushuka kwa upinde rangi na tofauti zake kutatuleta polepole lakini kwa hakika karibu na lengo - kiwango cha chini cha utendaji. Na usijali kuhusu kasi - labda tutaangalia njia ambazo zitaturuhusu kuweka na kudhibiti urefu wa hatua (hiyo ni kasi).

Na sasa muhtasari mfupi halisi.

Kwanza, natumai kuwa nyenzo zilizowasilishwa katika kifungu zitasaidia kuanza "wanasayansi wa data" katika kuelewa jinsi ya kutatua hesabu rahisi (na sio tu) za urekebishaji wa mstari.

Pili, tuliangalia njia kadhaa za kutatua equation. Sasa, kulingana na hali hiyo, tunaweza kuchagua moja ambayo inafaa zaidi kutatua tatizo.

Tatu, tuliona nguvu ya mipangilio ya ziada, ambayo ni urefu wa hatua ya kushuka kwa gradient. Kigezo hiki hakiwezi kupuuzwa. Kama ilivyoonyeshwa hapo juu, ili kupunguza gharama ya mahesabu, urefu wa hatua unapaswa kubadilishwa wakati wa kushuka.

Nne, kwa upande wetu, kazi "zilizoandikwa nyumbani" zilionyesha matokeo bora ya wakati wa mahesabu. Labda hii ni kwa sababu ya kutokuwa na utumiaji wa kitaalamu zaidi wa uwezo wa maktaba Nambari ya Pili. Lakini iwe hivyo, hitimisho lifuatalo linajipendekeza. Kwa upande mmoja, wakati mwingine inafaa kuhoji maoni yaliyowekwa, na kwa upande mwingine, haifai kila wakati kugumu kila kitu - badala yake, wakati mwingine njia rahisi ya kutatua shida ni nzuri zaidi. Na kwa kuwa lengo letu lilikuwa kuchanganua mbinu tatu za kusuluhisha mlinganyo rahisi wa rejista ya mstari, matumizi ya vitendaji "vya kujiandikia" yalitutosha kabisa.

Fasihi (au kitu kama hicho)

1. Urejeshaji wa mstari

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

2. Njia ya angalau mraba

mathprofi.ru/metod_naimenshih_kvadratov.html

3. Derivative

www.mathprofi.ru/chastnye_proizvodnye_primery.html

4. Nzuri

mathprofi.ru/proizvodnaja_po_napravleniju_i_gradient.html

5. Kushuka kwa gradient

habr.com/sw/post/471458

habr.com/sw/post/307312

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

6. maktaba ya NumPy

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

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

pythonworld.ru/numpy/2.html

Chanzo: mapenzi.com