Datrys hafaliad atchweliad llinol syml

Mae'r erthygl yn trafod sawl ffordd o bennu hafaliad mathemategol llinell atchweliad syml (mewn parau).

Mae pob dull o ddatrys yr hafaliad a drafodir yma yn seiliedig ar y dull sgwariau lleiaf. Gadewch i ni nodi'r dulliau fel a ganlyn:

• Datrysiad dadansoddol
• Disgyniad Graddfa
• Disgyniad graddastig stochastig

Ar gyfer pob dull o ddatrys hafaliad llinell syth, mae'r erthygl yn darparu swyddogaethau amrywiol, sy'n cael eu rhannu'n bennaf i'r rhai sydd wedi'u hysgrifennu heb ddefnyddio'r llyfrgell nympy a'r rhai sy'n defnyddio ar gyfer cyfrifiadau nympy. Credir bod defnydd medrus nympy yn lleihau costau cyfrifiadurol.

Mae'r holl god a roddir yn yr erthygl wedi'i ysgrifennu yn yr iaith python 2.7 gan ddefnyddio Llyfr Nodiadau Jupyter. Mae'r cod ffynhonnell a'r ffeil gyda data sampl yn cael eu postio ymlaen Github

Mae'r erthygl wedi'i hanelu'n fwy at ddechreuwyr a'r rhai sydd eisoes wedi dechrau meistroli'r astudiaeth o adran eang iawn mewn deallusrwydd artiffisial - dysgu peiriant yn raddol.

I ddarlunio'r deunydd, rydym yn defnyddio enghraifft syml iawn.

Amodau enghreifftiol

Mae gennym bum gwerth sy'n nodweddu dibyniaeth Y o X (Tabl Rhif 1):

Tabl Rhif 1 “Amodau enghreifftiol”

Byddwn yn cymryd yn ganiataol bod y gwerthoedd yw mis y flwyddyn, a - refeniw y mis hwn. Mewn geiriau eraill, mae refeniw yn dibynnu ar fis y flwyddyn, a - yr unig arwydd y mae refeniw yn dibynnu arno.

Mae'r enghraifft mor-felly, o safbwynt dibyniaeth amodol refeniw ar fis y flwyddyn, ac o safbwynt nifer y gwerthoedd - ychydig iawn ohonynt. Fodd bynnag, bydd symleiddio o'r fath yn ei gwneud hi'n bosibl, fel y dywedant, esbonio, nid bob amser yn rhwydd, y deunydd y mae dechreuwyr yn ei gymathu. A hefyd bydd symlrwydd y niferoedd yn caniatáu i'r rhai sy'n dymuno datrys yr enghraifft ar bapur heb gostau llafur sylweddol.

Gadewch i ni dybio y gellir brasamcanu’r ddibyniaeth a roddir yn yr enghraifft yn eithaf da gan hafaliad mathemategol llinell atchweliad syml (mewn parau) o’r ffurf:

lle yw'r mis y derbyniwyd y refeniw, - refeniw sy'n cyfateb i'r mis, и yw cyfernodau atchweliad y llinell amcangyfrifedig.

Sylwch fod y cyfernod a elwir yn aml yn lethr neu raddiant y llinell amcangyfrifedig; yn cynrychioli y swm y mae'r pan fydd yn newid .

Yn amlwg, ein tasg yn yr enghraifft yw dewis cyfernodau o'r fath yn yr hafaliad и , lle mae gwyriadau ein gwerthoedd refeniw cyfrifedig fesul mis oddi wrth y gwir atebion, h.y. bydd y gwerthoedd a gyflwynir yn y sampl yn fach iawn.

Dull lleiaf sgwâr

Yn ôl y dull sgwariau lleiaf, dylid cyfrifo'r gwyriad trwy ei sgwario. Mae'r dechneg hon yn eich galluogi i osgoi canslo gwyriadau ar y cyd os oes ganddynt arwyddion cyferbyniol. Er enghraifft, os mewn un achos, y gwyriad yw +5 (plus pump), ac yn y llall -5 (llai pump), yna bydd swm y gwyriadau yn canslo ei gilydd ac yn dod i 0 (sero). Mae'n bosibl peidio â sgwario'r gwyriad, ond defnyddio eiddo'r modwlws ac yna bydd yr holl wyriadau yn bositif ac yn cronni. Ni fyddwn yn canolbwyntio ar y pwynt hwn yn fanwl, ond yn syml yn nodi, er hwylustod cyfrifiadau, ei bod yn arferol sgwario'r gwyriad.

Dyma sut olwg sydd ar y fformiwla y byddwn yn ei defnyddio i bennu’r swm lleiaf o wyriadau sgwâr (gwallau):

lle yn swyddogaeth brasamcan o atebion cywir (hynny yw, y refeniw a gyfrifwyd gennym),

yw'r gwir atebion (refeniw a ddarperir yn y sampl),

yw'r mynegai sampl (nifer y mis y pennir y gwyriad ynddo)

Gadewch i ni wahaniaethu'r swyddogaeth, diffinio'r hafaliadau gwahaniaethol rhannol, a bod yn barod i symud ymlaen i'r datrysiad dadansoddol. Ond yn gyntaf, gadewch i ni fynd ar daith fer i weld beth yw gwahaniaethu a chofio ystyr geometrig y deilliad.

Gwahaniaethu

Gwahaniaethu yw gweithrediad canfod deilliad ffwythiant.

Ar gyfer beth mae'r deilliad yn cael ei ddefnyddio? Mae deilliad ffwythiant yn nodweddu cyfradd newid y ffwythiant ac yn dweud wrthym ei gyfeiriad. Os yw'r deilliad ar bwynt penodol yn bositif, yna mae'r swyddogaeth yn cynyddu fel arall, mae'r swyddogaeth yn lleihau. A po fwyaf yw gwerth y deilliad absoliwt, yr uchaf yw cyfradd newid y gwerthoedd swyddogaeth, yn ogystal â'r mwyaf serth yw llethr y graff swyddogaeth.

Er enghraifft, o dan amodau system gyfesurynnau Cartesaidd, mae gwerth y deilliad ar y pwynt M(0,0) yn hafal i +25 yn golygu, ar bwynt penodol, pan fydd y gwerth yn cael ei symud i'r dde gan uned gonfensiynol, gwerth cynnydd o 25 uned confensiynol. Ar y graff mae'n edrych fel cynnydd eithaf serth mewn gwerthoedd o bwynt penodol.

Enghraifft arall. Mae'r gwerth deilliadol yn gyfartal 0,1- yn golygu hynny pan fydd wedi'i ddadleoli fesul un uned gonfensiynol, gwerth yn gostwng dim ond 0,1 uned gonfensiynol. Ar yr un pryd, ar graff y swyddogaeth, gallwn arsylwi ar lethr i lawr prin amlwg. Gan dynnu cyfatebiaeth â mynydd, mae fel petaem yn araf iawn yn disgyn ar lethr ysgafn o fynydd, yn wahanol i'r enghraifft flaenorol, lle bu'n rhaid dringo copaon serth iawn :)

Felly, ar ôl gwahaniaethu'r swyddogaeth gan groes и , rydym yn diffinio hafaliadau gwahaniaethol rhannol gorchymyn 1af. Ar ôl pennu'r hafaliadau, byddwn yn derbyn system o ddau hafaliad, trwy ddatrys y byddwn yn gallu dewis gwerthoedd o'r fath o'r cyfernodau и , y mae gwerthoedd y deilliadau cyfatebol ar bwyntiau penodol yn newid o swm bach iawn, iawn, ac yn achos datrysiad dadansoddol nid ydynt yn newid o gwbl. Mewn geiriau eraill, bydd y swyddogaeth gwall yn y cyfernodau a ddarganfuwyd yn cyrraedd isafswm, gan y bydd gwerthoedd y deilliadau rhannol ar y pwyntiau hyn yn hafal i sero.

Felly, yn ôl y rheolau gwahaniaethu, hafaliad deilliadol rhannol y gorchymyn 1af mewn perthynas â'r cyfernod bydd ar y ffurf:

Hafaliad deilliadol rhannol trefn 1af mewn perthynas â bydd ar y ffurf:

O ganlyniad, cawsom system o hafaliadau sydd â datrysiad dadansoddol eithaf syml:

dechrau{ hafaliad*}
dechrau{achosion}
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
diwedd{achosion}
diwedd{ hafaliad*}

Cyn datrys yr hafaliad, gadewch i ni rag-lwytho, gwirio bod y llwytho yn gywir, a fformatio'r data.

Llwytho a fformatio data

Dylid nodi, oherwydd y ffaith, ar gyfer y datrysiad dadansoddol, ac wedi hynny ar gyfer disgyniad graddiant graddiant a stochastig, y byddwn yn defnyddio'r cod mewn dau amrywiad: defnyddio'r llyfrgell nympy a heb ei ddefnyddio, yna bydd angen fformatio data priodol arnom (gweler y cod).

Cod llwytho a phrosesu 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 '********************************************'

Delweddu

Nawr, ar ôl i ni, yn gyntaf, lwytho'r data, yn ail, gwirio cywirdeb y llwytho ac yn olaf fformatio'r data, byddwn yn cynnal y delweddu cyntaf. Y dull a ddefnyddir yn aml ar gyfer hyn yw plot pâr llyfrgelloedd Mor-eni. Yn ein hesiampl, oherwydd y niferoedd cyfyngedig, nid oes diben defnyddio'r llyfrgell Mor-eni. Byddwn yn defnyddio'r llyfrgell arferol matplotlib a dim ond edrych ar y plot gwasgariad.

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

Siart Rhif 1 “Dibyniaeth refeniw ar fis y flwyddyn”

Datrysiad dadansoddol

Gadewch i ni ddefnyddio'r offer mwyaf cyffredin yn python a datrys y system o hafaliadau:

dechrau{ hafaliad*}
dechrau{achosion}
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
diwedd{achosion}
diwedd{ hafaliad*}

Yn ol rheol Cramer cawn y penderfynydd cyffredinol, yn gystal a phenderfynyddion gan a chan , wedi hynny, rhannu'r penderfynydd â i'r penderfynydd cyffredinol - darganfyddwch y cyfernod , yn yr un modd rydym yn dod o hyd i'r cyfernod .

Cod datrysiad dadansoddol

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

Dyma beth gawson ni:

Felly, mae gwerthoedd y cyfernodau wedi'u canfod, mae swm y gwyriadau sgwâr wedi'u sefydlu. Gadewch i ni dynnu llinell syth ar yr histogram gwasgariad yn unol â'r cyfernodau a ddarganfuwyd.

Cod llinell atchweliad

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

Siart Rhif 2 “Atebion cywir a chyfrifol”

Gallwch edrych ar y graff gwyriad ar gyfer pob mis. Yn ein hachos ni, ni fyddwn yn cael unrhyw werth ymarferol sylweddol ohono, ond byddwn yn bodloni ein chwilfrydedd ynghylch pa mor dda y mae'r hafaliad atchweliad llinol syml yn nodweddu dibyniaeth refeniw ar fis y flwyddyn.

Cod siart gwyriad

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

Siart Rhif 3 “Gwyriadau, %”

Ddim yn berffaith, ond fe wnaethom gwblhau ein tasg.

Gadewch i ni ysgrifennu swyddogaeth sydd, i benderfynu ar y cyfernodau и yn defnyddio'r llyfrgell nympy, yn fwy manwl gywir, byddwn yn ysgrifennu dwy swyddogaeth: un gan ddefnyddio matrics ffug-wrthdro (nid argymhellir yn ymarferol, gan fod y broses yn gymhleth ac yn ansefydlog yn gyfrifiadol), a'r llall gan ddefnyddio hafaliad matrics.

Cod Datrysiad Dadansoddol (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

Gadewch i ni gymharu'r amser a dreulir ar bennu'r cyfernodau и , yn unol â'r 3 dull a gyflwynwyd.

Cod ar gyfer cyfrifo amser cyfrifo

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)

Gydag ychydig bach o ddata, mae swyddogaeth “hunanysgrifenedig” yn dod allan, sy'n dod o hyd i'r cyfernodau gan ddefnyddio dull Cramer.

Nawr gallwch symud ymlaen i ffyrdd eraill o ddod o hyd i cyfernodau и .

Disgyniad Graddfa

Yn gyntaf, gadewch i ni ddiffinio beth yw graddiant. Yn syml, segment yw'r graddiant sy'n nodi cyfeiriad twf mwyaf ffwythiant. Trwy gydweddiad â dringo mynydd, lle mae'r graddiant yn wynebu yw lle mae'r ddringfa fwyaf serth i ben y mynydd. Wrth ddatblygu'r enghraifft gyda'r mynydd, cofiwn fod angen y disgyniad mwyaf serth arnom mewn gwirionedd er mwyn cyrraedd yr iseldir cyn gynted â phosibl, hynny yw, y lleiafswm - y man lle nad yw'r swyddogaeth yn cynyddu neu'n lleihau. Ar y pwynt hwn bydd y deilliad yn hafal i sero. Felly, nid graddiant sydd ei angen arnom, ond gwrthraddiant. I ddod o hyd i'r gwrthraddiant y cyfan sydd angen i chi ei wneud yw lluosi'r graddiant â -1 (llai un).

Gadewch inni roi sylw i'r ffaith y gall swyddogaeth gael nifer o leiafrifoedd, ac ar ôl disgyn i un ohonynt gan ddefnyddio'r algorithm a gynigir isod, ni fyddwn yn gallu dod o hyd i isafswm arall, a all fod yn is na'r un a ddarganfuwyd. Gadewch i ni ymlacio, nid yw hyn yn fygythiad i ni! Yn ein hachos ni rydym yn delio ag isafswm sengl, ers ein swyddogaeth ar y graff mae parabola rheolaidd. Ac fel y dylem ni i gyd wybod yn iawn o'n cwrs mathemateg ysgol, dim ond un lleiafswm sydd gan barabola.

Ar ôl i ni ddarganfod pam roedd angen graddiant arnom, a hefyd bod y graddiant yn segment, hynny yw, fector gyda chyfesurynnau penodol, sydd yn union yr un cyfernodau и gallwn weithredu disgyniad graddiant.

Cyn dechrau, rwy'n awgrymu darllen dim ond ychydig o frawddegau am yr algorithm disgyniad:

• Rydym yn pennu mewn modd ffug-hap gyfesurynnau'r cyfernodau и . Yn ein hesiampl, byddwn yn diffinio cyfernodau ger sero. Mae hwn yn arfer cyffredin, ond gall fod gan bob achos ei arfer ei hun.
• O cyfesuryn tynnu gwerth y deilliad rhannol gorchymyn 1af ar y pwynt . Felly, os yw'r deilliad yn bositif, yna mae'r swyddogaeth yn cynyddu. Felly, trwy dynnu gwerth y deilliad, byddwn yn symud i gyfeiriad arall y twf, hynny yw, i gyfeiriad disgyniad. Os yw'r deilliad yn negatif, yna mae'r ffwythiant ar y pwynt hwn yn lleihau a thrwy dynnu gwerth y deilliad rydym yn symud i gyfeiriad disgyniad.
• Rydym yn cynnal gweithrediad tebyg gyda'r cyfesuryn : tynnu gwerth y deilliad rhannol ar y pwynt .
• Er mwyn peidio â neidio dros yr isafswm a hedfan i'r gofod dwfn, mae angen gosod maint y cam i gyfeiriad disgyniad. Yn gyffredinol, gallech ysgrifennu erthygl gyfan am sut i osod y cam yn gywir a sut i'w newid yn ystod y broses ddisgyn er mwyn lleihau costau cyfrifiannol. Ond nawr mae gennym ni dasg ychydig yn wahanol o'n blaenau, a byddwn yn sefydlu maint y gris gan ddefnyddio'r dull gwyddonol o “brocio” neu, fel maen nhw'n dweud yn gyffredin, yn empirig.
• Unwaith y byddwn o'r cyfesurynnau a roddir и tynnu gwerthoedd y deilliadau, rydym yn cael cyfesurynnau newydd и . Rydym yn cymryd y cam nesaf (tynnu), eisoes o'r cyfesurynnau a gyfrifwyd. Ac felly mae'r cylch yn dechrau dro ar ôl tro, nes cyflawni'r cydgyfeiriant gofynnol.

I gyd! Nawr rydym yn barod i fynd i chwilio am geunant dyfnaf Ffos Mariana. Gadewch i ni ddechrau.

Cod ar gyfer disgyniad graddiant

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

Fe wnaethom blymio i waelod Ffos Mariana ac yno daethom o hyd i'r un gwerthoedd cyfernod и , sef yr union beth oedd i'w ddisgwyl.

Gadewch i ni blymio arall, dim ond y tro hwn, bydd ein cerbyd môr dwfn yn cael ei lenwi â thechnolegau eraill, sef llyfrgell nympy.

Cod ar gyfer disgyniad graddiant (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

Gwerthoedd cyfernod и anghyfnewidiol.

Gadewch i ni edrych ar sut y newidiodd y gwall yn ystod disgyniad graddiant, hynny yw, sut y newidiodd swm y gwyriadau sgwâr gyda phob cam.

Cod ar gyfer plotio symiau gwyriadau sgwâr

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

Graff Rhif 4 “Swm y gwyriadau sgwâr yn ystod disgyniad graddiant”

Ar y graff gwelwn fod y gwall yn lleihau gyda phob cam, ac ar ôl nifer penodol o iteriadau rydym yn arsylwi llinell lorweddol bron.

Yn olaf, gadewch i ni amcangyfrif y gwahaniaeth mewn amser gweithredu cod:

Cod i bennu amser cyfrifo graddiant disgyniad

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)

Efallai ein bod yn gwneud rhywbeth o'i le, ond eto mae'n swyddogaeth “ysgrifenedig gartref” syml nad yw'n defnyddio'r llyfrgell nympy yn perfformio'n well nag amser cyfrifo swyddogaeth gan ddefnyddio'r llyfrgell nympy.

Ond nid ydym yn sefyll yn ein hunfan, ond rydym yn symud tuag at astudio ffordd gyffrous arall o ddatrys yr hafaliad atchweliad llinol syml. Cyfarfod!

Disgyniad graddastig stochastig

Er mwyn deall yn gyflym yr egwyddor o weithredu disgyniad graddiant stochastig, mae'n well pennu ei wahaniaethau o ddisgyniad graddiant cyffredin. Rydym ni, yn achos disgyniad graddiant, yn hafaliadau deilliadau o и defnyddio symiau gwerthoedd yr holl nodweddion a gwir atebion sydd ar gael yn y sampl (hynny yw, symiau'r cyfan и ). Mewn disgyniad graddiant stochastig, ni fyddwn yn defnyddio'r holl werthoedd sy'n bresennol yn y sampl, ond yn hytrach, ffug-hap yn dewis y mynegai sampl fel y'i gelwir a defnyddio ei werthoedd.

Er enghraifft, os penderfynir bod y mynegai yn rhif 3 (tri), yna rydym yn cymryd y gwerthoedd и , yna rydym yn amnewid y gwerthoedd yn yr hafaliadau deilliadol a phennu cyfesurynnau newydd. Yna, ar ôl pennu'r cyfesurynnau, rydym unwaith eto yn ffug-hap yn pennu'r mynegai sampl, yn amnewid y gwerthoedd sy'n cyfateb i'r mynegai yn yr hafaliadau gwahaniaethol rhannol, ac yn pennu'r cyfesurynnau mewn ffordd newydd и etc. nes bod y cydgyfeiriant yn troi'n wyrdd. Ar yr olwg gyntaf, efallai na fydd yn ymddangos y gallai hyn weithio o gwbl, ond mae'n gwneud hynny. Mae'n wir ei bod yn werth nodi nad yw'r gwall yn lleihau gyda phob cam, ond yn sicr mae tuedd.

Beth yw manteision disgyniad graddiant stocastig o'i gymharu â'r un confensiynol? Os yw maint ein sampl yn fawr iawn ac wedi'i fesur mewn degau o filoedd o werthoedd, yna mae'n llawer haws prosesu, dyweder, mil ar hap ohonynt, yn hytrach na'r sampl gyfan. Dyma lle mae disgyniad graddiant stocastig yn dod i rym. Yn ein hachos ni, wrth gwrs, ni fyddwn yn sylwi ar lawer o wahaniaeth.

Gadewch i ni edrych ar y cod.

Cod ar gyfer disgyniad graddiant stocastig

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

Edrychwn yn ofalus ar y cyfernodau a dal ein hunain yn gofyn y cwestiwn “Sut all hyn fod?” Cawsom werthoedd cyfernod eraill и . Efallai bod disgyniad graddiant stocastig wedi dod o hyd i baramedrau mwy optimaidd ar gyfer yr hafaliad? Yn anffodus na. Mae'n ddigon i edrych ar swm y gwyriadau sgwâr a gweld bod gyda gwerthoedd newydd o'r cyfernodau, y gwall yn fwy. Nid ydym mewn unrhyw frys i anobaith. Gadewch i ni adeiladu graff o'r newid gwall.

Cod ar gyfer plotio swm y gwyriadau sgwâr mewn disgyniad graddiant stochastig

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

Graff Rhif 5 “Swm y gwyriadau sgwâr yn ystod disgyniad graddiant stocastig”

O edrych ar yr amserlen, mae popeth yn disgyn i'w le a nawr byddwn yn trwsio popeth.

Felly beth ddigwyddodd? Digwyddodd y canlynol. Pan fyddwn yn dewis mis ar hap, yna ar gyfer y mis a ddewiswyd y mae ein algorithm yn ceisio lleihau'r gwall wrth gyfrifo refeniw. Yna rydyn ni'n dewis mis arall ac yn ailadrodd y cyfrifiad, ond rydyn ni'n lleihau'r gwall am yr ail fis a ddewiswyd. Nawr cofiwch fod y ddau fis cyntaf yn gwyro'n sylweddol oddi wrth linell yr hafaliad atchweliad llinol syml. Mae hyn yn golygu, pan ddewisir unrhyw un o'r ddau fis hyn, trwy leihau gwall pob un ohonynt, mae ein algorithm yn cynyddu'r gwall ar gyfer y sampl gyfan yn ddifrifol. Felly beth i'w wneud? Mae'r ateb yn syml: mae angen i chi leihau'r cam disgyn. Wedi'r cyfan, trwy leihau'r cam disgyn, bydd y gwall hefyd yn atal "neidio" i fyny ac i lawr. Neu yn hytrach, ni fydd y gwall “neidio” yn dod i ben, ond ni fydd yn ei wneud mor gyflym :) Gadewch i ni wirio.

Cod i redeg SGD gyda chynyddrannau llai

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

Graff Rhif 6 “Swm y gwyriadau sgwâr yn ystod disgyniad graddiant stocastig (80 mil o gamau)”

Mae'r cyfernodau wedi gwella, ond nid ydynt yn ddelfrydol o hyd. Yn ddamcaniaethol, gellir cywiro hyn fel hyn. Rydym yn dewis, er enghraifft, yn y 1000 o iteriadau diwethaf werthoedd y cyfernodau y gwnaed y gwall lleiaf ohonynt. Yn wir, ar gyfer hyn bydd yn rhaid i ni hefyd ysgrifennu gwerthoedd y cyfernodau eu hunain. Ni fyddwn yn gwneud hyn, ond yn hytrach yn rhoi sylw i'r amserlen. Mae'n edrych yn llyfn ac mae'n ymddangos bod y gwall yn gostwng yn gyfartal. Mewn gwirionedd nid yw hyn yn wir. Edrychwn ar y 1000 o iteriadau cyntaf a'u cymharu â'r olaf.

Cod ar gyfer siart SGD (1000 cam cyntaf)

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

Graff Rhif 7 “Swm y gwyriadau sgwâr SGD (1000 cam cyntaf)”

Graff Rhif 8 “Swm y gwyriadau sgwâr SGD (1000 cam olaf)”

Ar ddechrau'r disgyniad, gwelwn ostyngiad eithaf unffurf a serth mewn gwallau. Yn yr iteriadau diwethaf, gwelwn fod y gwall yn mynd o gwmpas ac o gwmpas gwerth 1,475 ac ar rai eiliadau mae hyd yn oed yn cyfateb i'r gwerth gorau posibl hwn, ond yna mae'n dal i fynd i fyny ... Rwy'n ailadrodd, gallwch chi ysgrifennu gwerthoedd y cyfernodau и , ac yna dewiswch y rhai y mae'r gwall yn fach iawn ar eu cyfer. Fodd bynnag, roedd gennym broblem fwy difrifol: roedd yn rhaid i ni gymryd 80 mil o gamau (gweler y cod) i gael gwerthoedd yn agos at optimaidd. Ac mae hyn eisoes yn gwrth-ddweud y syniad o arbed amser cyfrifiant gyda disgyniad graddiant stochastig o'i gymharu â disgyniad graddiant. Beth ellir ei gywiro a'i wella? Nid yw’n anodd sylwi ein bod yn mynd i lawr yn hyderus yn yr iteriadau cyntaf ac, felly, dylem adael cam mawr yn yr iteriadau cyntaf a lleihau’r cam wrth inni symud ymlaen. Ni fyddwn yn gwneud hyn yn yr erthygl hon - mae eisoes yn rhy hir. Gall y rhai sy'n dymuno feddwl drostynt eu hunain sut i wneud hyn, nid yw'n anodd :)

Nawr gadewch i ni berfformio disgyniad graddiant stochastig gan ddefnyddio'r llyfrgell nympy (a pheidiwn â baglu dros y cerrig a nodwyd gennym yn gynharach)

Cod ar gyfer Disgyniad Graddiant Stochastig (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

Trodd y gwerthoedd bron yr un fath ag wrth ddisgyn heb ddefnyddio nympy. Fodd bynnag, mae hyn yn rhesymegol.

Dewch i ni ddarganfod pa mor hir y cymerodd disgyniadau graddiant stochastig ni.

Cod ar gyfer pennu amser cyfrifo SGD (80 mil o gamau)

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)

Po bellaf i mewn i’r goedwig, y tywyllaf yw’r cymylau: eto, mae’r fformiwla “hunanysgrifenedig” yn dangos y canlyniad gorau. Mae hyn i gyd yn awgrymu bod yn rhaid cael ffyrdd mwy cynnil fyth o ddefnyddio'r llyfrgell nympy, sydd wir yn cyflymu gweithrediadau cyfrifiant. Yn yr erthygl hon ni fyddwn yn dysgu amdanynt. Bydd rhywbeth i feddwl amdano yn eich amser hamdden :)

Rydym yn crynhoi

Cyn crynhoi, hoffwn ateb cwestiwn a gododd yn fwyaf tebygol gan ein hanwyl ddarllenydd. Pam, mewn gwirionedd, y fath “artaith” gyda disgyniadau, pam fod angen i ni gerdded i fyny ac i lawr y mynydd (i lawr yn bennaf) er mwyn dod o hyd i'r iseldir gwerthfawr, os oes gennym ddyfais mor bwerus a syml yn ein dwylo, yn y ffurf datrysiad dadansoddol, sy'n ein teleportio ar unwaith i'r Lle Iawn?

Mae'r ateb i'r cwestiwn hwn yn gorwedd ar yr wyneb. Nawr rydym wedi edrych ar enghraifft syml iawn, yn yr hon y mae'r ateb cywir yn dibynnu ar un arwydd . Nid ydych chi'n gweld hyn yn aml mewn bywyd, felly gadewch i ni ddychmygu bod gennym ni 2, 30, 50 neu fwy o arwyddion. Gadewch i ni ychwanegu at hyn filoedd, neu hyd yn oed ddegau o filoedd o werthoedd ar gyfer pob priodoledd. Yn yr achos hwn, efallai na fydd yr ateb dadansoddol yn gwrthsefyll y prawf ac yn methu. Yn ei dro, bydd disgyniad graddiant a'i amrywiadau yn araf ond yn sicr yn dod â ni'n agosach at y nod - lleiafswm y swyddogaeth. A pheidiwch â phoeni am gyflymder - mae'n debyg y byddwn yn edrych ar ffyrdd a fydd yn caniatáu inni osod a rheoleiddio hyd cam (hynny yw, cyflymder).

Ac yn awr y crynodeb byr gwirioneddol.

Yn gyntaf, gobeithio y bydd y deunydd a gyflwynir yn yr erthygl yn helpu i ddechrau “gwyddonwyr data” i ddeall sut i ddatrys hafaliadau atchweliad llinol syml (ac nid yn unig).

Yn ail, buom yn edrych ar sawl ffordd o ddatrys yr hafaliad. Nawr, yn dibynnu ar y sefyllfa, gallwn ddewis yr un sydd fwyaf addas i ddatrys y broblem.

Yn drydydd, gwelsom bŵer gosodiadau ychwanegol, sef hyd y cam disgyniad graddiant. Ni ellir esgeuluso'r paramedr hwn. Fel y nodwyd uchod, er mwyn lleihau cost cyfrifiadau, dylid newid hyd y cam yn ystod y disgyniad.

Yn bedwerydd, yn ein hachos ni, swyddogaethau “ysgrifenedig gartref” a ddangosodd y canlyniadau amser gorau ar gyfer cyfrifiadau. Mae'n debyg mai nid y defnydd mwyaf proffesiynol o alluoedd y llyfrgell sy'n gyfrifol am hyn nympy. Ond boed hyny fel y byddo, y mae y casgliad canlynol yn ei awgrymu ei hun. Ar y naill law, weithiau mae'n werth cwestiynu barn sefydledig, ac ar y llaw arall, nid yw bob amser yn werth cymhlethu popeth - i'r gwrthwyneb, weithiau mae ffordd symlach o ddatrys problem yn fwy effeithiol. A chan mai ein nod oedd dadansoddi tri dull o ddatrys hafaliad atchweliad llinol syml, roedd y defnydd o swyddogaethau “hunanysgrifenedig” yn ddigon i ni.

Llenyddiaeth (neu rywbeth felly)

1. Atchweliad llinol

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

2. Sgwariau lleiaf dull

mathprofi.ru/metod_naimenshih_kvadratov.html

3. Deilliadol

www.mathprofi.ru/chastnye_proizvodnye_primery.html

4. graddiant

mathprofi.ru/proizvodnaja_po_napravleniju_i_gradient.html

5. Disgyniad graddiant

habr.com/ru/post/471458

habr.com/ru/post/307312

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

6. llyfrgell 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

Ffynhonnell: hab.com