ການແກ້ໄຂສົມຜົນຂອງ regression ເສັ້ນງ່າຍດາຍ

ບົດຄວາມສົນທະນາຫຼາຍວິທີໃນການກໍານົດສົມຜົນທາງຄະນິດສາດຂອງເສັ້ນ regression ແບບງ່າຍດາຍ (ຄູ່).

ວິທີການທັງໝົດຂອງການແກ້ໄຂສົມຜົນທີ່ໄດ້ກ່າວມານີ້ແມ່ນອີງໃສ່ວິທີການສີ່ຫຼ່ຽມນ້ອຍທີ່ສຸດ. ຂໍ​ໃຫ້​ສັງ​ເກດ​ວິ​ທີ​ການ​ດັ່ງ​ຕໍ່​ໄປ​ນີ້​:

• ການແກ້ໄຂການວິເຄາະ
• Gradient Descent
• Stochastic gradient descent

ສໍາລັບແຕ່ລະວິທີຂອງການແກ້ໄຂສົມຜົນຂອງເສັ້ນຊື່, ບົດຄວາມສະຫນອງຫນ້າທີ່ຕ່າງໆ, ເຊິ່ງສ່ວນໃຫຍ່ແມ່ນແບ່ງອອກເປັນລາຍລັກອັກສອນໂດຍບໍ່ມີການນໍາໃຊ້ຫ້ອງສະຫມຸດ. ຕົວເລກ ແລະຜູ້ທີ່ໃຊ້ສໍາລັບການຄິດໄລ່ ຕົວເລກ. ມັນໄດ້ຖືກເຊື່ອວ່າການນໍາໃຊ້ທັກສະ ຕົວເລກ ຈະຫຼຸດຜ່ອນຄ່າໃຊ້ຈ່າຍໃນຄອມພິວເຕີ້.

ລະຫັດທັງຫມົດທີ່ໃຫ້ຢູ່ໃນບົດຄວາມແມ່ນຂຽນເປັນພາສາ python 2.7 ການນໍາໃຊ້ ປື້ມບັນທຶກ Jupyter. ລະຫັດແຫຼ່ງແລະໄຟລ໌ທີ່ມີຂໍ້ມູນຕົວຢ່າງຖືກຈັດພີມມາຢູ່ Github

ບົດຄວາມແມ່ນແນໃສ່ທັງຜູ້ເລີ່ມຕົ້ນ ແລະຜູ້ທີ່ໄດ້ເລີ່ມຄ່ອຍໆທີ່ຈະເປັນແມ່ບົດຂອງການສຶກສາພາກທີ່ກວ້າງຂວາງໃນປັນຍາປະດິດ - ການຮຽນຮູ້ເຄື່ອງຈັກ.

ເພື່ອສະແດງໃຫ້ເຫັນເຖິງເອກະສານ, ພວກເຮົາໃຊ້ຕົວຢ່າງທີ່ງ່າຍດາຍຫຼາຍ.

ເງື່ອນໄຂຕົວຢ່າງ

ພວກເຮົາມີຫ້າຄຸນຄ່າທີ່ມີລັກສະນະການເພິ່ງພາອາໄສ Y ຈາກ X (ຕາຕະລາງ 1):

ຕາຕະລາງ 1 “ເງື່ອນໄຂຕົວຢ່າງ”

ພວກເຮົາຈະສົມມຸດວ່າຄຸນຄ່າ ແມ່ນເດືອນຂອງປີ, ແລະ — ລາຍ​ຮັບ​ໃນ​ເດືອນ​ນີ້​. ໃນຄໍາສັບຕ່າງໆອື່ນໆ, ລາຍຮັບແມ່ນຂຶ້ນກັບເດືອນຂອງປີ, ແລະ - ເຄື່ອງຫມາຍດຽວທີ່ລາຍຮັບຂຶ້ນກັບ.

ຕົວຢ່າງແມ່ນດັ່ງນັ້ນ, ທັງຈາກທັດສະນະຂອງການເພິ່ງພາອາໄສເງື່ອນໄຂຂອງລາຍໄດ້ໃນເດືອນຂອງປີ, ແລະຈາກຈຸດຂອງຈໍານວນມູນຄ່າ - ມີຈໍານວນຫນ້ອຍຫຼາຍຂອງພວກເຂົາ. ແນວໃດກໍ່ຕາມ, ຄວາມງ່າຍດາຍດັ່ງກ່າວຈະເຮັດໃຫ້ມັນເປັນໄປໄດ້, ຍ້ອນວ່າເຂົາເຈົ້າເວົ້າວ່າ, ເພື່ອອະທິບາຍ, ບໍ່ສະເຫມີໄປດ້ວຍຄວາມງ່າຍ, ວັດສະດຸທີ່ຜູ້ເລີ່ມ assimilate. ແລະຍັງຄວາມງ່າຍດາຍຂອງຕົວເລກຈະຊ່ວຍໃຫ້ຜູ້ທີ່ຕ້ອງການແກ້ໄຂຕົວຢ່າງໃນເຈ້ຍໂດຍບໍ່ມີຄ່າໃຊ້ຈ່າຍແຮງງານທີ່ສໍາຄັນ.

ໃຫ້ພວກເຮົາສົມມຸດວ່າການເພິ່ງພາອາໄສໃນຕົວຢ່າງສາມາດຖືກປະມານຂ້ອນຂ້າງດີໂດຍສົມຜົນທາງຄະນິດສາດຂອງເສັ້ນ regression ແບບງ່າຍດາຍ (ຄູ່) ຂອງແບບຟອມ:

ບ່ອນທີ່ ແມ່ນເດືອນທີ່ໄດ້ຮັບລາຍຮັບ, - ລາຍ​ຮັບ​ທີ່​ສອດ​ຄ້ອງ​ກັນ​ກັບ​ເດືອນ​, и ແມ່ນຄ່າສໍາປະສິດການຖົດຖອຍຂອງເສັ້ນທີ່ຄາດຄະເນ.

ໃຫ້ສັງເກດວ່າຄ່າສໍາປະສິດ ມັກຈະເອີ້ນວ່າ slope ຫຼື gradient ຂອງເສັ້ນຄາດຄະເນ; ເປັນຕົວແທນຂອງຈໍານວນທີ່ ເມື່ອມັນປ່ຽນແປງ .

ແນ່ນອນ, ວຽກງານຂອງພວກເຮົາໃນຕົວຢ່າງແມ່ນການເລືອກຕົວຄູນດັ່ງກ່າວໃນສົມຜົນ и , ທີ່ deviations ຂອງມູນຄ່າລາຍຮັບຂອງພວກເຮົາຄິດໄລ່ໂດຍເດືອນຈາກຄໍາຕອບທີ່ແທ້ຈິງ, i.e. ຄ່າທີ່ນໍາສະເຫນີໃນຕົວຢ່າງຈະມີຫນ້ອຍ.

ວິທີການສີ່ຫຼ່ຽມນ້ອຍທີ່ສຸດ

ອີງຕາມວິທີການສີ່ຫຼ່ຽມນ້ອຍທີ່ສຸດ, ການບ່ຽງເບນຄວນຈະຖືກຄິດໄລ່ໂດຍການສີ່ຫລ່ຽມ. ເຕັກນິກນີ້ອະນຸຍາດໃຫ້ທ່ານເພື່ອຫຼີກເວັ້ນການຍົກເລີກເຊິ່ງກັນແລະກັນຂອງ deviations ຖ້າພວກເຂົາມີອາການກົງກັນຂ້າມ. ຕົວຢ່າງ, ຖ້າຢູ່ໃນກໍລະນີຫນຶ່ງ, ການບ່ຽງເບນແມ່ນ +5 (ບວກ​ຫ້າ​)​, ແລະ​ອື່ນໆ​ -5 (ລົບຫ້າ), ຫຼັງຈາກນັ້ນຜົນລວມຂອງ deviations ຈະຍົກເລີກເຊິ່ງກັນແລະກັນອອກແລະຈໍານວນ 0 (ສູນ). ມັນເປັນໄປໄດ້ທີ່ຈະບໍ່ສີ່ຫລ່ຽມ deviation, ແຕ່ໃຊ້ຄຸນສົມບັດຂອງໂມດູລແລະຫຼັງຈາກນັ້ນ deviation ທັງຫມົດຈະເປັນບວກແລະຈະສະສົມ. ພວກເຮົາຈະບໍ່ຢູ່ໃນຈຸດນີ້ໂດຍລະອຽດ, ແຕ່ພຽງແຕ່ຊີ້ໃຫ້ເຫັນວ່າເພື່ອຄວາມສະດວກຂອງການຄິດໄລ່, ມັນເປັນປະເພນີທີ່ຈະສີ່ຫລ່ຽມ deviation.

ນີ້ແມ່ນສິ່ງທີ່ສູດເບິ່ງຄືວ່າທີ່ພວກເຮົາຈະກໍານົດຜົນລວມຢ່າງຫນ້ອຍຂອງ deviations ຮຽບຮ້ອຍ (ຄວາມຜິດພາດ):

ບ່ອນທີ່ ແມ່ນຫນ້າທີ່ຂອງການປະມານຄໍາຕອບທີ່ແທ້ຈິງ (ນັ້ນແມ່ນ, ລາຍຮັບທີ່ພວກເຮົາຄິດໄລ່),

ແມ່ນຄໍາຕອບທີ່ແທ້ຈິງ (ລາຍຮັບທີ່ສະຫນອງໃຫ້ຢູ່ໃນຕົວຢ່າງ),

ແມ່ນດັດຊະນີຕົວຢ່າງ (ຈໍານວນຂອງເດືອນທີ່ deviation ຖືກກໍານົດ)

ໃຫ້ຄວາມແຕກຕ່າງຂອງຫນ້າທີ່, ກໍານົດສົມຜົນຄວາມແຕກຕ່າງບາງສ່ວນ, ແລະພ້ອມທີ່ຈະກ້າວໄປສູ່ການແກ້ໄຂການວິເຄາະ. ແຕ່ກ່ອນອື່ນໝົດ, ໃຫ້ພິຈາລະນາສັ້ນໆກ່ຽວກັບຄວາມແຕກຕ່າງ ແລະຈື່ຈຳຄວາມໝາຍທາງເລຂາຄະນິດຂອງອະນຸພັນ.

ຄວາມແຕກຕ່າງ

ຄວາມແຕກຕ່າງແມ່ນການປະຕິບັດງານຂອງການຄົ້ນຫາຜົນມາຈາກການທໍາງານ.

ອະນຸພັນທີ່ໃຊ້ເພື່ອຫຍັງ? ອະນຸພັນຂອງຟັງຊັນລັກສະນະອັດຕາການປ່ຽນແປງຂອງຫນ້າທີ່ແລະບອກພວກເຮົາທິດທາງຂອງມັນ. ຖ້າອະນຸພັນໃນຈຸດໃດນຶ່ງເປັນບວກ, ຟັງຊັນຈະເພີ່ມຂຶ້ນ, ຖ້າບໍ່ດັ່ງນັ້ນ, ຫນ້າທີ່ຫຼຸດລົງ. ແລະຫຼາຍມູນຄ່າຂອງອະນຸພັນຢ່າງແທ້ຈິງ, ອັດຕາການປ່ຽນແປງຂອງຄ່າຟັງຊັນທີ່ສູງຂຶ້ນ, ເຊັ່ນດຽວກັນກັບຄວາມຊັນຂອງກາຟຟັງຊັນ.

ຕົວຢ່າງ, ພາຍໃຕ້ເງື່ອນໄຂຂອງລະບົບປະສານງານ Cartesian, ຄ່າຂອງອະນຸພັນທີ່ຈຸດ M(0,0) ເທົ່າກັບ. + 25 ໝາຍ ຄວາມວ່າໃນຈຸດໃດ ໜຶ່ງ, ເມື່ອຄ່າຖືກປ່ຽນ ໄປທາງຂວາໂດຍຫົວໜ່ວຍທຳມະດາ, ຄ່າ ​ເພີ່ມ​ຂຶ້ນ 25 ໜ່ວຍ​ທຳ​ມະ​ດາ. ໃນກາຟມັນເບິ່ງຄືວ່າມີຄ່າເພີ່ມຂຶ້ນສູງຫຼາຍ ຈາກຈຸດໃດຫນຶ່ງ.

ຕົວຢ່າງອື່ນ. ຄ່າອະນຸພັນແມ່ນເທົ່າກັນ -0,1 ຫມາຍຄວາມວ່າເມື່ອຖືກຍົກຍ້າຍ ຕໍ່ໜຶ່ງຫົວໜ່ວຍທຳມະດາ, ຄ່າ ຫຼຸດລົງພຽງແຕ່ 0,1 ຫນ່ວຍທໍາມະດາ. ໃນຂະນະດຽວກັນ, ໃນກາຟຂອງຫນ້າທີ່, ພວກເຮົາສາມາດສັງເກດເຫັນຄວາມຊັນລົງລຸ່ມທີ່ບໍ່ຄ່ອຍສັງເກດເຫັນ. ແຕ້ມການປຽບທຽບກັບພູເຂົາ, ມັນຄືກັບວ່າພວກເຮົາລົງຊ້າໆລົງຈາກພູທີ່ອ່ອນໂຍນ, ບໍ່ຄືກັບຕົວຢ່າງທີ່ຜ່ານມາ, ບ່ອນທີ່ພວກເຮົາຕ້ອງປີນພູທີ່ສູງຊັນຫຼາຍ :)

ດັ່ງນັ້ນ, ຫຼັງຈາກຄວາມແຕກຕ່າງຂອງຫນ້າທີ່ ໂດຍບໍ່ລົງຮອຍກັນ и , ພວກເຮົາກໍານົດ 1st order partial equations . ຫຼັງຈາກກໍານົດສົມຜົນ, ພວກເຮົາຈະໄດ້ຮັບລະບົບຂອງສອງສົມຜົນ, ໂດຍການແກ້ໄຂທີ່ພວກເຮົາຈະສາມາດເລືອກເອົາຄ່າດັ່ງກ່າວຂອງສໍາປະສິດ. и , ເຊິ່ງຄ່າຂອງອະນຸພັນທີ່ສອດຄ້ອງກັນຢູ່ໃນຈຸດທີ່ໃຫ້ມີການປ່ຽນແປງໂດຍປະລິມານຫນ້ອຍຫຼາຍ, ແລະໃນກໍລະນີຂອງການແກ້ໄຂການວິເຄາະບໍ່ປ່ຽນແປງທັງຫມົດ. ໃນຄໍາສັບຕ່າງໆອື່ນໆ, ຫນ້າທີ່ຜິດພາດຢູ່ທີ່ຕົວຄູນທີ່ພົບເຫັນຈະບັນລຸຕໍາ່ສຸດທີ່, ເນື່ອງຈາກວ່າຄ່າຂອງອະນຸພັນບາງສ່ວນຢູ່ໃນຈຸດເຫຼົ່ານີ້ຈະເທົ່າກັບສູນ.

ດັ່ງນັ້ນ, ຕາມກົດລະບຽບຂອງຄວາມແຕກຕ່າງ, ສົມຜົນອະນຸພັນບາງສ່ວນຂອງຄໍາສັ່ງທີ 1 ກ່ຽວກັບຄ່າສໍາປະສິດ. ຈະ​ໃຊ້​ຮູບ​ແບບ​:

ລຳດັບທີ 1 ສົມຜົນອະນຸພັນບາງສ່ວນກ່ຽວກັບ ຈະ​ໃຊ້​ຮູບ​ແບບ​:

ດັ່ງນັ້ນ, ພວກເຮົາໄດ້ຮັບລະບົບສົມຜົນທີ່ມີການແກ້ໄຂການວິເຄາະທີ່ງ່າຍດາຍພໍສົມຄວນ:

ເລີ່ມ{ສົມຜົນ*}
ເລີ່ມ{ກໍລະນີ}
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
ສິ້ນສຸດ{cases}
ສິ້ນສຸດ{ສົມຜົນ*}

ກ່ອນທີ່ຈະແກ້ໄຂສົມຜົນ, ໃຫ້ພວກເຮົາ preload, ກວດເບິ່ງວ່າການໂຫຼດແມ່ນຖືກຕ້ອງ, ແລະຈັດຮູບແບບຂໍ້ມູນ.

ກຳລັງໂຫຼດ ແລະຈັດຮູບແບບຂໍ້ມູນ

ມັນຄວນຈະສັງເກດວ່າເນື່ອງຈາກຄວາມຈິງທີ່ວ່າສໍາລັບການແກ້ໄຂການວິເຄາະ, ແລະຕໍ່ມາສໍາລັບການ gradient ແລະ stochastic descent, ພວກເຮົາຈະນໍາໃຊ້ລະຫັດໃນສອງຕົວແປ: ການນໍາໃຊ້ຫ້ອງສະຫມຸດ. ຕົວເລກ ແລະໂດຍບໍ່ມີການນໍາໃຊ້ມັນ, ຫຼັງຈາກນັ້ນພວກເຮົາຈະຕ້ອງການການຈັດຮູບແບບຂໍ້ມູນທີ່ເຫມາະສົມ (ເບິ່ງລະຫັດ).

ການໂຫຼດຂໍ້ມູນ ແລະລະຫັດການປະມວນຜົນ

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

ການເບິ່ງເຫັນ

ໃນປັດຈຸບັນ, ຫຼັງຈາກທີ່ພວກເຮົາມີ, ທໍາອິດ, ໂຫຼດຂໍ້ມູນ, ອັນທີສອງ, ກວດເບິ່ງຄວາມຖືກຕ້ອງຂອງການໂຫຼດແລະສຸດທ້າຍໄດ້ຮູບແບບຂໍ້ມູນ, ພວກເຮົາຈະປະຕິບັດການເບິ່ງເຫັນຄັ້ງທໍາອິດ. ວິທີການທີ່ໃຊ້ເລື້ອຍໆສໍາລັບການນີ້ແມ່ນ ແຜນຄູ່ ຫ້ອງສະ ໝຸດ ທະເລ. ໃນຕົວຢ່າງຂອງພວກເຮົາ, ເນື່ອງຈາກຈໍານວນຈໍາກັດ, ບໍ່ມີຈຸດໃດໃນການນໍາໃຊ້ຫ້ອງສະຫມຸດ ທະເລ. ພວກເຮົາຈະໃຊ້ຫ້ອງສະຫມຸດປົກກະຕິ matplotlib ແລະພຽງແຕ່ເບິ່ງຢູ່ໃນກະແຈກກະຈາຍ.

ລະຫັດ 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()

ຕາຕະລາງເລກທີ 1 “ການຂຶ້ນກັບລາຍຮັບຂອງເດືອນຂອງປີ”

ການແກ້ໄຂການວິເຄາະ

ໃຫ້ໃຊ້ເຄື່ອງມືທົ່ວໄປທີ່ສຸດໃນ python ແລະ​ແກ້​ໄຂ​ລະ​ບົບ​ຂອງ​ສົມ​ຜົນ​:

ເລີ່ມ{ສົມຜົນ*}
ເລີ່ມ{ກໍລະນີ}
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
ສິ້ນສຸດ{cases}
ສິ້ນສຸດ{ສົມຜົນ*}

ຕາມກົດລະບຽບຂອງ Cramer ພວກເຮົາຈະຊອກຫາຕົວກໍານົດທົ່ວໄປ, ເຊັ່ນດຽວກັນກັບຕົວກໍານົດໂດຍ ແລະໂດຍ , ຫຼັງຈາກນັ້ນ, ການແບ່ງຕົວກໍານົດໂດຍ ໄປຫາຕົວກໍານົດທົ່ວໄປ - ຊອກຫາຄ່າສໍາປະສິດ , ເຊັ່ນດຽວກັນພວກເຮົາຊອກຫາຄ່າສໍາປະສິດ .

ລະຫັດການແກ້ໄຂການວິເຄາະ

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

ນີ້ແມ່ນສິ່ງທີ່ພວກເຮົາໄດ້ຮັບ:

ດັ່ງນັ້ນ, ຄ່າຂອງຄ່າສໍາປະສິດໄດ້ຖືກພົບເຫັນ, ຜົນລວມຂອງ deviations ຮຽບຮ້ອຍໄດ້ຖືກສ້າງຕັ້ງຂຶ້ນ. ໃຫ້ແຕ້ມເສັ້ນຊື່ໃສ່ histogram ກະແຈກກະຈາຍຕາມຄ່າສໍາປະສິດທີ່ພົບເຫັນ.

ລະຫັດເສັ້ນ Regression

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

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

ຕາຕະລາງ 2 "ຄໍາຕອບທີ່ຖືກຕ້ອງແລະຄໍານວນ"

ທ່ານສາມາດເບິ່ງຕາຕະລາງ deviation ສໍາລັບແຕ່ລະເດືອນ. ໃນກໍລະນີຂອງພວກເຮົາ, ພວກເຮົາຈະບໍ່ໄດ້ຮັບມູນຄ່າການປະຕິບັດທີ່ສໍາຄັນໃດໆຈາກມັນ, ແຕ່ພວກເຮົາຈະຕອບສະຫນອງຄວາມຢາກຮູ້ຢາກເຫັນຂອງພວກເຮົາກ່ຽວກັບສົມຜົນການຖົດຖອຍແບບເສັ້ນແບບງ່າຍດາຍສະແດງໃຫ້ເຫັນເຖິງການເພິ່ງພາອາໄສຂອງລາຍໄດ້ໃນເດືອນຂອງປີ.

ລະຫັດຕາຕະລາງ deviation

# определим функцию для формирования массива отклонений в процентах
def error_per_month(ab,x,y):
    sales_c = sales_count(ab,x,y)
    errors_percent = []
    for i in range(len(x)):
        errors_percent.append(100*(sales_c[i]-y[i])/y[i])
    return errors_percent

# построим график
print 'График№3 "Отклонения по-месячно, %"'
plt.gca().bar(x_us, error_per_month(ab_us,x_us,y_us), color='brown')
plt.xlabel('Months', size=16)
plt.ylabel('Calculation error, %', size=16)
plt.show()

ຕາຕະລາງທີ 3 “ການບ່ຽງເບນ, %”

ບໍ່ສົມບູນແບບ, ແຕ່ພວກເຮົາເຮັດສໍາເລັດວຽກງານຂອງພວກເຮົາ.

ໃຫ້ຂຽນຫນ້າທີ່, ເພື່ອກໍານົດຄ່າສໍາປະສິດ и ໃຊ້ຫ້ອງສະຫມຸດ ຕົວເລກ, ຊັດເຈນກວ່ານັ້ນ, ພວກເຮົາຈະຂຽນສອງຫນ້າທີ່: ຫນຶ່ງໃຊ້ pseudoinverse matrix (ບໍ່ແນະນໍາໃນການປະຕິບັດ, ເນື່ອງຈາກວ່າຂະບວນການແມ່ນສັບສົນແລະບໍ່ຫມັ້ນຄົງ), ອື່ນໃຊ້ສົມຜົນ matrix.

ລະຫັດການແກ້ໄຂການວິເຄາະ (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

ໃຫ້ສົມທຽບເວລາທີ່ໃຊ້ໃນການກໍານົດຄ່າສໍາປະສິດ и , ອີງຕາມ 3 ວິທີການທີ່ນໍາສະເຫນີ.

ລະຫັດສໍາລັບການຄິດໄລ່ເວລາການຄິດໄລ່

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)

ດ້ວຍຂໍ້ມູນຈໍານວນນ້ອຍໆ, ຟັງຊັນ "ຂຽນດ້ວຍຕົນເອງ" ອອກມາກ່ອນ, ເຊິ່ງຊອກຫາຄ່າສໍາປະສິດໂດຍໃຊ້ວິທີການຂອງ Cramer.

ຕອນນີ້ທ່ານສາມາດກ້າວໄປສູ່ວິທີອື່ນເພື່ອຊອກຫາຄ່າສໍາປະສິດໄດ້ и .

Gradient Descent

ທໍາອິດ, ໃຫ້ກໍານົດສິ່ງທີ່ gradient ແມ່ນຫຍັງ. ເວົ້າງ່າຍໆ, gradient ແມ່ນສ່ວນທີ່ຊີ້ບອກທິດທາງການຂະຫຍາຍຕົວສູງສຸດຂອງຟັງຊັນ. ໂດຍການປຽບທຽບກັບການປີນພູ, ບ່ອນທີ່ gradient ປະເຊີນຫນ້າແມ່ນບ່ອນທີ່ steepest ປີນຂຶ້ນເທິງຂອງພູເຂົາ. ການພັດທະນາຕົວຢ່າງທີ່ມີພູເຂົາ, ພວກເຮົາຈື່ໄວ້ວ່າໃນຄວາມເປັນຈິງພວກເຮົາຕ້ອງການການສືບເຊື້ອສາຍ steepest ໃນຄໍາສັ່ງທີ່ຈະສາມາດບັນລຸເຂດທົ່ງພຽງໄວເທົ່າທີ່ເປັນໄປໄດ້, ນັ້ນແມ່ນ, ຕໍາ່ສຸດທີ່ - ສະຖານທີ່ທີ່ບໍ່ມີຫນ້າທີ່ເພີ່ມຂຶ້ນຫຼືຫຼຸດລົງ. ໃນຈຸດນີ້, ອະນຸພັນຈະເທົ່າກັບສູນ. ດັ່ງນັ້ນ, ພວກເຮົາບໍ່ຕ້ອງການ gradient, ແຕ່ antigradient. ເພື່ອຊອກຫາ antigradient ທ່ານພຽງແຕ່ຕ້ອງການຄູນ gradient ໂດຍ -1 (ລົບຫນຶ່ງ).

ໃຫ້ພວກເຮົາເອົາໃຈໃສ່ກັບຄວາມຈິງທີ່ວ່າຟັງຊັນຫນຶ່ງສາມາດມີຫຼາຍ minima, ແລະໄດ້ລົງໄປຫາຫນຶ່ງໃນນັ້ນໂດຍໃຊ້ algorithm ທີ່ສະເຫນີຂ້າງລຸ່ມນີ້, ພວກເຮົາຈະບໍ່ສາມາດຊອກຫາຕໍາ່ສຸດທີ່ອື່ນ, ເຊິ່ງອາດຈະຕ່ໍາກວ່າທີ່ພົບ. ໃຫ້ຜ່ອນຄາຍ, ນີ້ບໍ່ແມ່ນໄພຂົ່ມຂູ່ຕໍ່ພວກເຮົາ! ໃນກໍລະນີຂອງພວກເຮົາພວກເຮົາກໍາລັງຈັດການກັບຕໍາ່ສຸດທີ່ຫນຶ່ງ, ນັບຕັ້ງແຕ່ຫນ້າທີ່ຂອງພວກເຮົາ ໃນເສັ້ນສະແດງແມ່ນ parabola ປົກກະຕິ. ແລະດັ່ງທີ່ພວກເຮົາທຸກຄົນຄວນຮູ້ດີຈາກຫຼັກສູດຄະນິດສາດຂອງໂຮງຮຽນຂອງພວກເຮົາ, parabola ມີພຽງແຕ່ຫນຶ່ງຕໍາ່ສຸດທີ່.

ຫຼັງຈາກທີ່ພວກເຮົາຄົ້ນພົບວ່າເປັນຫຍັງພວກເຮົາຕ້ອງການ gradient, ແລະອີກວ່າ gradient ແມ່ນສ່ວນຫນຶ່ງ, ນັ້ນແມ່ນ, vector ທີ່ມີຈຸດປະສານງານທີ່ໃຫ້, ຊຶ່ງເປັນຄ່າສໍາປະສິດດຽວກັນທີ່ຊັດເຈນ. и ພວກເຮົາສາມາດປະຕິບັດການສືບເຊື້ອສາຍ gradient.

ກ່ອນທີ່ຈະເລີ່ມຕົ້ນ, ຂ້າພະເຈົ້າແນະນໍາໃຫ້ອ່ານພຽງແຕ່ສອງສາມປະໂຫຍກກ່ຽວກັບສູດການສືບເຊື້ອສາຍ:

• ພວກ​ເຮົາ​ກໍາ​ນົດ​ໃນ​ລັກ​ສະ​ນະ pseudo​-random ການ​ປະ​ສານ​ງານ​ຂອງ​ສໍາ​ປະ​ສິດ​ и . ໃນຕົວຢ່າງຂອງພວກເຮົາ, ພວກເຮົາຈະກໍານົດຄ່າສໍາປະສິດຢູ່ໃກ້ກັບສູນ. ນີ້ແມ່ນການປະຕິບັດທົ່ວໄປ, ແຕ່ແຕ່ລະກໍລະນີອາດຈະມີການປະຕິບັດຂອງຕົນເອງ.
• ຈາກການປະສານງານ ຫັກຄ່າຂອງອະນຸພັນສ່ວນໜຶ່ງຂອງລຳດັບທີ 1 ຢູ່ຈຸດ . ດັ່ງນັ້ນ, ຖ້າອະນຸພັນແມ່ນບວກ, ຫຼັງຈາກນັ້ນ, ຫນ້າທີ່ເພີ່ມຂຶ້ນ. ດັ່ງນັ້ນ, ໂດຍການຫັກຄ່າຂອງອະນຸພັນ, ພວກເຮົາຈະກ້າວໄປໃນທິດທາງກົງກັນຂ້າມຂອງການເຕີບໂຕ, ນັ້ນແມ່ນ, ໃນທິດທາງຂອງການສືບເຊື້ອສາຍ. ຖ້າອະນຸພັນເປັນລົບ, ຫຼັງຈາກນັ້ນ, ຫນ້າທີ່ຢູ່ໃນຈຸດນີ້ຫຼຸດລົງແລະໂດຍການຫັກຄ່າຂອງອະນຸພັນທີ່ພວກເຮົາຍ້າຍອອກໄປໃນທິດທາງຂອງການສືບເຊື້ອສາຍ.
• ພວກເຮົາປະຕິບັດການປະຕິບັດງານທີ່ຄ້າຍຄືກັນກັບການປະສານງານ : ລົບຄ່າຂອງອະນຸພັນບາງສ່ວນຢູ່ທີ່ຈຸດ .
• ໃນຄໍາສັ່ງທີ່ຈະບໍ່ເຕັ້ນໄປຫາຕໍາ່ສຸດທີ່ແລະບິນເຂົ້າໄປໃນຊ່ອງເລິກ, ມັນຈໍາເປັນຕ້ອງໄດ້ກໍານົດຂະຫນາດຂັ້ນຕອນໃນທິດທາງຂອງການສືບເຊື້ອສາຍ. ໂດຍທົ່ວໄປ, ທ່ານສາມາດຂຽນບົດຄວາມທັງຫມົດກ່ຽວກັບວິທີການກໍານົດຂັ້ນຕອນຢ່າງຖືກຕ້ອງແລະວິທີການປ່ຽນມັນໃນລະຫວ່າງການຂະບວນການສືບເຊື້ອສາຍເພື່ອຫຼຸດຜ່ອນຄ່າໃຊ້ຈ່າຍໃນຄອມພິວເຕີ້. ແຕ່ໃນປັດຈຸບັນພວກເຮົາມີວຽກງານທີ່ແຕກຕ່າງກັນເລັກນ້ອຍຢູ່ຂ້າງຫນ້າຂອງພວກເຮົາ, ແລະພວກເຮົາຈະສ້າງຂະຫນາດຂັ້ນຕອນໂດຍໃຊ້ວິທີການວິທະຍາສາດຂອງ "poke" ຫຼື, ຍ້ອນວ່າພວກເຂົາເວົ້າໃນຄໍາສັບທົ່ວໄປ, ໃນທາງທິດສະດີ.
• ເມື່ອພວກເຮົາມາຈາກຈຸດປະສານງານ и ລົບຄ່າຂອງອະນຸພັນ, ພວກເຮົາໄດ້ຮັບການປະສານງານໃຫມ່ и . ພວກເຮົາເອົາຂັ້ນຕອນຕໍ່ໄປ (ການລົບ), ແລ້ວຈາກຈຸດປະສານງານທີ່ຄິດໄລ່. ແລະດັ່ງນັ້ນວົງຈອນເລີ່ມຕົ້ນອີກເທື່ອຫນຶ່ງແລະອີກເທື່ອຫນຶ່ງ, ຈົນກ່ວາ convergence ທີ່ກໍານົດໄວ້ແມ່ນບັນລຸໄດ້.

ທັງໝົດ! ຕອນນີ້ພວກເຮົາພ້ອມທີ່ຈະໄປຊອກຫາບ່ອນເລິກທີ່ສຸດຂອງຮ່ອງຮອຍ Mariana Trench. ໃຫ້ເລີ່ມຕົ້ນ.

ລະຫັດສໍາລັບການສືບເຊື້ອສາຍ 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

ພວກ​ເຮົາ​ໄດ້​ດຳ​ລົງ​ໄປ​ສູ່​ລຸ່ມ​ສຸດ​ຂອງ Mariana Trench ແລະ​ຢູ່​ທີ່​ນັ້ນ ພວກ​ເຮົາ​ໄດ້​ພົບ​ເຫັນ​ຄ່າ​ສຳ​ປະ​ສິດ​ດຽວ​ກັນ​ທັງ​ໝົດ и , ຊຶ່ງເປັນສິ່ງທີ່ຄາດຫວັງ.

ພາກັນໄປດຳນ້ຳອີກ, ສະເພາະຊ່ວງນີ້ລົດນ້ຳເລິກຂອງພວກເຮົາຈະເຕັມໄປດ້ວຍເທັກໂນໂລຍີອື່ນໆຄືຫໍສະໝຸດ. ຕົວເລກ.

ລະຫັດສໍາລັບການສືບເຊື້ອສາຍ (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

ຄ່າສຳປະສິດ и ປ່ຽນແປງບໍ່ໄດ້.

ຂໍໃຫ້ເບິ່ງວິທີການທີ່ຄວາມຜິດພາດໄດ້ປ່ຽນແປງໃນລະຫວ່າງການສືບເຊື້ອສາຍ gradient, ນັ້ນແມ່ນ, ຜົນລວມຂອງ deviations ສີ່ຫລ່ຽມໄດ້ປ່ຽນແປງກັບແຕ່ລະຂັ້ນຕອນ.

ລະຫັດສໍາລັບການວາງແຜນຜົນບວກຂອງ deviations ຮຽບຮ້ອຍ

print 'График№4 "Сумма квадратов отклонений по-шагово"'
plt.plot(range(len(list_parametres_gradient_descence[1])), list_parametres_gradient_descence[1], color='red', lw=3)
plt.xlabel('Steps (Iteration)', size=16)
plt.ylabel('Sum of squared deviations', size=16)
plt.show()

ເສັ້ນສະແດງທີ 4 “ຜົນລວມຂອງການບ່ຽງເບນສີ່ຫຼ່ຽມລະຫວ່າງການສືບເຊື້ອສາຍ gradient”

ໃນກາຟທີ່ພວກເຮົາເຫັນວ່າໃນແຕ່ລະຂັ້ນຕອນຄວາມຜິດພາດຫຼຸດລົງ, ແລະຫຼັງຈາກຈໍານວນທີ່ແນ່ນອນຂອງ iterations ພວກເຮົາສັງເກດເຫັນເສັ້ນອອກຕາມລວງນອນເກືອບ.

ສຸດທ້າຍ, ໃຫ້ປະເມີນຄວາມແຕກຕ່າງຂອງເວລາປະຕິບັດລະຫັດ:

ລະຫັດເພື່ອກໍານົດເວລາການຄິດໄລ່ gradient descent

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)

ບາງທີພວກເຮົາກໍາລັງເຮັດບາງສິ່ງບາງຢ່າງທີ່ຜິດພາດ, ແຕ່ອີກເທື່ອຫນຶ່ງມັນເປັນຫນ້າທີ່ "ຂຽນຢູ່ເຮືອນ" ທີ່ງ່າຍດາຍທີ່ບໍ່ໃຊ້ຫ້ອງສະຫມຸດ. ຕົວເລກ ເຮັດວຽກຫຼາຍກວ່າເວລາການຄິດໄລ່ຂອງຟັງຊັນທີ່ໃຊ້ຫ້ອງສະໝຸດ ຕົວເລກ.

ແຕ່ພວກເຮົາບໍ່ໄດ້ຢືນຢູ່, ແຕ່ກໍາລັງກ້າວໄປສູ່ການສຶກສາອີກວິທີຫນຶ່ງທີ່ຫນ້າຕື່ນເຕັ້ນທີ່ຈະແກ້ໄຂສົມຜົນ regression linear ງ່າຍດາຍ. ພົບກັນ!

Stochastic gradient descent

ເພື່ອໃຫ້ເຂົ້າໃຈເຖິງຫຼັກການຂອງການດໍາເນີນງານຂອງການສືບເຊື້ອສາຍ gradient stochastic, ມັນດີກວ່າທີ່ຈະກໍານົດຄວາມແຕກຕ່າງຂອງມັນຈາກການສືບເຊື້ອສາຍ gradient ທົ່ວໄປ. ພວກເຮົາ, ໃນກໍລະນີຂອງການສືບເຊື້ອສາຍ gradient, ໃນສົມຜົນຂອງອະນຸພັນຂອງ и ໄດ້ນໍາໃຊ້ຜົນລວມຂອງຄ່າຂອງລັກສະນະທັງຫມົດແລະຄໍາຕອບທີ່ແທ້ຈິງທີ່ມີຢູ່ໃນຕົວຢ່າງ (ນັ້ນແມ່ນ, ຜົນລວມຂອງທັງຫມົດ. и ). ໃນ stochastic gradient descent, ພວກເຮົາຈະບໍ່ນໍາໃຊ້ຄ່າທັງຫມົດທີ່ມີຢູ່ໃນຕົວຢ່າງ, ແຕ່ແທນທີ່ຈະ, pseudo-random ເລືອກອັນທີ່ເອີ້ນວ່າດັດຊະນີຕົວຢ່າງແລະນໍາໃຊ້ຄ່າຂອງມັນ.

ຕົວຢ່າງ, ຖ້າດັດຊະນີຖືກກໍານົດວ່າເປັນຕົວເລກ 3 (ສາມ), ຫຼັງຈາກນັ້ນພວກເຮົາເອົາຄ່າ и , ຫຼັງຈາກນັ້ນພວກເຮົາທົດແທນຄ່າເຂົ້າໄປໃນສົມຜົນອະນຸພັນແລະກໍານົດຈຸດປະສານງານໃຫມ່. ຫຼັງຈາກນັ້ນ, ໂດຍໄດ້ກໍານົດຈຸດປະສານງານ, ພວກເຮົາອີກເທື່ອຫນຶ່ງ pseudo-random ກໍານົດດັດຊະນີຕົວຢ່າງ, ທົດແທນຄ່າທີ່ສອດຄ້ອງກັນກັບດັດຊະນີເຂົ້າໄປໃນສົມຜົນຄວາມແຕກຕ່າງບາງສ່ວນ, ແລະກໍານົດຈຸດປະສານງານໃນຮູບແບບໃຫມ່. и ແລະອື່ນໆ ຈົນກ່ວາ convergence ປ່ຽນເປັນສີຂຽວ. ຢູ່ glance ທໍາອິດ, ມັນອາດຈະບໍ່ເບິ່ງຄືວ່ານີ້ສາມາດເຮັດວຽກໄດ້ທັງຫມົດ, ແຕ່ມັນເຮັດໄດ້. ມັນເປັນຄວາມຈິງທີ່ວ່າມັນເປັນມູນຄ່າທີ່ສັງເກດວ່າຄວາມຜິດພາດບໍ່ໄດ້ຫຼຸດລົງກັບທຸກໆຂັ້ນຕອນ, ແຕ່ແນ່ນອນວ່າມີແນວໂນ້ມ.

ຂໍ້ດີຂອງການສືບເຊື້ອສາຍ gradient stochastic ຫຼາຍກວ່າແບບທໍາມະດາແມ່ນຫຍັງ? ຖ້າຂະຫນາດຕົວຢ່າງຂອງພວກເຮົາມີຂະຫນາດໃຫຍ່ຫຼາຍແລະຖືກວັດແທກເປັນສິບພັນຄ່າ, ຫຼັງຈາກນັ້ນມັນງ່າຍຕໍ່ການປຸງແຕ່ງ, ເວົ້າວ່າ, ເປັນພັນຕົວແບບສຸ່ມ, ແທນທີ່ຈະເປັນຕົວຢ່າງທັງຫມົດ. ນີ້ແມ່ນບ່ອນທີ່ການສືບເຊື້ອສາຍ gradient stochastic ເຂົ້າມາຫຼິ້ນ. ໃນກໍລະນີຂອງພວກເຮົາ, ແນ່ນອນ, ພວກເຮົາຈະບໍ່ສັງເກດເຫັນຄວາມແຕກຕ່າງຫຼາຍ.

ໃຫ້ເບິ່ງລະຫັດ.

ລະຫັດສໍາລັບການສືບເຊື້ອສາຍ 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])

ພວກເຮົາເບິ່ງຄ່າສໍາປະສິດຢ່າງລະມັດລະວັງແລະຈັບຕົວເຮົາເອງຖາມຄໍາຖາມ "ມັນເປັນໄປໄດ້ແນວໃດ?" ພວກເຮົາໄດ້ຮັບຄ່າສໍາປະສິດອື່ນໆ и . ບາງທີການສືບເຊື້ອສາຍ gradient stochastic ໄດ້ພົບເຫັນຕົວກໍານົດການທີ່ດີທີ່ສຸດສໍາລັບສົມຜົນ? ແຕ່ຫນ້າເສຍດາຍທີ່ບໍ່ມີ. ມັນພຽງພໍທີ່ຈະເບິ່ງຜົນລວມຂອງ deviations squared ແລະເຫັນວ່າດ້ວຍຄ່າໃຫມ່ຂອງຄ່າສໍາປະສິດ, ຄວາມຜິດພາດແມ່ນໃຫຍ່ກວ່າ. ພວກເຮົາບໍ່ຮີບຮ້ອນທີ່ຈະໝົດຫວັງ. ໃຫ້ສ້າງເສັ້ນສະແດງຂອງການປ່ຽນແປງຄວາມຜິດພາດ.

ລະຫັດສໍາລັບການວາງແຜນຜົນລວມຂອງ deviations ຮຽບຮ້ອຍໃນ stochastic gradient descent

print 'График №5 "Сумма квадратов отклонений по-шагово"'
plt.plot(range(len(list_parametres_stoch_gradient_descence[1])), list_parametres_stoch_gradient_descence[1], color='red', lw=2)
plt.xlabel('Steps (Iteration)', size=16)
plt.ylabel('Sum of squared deviations', size=16)
plt.show()

ເສັ້ນສະແດງທີ 5 “ຜົນລວມຂອງການບ່ຽງເບນສີ່ຫຼ່ຽມລະຫວ່າງການສືບເຊື້ອສາຍ gradient stochastic”

ຊອກຫາຢູ່ໃນຕາຕະລາງ, ທຸກສິ່ງທຸກຢ່າງຕົກເຂົ້າໄປໃນສະຖານທີ່ແລະໃນປັດຈຸບັນພວກເຮົາຈະແກ້ໄຂທຸກສິ່ງທຸກຢ່າງ.

ດັ່ງນັ້ນສິ່ງທີ່ເກີດຂຶ້ນ? ຕໍ່ໄປນີ້ເກີດຂຶ້ນ. ເມື່ອພວກເຮົາເລືອກເດືອນແບບສຸ່ມ, ມັນແມ່ນສໍາລັບເດືອນທີ່ເລືອກທີ່ algorithm ຂອງພວກເຮົາຊອກຫາເພື່ອຫຼຸດຜ່ອນຄວາມຜິດພາດໃນການຄິດໄລ່ລາຍໄດ້. ຫຼັງຈາກນັ້ນ, ພວກເຮົາເລືອກເດືອນອື່ນແລະເຮັດຊ້ໍາການຄິດໄລ່, ແຕ່ພວກເຮົາຫຼຸດຜ່ອນຄວາມຜິດພາດສໍາລັບເດືອນທີ່ເລືອກທີສອງ. ໃນປັດຈຸບັນຈື່ໄວ້ວ່າສອງເດືອນທໍາອິດ deviate ຢ່າງຫຼວງຫຼາຍຈາກເສັ້ນຂອງສົມຜົນ regression ເສັ້ນງ່າຍດາຍ. ນີ້ຫມາຍຄວາມວ່າເມື່ອໃດໃນສອງເດືອນນີ້ຖືກເລືອກ, ໂດຍການຫຼຸດຜ່ອນຄວາມຜິດພາດຂອງແຕ່ລະຄົນ, algorithm ຂອງພວກເຮົາຈະເພີ່ມຄວາມຜິດພາດສໍາລັບຕົວຢ່າງທັງຫມົດ. ດັ່ງນັ້ນສິ່ງທີ່ຕ້ອງເຮັດ? ຄໍາຕອບແມ່ນງ່າຍດາຍ: ທ່ານຈໍາເປັນຕ້ອງຫຼຸດຜ່ອນຂັ້ນຕອນການສືບເຊື້ອສາຍ. ຫຼັງຈາກທີ່ທັງຫມົດ, ໂດຍການຫຼຸດຜ່ອນຂັ້ນຕອນທີ່ສືບເຊື້ອສາຍ, ຄວາມຜິດພາດຍັງຈະຢຸດ "ໂດດ" ຂຶ້ນແລະລົງ. ຫຼືແທນທີ່ຈະ, ຄວາມຜິດພາດ "ໂດດ" ຈະບໍ່ຢຸດ, ແຕ່ມັນຈະບໍ່ເຮັດຢ່າງໄວວາ :) ໃຫ້ກວດເບິ່ງ.

ລະຫັດເພື່ອດໍາເນີນການ SGD ດ້ວຍການເພີ່ມຂຶ້ນຫນ້ອຍລົງ

# запустим функцию, уменьшив шаг в 100 раз и увеличив количество шагов соответсвующе 
list_parametres_stoch_gradient_descence = stoch_grad_descent_usual(x_us, y_us, l=0.001, steps = 80000)

print ' 33[1m' + ' 33[4m' + "Значения коэффициентов a и b:" + ' 33[0m'
print 'a =', round(list_parametres_stoch_gradient_descence[0][0],3)
print 'b =', round(list_parametres_stoch_gradient_descence[0][1],3)
print


print ' 33[1m' + ' 33[4m' + "Сумма квадратов отклонений:" + ' 33[0m'
print round(list_parametres_stoch_gradient_descence[1][-1],3)
print



print ' 33[1m' + ' 33[4m' + "Количество итераций в стохастическом градиентном спуске:" + ' 33[0m'
print len(list_parametres_stoch_gradient_descence[1])

print 'График №6 "Сумма квадратов отклонений по-шагово"'
plt.plot(range(len(list_parametres_stoch_gradient_descence[1])), list_parametres_stoch_gradient_descence[1], color='red', lw=2)
plt.xlabel('Steps (Iteration)', size=16)
plt.ylabel('Sum of squared deviations', size=16)
plt.show()

ເສັ້ນສະແດງທີ 6 “ຜົນລວມຂອງການບ່ຽງເບນສີ່ຫຼ່ຽມລະຫວ່າງການສືບເຊື້ອສາຍ gradient stochastic (80 ພັນຂັ້ນຕອນ)”

ຄ່າສໍາປະສິດໄດ້ຮັບການປັບປຸງ, ແຕ່ຍັງບໍ່ເຫມາະສົມ. ໂດຍສົມມຸດຕິຖານ, ນີ້ສາມາດຖືກແກ້ໄຂດ້ວຍວິທີນີ້. ພວກເຮົາເລືອກເອົາ, ສໍາລັບການຍົກຕົວຢ່າງ, ໃນ 1000 iterations ທີ່ຜ່ານມາ, ຄ່າຂອງສໍາປະສິດທີ່ມີຄວາມຜິດພາດຕໍາ່ສຸດທີ່ໄດ້ເຮັດ. ແທ້ຈິງແລ້ວ, ສໍາລັບການນີ້ພວກເຮົາຍັງຈະຕ້ອງຂຽນລົງຄ່າຂອງຕົວຄູນດ້ວຍຕົນເອງ. ພວກເຮົາຈະບໍ່ເຮັດແນວນີ້, ແຕ່ແທນທີ່ຈະເອົາໃຈໃສ່ກັບຕາຕະລາງ. ມັນເບິ່ງຄືວ່າກ້ຽງແລະຄວາມຜິດພາດເບິ່ງຄືວ່າຈະຫຼຸດລົງຢ່າງເທົ່າທຽມກັນ. ໃນຄວາມເປັນຈິງ, ນີ້ບໍ່ແມ່ນຄວາມຈິງ. ລອງເບິ່ງ 1000 ເທື່ອທຳອິດ ແລະປຽບທຽບກັບອັນສຸດທ້າຍ.

ລະຫັດສໍາລັບຕາຕະລາງ SGD (1000 ຂັ້ນຕອນທໍາອິດ)

print 'График №7 "Сумма квадратов отклонений по-шагово. Первые 1000 итераций"'
plt.plot(range(len(list_parametres_stoch_gradient_descence[1][:1000])), 
         list_parametres_stoch_gradient_descence[1][:1000], color='red', lw=2)
plt.xlabel('Steps (Iteration)', size=16)
plt.ylabel('Sum of squared deviations', size=16)
plt.show()

print 'График №7 "Сумма квадратов отклонений по-шагово. Последние 1000 итераций"'
plt.plot(range(len(list_parametres_stoch_gradient_descence[1][-1000:])), 
         list_parametres_stoch_gradient_descence[1][-1000:], color='red', lw=2)
plt.xlabel('Steps (Iteration)', size=16)
plt.ylabel('Sum of squared deviations', size=16)
plt.show()

ກຣາບທີ 7 “ຜົນລວມຂອງການບ່ຽງເບນສີ່ຫຼ່ຽມ SGD (1000 ຂັ້ນຕອນທຳອິດ)”

ກຣາບເລກ 8 “ຜົນລວມຂອງການບ່ຽງເບນສີ່ຫຼ່ຽມ SGD (1000 ຂັ້ນຕອນສຸດທ້າຍ)”

ໃນຕອນເລີ່ມຕົ້ນຂອງການສືບເຊື້ອສາຍ, ພວກເຮົາສັງເກດເຫັນຄວາມເປັນເອກະພາບທີ່ຂ້ອນຂ້າງແລະຄວາມຜິດພາດທີ່ຫຼຸດລົງ. ໃນ iterations ທີ່ຜ່ານມາ, ພວກເຮົາເຫັນວ່າຄວາມຜິດພາດໄປປະມານແລະປະມານຄ່າຂອງ 1,475 ແລະໃນບາງຊ່ວງເວລາເຖິງແມ່ນວ່າເທົ່າກັບມູນຄ່າທີ່ດີທີ່ສຸດນີ້, ແຕ່ຫຼັງຈາກນັ້ນມັນຍັງຂຶ້ນ ... ຂ້າພະເຈົ້າເຮັດຊ້ໍາ, ທ່ານສາມາດຂຽນລົງຄ່າຂອງ. ຄ່າສໍາປະສິດ и , ແລະຫຼັງຈາກນັ້ນເລືອກເອົາສິ່ງທີ່ຄວາມຜິດພາດແມ່ນຫນ້ອຍທີ່ສຸດ. ຢ່າງໃດກໍ່ຕາມ, ພວກເຮົາມີບັນຫາທີ່ຮ້າຍແຮງກວ່າເກົ່າ: ພວກເຮົາຕ້ອງໃຊ້ເວລາ 80 ພັນຂັ້ນຕອນ (ເບິ່ງລະຫັດ) ເພື່ອໃຫ້ໄດ້ຮັບຄ່າທີ່ໃກ້ຄຽງກັບທີ່ດີທີ່ສຸດ. ແລະນີ້ແລ້ວກົງກັນຂ້າມກັບຄວາມຄິດຂອງການປະຫຍັດເວລາຂອງຄອມພິວເຕີ້ກັບ stochastic gradient descent ທຽບກັບ gradient descent. ສິ່ງທີ່ສາມາດແກ້ໄຂແລະປັບປຸງໄດ້? ມັນບໍ່ຍາກທີ່ຈະສັງເກດເຫັນວ່າໃນ iterations ທໍາອິດພວກເຮົາມີຄວາມຫມັ້ນໃຈທີ່ຈະຫຼຸດລົງແລະດັ່ງນັ້ນ, ພວກເຮົາຄວນຈະອອກຈາກບາດກ້າວຂະຫນາດໃຫຍ່ໃນ iterations ທໍາອິດແລະຫຼຸດຜ່ອນບາດກ້າວທີ່ພວກເຮົາກ້າວໄປຂ້າງຫນ້າ. ພວກເຮົາຈະບໍ່ເຮັດໃນບົດຄວາມນີ້ - ມັນຍາວເກີນໄປແລ້ວ. ຜູ້​ທີ່​ປາ​ຖະ​ຫນາ​ສາ​ມາດ​ຄິດ​ສໍາ​ລັບ​ຕົນ​ເອງ​ວ່າ​ຈະ​ເຮັດ​ແນວ​ນີ້​, ມັນ​ບໍ່​ແມ່ນ​ການ​ຍາກ :)

ຕອນນີ້ໃຫ້ພວກເຮົາປະຕິບັດການສືບເຊື້ອສາຍ gradient stochastic ໂດຍໃຊ້ຫ້ອງສະຫມຸດ ຕົວເລກ (ແລະ​ຢ່າ​ສະ​ດຸດ​ຕໍ່​ກ້ອນ​ຫີນ​ທີ່​ພວກ​ເຮົາ​ໄດ້​ລະ​ບຸ​ໄວ້​ກ່ອນ​ຫນ້າ​ນີ້​)

ລະຫັດສໍາລັບ Stochastic Gradient Descent (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

ຄ່າໄດ້ຫັນອອກເກືອບຄືກັນກັບເວລາທີ່ຫຼຸດລົງໂດຍບໍ່ມີການນໍາໃຊ້ ຕົວເລກ. ຢ່າງໃດກໍຕາມ, ນີ້ແມ່ນເຫດຜົນ.

ໃຫ້ເຮົາຮູ້ວ່າການສືບເຊື້ອສາຍ gradient stochastic ໃຊ້ເວລາດົນປານໃດ.

ລະຫັດສໍາລັບການກໍານົດເວລາການຄິດໄລ່ SGD (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)

ຍິ່ງເຂົ້າໄປໃນປ່າ, ເມກທີ່ມືດລົງຫຼາຍ: ອີກເທື່ອຫນຶ່ງ, ສູດ "ຂຽນດ້ວຍຕົນເອງ" ສະແດງໃຫ້ເຫັນຜົນໄດ້ຮັບທີ່ດີທີ່ສຸດ. ທັງ​ຫມົດ​ນີ້​ສະ​ແດງ​ໃຫ້​ເຫັນ​ວ່າ​ຈະ​ຕ້ອງ​ມີ​ວິ​ທີ​ການ​ທີ່​ອ່ອນ​ໂຍນ​ຫຼາຍ​ກວ່າ​ທີ່​ຈະ​ນໍາ​ໃຊ້​ຫ້ອງ​ສະ​ຫມຸດ​ໄດ້​ ຕົວເລກ, ເຊິ່ງກໍ່ເລັ່ງການດໍາເນີນງານການຄິດໄລ່. ໃນບົດຄວາມນີ້ພວກເຮົາຈະບໍ່ໄດ້ຮຽນຮູ້ກ່ຽວກັບພວກມັນ. ຈະມີບາງສິ່ງບາງຢ່າງທີ່ຈະຄິດກ່ຽວກັບເວລາຫວ່າງຂອງເຈົ້າ :)

ສະຫຼຸບ

ກ່ອນທີ່ຈະສະຫຼຸບ, ຂ້າພະເຈົ້າຢາກຕອບຄໍາຖາມທີ່ອາດຈະເກີດຂື້ນຈາກຜູ້ອ່ານທີ່ຮັກແພງຂອງພວກເຮົາ. ເປັນຫຍັງ, ໃນຄວາມເປັນຈິງ, "ການທໍລະມານ" ດັ່ງກ່າວກັບຜູ້ສືບເຊື້ອສາຍ, ເປັນຫຍັງພວກເຮົາຈໍາເປັນຕ້ອງຍ່າງຂຶ້ນແລະລົງພູເຂົາ (ສ່ວນຫຼາຍແມ່ນລົງ) ເພື່ອຊອກຫາເຂດທົ່ງພຽງທີ່ສົມກຽດ, ຖ້າພວກເຮົາມີອຸປະກອນທີ່ມີປະສິດທິພາບແລະງ່າຍດາຍ, ຢູ່ໃນມືຂອງພວກເຮົາ. ຮູບ​ແບບ​ການ​ແກ້​ໄຂ​ການ​ວິ​ເຄາະ​, ທີ່ instantly teleports ພວກ​ເຮົາ​ກັບ​ສະ​ຖານ​ທີ່​ສິດ​?

ຄໍາຕອບຂອງຄໍາຖາມນີ້ແມ່ນຢູ່ໃນຫນ້າດິນ. ຕອນນີ້ພວກເຮົາໄດ້ເບິ່ງຕົວຢ່າງທີ່ງ່າຍດາຍຫຼາຍ, ເຊິ່ງຄໍາຕອບທີ່ແທ້ຈິງແມ່ນ ຂຶ້ນກັບຫນຶ່ງອາການ . ເຈົ້າບໍ່ເຫັນສິ່ງນີ້ເລື້ອຍໆໃນຊີວິດ, ສະນັ້ນໃຫ້ຈິນຕະນາການວ່າພວກເຮົາມີ 2, 30, 50 ຫຼືຫຼາຍກວ່ານັ້ນ. ຂໍໃຫ້ເພີ່ມມູນຄ່າຫລາຍພັນນີ້, ຫຼືແມ້ກະທັ້ງຫລາຍສິບພັນຄ່າສໍາລັບແຕ່ລະຄຸນລັກສະນະ. ໃນກໍລະນີນີ້, ການແກ້ໄຂການວິເຄາະອາດຈະບໍ່ທົນກັບການທົດສອບແລະລົ້ມເຫລວ. ໃນທາງກັບກັນ, ການສືບເຊື້ອສາຍ gradient ແລະການປ່ຽນແປງຂອງມັນຈະຊ້າໆແຕ່ແນ່ນອນເຮັດໃຫ້ພວກເຮົາໃກ້ຊິດກັບເປົ້າຫມາຍ - ຕໍາ່ສຸດທີ່ຂອງຫນ້າທີ່. ແລະບໍ່ຕ້ອງກັງວົນກ່ຽວກັບຄວາມໄວ - ພວກເຮົາອາດຈະເບິ່ງວິທີການທີ່ຈະຊ່ວຍໃຫ້ພວກເຮົາກໍານົດແລະຄວບຄຸມຄວາມຍາວຂອງຂັ້ນຕອນ (ຄືຄວາມໄວ).

ແລະຕອນນີ້ບົດສະຫຼຸບສັ້ນໆຕົວຈິງ.

ກ່ອນອື່ນ ໝົດ, ຂ້າພະເຈົ້າຫວັງວ່າເອກະສານທີ່ ນຳ ສະ ເໜີ ໃນບົດຂຽນຈະຊ່ວຍເລີ່ມຕົ້ນ "ນັກວິທະຍາສາດຂໍ້ມູນ" ໃນການເຂົ້າໃຈວິທີການແກ້ໄຂສົມຜົນການຖົດຖອຍແບບເສັ້ນແບບງ່າຍດາຍ (ແລະບໍ່ພຽງແຕ່).

ອັນທີສອງ, ພວກເຮົາໄດ້ເບິ່ງຫຼາຍວິທີເພື່ອແກ້ໄຂສົມຜົນ. ໃນປັດຈຸບັນ, ອີງຕາມສະຖານະການ, ພວກເຮົາສາມາດເລືອກເອົາຫນຶ່ງທີ່ເຫມາະສົມທີ່ສຸດເພື່ອແກ້ໄຂບັນຫາ.

ອັນທີສາມ, ພວກເຮົາໄດ້ເຫັນພະລັງງານຂອງການຕັ້ງຄ່າເພີ່ມເຕີມ, ຄືຄວາມຍາວຂອງຂັ້ນຕອນການສືບເຊື້ອສາຍ gradient. ພາລາມິເຕີນີ້ບໍ່ສາມາດຖືກລະເລີຍ. ດັ່ງທີ່ໄດ້ກ່າວໄວ້ຂ້າງເທິງ, ເພື່ອຫຼຸດຜ່ອນຄ່າໃຊ້ຈ່າຍໃນການຄິດໄລ່, ຄວາມຍາວຂອງຂັ້ນຕອນຄວນໄດ້ຮັບການປ່ຽນແປງໃນລະຫວ່າງການສືບເຊື້ອສາຍ.

ອັນທີສີ່, ໃນກໍລະນີຂອງພວກເຮົາ, ຫນ້າທີ່ "ຂຽນຢູ່ເຮືອນ" ສະແດງໃຫ້ເຫັນຜົນໄດ້ຮັບທີ່ດີທີ່ສຸດສໍາລັບການຄິດໄລ່. ອັນນີ້ອາດຈະເປັນຍ້ອນບໍ່ແມ່ນການໃຊ້ຄວາມສາມາດຂອງຫ້ອງສະໝຸດທີ່ເປັນມືອາຊີບທີ່ສຸດ ຕົວເລກ. ແຕ່ເປັນໄປໄດ້, ສະຫຼຸບຕໍ່ໄປນີ້ຊີ້ໃຫ້ເຫັນຕົວມັນເອງ. ໃນອີກດ້ານຫນຶ່ງ, ບາງຄັ້ງມັນກໍ່ຄຸ້ມຄ່າທີ່ຈະຖາມຄວາມຄິດເຫັນທີ່ຖືກສ້າງຕັ້ງຂື້ນ, ແລະອີກດ້ານຫນຶ່ງ, ມັນບໍ່ສົມຄວນທີ່ຈະສັບສົນທຸກຢ່າງ - ໃນທາງກົງກັນຂ້າມ, ບາງຄັ້ງວິທີການແກ້ໄຂບັນຫາທີ່ງ່າຍດາຍແມ່ນມີປະສິດທິພາບຫຼາຍຂຶ້ນ. ແລະນັບຕັ້ງແຕ່ເປົ້າຫມາຍຂອງພວກເຮົາແມ່ນເພື່ອວິເຄາະສາມວິທີການແກ້ໄຂສົມຜົນ regression linear ແບບງ່າຍດາຍ, ການນໍາໃຊ້ຫນ້າທີ່ "ຂຽນດ້ວຍຕົນເອງ" ແມ່ນຂ້ອນຂ້າງພຽງພໍສໍາລັບພວກເຮົາ.

ວັນນະຄະດີ (ຫຼືບາງສິ່ງບາງຢ່າງເຊັ່ນນັ້ນ)

1. Linear regression

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

2. ວິທີການສີ່ຫຼ່ຽມນ້ອຍສຸດ

mathprofi.ru/metod_naimenshih_kvadratov.html

3. ອະນຸພັນ

www.mathprofi.ru/chastnye_proizvodnye_primery.html

4. Gradient

mathprofi.ru/proizvodnaja_po_napravleniju_i_gradient.html

5. Gradient descent

habr.com/ru/post/471458

habr.com/ru/post/307312

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

6. ຫ້ອງສະໝຸດ 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

ແຫຼ່ງຂໍ້ມູນ: www.habr.com