🥇 Warware ma'auni na koma baya na layi mai sauƙi

Labarin ya tattauna hanyoyi da yawa don ƙayyade ma'auni na lissafi na layi mai sauƙi (haɗe-haɗe).

Duk hanyoyin warware lissafin da aka tattauna anan sun dogara ne akan mafi ƙarancin hanyar murabba'i. Bari mu nuna hanyoyin kamar haka:

Magani na nazari
Saukowar Gradient
Saukowar gradient na Stochastic

Ga kowace hanyar warware ma'auni na madaidaiciyar layi, labarin yana ba da ayyuka daban-daban, waɗanda galibi an raba su zuwa waɗanda aka rubuta ba tare da amfani da ɗakin karatu ba. Lambobi da wadanda suke amfani da lissafi Lambobi. An yi imani da cewa yin amfani da gwaninta Lambobi zai rage farashin kwamfuta.

Duk lambar da aka bayar a cikin labarin an rubuta su cikin harshe Python 2.7 amfani Jupyter Notebook. Ana buga lambar tushe da fayil tare da bayanan samfurin akan Github

Labarin ya fi niyya ga masu farawa da kuma waɗanda a hankali suka fara ƙware kan nazarin wani yanki mai fa'ida a cikin hankali na wucin gadi - koyan na'ura.

Don kwatanta abin, muna amfani da misali mai sauƙi.

Misali yanayi

Muna da dabi'u guda biyar waɗanda ke nuna dogaro Y daga X (Table No. 1):

Tebur Na 1 "Misali Sharuɗɗan"

Za mu ɗauka cewa dabi'u shine watan shekara, kuma - kudaden shiga a wannan watan. A takaice dai, kudaden shiga ya dogara da watan shekara, kuma - kawai alamar abin da kudaden shiga ya dogara.

Misali shi ne haka-haka, duka daga mahangar ra'ayi na dogaro da sharadi na kudaden shiga a watan shekara, kuma daga ra'ayi na adadin dabi'u - akwai kadan daga cikinsu. Duk da haka, irin wannan sauƙi zai sa ya yiwu, kamar yadda suke faɗa, don bayyanawa, ba koyaushe tare da sauƙi ba, kayan da masu farawa ke haɗuwa. Har ila yau, sauƙi na lambobi zai ba da damar waɗanda suke so su warware misali a kan takarda ba tare da mahimmancin farashin aiki ba.

Bari mu ɗauka cewa dogara da aka bayar a cikin misalin za a iya kusantar da shi da kyau ta hanyar lissafin lissafi na layi mai sauƙi (nau'i-nau'i) na regression na nau'i:

inda shine watan da aka samu kudaden shiga. - kudaden shiga daidai da watan, и su ne regression coefficients na kimanta layin.

Lura cewa coefficient sau da yawa ana kiransa gangara ko gradient na layin da aka kiyasta; wakiltar adadin da abin da idan ya canza .

Babu shakka, aikinmu a cikin misalin shine zabar irin waɗannan ƙididdiga a cikin ma'auni и , inda karkatattun kididdigar kudaden shiga ta wata-wata daga amsoshi na gaskiya, watau. dabi'un da aka gabatar a cikin samfurin za su kasance kadan.

Hanyar murabba'i mafi ƙarancin

Bisa ga mafi ƙarancin hanyar murabba'i, ya kamata a ƙididdige ɓarna ta hanyar squaring shi. Wannan dabarar tana ba ku damar guje wa sokewar juna idan suna da alamun sabani. Misali, idan a cikin wani hali, karkatacciyar hanya ce +5 (da biyar), da sauran -5 (a debe biyar), sannan jimlar karkatattun za su soke juna kuma su kai 0 (sifili). Ba dole ba ne ku yi maƙasudin ɓarna, amma ku yi amfani da kayan modules sannan duk karkacewar za su kasance tabbatacce kuma za su tara. Ba za mu tsaya a kan wannan batu daki-daki ba, amma kawai nuna cewa don dacewa da ƙididdiga, al'ada ne don daidaitawa.

Wannan shine yadda dabarar ta yi kama da wacce za mu tantance mafi ƙarancin jimlar sabawa murabba'i (kurakurai):

inda aiki ne na kusantar amsoshin gaskiya (wato, kudaden shiga da muka ƙididdigewa),

amsoshi na gaskiya ne (kudaden da aka bayar a cikin samfurin),

shine ma'aunin samfurin (yawan watan da aka ƙayyade karkacewar)

Bari mu bambance aikin, mu ayyana ma'auni na banbanci, kuma mu kasance cikin shiri don matsawa zuwa mafita na nazari. Amma da farko, bari mu ɗauki ɗan gajeren balaguron balaguro game da mene ne banbancewa kuma mu tuna ma'anar jigon jigon.

Bambance-bambance

Bambance-bambance shine aikin nemo abin da aka samu na aiki.

Menene abin da ake amfani dashi? Asalin aikin yana nuna ƙimar canjin aikin kuma yana gaya mana alkiblarsa. Idan abin da aka samo asali a wurin da aka ba shi yana da inganci, to aikin yana ƙaruwa, in ba haka ba, aikin yana raguwa. Kuma mafi girman ƙimar cikakkiyar abin da aka samo asali, mafi girman ƙimar canjin dabi'un ayyuka, haka kuma mafi girman gangaren jadawalin aikin.

Misali, a ƙarƙashin yanayin tsarin haɗin gwiwar Cartesian, ƙimar abin da aka samo asali a wurin M(0,0) daidai yake da + 25 yana nufin cewa a wani batu, lokacin da aka canza darajar zuwa dama ta naúrar ta al'ada, ƙima yana ƙaruwa da raka'a 25 na al'ada. A kan jadawali yana kama da tsayi mai tsayi a cikin ƙima daga wani batu.

Wani misali. Ƙimar da aka samu daidai take -0,1 yana nufin cewa lokacin da aka ƙaura kowace naúrar al'ada ɗaya, ƙima yana raguwa da kashi 0,1 na al'ada kawai. A lokaci guda, a kan jadawali na aikin, za mu iya ganin wani gangare da ba a iya gani da kyar. Zana kwatanci da dutse, kamar muna saukowa a hankali a hankali daga dutsen, sabanin misalin da ya gabata, inda muka hau tudu masu tsayi :)

Don haka, bayan bambance aikin ta rashin daidaito и , Mun ayyana oda na 1st na juzu'i daban-daban. Bayan kayyade ma'auni, za mu sami tsarin ma'auni guda biyu, ta hanyar warwarewa wanda za mu iya zaɓar irin waɗannan ƙimar ƙididdiga. и , wanda darajar abubuwan da suka dace a wuraren da aka ba su suna canzawa da ɗan ƙaramin adadi, kuma a cikin yanayin bayani na nazari ba ya canzawa ko kaɗan. A takaice dai, aikin kuskure a cikin ƙididdiga da aka samo zai kai mafi ƙanƙanta, tunda ƙimar abubuwan da aka samo asali a waɗannan maki za su kasance daidai da sifili.

Don haka, bisa ga ka'idodin bambance-bambance, ma'auni mai ban sha'awa na tsari na 1st dangane da ƙima. zai dauki form:

1st oda partivative equation game da zai dauki form:

A sakamakon haka, mun sami tsarin daidaitawa wanda ke da mafita mai sauƙi mai sauƙi:

fara {equation*}
fara{harkoki}
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
karshen{harsashi}
karshen {equation*}

Kafin warware lissafin, bari mu fara lodawa, duba cewa lodin daidai ne, sannan mu tsara bayanan.

Loading da tsara bayanai

Ya kamata a lura cewa saboda gaskiyar cewa don bayani na nazari, kuma daga baya don gradient da stochastic gradient zuriya, za mu yi amfani da lambar a cikin bambance-bambancen guda biyu: ta amfani da ɗakin karatu. Lambobi kuma ba tare da amfani da shi ba, to za mu buƙaci tsara bayanan da suka dace (duba lambar).

Loda bayanai da lambar sarrafawa

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

Nunawa

Yanzu, bayan da muka yi, da farko, mun loda bayanan, na biyu, bincika daidaiton kayan aikin kuma a ƙarshe mun tsara bayanan, za mu aiwatar da hangen nesa na farko. Hanyar da ake amfani da ita don wannan ita ce shirin biyu dakunan karatu Jirgin ruwa. A cikin misalinmu, saboda ƙayyadaddun lambobi, babu ma'ana a amfani da ɗakin karatu Jirgin ruwa. Za mu yi amfani da ɗakin karatu na yau da kullum matplotlib sannan ka kalli inda ake watsawa.

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

Chart No. 1 "Dogara na kudaden shiga a watan shekara"

Magani na nazari

Bari mu yi amfani da kayan aikin gama gari a ciki python da warware tsarin daidaitawa:

fara {equation*}
fara{harkoki}
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
karshen{harsashi}
karshen {equation*}

Bisa ga tsarin Cramer za mu nemo maƙasudin ƙayyadaddun ƙayyadaddun ƙayyadaddun ƙayyadaddun ƙayyadaddun ƙayyadaddun ƙayyadaddun bayanai ta hanyar kuma ta , bayan haka, rarraba mai ƙayyade ta zuwa ga maƙasudin gabaɗaya - nemo ƙididdiga , Hakazalika muna samun coefficient .

Lambar bayani na nazari

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

Ga abin da muka samu:

Don haka, an samo ƙididdiga na ƙididdiga, an kafa jimillar ma'auni. Bari mu zana madaidaicin layi akan rarrabuwa histogram daidai da abubuwan da aka samo.

Layin layi na koma baya

# определим функцию для формирования массива рассчетных значений выручки
def sales_count(ab,x,y):
    line_answers = []
    [line_answers.append(ab[0]+ab[1]*x[i]) for i in range(len(x))]
    return line_answers

# построим графики
print 'Грфик№2 "Правильные и расчетные ответы"'
plt.plot(x_us,y_us,'o',color='green',markersize=16, label = '$True$ $answers$')
plt.plot(x_us, sales_count(ab_us,x_us,y_us), color='red',lw=4,
         label='$Function: a + bx,$ $where$ $a='+str(round(ab_us[0],2))+',$ $b='+str(round(ab_us[1],2))+'$')
plt.xlabel('$Months$', size=16)
plt.ylabel('$Sales$', size=16)
plt.legend(loc=1, prop={'size': 16})
plt.show()

Chart No. 2 "Amsoshi Daidai da ƙididdiga"

Kuna iya duba jadawali na kowane wata. A cikin yanayinmu, ba za mu sami wata muhimmiyar ƙima mai amfani daga gare ta ba, amma za mu gamsar da sha'awarmu game da yadda daidaitaccen ma'auni mai sauƙi na koma baya ya kwatanta dogaron kudaden shiga ga watan shekara.

Lambar ginshiƙi na karkata

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

Jadawalin Lamba. 3 "Ra'ayi, %"

Ba cikakke ba, amma mun kammala aikinmu.

Bari mu rubuta wani aiki wanda, don ƙayyade ƙididdiga и yana amfani da ɗakin karatu Lambobi, mafi daidai, za mu rubuta ayyuka guda biyu: ɗaya ta amfani da matrix pseudoinverse (ba a ba da shawarar yin aiki ba, tun da tsarin yana da rikitarwa da rashin daidaituwa), ɗayan ta amfani da matrix equation.

Lambar Magani na Nazari (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

Bari mu kwatanta lokacin da aka kashe don tantance ƙididdiga и , daidai da hanyoyin 3 da aka gabatar.

Lambar don ƙididdige lokacin lissafin

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)

Tare da ƙaramin adadin bayanai, aikin "rubuta kansa" yana fitowa gaba, wanda ke gano ƙididdiga ta amfani da hanyar Cramer.

Yanzu zaku iya matsawa zuwa wasu hanyoyin don nemo ƙididdiga и .

Saukowar Gradient

Da farko, bari mu ayyana menene gradient. A taƙaice, gradient yanki ne wanda ke nuna alkiblar girman girman aiki. Ta hanyar kwatankwacin hawa dutsen, inda fuskokin ƙwaƙƙwaran su ne inda mafi girman hawan dutsen yake. Samar da misali tare da dutsen, mun tuna cewa a gaskiya muna buƙatar gangara mai zurfi don isa ga ƙananan ƙasa da sauri, wato, mafi ƙanƙanta - wurin da aikin ba ya karuwa ko raguwa. A wannan lokacin abin da aka samo asali zai zama daidai da sifili. Saboda haka, ba mu buƙatar gradient, amma antigradient. Don nemo antigradient kawai kuna buƙatar ninka gradient ta -1 (rasa daya).

Bari mu kula da gaskiyar cewa wani aiki na iya samun minima da yawa, kuma tun da ya sauko cikin ɗayan su ta amfani da algorithm da aka tsara a ƙasa, ba za mu iya samun wani ƙarami ba, wanda zai iya zama ƙasa da wanda aka samo. Mu huta, wannan ba barazana ce gare mu ba! A cikin yanayinmu muna ma'amala da ƙaramin ƙarami, tunda aikinmu a kan jadawali ne na yau da kullum parabola. Kuma kamar yadda ya kamata mu sani sosai daga kwas ɗin ilimin lissafi na makaranta, parabola yana da ƙarami ɗaya kawai.

Bayan mun gano dalilin da ya sa muke buƙatar gradient, da kuma cewa gradient yanki ne, wato, vector tare da haɗin gwiwar da aka ba da, wanda daidai yake daidai da coefficients iri ɗaya. и za mu iya aiwatar da zuriyar gradient.

Kafin farawa, Ina ba da shawarar karanta kawai ƴan jimloli game da zuriyar algorithm:

Muna ƙididdige ƙididdiga ta hanyar bazuwar hanyar haɗin gwiwar mahaɗaɗɗen и . A cikin misalinmu, za mu ayyana ƙididdiga kusa da sifili. Wannan al'ada ce ta gama gari, amma kowane lamari yana iya samun nasa aikin.
Daga daidaitawa cire darajar oda ta 1 part partivative a batu . Don haka, idan abin da aka samo asali ya tabbata, to aikin yana ƙaruwa. Saboda haka, ta hanyar rage darajar abin da aka samo asali, za mu matsa zuwa wani bangare na girma, wato, a hanyar gangarawa. Idan abin da aka samo asali ya kasance mara kyau, to aikin a wannan lokacin yana raguwa kuma ta hanyar rage darajar abin da aka samo asali muna matsawa zuwa hanyar zuriya.
Muna yin irin wannan aiki tare da haɗin gwiwar : cire darajar abin da aka samo asali a wurin .
Don kada ku yi tsalle a kan mafi ƙanƙanta kuma ku tashi zuwa sararin samaniya mai zurfi, yana da muhimmanci a saita girman mataki a cikin hanyar saukowa. Gabaɗaya, zaku iya rubuta labarin gabaɗaya game da yadda ake saita matakin daidai da yadda ake canza shi yayin tsarin saukowa don rage farashin lissafi. Amma yanzu muna da wani aiki daban a gabanmu, kuma za mu kafa girman matakin ta hanyar amfani da hanyar kimiyya ta “poke” ko, kamar yadda suke faɗa a cikin yaren gama gari, a zahiri.
Da zarar mun kasance daga haɗin gwiwar da aka ba и cire dabi'u na abubuwan da aka samo asali, muna samun sabbin hanyoyin daidaitawa и . Muna ɗaukar mataki na gaba (ragi) riga daga madaidaitan ƙididdiga. Sabili da haka sake zagayowar yana farawa akai-akai, har sai an sami haɗin kai da ake buƙata.

Duka! Yanzu muna shirye mu je neman mafi zurfin kwazazzabo na Mariana Trench. Mu fara.

Lambar don saukowar 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

Mun nutse zuwa kasan maharbin Mariana kuma a can muka sami duk ƙimar ƙima iri ɗaya и , wanda shine ainihin abin da ake tsammani.

Mu sake nitsewa, sai a wannan karon, motar mu mai zurfin teku za ta cika da wasu fasahohi, wato dakin karatu. Lambobi.

Lambar don zuriyar gradient (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

Ƙimar ƙima и maras canzawa.

Bari mu kalli yadda kuskuren ya canza a lokacin saukar gradient, wato, yadda jimillar ɓangarorin murabba'i suka canza tare da kowane mataki.

Lambar don ƙirƙira jimlar sabawa murabba'i

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

Hoton Lamba 4 “Tallakar karkatattun madaidaicin murabba'i yayin saukowar gradient"

A kan jadawali muna ganin cewa tare da kowane mataki kuskuren yana raguwa, kuma bayan wasu adadin adadin za mu lura da layin kusan kwance.

A ƙarshe, bari mu ƙididdige bambancin lokacin aiwatar da code:

Lambar don tantance lokacin ƙididdigewar ƙasa

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)

Wataƙila muna yin wani abu ba daidai ba, amma kuma aiki ne mai sauƙi "rubuta gida" wanda baya amfani da ɗakin karatu. Lambobi ya zarce lokacin lissafin aiki ta amfani da ɗakin karatu Lambobi.

Amma ba mu tsaya cak ba, amma muna matsawa zuwa nazarin wata hanya mai ban sha'awa don warware ma'auni mai sauƙi na koma baya. Haɗu!

Saukowar gradient na Stochastic

Domin da sauri fahimtar ka'idar aiki na stochastic gradient zuriya, shi ne mafi alhẽri a ƙayyade ta bambance-bambance daga talakawa gradient zuriya. Mu, a cikin yanayin zuriyar gradient, a cikin ma'auni na abubuwan da aka samo daga и yayi amfani da jimillar kimar duk fasalulluka da amsoshi na gaskiya da ke cikin samfurin (wato, jimillar duka duka. и ). A cikin zuriyar stochastic gradient, ba za mu yi amfani da duk ƙimar da ke cikin samfurin ba, amma a maimakon haka, ba da gangan zaɓi abin da ake kira fihirisar samfurin kuma amfani da ƙimar sa.

Misali, idan ma'aunin ya kayyade ya zama lamba 3 (uku), to sai mu dauki darajojin и , sa'an nan kuma mu canza dabi'u a cikin abubuwan da aka samo asali kuma mu ƙayyade sababbin haɗin kai. Bayan haka, bayan ƙaddamar da daidaitawa, mun sake ƙididdige ƙididdige ƙididdiga na samfurin, musanya dabi'un da suka yi daidai da fihirisar cikin ma'auni daban-daban, kuma mu tantance daidaitawa ta sabuwar hanya. и da dai sauransu. har sai haduwar ta zama kore. A kallo na farko, yana iya zama kamar ba zai iya yin aiki kwata-kwata ba, amma yana yi. Gaskiya ne cewa yana da kyau a lura cewa kuskuren ba ya raguwa tare da kowane mataki, amma tabbas akwai hali.

Menene fa'idodin stochastic gradient zuriyar fiye da na al'ada? Idan girman samfurin mu yana da girma sosai kuma an auna shi cikin dubunnan dabi'u, to yana da sauƙin aiwatarwa, a ce, dubun bazuwar su, maimakon duka samfurin. Wannan shine inda zuriyar gradient ta shiga cikin wasa. A cikin yanayinmu, ba shakka, ba za mu lura da bambanci da yawa ba.

Bari mu dubi lambar.

Lambar don saukowar gradient 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])

Mun duba a hankali a cikin ƙididdiga kuma mu kama kanmu muna tambayar "Ta yaya wannan zai kasance?" Mun sami wasu ƙididdiga masu ƙima и . Watakila zuriyar gradient stochastic ya samo mafi kyawun sigogi don lissafin? Abin takaici a'a. Ya isa a duba jimlar karkatattun murabba'i kuma ku ga cewa tare da sabbin ƙima na ƙididdiga, kuskuren ya fi girma. Ba mu gaggawar yanke kauna ba. Bari mu gina jadawali na canjin kuskure.

Lambar don ƙirƙira jimillar sabawa murabba'i a cikin zuriyar gradient

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

Hoton Lamba 5 “Jimillar sabani mai murabba'i a lokacin gangaren gradient na stochastic"

Duban jadawalin, duk abin da ya fada cikin wuri kuma yanzu za mu gyara komai.

To me ya faru? Abin da ya faru ya faru. Lokacin da muka zaɓi wata ɗaya ba da gangan ba, to ga watan da aka zaɓa ne algorithm ɗinmu ke neman rage kuskuren ƙididdige kudaden shiga. Sai mu sake zabar wata sai mu maimaita lissafin, amma mun rage kuskuren wata na biyu da aka zaba. Yanzu ku tuna cewa watanni biyun farko sun karkata sosai daga layin ma'auni mai sauƙi na koma baya. Wannan yana nufin cewa lokacin da aka zaɓi ɗaya daga cikin waɗannan watanni biyu, ta hanyar rage kuskuren kowannensu, algorithm ɗinmu yana ƙaruwa da kuskure ga duka samfurin. To me za ayi? Amsar ita ce mai sauƙi: kuna buƙatar rage matakin saukowa. Bayan haka, ta hanyar rage matakin saukowa, kuskuren zai kuma daina "tsalle" sama da ƙasa. Ko kuma, kuskuren "tsalle" ba zai daina ba, amma ba zai yi sauri ba :) Bari mu duba.

Lambar don gudanar da SGD tare da ƙananan haɓaka

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

Graph No. 6 "Jimillar karkacewar murabba'i a lokacin zuriyar gradient (matakai dubu 80)"

Ƙididdigar ƙididdiga sun inganta, amma har yanzu ba su dace ba. A hasashe, ana iya gyara wannan ta wannan hanya. Mun zaɓi, alal misali, a cikin 1000 na ƙarshe na maimaita ƙimar ƙididdiga waɗanda aka yi mafi ƙarancin kuskure. Gaskiya ne, saboda wannan kuma dole ne mu rubuta ƙimar ƙididdiga da kansu. Ba za mu yi wannan ba, amma a maimakon haka kula da jadawalin. Yana kama da santsi kuma da alama kuskuren yana raguwa daidai. A gaskiya wannan ba gaskiya ba ne. Bari mu kalli gyare-gyare 1000 na farko kuma mu kwatanta su da na ƙarshe.

Lambar don ginshiƙi SGD (matakai 1000 na farko)

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

Graph No. 7 "Jimillar karkacewar murabba'i SGD (matakai 1000 na farko)"

Graph No. 8 "Jimillar karkacewar murabba'i SGD (matakai 1000 na ƙarshe)"

A farkon saukowar, muna lura da daidaitaccen uniform da raguwar kuskure. A cikin abubuwan da suka gabata, mun ga cewa kuskuren yana kewaye da kusa da ƙimar 1,475 kuma a wasu lokuta ma yana daidai da wannan ƙimar mafi kyau, amma har yanzu yana haɓaka… Na maimaita, zaku iya rubuta ƙimar ƙimar. coefficients и , sannan ka zabi wadanda kuskuren yayi kadan. Duk da haka, muna da matsala mafi tsanani: dole ne mu dauki matakai 80 dubu (duba lambar) don samun dabi'u kusa da mafi kyau. Kuma wannan ya riga ya saba wa ra'ayin adana lokacin ƙididdigewa tare da zuriyar gradient stochastic dangane da zuriyar gradient. Me za a iya gyara da ingantawa? Ba shi da wuya a lura cewa a cikin sauye-sauye na farko muna da amincewa da raguwa kuma, sabili da haka, ya kamata mu bar babban mataki a cikin matakan farko da kuma rage mataki yayin da muke ci gaba. Ba za mu yi wannan a cikin wannan labarin ba - ya riga ya yi tsayi da yawa. Wadanda suke so za su iya tunanin kansu yadda za su yi wannan, ba shi da wahala :)

Yanzu bari mu yi stochastic gradient zuriyar ta amfani da ɗakin karatu Lambobi (kuma kada mu yi tuntuɓe a kan duwatsun da muka gano a baya)

Lamba don Zuriyar Gradient 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

Ƙimar sun zama kusan iri ɗaya da lokacin saukowa ba tare da amfani ba Lambobi. Duk da haka, wannan yana da ma'ana.

Bari mu gano tsawon lokacin da zuriyar stochastic gradient suka ɗauke mu.

Lambar don ƙayyade lokacin lissafin SGD (matakai dubu 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)

Ci gaba a cikin gandun daji, mafi duhu ga girgije: sake, tsarin "rubuta kansa" yana nuna sakamako mafi kyau. Duk wannan yana nuna cewa dole ne a sami ƙarin dabarar hanyoyin amfani da ɗakin karatu Lambobi, wanda da gaske yana hanzarta ayyukan ƙididdiga. A cikin wannan labarin ba za mu koyi game da su ba. Za a sami wani abu da za ku yi tunani a kai a lokacin hutunku :)

Mun takaita

Kafin in takaita, zan so in amsa wata tambaya da mai yiwuwa ta taso daga masoyi mai karatu. Me ya sa, a gaskiya, irin wannan "azabtarwa" tare da zuriya, me yasa muke buƙatar tafiya sama da ƙasa daga dutsen (mafi yawa) don samun ƙasa mai daraja, idan muna da hannunmu irin wannan na'ura mai ƙarfi da sauƙi, a cikin nau'i na wani bayani na nazari, wanda nan take ya aika mu mu zuwa wurin da ya dace?

Amsar wannan tambayar tana kan sama. Yanzu mun kalli misali mai sauƙi, wanda amsar gaskiya ta kasance ya dogara da alama ɗaya . Ba kwa ganin wannan sau da yawa a rayuwa, don haka bari mu yi tunanin cewa muna da alamun 2, 30, 50 ko fiye. Bari mu ƙara zuwa ga wannan dubban, ko ma dubun dubatar dabi'u ga kowane sifa. A wannan yanayin, maganin bincike bazai jure gwajin ba kuma ya gaza. A bi da bi, saukar gradient da bambance-bambancensa sannu a hankali amma tabbas za su kusantar da mu zuwa ga manufa - mafi ƙarancin aikin. Kuma kada ku damu da saurin gudu - tabbas za mu duba hanyoyin da za su ba mu damar saita da daidaita tsayin mataki (wato gudun).

Kuma yanzu ainihin taƙaitaccen taƙaitaccen bayani.

Da fari dai, ina fata cewa kayan da aka gabatar a cikin labarin zai taimaka fara "masana kimiyyar bayanai" don fahimtar yadda za a warware sauƙi (kuma ba kawai) ma'auni na layi na layi ba.

Na biyu, mun kalli hanyoyi da yawa don warware lissafin. Yanzu, dangane da yanayin, za mu iya zaɓar wanda ya fi dacewa don magance matsalar.

Na uku, mun ga ƙarfin ƙarin saituna, wato tsayin matakin saukowar gradient. Ba za a iya yin watsi da wannan siga ba. Kamar yadda aka gani a sama, don rage farashin ƙididdiga, ya kamata a canza tsayin mataki yayin saukowa.

Na hudu, a cikin yanayinmu, ayyukan "rubutun gida" sun nuna mafi kyawun sakamakon lokaci don ƙididdiga. Wataƙila wannan ya faru ne saboda rashin ƙwararrun amfani da damar ɗakin karatu Lambobi. Amma duk da haka, ƙarshe na gaba yana nuna kansa. A gefe guda, wani lokacin yana da daraja yin tambayoyi game da ra'ayoyin da aka kafa, kuma a gefe guda, ba koyaushe ya dace da rikitarwa komai ba - akasin haka, wani lokacin hanya mafi sauƙi don magance matsala ta fi tasiri. Kuma tun da manufarmu ita ce nazarin hanyoyi guda uku don warware ma'auni mai sauƙi na koma baya, amfani da ayyukan "rubuta da kansa" ya ishe mu.