ലളിതമായ ലീനിയർ റിഗ്രഷന്റെ സമവാക്യം പരിഹരിക്കുന്നു

ലളിതമായ (ജോടിയാക്കിയ) റിഗ്രഷൻ ലൈനിൻ്റെ ഗണിത സമവാക്യം നിർണ്ണയിക്കുന്നതിനുള്ള നിരവധി വഴികൾ ലേഖനം ചർച്ചചെയ്യുന്നു.

ഇവിടെ ചർച്ച ചെയ്ത സമവാക്യം പരിഹരിക്കുന്നതിനുള്ള എല്ലാ രീതികളും ഏറ്റവും കുറഞ്ഞ സ്ക്വയർ രീതിയെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്. ഇനിപ്പറയുന്ന രീതികളെ നമുക്ക് സൂചിപ്പിക്കാം:

• വിശകലന പരിഹാരം
• ഗ്രേഡിയന്റ് ഡിസന്റ്
• സ്ഥായിയായ ഗ്രേഡിയൻ്റ് ഇറക്കം

ഒരു നേർരേഖയുടെ സമവാക്യം പരിഹരിക്കുന്നതിനുള്ള ഓരോ രീതിക്കും, ലേഖനം വിവിധ പ്രവർത്തനങ്ങൾ നൽകുന്നു, അവ പ്രധാനമായും ലൈബ്രറി ഉപയോഗിക്കാതെ എഴുതിയവയായി തിരിച്ചിരിക്കുന്നു. നമ്പി കണക്കുകൂട്ടലുകൾക്കായി ഉപയോഗിക്കുന്നവയും നമ്പി. വിദഗ്‌ധമായ ഉപയോഗമാണെന്ന് വിശ്വസിക്കപ്പെടുന്നു നമ്പി കമ്പ്യൂട്ടിംഗ് ചെലവ് കുറയ്ക്കും.

ലേഖനത്തിൽ നൽകിയിരിക്കുന്ന എല്ലാ കോഡുകളും എഴുതിയിരിക്കുന്നു പൈത്തൺ 2.7 ഉപയോഗിക്കുന്നു ജൂപ്പിറ്റർ നോട്ട്ബുക്ക്. സോഴ്‌സ് കോഡും സാമ്പിൾ ഡാറ്റയുള്ള ഫയലും പോസ്റ്റ് ചെയ്‌തിരിക്കുന്നു ഗിത്തബ്

ആർട്ടിഫിഷ്യൽ ഇൻ്റലിജൻസ് - മെഷീൻ ലേണിംഗ് - ലെ വളരെ വിശാലമായ ഒരു വിഭാഗത്തിൻ്റെ പഠനം തുടക്കക്കാർക്കും ഇതിനകം ക്രമേണ പഠിക്കാൻ തുടങ്ങിയവർക്കും ലേഖനം കൂടുതൽ ലക്ഷ്യമിടുന്നു.

മെറ്റീരിയൽ വ്യക്തമാക്കുന്നതിന്, ഞങ്ങൾ വളരെ ലളിതമായ ഒരു ഉദാഹരണം ഉപയോഗിക്കുന്നു.

ഉദാഹരണ വ്യവസ്ഥകൾ

ആശ്രിതത്വത്തെ ചിത്രീകരിക്കുന്ന അഞ്ച് മൂല്യങ്ങൾ നമുക്കുണ്ട് Y от X (പട്ടിക നമ്പർ 1):

പട്ടിക നമ്പർ 1 "ഉദാഹരണ വ്യവസ്ഥകൾ"

മൂല്യങ്ങൾ എന്ന് ഞങ്ങൾ അനുമാനിക്കും വർഷത്തിലെ മാസമാണ്, ഒപ്പം - ഈ മാസത്തെ വരുമാനം. മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, വരുമാനം വർഷത്തിലെ മാസത്തെ ആശ്രയിച്ചിരിക്കുന്നു, കൂടാതെ - വരുമാനത്തെ ആശ്രയിക്കുന്ന ഒരേയൊരു അടയാളം.

ഉദാഹരണം അങ്ങനെയാണ്, വർഷത്തിലെ മാസത്തെ വരുമാനത്തിൻ്റെ സോപാധിക ആശ്രിതത്വത്തിൻ്റെ വീക്ഷണകോണിൽ നിന്നും മൂല്യങ്ങളുടെ എണ്ണത്തിൻ്റെ വീക്ഷണകോണിൽ നിന്നും - അവയിൽ വളരെ കുറച്ച് മാത്രമേ ഉള്ളൂ. എന്നിരുന്നാലും, അത്തരമൊരു ലളിതവൽക്കരണം, അവർ പറയുന്നതുപോലെ, തുടക്കക്കാർ സ്വാംശീകരിക്കുന്ന മെറ്റീരിയൽ എല്ലായ്പ്പോഴും അനായാസമായി വിശദീകരിക്കാൻ സഹായിക്കും. കൂടാതെ, സംഖ്യകളുടെ ലാളിത്യം കാര്യമായ തൊഴിൽ ചെലവുകളില്ലാതെ കടലാസിൽ ഉദാഹരണം പരിഹരിക്കാൻ ആഗ്രഹിക്കുന്നവരെ അനുവദിക്കും.

ഉദാഹരണത്തിൽ നൽകിയിരിക്കുന്ന ആശ്രിതത്വം ഫോമിൻ്റെ ഒരു ലളിതമായ (ജോടിയാക്കിയ) റിഗ്രഷൻ ലൈനിൻ്റെ ഗണിത സമവാക്യം ഉപയോഗിച്ച് നന്നായി കണക്കാക്കാൻ കഴിയുമെന്ന് നമുക്ക് അനുമാനിക്കാം:

എവിടെ വരുമാനം ലഭിച്ച മാസമാണ്, - മാസവുമായി ബന്ധപ്പെട്ട വരുമാനം, и കണക്കാക്കിയ വരിയുടെ റിഗ്രഷൻ കോഫിഫിഷ്യൻ്റുകളാണ്.

ഗുണകം എന്നത് ശ്രദ്ധിക്കുക കണക്കാക്കിയ വരിയുടെ ചരിവ് അല്ലെങ്കിൽ ഗ്രേഡിയൻ്റ് എന്ന് പലപ്പോഴും വിളിക്കപ്പെടുന്നു; തുകയെ പ്രതിനിധീകരിക്കുന്നു അത് മാറുമ്പോൾ .

വ്യക്തമായും, സമവാക്യത്തിലെ അത്തരം ഗുണകങ്ങൾ തിരഞ്ഞെടുക്കുക എന്നതാണ് ഉദാഹരണത്തിലെ ഞങ്ങളുടെ ചുമതല и , യഥാർത്ഥ ഉത്തരങ്ങളിൽ നിന്ന് മാസം തോറും ഞങ്ങൾ കണക്കാക്കിയ വരുമാന മൂല്യങ്ങളുടെ വ്യതിയാനങ്ങൾ, അതായത്. സാമ്പിളിൽ അവതരിപ്പിച്ച മൂല്യങ്ങൾ വളരെ കുറവായിരിക്കും.

ഏറ്റവും കുറഞ്ഞ ചതുര രീതി

ഏറ്റവും കുറഞ്ഞ സ്ക്വയറുകളുടെ രീതി അനുസരിച്ച്, വ്യതിയാനം ചതുരാകൃതിയിൽ കണക്കാക്കണം. വിപരീത ചിഹ്നങ്ങളുണ്ടെങ്കിൽ വ്യതിയാനങ്ങൾ പരസ്പരം റദ്ദാക്കുന്നത് ഒഴിവാക്കാൻ ഈ സാങ്കേതികത നിങ്ങളെ അനുവദിക്കുന്നു. ഉദാഹരണത്തിന്, ഒരു കേസിൽ എങ്കിൽ, വ്യതിയാനം ആണ് +5 (പ്ലസ് അഞ്ച്), മറ്റൊന്നിൽ -5 (മൈനസ് അഞ്ച്), അപ്പോൾ വ്യതിയാനങ്ങളുടെ ആകെത്തുക പരസ്പരം റദ്ദാക്കുകയും തുക 0 (പൂജ്യം) ആകുകയും ചെയ്യും. ഡീവിയേഷൻ സ്ക്വയർ ചെയ്യാതെ, മോഡുലസിൻ്റെ പ്രോപ്പർട്ടി ഉപയോഗിക്കുന്നതിന് സാധ്യമാണ്, തുടർന്ന് എല്ലാ വ്യതിയാനങ്ങളും പോസിറ്റീവ് ആകുകയും ശേഖരിക്കപ്പെടുകയും ചെയ്യും. ഞങ്ങൾ ഈ പോയിൻ്റിൽ വിശദമായി വസിക്കില്ല, പക്ഷേ കണക്കുകൂട്ടലുകളുടെ സൗകര്യാർത്ഥം, വ്യതിയാനം സ്ക്വയർ ചെയ്യുന്നത് പതിവാണെന്ന് സൂചിപ്പിക്കുന്നു.

സമവാക്യം ഇങ്ങനെയാണ് കാണപ്പെടുന്നത്, ഇത് ഉപയോഗിച്ച് ഞങ്ങൾ സ്ക്വയർ വ്യതിയാനങ്ങളുടെ ഏറ്റവും കുറഞ്ഞ തുക നിർണ്ണയിക്കും (പിശകുകൾ):

എവിടെ യഥാർത്ഥ ഉത്തരങ്ങളുടെ ഏകദേശ പ്രവർത്തനമാണ് (അതായത്, ഞങ്ങൾ കണക്കാക്കിയ വരുമാനം),

യഥാർത്ഥ ഉത്തരങ്ങളാണ് (സാമ്പിളിൽ നൽകിയിരിക്കുന്ന വരുമാനം),

സാമ്പിൾ സൂചികയാണ് (വ്യതിയാനം നിർണ്ണയിക്കുന്ന മാസത്തിൻ്റെ എണ്ണം)

നമുക്ക് പ്രവർത്തനത്തെ വേർതിരിക്കാം, ഭാഗിക ഡിഫറൻഷ്യൽ സമവാക്യങ്ങൾ നിർവചിക്കാം, വിശകലന പരിഹാരത്തിലേക്ക് നീങ്ങാൻ തയ്യാറാകുക. എന്നാൽ ആദ്യം, വ്യത്യാസം എന്താണെന്നതിനെക്കുറിച്ചുള്ള ഒരു ചെറിയ വിനോദയാത്ര നടത്തുകയും ഡെറിവേറ്റീവിൻ്റെ ജ്യാമിതീയ അർത്ഥം ഓർമ്മിക്കുകയും ചെയ്യാം.

വ്യത്യാസം

ഒരു ഫംഗ്ഷൻ്റെ ഡെറിവേറ്റീവ് കണ്ടെത്തുന്നതിനുള്ള പ്രവർത്തനമാണ് ഡിഫറൻഷ്യേഷൻ.

ഡെറിവേറ്റീവ് എന്തിനുവേണ്ടിയാണ് ഉപയോഗിക്കുന്നത്? ഒരു ഫംഗ്‌ഷൻ്റെ ഡെറിവേറ്റീവ് ഫംഗ്‌ഷൻ്റെ മാറ്റത്തിൻ്റെ നിരക്കിനെ ചിത്രീകരിക്കുകയും അതിൻ്റെ ദിശ നമ്മോട് പറയുകയും ചെയ്യുന്നു. ഒരു നിശ്ചിത പോയിൻ്റിലെ ഡെറിവേറ്റീവ് പോസിറ്റീവ് ആണെങ്കിൽ, ഫംഗ്ഷൻ വർദ്ധിക്കുന്നു, അല്ലാത്തപക്ഷം, പ്രവർത്തനം കുറയുന്നു. കേവല ഡെറിവേറ്റീവിൻ്റെ മൂല്യം കൂടുന്തോറും ഫംഗ്‌ഷൻ മൂല്യങ്ങളുടെ മാറ്റത്തിൻ്റെ നിരക്ക് കൂടും, അതുപോലെ ഫംഗ്‌ഷൻ ഗ്രാഫിൻ്റെ ചരിവ് കുത്തനെ കൂടും.

ഉദാഹരണത്തിന്, ഒരു കാർട്ടീഷ്യൻ കോർഡിനേറ്റ് സിസ്റ്റത്തിൻ്റെ അവസ്ഥയിൽ, പോയിൻ്റ് M(0,0) ലെ ഡെറിവേറ്റീവിൻ്റെ മൂല്യം തുല്യമാണ് + 25 ഒരു നിശ്ചിത ഘട്ടത്തിൽ, മൂല്യം മാറുമ്പോൾ എന്നാണ് അർത്ഥമാക്കുന്നത് ഒരു പരമ്പരാഗത യൂണിറ്റ് വഴി വലത്തേക്ക്, മൂല്യം 25 പരമ്പരാഗത യൂണിറ്റുകളുടെ വർദ്ധനവ്. ഗ്രാഫിൽ അത് മൂല്യങ്ങളിൽ കുത്തനെയുള്ള ഉയർച്ച പോലെ കാണപ്പെടുന്നു ഒരു നിശ്ചിത പോയിൻ്റിൽ നിന്ന്.

മറ്റൊരു ഉദാഹരണം. ഡെറിവേറ്റീവ് മൂല്യം തുല്യമാണ് -0,1 സ്ഥലം മാറ്റപ്പെടുമ്പോൾ എന്നാണ് ഒരു പരമ്പരാഗത യൂണിറ്റിന്, മൂല്യം 0,1 പരമ്പരാഗത യൂണിറ്റ് മാത്രം കുറയുന്നു. അതേ സമയം, ഫംഗ്ഷൻ്റെ ഗ്രാഫിൽ, നമുക്ക് വളരെ ശ്രദ്ധേയമായ ഒരു താഴോട്ട് ചരിവ് നിരീക്ഷിക്കാൻ കഴിയും. ഒരു പർവതവുമായി ഒരു സാമ്യം വരയ്ക്കുന്നത്, മുമ്പത്തെ ഉദാഹരണത്തിൽ നിന്ന് വ്യത്യസ്തമായി, വളരെ കുത്തനെയുള്ള കൊടുമുടികൾ കയറേണ്ടി വന്ന ഒരു പർവതത്തിൽ നിന്ന് ഞങ്ങൾ വളരെ സാവധാനത്തിൽ ഒരു ചെറിയ ചരിവ് ഇറങ്ങുന്നത് പോലെയാണ് :)

അങ്ങനെ, ഫംഗ്ഷൻ വ്യത്യാസപ്പെടുത്തിയ ശേഷം സാധ്യതകൾ പ്രകാരം и , ഞങ്ങൾ 1st ഓർഡർ ഭാഗിക ഡിഫറൻഷ്യൽ സമവാക്യങ്ങൾ നിർവ്വചിക്കുന്നു. സമവാക്യങ്ങൾ നിർണ്ണയിച്ച ശേഷം, നമുക്ക് രണ്ട് സമവാക്യങ്ങളുടെ ഒരു സിസ്റ്റം ലഭിക്കും, അത് പരിഹരിക്കുന്നതിലൂടെ നമുക്ക് ഗുണകങ്ങളുടെ അത്തരം മൂല്യങ്ങൾ തിരഞ്ഞെടുക്കാൻ കഴിയും. и , അതിനായി നൽകിയിരിക്കുന്ന പോയിൻ്റുകളിലെ അനുബന്ധ ഡെറിവേറ്റീവുകളുടെ മൂല്യങ്ങൾ വളരെ വളരെ ചെറിയ അളവിൽ മാറുന്നു, കൂടാതെ ഒരു വിശകലന പരിഹാരത്തിൻ്റെ കാര്യത്തിൽ ഒട്ടും മാറില്ല. മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, കണ്ടെത്തിയ ഗുണകങ്ങളിലെ പിശക് പ്രവർത്തനം ഏറ്റവും കുറഞ്ഞതിലെത്തും, കാരണം ഈ പോയിൻ്റുകളിലെ ഭാഗിക ഡെറിവേറ്റീവുകളുടെ മൂല്യങ്ങൾ പൂജ്യത്തിന് തുല്യമായിരിക്കും.

അതിനാൽ, ഡിഫറൻഷ്യേഷൻ നിയമങ്ങൾ അനുസരിച്ച്, ഗുണകവുമായി ബന്ധപ്പെട്ട് 1st ഓർഡറിൻ്റെ ഭാഗിക ഡെറിവേറ്റീവ് സമവാക്യം ഫോം എടുക്കും:

1st ഓർഡർ ഭാഗിക ഡെറിവേറ്റീവ് സമവാക്യവുമായി ബന്ധപ്പെട്ട് ഫോം എടുക്കും:

തൽഫലമായി, ഞങ്ങൾക്ക് വളരെ ലളിതമായ വിശകലന പരിഹാരമുള്ള സമവാക്യങ്ങളുടെ ഒരു സിസ്റ്റം ലഭിച്ചു:

ആരംഭിക്കുക{സമവാക്യം*}
ആരംഭിക്കുക{കേസുകൾ}
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
അവസാനം{കേസുകൾ}
അവസാനം{സമവാക്യം*}

സമവാക്യം പരിഹരിക്കുന്നതിന് മുമ്പ്, നമുക്ക് പ്രീലോഡ് ചെയ്യാം, ലോഡിംഗ് ശരിയാണോ എന്ന് പരിശോധിക്കുക, ഡാറ്റ ഫോർമാറ്റ് ചെയ്യുക.

ഡാറ്റ ലോഡുചെയ്യുകയും ഫോർമാറ്റുചെയ്യുകയും ചെയ്യുന്നു

അനലിറ്റിക്കൽ സൊല്യൂഷനും തുടർന്ന് ഗ്രേഡിയൻ്റിനും സ്റ്റോക്കാസ്റ്റിക് ഗ്രേഡിയൻ്റ് ഡിസെൻ്റിനും വേണ്ടി, ഞങ്ങൾ കോഡ് രണ്ട് വ്യതിയാനങ്ങളിൽ ഉപയോഗിക്കുമെന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്: ലൈബ്രറി ഉപയോഗിക്കുന്നു നമ്പി അത് ഉപയോഗിക്കാതെ തന്നെ, ഞങ്ങൾക്ക് ഉചിതമായ ഡാറ്റ ഫോർമാറ്റിംഗ് ആവശ്യമാണ് (കോഡ് കാണുക).

ഡാറ്റ ലോഡിംഗ്, പ്രോസസ്സിംഗ് കോഡ്

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

ദൃശ്യവൽക്കരണം

ഇപ്പോൾ, ഞങ്ങൾ ആദ്യം, ഡാറ്റ ലോഡുചെയ്‌തു, രണ്ടാമതായി, ലോഡിംഗിൻ്റെ കൃത്യത പരിശോധിച്ച് ഒടുവിൽ ഡാറ്റ ഫോർമാറ്റ് ചെയ്‌ത ശേഷം, ഞങ്ങൾ ആദ്യത്തെ ദൃശ്യവൽക്കരണം നടത്തും. ഇതിനായി പലപ്പോഴും ഉപയോഗിക്കുന്ന രീതി ജോഡിപ്ലോട്ട് ലൈബ്രറികൾ കടൽ. ഞങ്ങളുടെ ഉദാഹരണത്തിൽ, പരിമിതമായ സംഖ്യകൾ കാരണം, ലൈബ്രറി ഉപയോഗിക്കുന്നതിൽ അർത്ഥമില്ല കടൽ. ഞങ്ങൾ സാധാരണ ലൈബ്രറി ഉപയോഗിക്കും മാറ്റ്‌പ്ലോട്ട്ലിബ് കൂടാതെ ചിതറിക്കിടക്കുന്ന സ്ഥലം നോക്കൂ.

സ്കാറ്റർപ്ലോട്ട് കോഡ്

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 "വർഷത്തിലെ മാസത്തെ വരുമാനത്തിൻ്റെ ആശ്രിതത്വം"

വിശകലന പരിഹാരം

നമുക്ക് ഏറ്റവും സാധാരണമായ ഉപകരണങ്ങൾ ഉപയോഗിക്കാം പൈത്തൺ സമവാക്യങ്ങളുടെ സിസ്റ്റം പരിഹരിക്കുക:

ആരംഭിക്കുക{സമവാക്യം*}
ആരംഭിക്കുക{കേസുകൾ}
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
അവസാനം{കേസുകൾ}
അവസാനം{സമവാക്യം*}

ക്രാമർ നിയമം അനുസരിച്ച് പൊതുവായ ഡിറ്റർമിനൻ്റും അതുപോലെ ഡിറ്റർമിനൻ്റുകളും ഞങ്ങൾ കണ്ടെത്തും ഒപ്പം , അതിനുശേഷം, ഡിറ്റർമിനൻ്റിനെ ഹരിക്കുന്നു പൊതുവായ ഡിറ്റർമിനൻ്റിലേക്ക് - ഗുണകം കണ്ടെത്തുക , അതുപോലെ ഞങ്ങൾ ഗുണകം കണ്ടെത്തുന്നു .

വിശകലന പരിഹാര കോഡ്

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

ഞങ്ങൾക്ക് ലഭിച്ചത് ഇതാ:

അതിനാൽ, ഗുണകങ്ങളുടെ മൂല്യങ്ങൾ കണ്ടെത്തി, ചതുരാകൃതിയിലുള്ള വ്യതിയാനങ്ങളുടെ ആകെത്തുക സ്ഥാപിച്ചു. കണ്ടെത്തിയ ഗുണകങ്ങൾക്ക് അനുസൃതമായി സ്കാറ്ററിംഗ് ഹിസ്റ്റോഗ്രാമിൽ ഒരു നേർരേഖ വരയ്ക്കാം.

റിഗ്രഷൻ ലൈൻ കോഡ്

# определим функцию для формирования массива рассчетных значений выручки
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 "ശരിയായതും കണക്കുകൂട്ടിയതുമായ ഉത്തരങ്ങൾ"

നിങ്ങൾക്ക് ഓരോ മാസത്തേയും ഡീവിയേഷൻ ഗ്രാഫ് നോക്കാം. ഞങ്ങളുടെ കാര്യത്തിൽ, അതിൽ നിന്ന് കാര്യമായ പ്രായോഗിക മൂല്യമൊന്നും ഞങ്ങൾ നേടുകയില്ല, എന്നാൽ ലളിതമായ ലീനിയർ റിഗ്രഷൻ സമവാക്യം വർഷത്തിലെ മാസത്തെ വരുമാനത്തിൻ്റെ ആശ്രിതത്വത്തെ എത്ര നന്നായി ചിത്രീകരിക്കുന്നു എന്നതിനെക്കുറിച്ചുള്ള ഞങ്ങളുടെ ജിജ്ഞാസ ഞങ്ങൾ തൃപ്തിപ്പെടുത്തും.

വ്യതിയാന ചാർട്ട് കോഡ്

# определим функцию для формирования массива отклонений в процентах
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 "വ്യതിയാനങ്ങൾ, %"

തികഞ്ഞതല്ല, പക്ഷേ ഞങ്ങൾ ഞങ്ങളുടെ ചുമതല പൂർത്തിയാക്കി.

ഗുണകങ്ങൾ നിർണ്ണയിക്കാൻ നമുക്ക് ഒരു ഫംഗ്ഷൻ എഴുതാം и ലൈബ്രറി ഉപയോഗിക്കുന്നു നമ്പി, കൂടുതൽ കൃത്യമായി പറഞ്ഞാൽ, ഞങ്ങൾ രണ്ട് ഫംഗ്ഷനുകൾ എഴുതും: ഒന്ന് ഒരു കപട മാട്രിക്സ് ഉപയോഗിച്ച് (പ്രായോഗികമായി ശുപാർശ ചെയ്യുന്നില്ല, കാരണം പ്രോസസ്സ് കമ്പ്യൂട്ടേഷണൽ സങ്കീർണ്ണവും അസ്ഥിരവുമാണ്), മറ്റൊന്ന് ഒരു മാട്രിക്സ് സമവാക്യം ഉപയോഗിക്കുന്നു.

അനലിറ്റിക്കൽ സൊല്യൂഷൻ കോഡ് (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)

ഒരു ചെറിയ അളവിലുള്ള ഡാറ്റ ഉപയോഗിച്ച്, ഒരു "സ്വയം എഴുതിയ" ഫംഗ്ഷൻ മുന്നോട്ട് വരുന്നു, അത് ക്രാമർ രീതി ഉപയോഗിച്ച് ഗുണകങ്ങൾ കണ്ടെത്തുന്നു.

ഇപ്പോൾ നിങ്ങൾക്ക് ഗുണകങ്ങൾ കണ്ടെത്തുന്നതിനുള്ള മറ്റ് വഴികളിലേക്ക് പോകാം и .

ഗ്രേഡിയന്റ് ഡിസന്റ്

ആദ്യം, ഗ്രേഡിയൻ്റ് എന്താണെന്ന് നമുക്ക് നിർവചിക്കാം. ലളിതമായി പറഞ്ഞാൽ, ഒരു ഫംഗ്‌ഷൻ്റെ പരമാവധി വളർച്ചയുടെ ദിശയെ സൂചിപ്പിക്കുന്ന ഒരു സെഗ്‌മെൻ്റാണ് ഗ്രേഡിയൻ്റ്. മലകയറുന്നതിനോട് സാമ്യമുള്ളതിനാൽ, മലമുകളിലേക്കുള്ള ഏറ്റവും കുത്തനെയുള്ള കയറ്റം എവിടെയാണ് ഗ്രേഡിയൻ്റ് മുഖങ്ങൾ. പർവതത്തിനൊപ്പം ഒരു ഉദാഹരണം വികസിപ്പിച്ചെടുക്കുമ്പോൾ, താഴ്ന്ന പ്രദേശത്തേക്ക് എത്രയും വേഗം എത്തിച്ചേരാൻ നമുക്ക് കുത്തനെയുള്ള ഇറക്കം ആവശ്യമാണെന്ന് ഞങ്ങൾ ഓർക്കുന്നു, അതായത്, ഏറ്റവും കുറഞ്ഞത് - പ്രവർത്തനം കൂടുകയോ കുറയുകയോ ചെയ്യാത്ത സ്ഥലം. ഈ ഘട്ടത്തിൽ ഡെറിവേറ്റീവ് പൂജ്യത്തിന് തുല്യമായിരിക്കും. അതിനാൽ, നമുക്ക് ഒരു ഗ്രേഡിയൻ്റ് ആവശ്യമില്ല, മറിച്ച് ഒരു ആൻ്റിഗ്രേഡിയൻ്റ്. ആൻ്റിഗ്രേഡിയൻ്റ് കണ്ടെത്താൻ, നിങ്ങൾ ഗ്രേഡിയൻ്റ് ഗുണിച്ചാൽ മതി -1 (മൈനസ് ഒന്ന്).

ഒരു ഫംഗ്‌ഷന് നിരവധി മിനിമകൾ ഉണ്ടായിരിക്കുമെന്ന വസ്തുത നമുക്ക് ശ്രദ്ധിക്കാം, കൂടാതെ ചുവടെ നിർദ്ദേശിച്ചിരിക്കുന്ന അൽഗോരിതം ഉപയോഗിച്ച് അവയിലൊന്നിലേക്ക് ഇറങ്ങിയാൽ, മറ്റൊരു മിനിമം കണ്ടെത്താൻ ഞങ്ങൾക്ക് കഴിയില്ല, അത് കണ്ടെത്തിയതിനേക്കാൾ കുറവായിരിക്കാം. നമുക്ക് വിശ്രമിക്കാം, ഇത് ഞങ്ങൾക്ക് ഒരു ഭീഷണിയല്ല! ഞങ്ങളുടെ കാര്യത്തിൽ, ഞങ്ങളുടെ പ്രവർത്തനം മുതൽ ഞങ്ങൾ ഒരു മിനിമം കൈകാര്യം ചെയ്യുന്നു ഗ്രാഫിൽ ഒരു സാധാരണ പരവലയമാണ്. നമ്മുടെ സ്കൂൾ മാത്തമാറ്റിക്‌സ് കോഴ്‌സിൽ നിന്ന് നാമെല്ലാവരും നന്നായി അറിയേണ്ടതുപോലെ, ഒരു പരവലയത്തിന് ഒരു മിനിമം മാത്രമേയുള്ളൂ.

എന്തുകൊണ്ടാണ് ഞങ്ങൾക്ക് ഒരു ഗ്രേഡിയൻ്റ് ആവശ്യമെന്നും ഗ്രേഡിയൻ്റ് ഒരു സെഗ്‌മെൻ്റാണെന്നും അതായത്, നൽകിയിരിക്കുന്ന കോർഡിനേറ്റുകളുള്ള ഒരു വെക്‌ടറാണെന്നും ഞങ്ങൾ കണ്ടെത്തിയതിന് ശേഷം, അവ കൃത്യമായി ഒരേ ഗുണകങ്ങളാണ്. и നമുക്ക് ഗ്രേഡിയൻ്റ് ഡിസെൻ്റ് നടപ്പിലാക്കാം.

ആരംഭിക്കുന്നതിന് മുമ്പ്, ഡിസെൻ്റ് അൽഗോരിതത്തെക്കുറിച്ചുള്ള കുറച്ച് വാക്യങ്ങൾ വായിക്കാൻ ഞാൻ നിർദ്ദേശിക്കുന്നു:

• ഗുണകങ്ങളുടെ കോർഡിനേറ്റുകൾ ഞങ്ങൾ കപട-റാൻഡം രീതിയിൽ നിർണ്ണയിക്കുന്നു и . ഞങ്ങളുടെ ഉദാഹരണത്തിൽ, പൂജ്യത്തിനടുത്തുള്ള ഗുണകങ്ങൾ ഞങ്ങൾ നിർവ്വചിക്കും. ഇതൊരു സാധാരണ രീതിയാണ്, എന്നാൽ ഓരോ കേസിനും അതിൻ്റേതായ സമ്പ്രദായം ഉണ്ടായിരിക്കാം.
• കോർഡിനേറ്റിൽ നിന്ന് പോയിൻ്റിലെ 1st ഓർഡർ ഭാഗിക ഡെറിവേറ്റീവിൻ്റെ മൂല്യം കുറയ്ക്കുക . അതിനാൽ, ഡെറിവേറ്റീവ് പോസിറ്റീവ് ആണെങ്കിൽ, ഫംഗ്ഷൻ വർദ്ധിക്കുന്നു. അതിനാൽ, ഡെറിവേറ്റീവിൻ്റെ മൂല്യം കുറയ്ക്കുന്നതിലൂടെ, വളർച്ചയുടെ വിപരീത ദിശയിലേക്ക്, അതായത്, ഇറക്കത്തിൻ്റെ ദിശയിലേക്ക് നാം നീങ്ങും. ഡെറിവേറ്റീവ് നെഗറ്റീവ് ആണെങ്കിൽ, ഈ ഘട്ടത്തിലെ ഫംഗ്ഷൻ കുറയുകയും ഡെറിവേറ്റീവിൻ്റെ മൂല്യം കുറയ്ക്കുന്നതിലൂടെ നമ്മൾ ഇറക്കത്തിൻ്റെ ദിശയിലേക്ക് നീങ്ങുകയും ചെയ്യുന്നു.
• കോർഡിനേറ്റിനൊപ്പം ഞങ്ങൾ സമാനമായ ഒരു പ്രവർത്തനം നടത്തുന്നു : പോയിൻ്റിലെ ഭാഗിക ഡെറിവേറ്റീവിൻ്റെ മൂല്യം കുറയ്ക്കുക .
• മിനിമം മറികടന്ന് ആഴത്തിലുള്ള സ്ഥലത്തേക്ക് പറക്കാതിരിക്കാൻ, ഇറങ്ങുന്ന ദിശയിൽ സ്റ്റെപ്പ് വലുപ്പം സജ്ജമാക്കേണ്ടത് ആവശ്യമാണ്. പൊതുവേ, കമ്പ്യൂട്ടേഷണൽ ചെലവ് കുറയ്ക്കുന്നതിന് സ്റ്റെപ്പ് എങ്ങനെ ശരിയായി സജ്ജീകരിക്കാമെന്നും ഇറക്കൽ പ്രക്രിയയിൽ അത് എങ്ങനെ മാറ്റാമെന്നും നിങ്ങൾക്ക് ഒരു മുഴുവൻ ലേഖനവും എഴുതാം. എന്നാൽ ഇപ്പോൾ ഞങ്ങൾക്ക് അൽപ്പം വ്യത്യസ്തമായ ഒരു ചുമതലയുണ്ട്, കൂടാതെ "പോക്ക്" എന്ന ശാസ്ത്രീയ രീതി ഉപയോഗിച്ച് ഞങ്ങൾ സ്റ്റെപ്പ് വലുപ്പം സ്ഥാപിക്കും അല്ലെങ്കിൽ അവർ പൊതുവായ ഭാഷയിൽ പറയുന്നതുപോലെ, അനുഭവപരമായി.
• നൽകിയിരിക്കുന്ന കോർഡിനേറ്റുകളിൽ നിന്ന് ഒരിക്കൽ ഞങ്ങൾ и ഡെറിവേറ്റീവുകളുടെ മൂല്യങ്ങൾ കുറയ്ക്കുക, നമുക്ക് പുതിയ കോർഡിനേറ്റുകൾ ലഭിക്കും и . ഞങ്ങൾ ഇതിനകം കണക്കുകൂട്ടിയ കോർഡിനേറ്റുകളിൽ നിന്ന് അടുത്ത ഘട്ടം (കുറക്കൽ) എടുക്കുന്നു. അതിനാൽ ആവശ്യമായ ഒത്തുചേരൽ കൈവരിക്കുന്നതുവരെ സൈക്കിൾ വീണ്ടും വീണ്ടും ആരംഭിക്കുന്നു.

എല്ലാം! ഇപ്പോൾ ഞങ്ങൾ മരിയാന ട്രെഞ്ചിൻ്റെ ആഴമേറിയ മലയിടുക്ക് തേടി പോകാൻ തയ്യാറാണ്. നമുക്ക് തുടങ്ങാം.

ഗ്രേഡിയൻ്റ് ഡിസെൻ്റിനുള്ള കോഡ്

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

ഞങ്ങൾ മരിയാന ട്രെഞ്ചിൻ്റെ ഏറ്റവും അടിയിലേക്ക് നീങ്ങി, അവിടെ ഞങ്ങൾ ഒരേ ഗുണക മൂല്യങ്ങൾ കണ്ടെത്തി и , ഇത് കൃത്യമായി പ്രതീക്ഷിക്കേണ്ടതായിരുന്നു.

നമുക്ക് മറ്റൊരു മുങ്ങാം, ഇത്തവണ മാത്രമേ, നമ്മുടെ ആഴക്കടൽ വാഹനം മറ്റ് സാങ്കേതികവിദ്യകളാൽ നിറയും, അതായത് ഒരു ലൈബ്രറി നമ്പി.

ഗ്രേഡിയൻ്റ് ഡിസെൻ്റിനുള്ള കോഡ് (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

ഗുണക മൂല്യങ്ങൾ и മാറ്റാനാവാത്ത.

ഗ്രേഡിയൻ്റ് ഇറക്കത്തിൽ പിശക് എങ്ങനെ മാറിയെന്ന് നോക്കാം, അതായത്, ഓരോ ഘട്ടത്തിലും സ്ക്വയർ വ്യതിയാനങ്ങളുടെ ആകെത്തുക എങ്ങനെ മാറിയെന്ന് നോക്കാം.

ചതുരാകൃതിയിലുള്ള വ്യതിയാനങ്ങളുടെ പ്ലോട്ടിംഗ് തുകയ്ക്കുള്ള കോഡ്

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 "ഗ്രേഡിയൻ്റ് ഡിസെൻറ് സമയത്ത് ചതുരാകൃതിയിലുള്ള വ്യതിയാനങ്ങളുടെ ആകെത്തുക"

ഓരോ ഘട്ടത്തിലും പിശക് കുറയുന്നതായി ഗ്രാഫിൽ ഞങ്ങൾ കാണുന്നു, ഒരു നിശ്ചിത എണ്ണം ആവർത്തനങ്ങൾക്ക് ശേഷം ഞങ്ങൾ ഏതാണ്ട് തിരശ്ചീന രേഖ നിരീക്ഷിക്കുന്നു.

അവസാനമായി, കോഡ് എക്സിക്യൂഷൻ സമയത്തിലെ വ്യത്യാസം നമുക്ക് കണക്കാക്കാം:

ഗ്രേഡിയൻ്റ് ഡിസെൻ്റ് കണക്കുകൂട്ടൽ സമയം നിർണ്ണയിക്കുന്നതിനുള്ള കോഡ്

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)

ഒരുപക്ഷേ ഞങ്ങൾ എന്തെങ്കിലും തെറ്റ് ചെയ്യുന്നുണ്ടാകാം, പക്ഷേ ഇത് ലൈബ്രറി ഉപയോഗിക്കാത്ത ഒരു ലളിതമായ "വീട്ടിൽ എഴുതിയ" ഫംഗ്‌ഷനാണ്. നമ്പി ലൈബ്രറി ഉപയോഗിച്ചുള്ള ഒരു ഫംഗ്‌ഷൻ്റെ കണക്കുകൂട്ടൽ സമയത്തെ മറികടക്കുന്നു നമ്പി.

എന്നാൽ ഞങ്ങൾ നിശ്ചലമായി നിൽക്കുന്നില്ല, മറിച്ച് ലളിതമായ ലീനിയർ റിഗ്രഷൻ സമവാക്യം പരിഹരിക്കുന്നതിനുള്ള മറ്റൊരു ആവേശകരമായ മാർഗം പഠിക്കുന്നതിലേക്ക് നീങ്ങുകയാണ്. കണ്ടുമുട്ടുക!

സ്ഥായിയായ ഗ്രേഡിയൻ്റ് ഇറക്കം

സ്റ്റോക്കാസ്റ്റിക് ഗ്രേഡിയൻ്റ് ഡിസെൻറിൻ്റെ പ്രവർത്തന തത്വം വേഗത്തിൽ മനസിലാക്കാൻ, സാധാരണ ഗ്രേഡിയൻ്റ് ഡിസെൻറിൽ നിന്ന് അതിൻ്റെ വ്യത്യാസങ്ങൾ നിർണ്ണയിക്കുന്നത് നല്ലതാണ്. ഞങ്ങൾ, ഗ്രേഡിയൻ്റ് ഡിസെൻറിൻ്റെ കാര്യത്തിൽ, ഡെറിവേറ്റീവുകളുടെ സമവാക്യങ്ങളിൽ и സാമ്പിളിൽ ലഭ്യമായ എല്ലാ സവിശേഷതകളുടേയും മൂല്യങ്ങളുടെയും യഥാർത്ഥ ഉത്തരങ്ങളുടെയും ആകെത്തുക ഉപയോഗിച്ചു (അതായത്, എല്ലാത്തിൻ്റെയും ആകെത്തുക и ). സ്‌റ്റോക്കാസ്റ്റിക് ഗ്രേഡിയൻ്റ് ഡിസെൻറിൽ, സാമ്പിളിൽ ഉള്ള എല്ലാ മൂല്യങ്ങളും ഞങ്ങൾ ഉപയോഗിക്കില്ല, പകരം, സാമ്പിൾ സൂചിക എന്ന് വിളിക്കപ്പെടുന്നതിനെ വ്യാജമായി ക്രമരഹിതമായി തിരഞ്ഞെടുത്ത് അതിൻ്റെ മൂല്യങ്ങൾ ഉപയോഗിക്കുക.

ഉദാഹരണത്തിന്, സൂചിക നമ്പർ 3 (മൂന്ന്) ആയി നിശ്ചയിച്ചിട്ടുണ്ടെങ്കിൽ, ഞങ്ങൾ മൂല്യങ്ങൾ എടുക്കുന്നു и , തുടർന്ന് ഞങ്ങൾ മൂല്യങ്ങളെ ഡെറിവേറ്റീവ് സമവാക്യങ്ങളിലേക്ക് മാറ്റി പുതിയ കോർഡിനേറ്റുകൾ നിർണ്ണയിക്കുന്നു. തുടർന്ന്, കോർഡിനേറ്റുകൾ നിർണ്ണയിച്ച ശേഷം, ഞങ്ങൾ വീണ്ടും സാമ്പിൾ സൂചിക കപടമായി നിർണ്ണയിക്കുന്നു, സൂചികയുമായി ബന്ധപ്പെട്ട മൂല്യങ്ങളെ ഭാഗിക ഡിഫറൻഷ്യൽ സമവാക്യങ്ങളിലേക്ക് മാറ്റി, കോർഡിനേറ്റുകൾ ഒരു പുതിയ രീതിയിൽ നിർണ്ണയിക്കുന്നു. и തുടങ്ങിയവ. ഒത്തുചേരൽ പച്ചയായി മാറുന്നത് വരെ. ഒറ്റനോട്ടത്തിൽ, ഇത് ഒട്ടും പ്രവർത്തിക്കുമെന്ന് തോന്നുന്നില്ല, പക്ഷേ അത് പ്രവർത്തിക്കുന്നു. ഓരോ ഘട്ടത്തിലും പിശക് കുറയുന്നില്ല എന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്, പക്ഷേ തീർച്ചയായും ഒരു പ്രവണതയുണ്ട്.

പരമ്പരാഗത ഗ്രേഡിയൻ്റ് ഡിസെൻ്റിൻ്റെ ഗുണങ്ങൾ എന്തൊക്കെയാണ്? ഞങ്ങളുടെ സാമ്പിൾ വലുപ്പം വളരെ വലുതും പതിനായിരക്കണക്കിന് മൂല്യങ്ങളിൽ അളക്കുന്നതുമാണെങ്കിൽ, മുഴുവൻ സാമ്പിളിനേക്കാളും അവയിൽ ക്രമരഹിതമായ ആയിരം പ്രോസസ്സ് ചെയ്യുന്നത് വളരെ എളുപ്പമാണ്. ഇവിടെയാണ് സ്‌റ്റോക്കാസ്റ്റിക് ഗ്രേഡിയൻ്റ് ഡിസെൻ്റ് പ്രവർത്തിക്കുന്നത്. ഞങ്ങളുടെ കാര്യത്തിൽ, തീർച്ചയായും, ഞങ്ങൾ വലിയ വ്യത്യാസം ശ്രദ്ധിക്കില്ല.

നമുക്ക് കോഡ് നോക്കാം.

സ്റ്റോക്കാസ്റ്റിക് ഗ്രേഡിയൻ്റ് ഡിസെൻ്റിനുള്ള കോഡ്

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

ഞങ്ങൾ ഗുണകങ്ങൾ ശ്രദ്ധാപൂർവ്വം നോക്കുകയും "ഇത് എങ്ങനെ സംഭവിക്കും?" എന്ന ചോദ്യം ചോദിക്കുകയും ചെയ്യുന്നു. ഞങ്ങൾക്ക് മറ്റ് ഗുണക മൂല്യങ്ങൾ ലഭിച്ചു и . ഒരുപക്ഷേ സ്റ്റോക്കാസ്റ്റിക് ഗ്രേഡിയൻ്റ് ഡിസെൻ്റ് സമവാക്യത്തിന് കൂടുതൽ അനുയോജ്യമായ പാരാമീറ്ററുകൾ കണ്ടെത്തിയിട്ടുണ്ടോ? നിർഭാഗ്യവശാൽ ഇല്ല. ചതുരാകൃതിയിലുള്ള വ്യതിയാനങ്ങളുടെ ആകെത്തുക നോക്കുകയും ഗുണകങ്ങളുടെ പുതിയ മൂല്യങ്ങൾ ഉപയോഗിച്ച്, പിശക് കൂടുതലാണെന്ന് കാണുകയും ചെയ്താൽ മതി. നിരാശപ്പെടാൻ ഞങ്ങൾക്ക് തിടുക്കമില്ല. പിശക് മാറ്റത്തിൻ്റെ ഒരു ഗ്രാഫ് നിർമ്മിക്കാം.

സ്‌റ്റോക്കാസ്റ്റിക് ഗ്രേഡിയൻ്റ് ഡിസെൻറിലെ സ്‌ക്വയർ ഡീവിയേഷനുകളുടെ ആകെത്തുക പ്ലോട്ട് ചെയ്യുന്നതിനുള്ള കോഡ്

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 "സ്‌റ്റോക്കാസ്റ്റിക് ഗ്രേഡിയൻ്റ് ഡിസെൻറ് സമയത്ത് സ്‌ക്വയർ വ്യതിയാനങ്ങളുടെ ആകെത്തുക"

ഷെഡ്യൂൾ നോക്കുമ്പോൾ, എല്ലാം ശരിയാകും, ഇപ്പോൾ ഞങ്ങൾ എല്ലാം ശരിയാക്കും.

അതുകൊണ്ട് എന്തു സംഭവിച്ചു? ഇനിപ്പറയുന്നത് സംഭവിച്ചു. ഞങ്ങൾ ക്രമരഹിതമായി ഒരു മാസം തിരഞ്ഞെടുക്കുമ്പോൾ, വരുമാനം കണക്കാക്കുന്നതിലെ പിശക് കുറയ്ക്കാൻ ഞങ്ങളുടെ അൽഗോരിതം ശ്രമിക്കുന്നത് തിരഞ്ഞെടുത്ത മാസത്തിനാണ്. തുടർന്ന് ഞങ്ങൾ മറ്റൊരു മാസം തിരഞ്ഞെടുത്ത് കണക്കുകൂട്ടൽ ആവർത്തിക്കുന്നു, എന്നാൽ തിരഞ്ഞെടുത്ത രണ്ടാമത്തെ മാസത്തേക്കുള്ള പിശക് ഞങ്ങൾ കുറയ്ക്കുന്നു. ലളിതമായ ലീനിയർ റിഗ്രഷൻ സമവാക്യത്തിൻ്റെ വരിയിൽ നിന്ന് ആദ്യത്തെ രണ്ട് മാസങ്ങൾ ഗണ്യമായി വ്യതിചലിക്കുന്നുവെന്ന് ഇപ്പോൾ ഓർക്കുക. ഇതിനർത്ഥം, ഈ രണ്ട് മാസങ്ങളിൽ ഏതെങ്കിലും തിരഞ്ഞെടുക്കുമ്പോൾ, അവയിൽ ഓരോന്നിൻ്റെയും പിശക് കുറയ്ക്കുന്നതിലൂടെ, ഞങ്ങളുടെ അൽഗോരിതം മുഴുവൻ സാമ്പിളിലും പിശക് വർദ്ധിപ്പിക്കുന്നു. അപ്പോൾ എന്ത് ചെയ്യണം? ഉത്തരം ലളിതമാണ്: നിങ്ങൾ ഇറക്കത്തിൻ്റെ ഘട്ടം കുറയ്ക്കേണ്ടതുണ്ട്. എല്ലാത്തിനുമുപരി, ഇറക്കത്തിൻ്റെ ഘട്ടം കുറയ്ക്കുന്നതിലൂടെ, പിശക് മുകളിലേക്കും താഴേക്കും "ചാടി" നിർത്തും. അല്ലെങ്കിൽ, "ജമ്പിംഗ്" പിശക് നിർത്തില്ല, പക്ഷേ അത് അത്ര വേഗത്തിൽ ചെയ്യില്ല :) നമുക്ക് പരിശോധിക്കാം.

ചെറിയ ഇൻക്രിമെൻ്റുകളോടെ 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 "സ്‌റ്റോക്കാസ്റ്റിക് ഗ്രേഡിയൻ്റ് ഡിസെൻറ് സമയത്ത് സ്‌ക്വയർ വ്യതിയാനങ്ങളുടെ ആകെത്തുക (80 ആയിരം പടികൾ)"

ഗുണകങ്ങൾ മെച്ചപ്പെട്ടു, പക്ഷേ ഇപ്പോഴും അനുയോജ്യമല്ല. സാങ്കൽപ്പികമായി, ഇത് ഈ രീതിയിൽ ശരിയാക്കാം. ഉദാഹരണത്തിന്, കഴിഞ്ഞ 1000 ആവർത്തനങ്ങളിൽ ഏറ്റവും കുറഞ്ഞ പിശക് വരുത്തിയ ഗുണകങ്ങളുടെ മൂല്യങ്ങൾ ഞങ്ങൾ തിരഞ്ഞെടുക്കുന്നു. ശരിയാണ്, ഇതിനായി നമുക്ക് ഗുണകങ്ങളുടെ മൂല്യങ്ങളും എഴുതേണ്ടിവരും. ഞങ്ങൾ ഇത് ചെയ്യില്ല, മറിച്ച് ഷെഡ്യൂളിൽ ശ്രദ്ധിക്കുക. ഇത് സുഗമമായി കാണപ്പെടുന്നു, പിശക് തുല്യമായി കുറയുന്നതായി തോന്നുന്നു. യഥാർത്ഥത്തിൽ ഇത് സത്യമല്ല. ആദ്യത്തെ 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 ഘട്ടങ്ങൾ)"

ഇറക്കത്തിൻ്റെ തുടക്കത്തിൽ തന്നെ, പിശകിൽ സാമാന്യം ഏകീകൃതവും കുത്തനെയുള്ളതുമായ കുറവ് ഞങ്ങൾ നിരീക്ഷിക്കുന്നു. അവസാനത്തെ ആവർത്തനങ്ങളിൽ, പിശക് 1,475 എന്ന മൂല്യത്തിന് ചുറ്റുമായി പോകുന്നതായും ചില നിമിഷങ്ങളിൽ ഈ ഒപ്റ്റിമൽ മൂല്യത്തിന് തുല്യമാണെന്നും ഞങ്ങൾ കാണുന്നു, പക്ഷേ അത് ഇപ്പോഴും ഉയരുന്നു ... ഞാൻ ആവർത്തിക്കുന്നു, നിങ്ങൾക്ക് ഇതിൻ്റെ മൂല്യങ്ങൾ എഴുതാം. ഗുണകങ്ങൾ и , തുടർന്ന് പിശക് കുറവുള്ളവ തിരഞ്ഞെടുക്കുക. എന്നിരുന്നാലും, ഞങ്ങൾക്ക് കൂടുതൽ ഗുരുതരമായ ഒരു പ്രശ്‌നമുണ്ടായിരുന്നു: മൂല്യങ്ങൾ ഒപ്റ്റിമലിന് അടുത്ത് ലഭിക്കുന്നതിന് ഞങ്ങൾക്ക് 80 ആയിരം ഘട്ടങ്ങൾ (കോഡ് കാണുക) എടുക്കേണ്ടി വന്നു. ഗ്രേഡിയൻ്റ് ഡിസെൻ്റുമായി താരതമ്യപ്പെടുത്തുമ്പോൾ സ്റ്റോക്കാസ്റ്റിക് ഗ്രേഡിയൻ്റ് ഡിസെൻ്റ് ഉപയോഗിച്ച് കമ്പ്യൂട്ടേഷൻ സമയം ലാഭിക്കുന്നതിനുള്ള ആശയത്തിന് ഇത് ഇതിനകം വിരുദ്ധമാണ്. എന്താണ് തിരുത്താനും മെച്ചപ്പെടുത്താനും കഴിയുക? ആദ്യ ആവർത്തനങ്ങളിൽ നമ്മൾ ആത്മവിശ്വാസത്തോടെ താഴേക്ക് പോകുന്നുവെന്നത് ശ്രദ്ധിക്കുന്നത് ബുദ്ധിമുട്ടുള്ള കാര്യമല്ല, അതിനാൽ, ആദ്യ ആവർത്തനങ്ങളിൽ ഒരു വലിയ ചുവടുവെച്ച് മുന്നോട്ട് പോകുമ്പോൾ ഘട്ടം കുറയ്ക്കണം. ഈ ലേഖനത്തിൽ ഞങ്ങൾ ഇത് ചെയ്യില്ല - ഇത് ഇതിനകം തന്നെ വളരെ നീണ്ടതാണ്. ഇത് എങ്ങനെ ചെയ്യണമെന്ന് ആഗ്രഹിക്കുന്നവർക്ക് സ്വയം ചിന്തിക്കാം, ഇത് ബുദ്ധിമുട്ടുള്ള കാര്യമല്ല :)

ഇനി നമുക്ക് ലൈബ്രറി ഉപയോഗിച്ച് സ്റ്റോക്കാസ്റ്റിക് ഗ്രേഡിയൻ്റ് ഇറക്കം നടത്താം നമ്പി (ഞങ്ങൾ നേരത്തെ തിരിച്ചറിഞ്ഞ കല്ലുകളിൽ ഇടറരുത്)

സ്റ്റോക്കാസ്റ്റിക് ഗ്രേഡിയൻ്റ് ഡിസെൻ്റിനുള്ള കോഡ് (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

ഉപയോഗിക്കാതെ ഇറങ്ങുമ്പോൾ മൂല്യങ്ങൾ ഏതാണ്ട് സമാനമാണ് നമ്പി. എന്നിരുന്നാലും, ഇത് യുക്തിസഹമാണ്.

സ്‌റ്റോക്കാസ്റ്റിക് ഗ്രേഡിയൻ്റ് ഡീസൻ്റുകൾ നമുക്ക് എത്ര സമയമെടുത്തുവെന്ന് നോക്കാം.

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)

കാട്ടിലേക്ക് കൂടുതൽ, ഇരുണ്ട മേഘങ്ങൾ: വീണ്ടും, "സ്വയം എഴുതിയ" ഫോർമുല മികച്ച ഫലം കാണിക്കുന്നു. ലൈബ്രറി ഉപയോഗിക്കുന്നതിന് ഇതിലും സൂക്ഷ്മമായ വഴികൾ ഉണ്ടായിരിക്കണം എന്നാണ് ഇതെല്ലാം സൂചിപ്പിക്കുന്നത് നമ്പി, ഇത് ശരിക്കും കണക്കുകൂട്ടൽ പ്രവർത്തനങ്ങൾ വേഗത്തിലാക്കുന്നു. ഈ ലേഖനത്തിൽ നമ്മൾ അവരെക്കുറിച്ച് പഠിക്കില്ല. നിങ്ങളുടെ ഒഴിവുസമയങ്ങളിൽ ചിന്തിക്കാൻ എന്തെങ്കിലും ഉണ്ടാകും :)

സംഗ്രഹിക്കുക

സംഗ്രഹിക്കുന്നതിനുമുമ്പ്, ഞങ്ങളുടെ പ്രിയ വായനക്കാരിൽ നിന്ന് ഉയർന്നുവന്ന ഒരു ചോദ്യത്തിന് ഉത്തരം നൽകാൻ ഞാൻ ആഗ്രഹിക്കുന്നു. എന്തുകൊണ്ടാണ്, വാസ്തവത്തിൽ, ഇറക്കങ്ങളുള്ള അത്തരം "പീഡനങ്ങൾ", അമൂല്യമായ താഴ്ന്ന പ്രദേശം കണ്ടെത്തുന്നതിന്, എന്തുകൊണ്ടാണ് നമ്മൾ പർവതത്തിൻ്റെ മുകളിലേക്കും താഴേക്കും (മിക്കപ്പോഴും താഴേക്ക്) നടക്കേണ്ടത്, അത്രയും ശക്തവും ലളിതവുമായ ഒരു ഉപകരണം നമ്മുടെ കൈയിലുണ്ടെങ്കിൽ, ശരിയായ സ്ഥലത്തേക്ക് ഞങ്ങളെ തൽക്ഷണം ടെലിപോർട്ട് ചെയ്യുന്ന ഒരു വിശകലന പരിഹാരത്തിൻ്റെ രൂപം?

ഈ ചോദ്യത്തിനുള്ള ഉത്തരം ഉപരിതലത്തിലാണ്. ഇപ്പോൾ നമ്മൾ വളരെ ലളിതമായ ഒരു ഉദാഹരണം പരിശോധിച്ചു, അതിൽ യഥാർത്ഥ ഉത്തരം ഒരു ചിഹ്നത്തെ ആശ്രയിച്ചിരിക്കുന്നു . ജീവിതത്തിൽ നിങ്ങൾ ഇത് പലപ്പോഴും കാണുന്നില്ല, അതിനാൽ നമുക്ക് 2, 30, 50 അല്ലെങ്കിൽ അതിലധികമോ അടയാളങ്ങൾ ഉണ്ടെന്ന് സങ്കൽപ്പിക്കുക. നമുക്ക് ഇതിലേക്ക് ഓരോ ആട്രിബ്യൂട്ടിനും ആയിരക്കണക്കിന് അല്ലെങ്കിൽ പതിനായിരക്കണക്കിന് മൂല്യങ്ങൾ ചേർക്കാം. ഈ സാഹചര്യത്തിൽ, വിശകലന പരിഹാരം പരിശോധനയെ നേരിടാനും പരാജയപ്പെടാനും ഇടയില്ല. അതാകട്ടെ, ഗ്രേഡിയൻ്റ് ഇറക്കവും അതിൻ്റെ വ്യതിയാനങ്ങളും ഞങ്ങളെ സാവധാനത്തിൽ എന്നാൽ തീർച്ചയായും ലക്ഷ്യത്തിലേക്ക് അടുപ്പിക്കും - ഫംഗ്ഷൻ്റെ മിനിമം. വേഗതയെക്കുറിച്ച് വിഷമിക്കേണ്ട - സ്റ്റെപ്പ് ദൈർഘ്യം (അതായത്, വേഗത) സജ്ജീകരിക്കാനും നിയന്ത്രിക്കാനും ഞങ്ങളെ അനുവദിക്കുന്ന വഴികൾ ഞങ്ങൾ പരിശോധിക്കും.

ഇപ്പോൾ യഥാർത്ഥ ഹ്രസ്വ സംഗ്രഹം.

ഒന്നാമതായി, ലളിതമായ (മാത്രമല്ല) ലീനിയർ റിഗ്രഷൻ സമവാക്യങ്ങൾ എങ്ങനെ പരിഹരിക്കാമെന്ന് മനസിലാക്കാൻ "ഡാറ്റ ശാസ്ത്രജ്ഞരെ" ആരംഭിക്കാൻ ലേഖനത്തിൽ അവതരിപ്പിച്ച മെറ്റീരിയൽ സഹായിക്കുമെന്ന് ഞാൻ പ്രതീക്ഷിക്കുന്നു.

രണ്ടാമതായി, സമവാക്യം പരിഹരിക്കുന്നതിനുള്ള നിരവധി വഴികൾ ഞങ്ങൾ നോക്കി. ഇപ്പോൾ, സാഹചര്യം അനുസരിച്ച്, പ്രശ്നം പരിഹരിക്കാൻ ഏറ്റവും അനുയോജ്യമായ ഒന്ന് തിരഞ്ഞെടുക്കാം.

മൂന്നാമതായി, അധിക ക്രമീകരണങ്ങളുടെ ശക്തി ഞങ്ങൾ കണ്ടു, അതായത് ഗ്രേഡിയൻ്റ് ഡിസെൻ്റ് സ്റ്റെപ്പ് ദൈർഘ്യം. ഈ പരാമീറ്റർ അവഗണിക്കാനാവില്ല. മുകളിൽ സൂചിപ്പിച്ചതുപോലെ, കണക്കുകൂട്ടലുകളുടെ ചെലവ് കുറയ്ക്കുന്നതിന്, ഇറക്കത്തിൽ ഘട്ടം നീളം മാറ്റണം.

നാലാമതായി, ഞങ്ങളുടെ കാര്യത്തിൽ, "വീട്ടിൽ എഴുതിയ" ഫംഗ്ഷനുകൾ കണക്കുകൂട്ടലുകൾക്ക് മികച്ച സമയ ഫലങ്ങൾ കാണിച്ചു. ലൈബ്രറിയുടെ കഴിവുകളുടെ ഏറ്റവും പ്രൊഫഷണലായി ഉപയോഗിക്കാത്തതുകൊണ്ടാകാം ഇത് നമ്പി. എന്നാൽ അത് എന്തായാലും, ഇനിപ്പറയുന്ന നിഗമനം സ്വയം നിർദ്ദേശിക്കുന്നു. ഒരു വശത്ത്, ചിലപ്പോൾ സ്ഥാപിത അഭിപ്രായങ്ങളെ ചോദ്യം ചെയ്യുന്നത് മൂല്യവത്താണ്, മറുവശത്ത്, എല്ലാം സങ്കീർണ്ണമാക്കുന്നത് എല്ലായ്പ്പോഴും വിലമതിക്കുന്നില്ല - നേരെമറിച്ച്, ചിലപ്പോൾ ഒരു പ്രശ്നം പരിഹരിക്കുന്നതിനുള്ള ലളിതമായ മാർഗ്ഗം കൂടുതൽ ഫലപ്രദമാണ്. ഒരു ലളിതമായ ലീനിയർ റിഗ്രഷൻ സമവാക്യം പരിഹരിക്കുന്നതിനുള്ള മൂന്ന് സമീപനങ്ങൾ വിശകലനം ചെയ്യുക എന്നതായിരുന്നു ഞങ്ങളുടെ ലക്ഷ്യം എന്നതിനാൽ, "സ്വയം എഴുതിയ" ഫംഗ്ഷനുകളുടെ ഉപയോഗം ഞങ്ങൾക്ക് മതിയായിരുന്നു.

സാഹിത്യം (അല്ലെങ്കിൽ അത്തരത്തിലുള്ള എന്തെങ്കിലും)

1. ലീനിയർ റിഗ്രഷൻ

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

2. ഏറ്റവും കുറഞ്ഞ ചതുരങ്ങൾ രീതി

mathprofi.ru/metod_naimenshih_kvadratov.html

3. ഡെറിവേറ്റീവ്

www.mathprofi.ru/chastnye_proizvodnye_primery.html

4. ഗ്രേഡിയൻ്റ്

mathprofi.ru/proizvodnaja_po_napravleniju_i_gradient.html

5. ഗ്രേഡിയൻ്റ് ഇറക്കം

habr.com/en/post/471458

habr.com/en/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