Solvendo aequationem regressuum simplicium linearium

Articulus pluribus modis tractat determinare aequationem mathematicam simplicis (pared) regressionis lineam.

Omnes methodi solvendi aequationem hic tractatam fundantur in minimis quadratis methodi. Eamus modos modos:

• Analytica solutio
• Gradiente Descensu
• Descensus stochastic CLIVUS

Uterque modus solvendi aequationis rectae, articulus varias functiones praebet, quae maxime dividuntur in ea quae scripta sunt sine bibliotheca. numpy et qui usus ad calculos numpy. Creditur usus peritus numpy computatis costs redigendum erit.

Totum codicem datum in articulo lingua scriptum est python 2.7 apud Pentium Jupyter. The source code and file with sample data are posted on Github

Articulus magis intenditur ad tam incipientium quam ab iis qui gradatim iam inceperunt studium latissimum sectionis in artificiali intelligentia obtinere.

Ad materiam illustrandam simplicissimo exemplo utimur.

Exemplum conditionibus

Habemus quinque valores qui dependentiam designant Y ex X (Tabula No. 1);

Tabula No. 1 "Exemplum conditiones"

Ponemus valores est mensis anni — reditus huius mensis. Id est, vectigal ex mense anni pendet — unicum signum ex quo vectigal dependet.

Exemplum sic est, tam ex parte dependentiae conditionalis reditus in mense anni, tum ex parte numeri valorum - paucissimi sunt. Sed talis simplicitas efficiet, ut aiunt, materiam ab incipientibus acquirendam non semper facile explicare. Et etiam simplicitas numerorum permittet eos qui exemplum in charta sine significantibus laboribus gratuita solvere volunt.

Ponamus exemplum dependentiae in exemplum satis bene approximari posse aequatione mathematicae simplicis (par) regressionis linea formae;

quibus mensis est, in quo vectigal receptum est; — reditus ad mensem respondentem; и regressio extimationis lineae sunt.

Nota quod coefficientes saepe clivum vel clivum extimationis linea appellatur; significat quantitatem qua cum mutat .

Uti patet, munus nostrum in exemplo est tales coefficientes in aequatione deligere и in quibus deflexionum nostrarum per mensem a veris responsionibus computata valorum reddituum, i.e. valores in sample exhibitis minimi erunt.

Quadratus modus minimus

Secundum modum quadratis minimis, declinatio calculi quadrandi est. Haec ars tibi concedit ut indultum deviationes mutuae vitentur, si signa opposita habent. Verbi gratia, si in uno casu declinatio est +5 (Quinque), et in aliis -5 tunc summa errorum invicem se destruent et summam 0 (nullam). Fieri non potest ut deviationem quadrare, sed uti moduli proprietate, et tunc omnes errores positivi erunt et accumulabunt. Non singillatim hoc loco immoramur, sed simpliciter indicamus, quod ad calculi commodum solet declinationis quadrare.

Haec est formula similis quacum minimum deflexionum quadratarum determinabimus.

quibus functio approximationis verorum responsionum est (id est reditus computavimus);

sunt vera responsa (revenue provisum in sample);

est specimen index (numerus mensis in quo declinatio determinatur)

Munus differamus, partiales aequationes differentiales definiamus, et ad solutionem analyticam progredi parati sint. Sed primum quid differentiae sit brevem excursionem sumamus, et geometricam significationem derivati ​​meminerimus.

Differentia

Differentia est operatio inveniendi inde functionis.

Quid est inde pro? Inde functionis ratem mutati muneris notat atque eius directionem docet. Si in dato puncto positivo derivativum est, munus augetur, secus munus decrescit. Quo maior utilitas derivativae absolutae, altior rate mutationis valorum functionis, ac altior scopuli functionis graphi.

Exempli gratia, sub condicionibus systematis coordinationis Cartesianae, valor inde in puncto M (0,0) aequalis est. + 25 significat quod ad datum punctum, cum valor bipertitus est ad dextram per conventional unitas, valorem auget XXV unitates conventional. In lacinia purus spectat quasi satis ardua in bonis oriuntur ex dato.

Aliud exemplum. Valor inde est aequalis -0,1 significat quod cum moti sunt per unum conventional unitas, valorem 0,1 unitas conventional modo decrescat. Eodem tempore, in graphe functionis, vix conspici potest prono loco notabilis. Cum monte analogiam ducentes, id est ac si lentissime declivis de monte descendimus, dissimili exemplo praecedenti, ubi cacumina praerupta ascendimus :)

Et sic, post differentiam functionis per odds и ordinem aequationum differentialium partialium definimus. Post aequationes determinandas, systema duarum aequationum accipiemus, solvendo quas tales valores coefficientium eligere poterimus. и unde valores derivatorum in datis punctis valde mutatis respondentium, minimo et in casu solutionis analyticae prorsus non mutantur. Aliis verbis, error functionis in coefficientibus inventis minimum perveniet, cum valores derivatorum partialium in his punctis aequales erunt nihilo.

Secundum regulas igitur differentiae, aequatio derivativa partialis ordinis primi respectu coëfficientis forma erit;

1st ordo partialis aequationis derivativae respectu to forma erit;

Quam ob rem systema aequationum quae solutionem analyticam satis simplicem habet, recipimus;

incipe aequationem
incipe
na + bsumlimits_{i=1}^nx_i — sumlimits_{i=1}^ny_i = 0

sumlimits_{i=}^nx_i(a + bsumlimits_{i=1}^nx_i — sumlimits_{i=}^ny_i) = 1
finis
finem aequationis

Priusquam aequationem solvas, preload, reprehendo quod oneratio recta est et notitia format.

Loading et formatting notitia

Notandum est quod propter hoc quod ad solutionem analyticam, et postea pro descensu gradiente et stochastico, in duobus variationibus codice utemur, utentes bibliotheca. numpy et sine utendo, tunc opportuna notitia formatura egebimus (vide codicem).

Data loading et dispensando codice

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

Nunc, postquam notitias primum oneratis, secundo rectitudinem onerandi cohibuimus, ac demum datas formatos, primum visualizationem peragemus. Ratio saepe usus est ad hoc pairplot bibliothecam seaborn. In nostro exemplo ob numeros limitatos nihil attinet bibliothecae usus seaborn. Nos bibliothecam regularis utere matplotlib' et vide in scatterplot.

Scatterplot code

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 N. 1 "Dependentia redituum in mense anni"

Analytica solutio

Utamur instrumenta communissima in python et systema aequationum solve;

incipe aequationem
incipe
na + bsumlimits_{i=1}^nx_i — sumlimits_{i=1}^ny_i = 0

sumlimits_{i=}^nx_i(a + bsumlimits_{i=1}^nx_i — sumlimits_{i=}^ny_i) = 1
finis
finem aequationis

Secundum Crameri regulae inveniemus determinatum generalem ac determinantes et ex post quem, dividens determinat ad determinatio generalis - invenire coefficientem similiter invenimus coefficientem .

Solutio analytica codice

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

Hic est quod cepimus;

Igitur inventae valores coëfficientium, constituitur summa duplicata errorum. Rectam lineam spargamus histogrammis secundum coefficientes inventis.

Regressionem linea codice

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

Inspicere potes lacinia purus pro cuiusque mensis declinationis. In nobis, nullum momentum practicum ex eo accipiemus, sed curiositati satisfaciemus quomodo simplex regressio linearis aequationis dependentiam reditus mense anni designat.

Deviationis chart codice

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

Chart No. 3 "Deviationes, %"

Non perfectum, sed negotium nostrum perfecit.

Munus quod scribamus, coefficientes determinare и utitur bibliotheca numpypressius scribemus duas functiones: unam utens matrice pseudoinversa (non in praxi commendatur, cum processus computationaliter sit complexus et instabilis), alterum utens aequatione matricis.

SOLUTIO Analytica Codicis (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

Conferamus tempus determinatum coefficientium и servato III modos.

Code ad colligendum tempus

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)

Cum parva notitia copia, munus "se-scriptum" praecedit, quod coefficientes methodo Crameri usus invenit.

Nunc ad alios vias transire coefficientes invenire potes и .

Gradiente Descensu

Primum quid sit clivus definiamus. Plane, clivus segmentum est quod directionem maximi incrementi functionis indicat. Et similiter per montem ascensus, ubi gradiens facies est ubi altissimus ascenditur ad cacumen montis. Exemplum cum monte enucleans, meminimus quidem altissimo descensu indigere ut quam celerrime perveniat ad ima, id est minima, locum ubi munus non augetur vel minuitur. Hic erit derivativus nihilo aequalis. Ergo non opus est clivo, sed antigradiente. Ad inveniendam antigradientem vos iustus postulo ut crescat in clivum -1 (minus unus).

Animadvertemus hoc munus habere plura minima posse, et descendendo in unum utens algorithmo infra proposita, non valemus aliud minimum invenire, quod sit infra repertum. Relaxemus, hoc nobis non minatur! In casu nostro de uno minimo agitur, cum munus nostrum in graph est parabola regularis. Et quia optime novimus omnes e nostra schola mathematici, parabola unum tantum minimum habet.

Postquam invenimus cur opus sit clivo, tum quod gradiens sit segmentum, hoc est, vector cum coordinatis datis, quae plane idem sunt coefficientes. и descensus efficere possumus.

Priusquam incipias, moneo paucas sententias de algorithmo descensu legere:

• Coordinatas coefficientium in pseudo-passim modo statuimus и . In exemplo nostro coefficientes prope nulla determinabimus. Hoc commune est, sed suam quisque causam habeat praxim.
• Ex coordinare aufer valorem ex 1 ordinis partialis derivativae ad punctum . Si igitur positivus derivativus est, munus augetur. Ergo subtrahendo valorem inde, movebimus in oppositum augmenti, scilicet in directione descensus. Si derivativa negativa est, munus hic decrescit et subtrahendo valorem inde movemur in directione descensus.
• Similem operationem cum coordinatione exequimur : detrahe valorem derivativum partialis in puncto .
• Ut minimum non transilire et in altum spatium volare, necesse est gradum magnitudinis in directione descensus ponere. In genere, totum articulum scribere potuisti quomodo gradum recte constituas et quomodo illum in processu descensu mutes ut sumptus computationales reducere possis. Nunc autem paulo aliud negotium ante nos habemus et gradum amplitudinis utendo methodo scientifica "poke" vel, ut vulgo loquuntur, empirice statuemus.
• Cum sumus ex coordinatis datis и valores derivatorum minue, novos coordinatas accipimus и . Proximum gradum sumimus iam ex coordinatis computatis. Et sic iterum iterumque incipit cyclus, donec confluentia debita perficiatur.

Omnis! Nunc parati sumus ad profundissimam fossam Marianae fossae quaerendam. Incipiamus.

Code for gradiente descensu

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

Ad ipsum fundum fossae Marianae iactivimus et ibi omnes valores coefficientes invenimus и quod ipsum erat expectandum.

Alterum dive capiamus, hoc solum tempore, vehiculum altum nostrum cum aliis technologiae technologiae implebitur, nempe bibliotheca. numpy.

Code for gradiente descensu (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

Valores coefficientes и immutabilis.

Intueamur quomodo error mutatur in descensu gradiente, hoc est, quomodo summa deflexionum quadrata cum singulis passibus mutatur.

Code consilium summae quadratorum deflexionum perspiciantur

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

Aliquam lacinia purus n.

In grapho videmus singulos gradus decrescere error, et post aliquot iterationes lineam paene horizontalem observamus.

Denique differentiam in codice exsecutionis temporis sestimamus:

Codicem statuere descensum calculi tempore gradientis

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)

Fortasse aliquid mali facimus, sed munus est simplex "domus-scriptum" quod bibliotheca non utitur numpy outperforms calculi tempus functionis in bibliotheca numpy.

Nos autem non subsistimus, sed ad aliam viam excitandam discendam impellimur ad aequationem simplicem regressionem linearem solvendam. Dignum!

Descensus stochastic CLIVUS

Ut cito intelligat principium operationis descensus stochastici gradientis, melius est eius differentias a gradiente ordinario descensu determinare. Nos in descensu gradiente, in aequationibus derivatorum и summae valorum omnium lineamentorum ac veri responsionum in sample praesto (id est, summarum omnium" и ). In descensu stochastico gradiente, valores omnes in sample praesentes non adhibebimus, sed pseudo-passim eligimus, qui vocantur index sample et utimur suis valoribus.

Exempli gratia, si index numerus 3 (tres) determinatus est, tum valores accipiamus и tunc valores in aequationibus derivatis substituimus ac novas coordinatas determinamus. Deinde, determinatis coordinatis, iterum pseudo-passim indicem speciminum decernimus, valores in aequationes differentiales partiales indice respondentes substituimus ac coordinatas novo modo determinamus. и etc. donec concursus virescit. In prima specie, non videri potest hoc omnino operari, sed facit. Verum est notatu dignum quod error non omni gradu decrescat, sed certe tendentia est.

Quae sunt commoda stochastici clivi descensus super placitum unum? Si magnitudo exempli nostri maxima est et mensurata in decem milibus valorum, multo facilius est ad processum, dicendo, temere milia eorum, quam totum specimen. Hoc est, ubi descensus stochasticus gradientis iungitur. In casu nostro, sane multum differentiae non animadvertimus.

Inspice codicem.

Code for stochastic CLIVUS descensus

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

Diligenter inspicimus coefficientes nosmet ipsos capientes quaerentes quaestionem « Quomodo hoc fieri potest? Venimus alia valores coefficientes и . Fortasse descensus stochasticus clivus meliorem parametris meliorem inuenit pro aequatione? Quod valde dolendum non. Satis est summam errorum quadratorum inspicere et videre novis valoribus coefficientium maiorem esse errorem. Non properamus desperare. Aliquam lacinia purus consequat error consequat.

Codex ad insidiandum summae deflexionum quadratarum in descensu clivo stochastico

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

Aliquam lacinia purus No. 5 "Summa deflexionum quadratarum in descensu stochastic gradientis"

Spectantes cedulam, omnia in locum cadunt et nunc omnia figemus.

Quid igitur factum est? sequentia facta sunt. Cum passim mensem eligimus, tunc pro mense delecto algorithmus nostrum errorem in vectigalibus computandis minuere quaerit. Deinde alterum mensem eligimus et calculum repetimus, sed errorem in alterum mensem delectum reducimus. Nunc mementote duos primos menses signanter a linea regressionis simplicis linearis deflectere. Hoc significat, cum aliquis ex duobus mensibus deligitur, errorem cuiusque eorum minuendo, nostrum algorithmus errorem pro integritate exempli serio auget. Quid igitur faciam? Responsio simplex est: debes gradum descensum reducere. Post omnes, descensum gradum reducendo, error etiam "silire" et descendere desinet. Vel potius error "silire" non cessabit, sed non tam cito:) Reprehendo.

Codex currere SGD minoribus incrementis

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

Aliquam lacinia purus No. 6 "Summa deflexionum quadratarum in descensu stochastic gradientis (80 mille gradibus)"

Emendarunt nnn, sed adhuc non sunt ideales. Hypothetice hoc modo corrigi potest. Eligemus, exempli gratia, in ultimis 1000 iterationibus valores coefficientium quibus minimus error factus est. Verum, ad hoc etiam ipsi valores coëfficientium scribere debebimus. Hoc non faciemus, sed potius cedulam attendimus. Spectat lenis, et aequaliter decrescere error videtur. Profecto hoc non est verum. Inspiciamus primum 1000 iterationes et eas cum ultimis confer.

Code for SGD chart (prima 1000 vestigia)

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

Aliquam lacinia purus No.

Aliquam lacinia purus N. 8 "SGD deflexionum quadratarum summarum (vestigiorum 1000)"

In ipso exordio descensus satis aequabilis et praeceps error observamus decrementa. In ultimis iterationibus videmus errorem circuire et circa valorem 1,475 et in quibusdam momentis etiam hanc meliorem valorem aequare, sed tunc adhuc ascendit... Iterum dico, valores ipsius scribere potes. coefficientes и et eligendi ea error minima enim. Tamen problema gravius ​​habuimus: LXXX milia passum (vide codicem) accipere debebamus ut bona proxima ad optimales perveniamus. Et hoc iam repugnat rationi computandi tempus servandi cum descensu clivo stochastico relativo ad descensum clivum. Quid corrigi et emendari potest? Haud difficile est animadvertere in primis iterationibus confidenter descendere ac proinde in primis iterationibus magnum gradum relinquere ac gradum progrediendo reducere. Nolumus hoc in hoc articulo - iam nimis longum est. Qui hoc facere sibi volunt, cogitare non difficile est :)

Nunc agamus descensus stochastic clivos utens bibliotheca numpy (et non offendamus super lapides quos antea notavimus)

Code for Stochastic Gradiente Descensu (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

Valores evasit eaedem fere ac sine usu descendentes numpy. Sed haec logica est.

Inueniamus quam diu descensus stochastici cliuos nos susceperint.

Codex ad determinandum SGD tempus calculi (80 mille gradus)

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)

Longius in silvam, nubes obscuriores: iterum formula "se-scripta" optimum exitum ostendit. Haec omnia suggerit subtilioribus etiam modis uti bibliotheca numpyquae quidem computationem accelerent. Nolumus in hoc articulo de illis. Erit aliquid cogitandum in vacat :)

Summatim

Priusquam perstringamus, quaestioni respondere velim, quam maxime a lectore nostro probabile est ortam. Cur, revera, talis "tortura" cum descensu, cur montem sursum ac deorsum (plerumque descendens) opus est ut campestrem thesaurum inveniamus, si tantam vim ac simplicem machinam in manibus habemus. forma solutionis analyticae, quae nos statim perspicit ad locum?

Responsio huius quaestionis est in superficie. Nunc inspeximus exemplum simplicissimum, in quo vera responsio est pendent uno signo . Hoc saepe in vita non vides, ut putes nos habere signa 2, 30, 50 vel plura. His mille vel etiam decem milia valorum pro singulis attributis adde. In hoc casu, solutio analytica non potest sustinere tentationem et defectum. Iamvero descensus gradiens eiusque variationes lente sed certe propius nos adducunt ad finem - minimum functionis. Et celeritatem non cures - probabiliter videbimus vias quae nos passum longitudinis (id est velocitatis) disponere et ordinare sinunt.

Jamque ipsa brevis summa est.

Primo, spero quod materialia in articulo exhibita adiuvabunt principium "datae phisicae" ad intelligendum quomodo solutionem simplicem (et non solum) lineares aequationes procedere.

Secundo, pluribus modis ad aequationem solvendam inspeximus. Nunc, pro rerum condicione, eligere possumus id quod maxime convenit ad problema solvendum.

Tertio vidimus virtutem accessionis occasus, scilicet descensus gradus longitudinis gradientis. Hic modulus negligendus non est. Sicut supra dictum est, ad reducendum sumptus calculi, debet immutari gradus longitudinis in descensu.

Quarto, in nobis functiones "domus-scriptas" optime ostendit eventus ad calculos. Hoc verisimile est ex usu maxime professio facultatum bibliothecae numpy. Sed ut sit, haec conclusio se suggerit. Ex altera parte, interdum valet percontationes opiniones constitutas, ex altera vero parte, non semper omnia intricata — e contra, interdum simplicior solvendae quaestionis modus efficacior est. Et cum propositum nobis esset tres aditus resolvere ad aequationem simplicem regressionem linearem solvendam, usus functionum "auto-scriptorum" satis nobis fuit.

Litterae (vel aliquid tale)

Linearibus 1. procedere

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

2. quadrata minime modum

mathprofi.ru/metod_naimenshih_kvadratov.html

3. Derivative

www.mathprofi.ru/chastnye_proizvodnye_primery.html

4. Gradiente

mathprofi.ru/proizvodnaja_po_napravleniju_i_gradient.html

5. Gradiente descensu

habr.com/en/post/471458

habr.com/en/post/307312

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

6. NumPy bibliotheca

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

Source: www.habr.com