🥇ការដោះស្រាយសមីការនៃតំរែតំរង់លីនេអ៊ែរសាមញ្ញ

អត្ថបទពិភាក្សាអំពីវិធីជាច្រើនដើម្បីកំណត់សមីការគណិតវិទ្យានៃបន្ទាត់តំរែតំរង់សាមញ្ញ (គូ) ។

វិធីសាស្រ្តទាំងអស់នៃការដោះស្រាយសមីការដែលបានពិភាក្សានៅទីនេះគឺផ្អែកលើវិធីសាស្ត្រការេតិចបំផុត។ ចូរយើងសម្គាល់វិធីសាស្រ្តដូចខាងក្រោមៈ

ដំណោះស្រាយវិភាគ
ជម្រាលជម្រាល
ការចុះជម្រាល Stochastic

សម្រាប់វិធីសាស្រ្តនីមួយៗនៃការដោះស្រាយសមីការនៃបន្ទាត់ត្រង់ អត្ថបទផ្តល់នូវមុខងារផ្សេងៗ ដែលភាគច្រើនត្រូវបានបែងចែកទៅជាអ្វីដែលត្រូវបានសរសេរដោយមិនប្រើបណ្ណាល័យ។ ណាំភី និងអ្នកដែលប្រើសម្រាប់ការគណនា ណាំភី. វាត្រូវបានគេជឿថាការប្រើជំនាញ ណាំភី នឹងកាត់បន្ថយការចំណាយលើកុំព្យូទ័រ។

កូដទាំងអស់ដែលបានផ្តល់ឱ្យនៅក្នុងអត្ថបទត្រូវបានសរសេរនៅក្នុង ពស់ថ្លាន់ 2.7 ដោយប្រើ កុំព្យូទ័រយួរដៃ Jupyter. កូដប្រភព និងឯកសារដែលមានទិន្នន័យគំរូត្រូវបានបង្ហោះនៅលើ Github

អត្ថបទនេះមានគោលបំណងកាន់តែច្រើនសម្រាប់អ្នកចាប់ផ្តើមដំបូង និងអ្នកដែលបានចាប់ផ្តើមបន្តិចម្តងៗដើម្បីធ្វើជាម្ចាស់នៃការសិក្សាផ្នែកដ៏ធំទូលាយមួយនៅក្នុងបញ្ញាសិប្បនិម្មិត - ការរៀនម៉ាស៊ីន។

ដើម្បីបង្ហាញសម្ភារៈ យើងប្រើឧទាហរណ៍ដ៏សាមញ្ញមួយ។

ឧទាហរណ៍លក្ខខណ្ឌ

យើងមានតម្លៃប្រាំយ៉ាងដែលកំណត់លក្ខណៈអាស្រ័យ Y ពី X (តារាងលេខ ១)៖

តារាងទី 1 “លក្ខខណ្ឌឧទាហរណ៍”

យើងនឹងសន្មតថាតម្លៃ គឺជាខែនៃឆ្នាំ, និង - ប្រាក់ចំណូលក្នុងខែនេះ។ ម្យ៉ាងទៀត ចំណូលគឺអាស្រ័យលើខែនៃឆ្នាំ និង - សញ្ញាតែមួយគត់ដែលប្រាក់ចំណូលអាស្រ័យ។

ឧទាហរណ៍គឺដូច្នេះ - ដូច្នេះទាំងពីទស្សនៈនៃការពឹងផ្អែកតាមលក្ខខណ្ឌនៃប្រាក់ចំណូលនៅលើខែនៃឆ្នាំនិងពីចំណុចនៃទិដ្ឋភាពនៃចំនួននៃតម្លៃ - មានតិចតួចណាស់នៃពួកគេ។ ទោះជាយ៉ាងណាក៏ដោយ ភាពសាមញ្ញបែបនេះនឹងធ្វើឱ្យវាអាចធ្វើទៅបាន ដូចដែលពួកគេនិយាយថា ដើម្បីពន្យល់ មិនមែនតែងតែមានភាពងាយស្រួលនោះទេ សម្ភារៈដែលអ្នកចាប់ផ្តើមដំបូងបញ្ចូល។ ហើយភាពសាមញ្ញនៃលេខនឹងអនុញ្ញាតឱ្យអ្នកដែលចង់ដោះស្រាយឧទាហរណ៍នៅលើក្រដាសដោយគ្មានតម្លៃពលកម្មសំខាន់។

អនុញ្ញាតឱ្យយើងសន្មត់ថាការពឹងផ្អែកដែលបានផ្តល់ឱ្យក្នុងឧទាហរណ៍អាចត្រូវបានប៉ាន់ប្រមាណយ៉ាងល្អដោយសមីការគណិតវិទ្យានៃបន្ទាត់តំរែតំរង់សាមញ្ញ (គូ) នៃទម្រង់:

ដែលជាកន្លែងដែល គឺជាខែដែលចំណូលត្រូវបានទទួល - ចំណូលដែលត្រូវនឹងខែ и គឺជាមេគុណតំរែតំរង់នៃបន្ទាត់ប៉ាន់ស្មាន។

ចំណាំថាមេគុណ ជារឿយៗគេហៅថាជម្រាល ឬជម្រាលនៃបន្ទាត់ប៉ាន់ស្មាន។ តំណាងឱ្យចំនួនដែល នៅពេលដែលវាផ្លាស់ប្តូរ .

ជាក់ស្តែង ភារកិច្ចរបស់យើងក្នុងឧទាហរណ៍គឺជ្រើសរើសមេគុណបែបនេះនៅក្នុងសមីការ и ដែលគម្លាតនៃតម្លៃចំណូលដែលបានគណនារបស់យើងតាមខែពីចម្លើយពិត i.e. តម្លៃដែលបង្ហាញក្នុងគំរូនឹងមានតិចតួច។

វិធីសាស្រ្តការ៉េតិចបំផុត។

យោងតាមវិធីសាស្ត្រការេតិចបំផុត គម្លាតគួរត្រូវបានគណនាដោយការ៉េ។ បច្ចេកទេសនេះអនុញ្ញាតឱ្យអ្នកជៀសវាងការលុបចោលទៅវិញទៅមកនៃគម្លាតប្រសិនបើពួកគេមានសញ្ញាផ្ទុយ។ ឧទាហរណ៍ប្រសិនបើក្នុងករណីមួយ គម្លាតគឺ +5 (បូកប្រាំ) និងមួយទៀត -5 (ដកប្រាំ) បន្ទាប់មកផលបូកនៃគម្លាតនឹងលុបចោលគ្នាទៅវិញទៅមក ហើយមានចំនួនដល់ 0 (សូន្យ)។ វាមិនអាចទៅរួចទេក្នុងការបំបែកគម្លាតប៉ុន្តែដើម្បីប្រើទ្រព្យសម្បត្តិនៃម៉ូឌុលហើយបន្ទាប់មកគម្លាតទាំងអស់នឹងមានភាពវិជ្ជមានហើយនឹងកកកុញ។ យើងនឹងមិនរស់នៅលើចំណុចនេះឱ្យបានលំអិតទេ ប៉ុន្តែគ្រាន់តែបង្ហាញថា ដើម្បីភាពងាយស្រួលនៃការគណនា វាជាទម្លាប់ក្នុងការដាក់គម្លាតពីគ្នាជាការ៉េ។

នេះគឺជាអ្វីដែលរូបមន្តមើលទៅដូចដែលយើងនឹងកំណត់ផលបូកតិចបំផុតនៃគម្លាតការេ (កំហុស):

ដែលជាកន្លែងដែល គឺជាមុខងារនៃការប៉ាន់ស្មានចម្លើយពិត (នោះគឺចំណូលដែលយើងគណនា)

គឺជាចម្លើយពិត (ចំណូលដែលបានផ្តល់ក្នុងគំរូ)

គឺជាសន្ទស្សន៍គំរូ (ចំនួនខែដែលគម្លាតត្រូវបានកំណត់)

ចូរយើងបែងចែកមុខងារ កំណត់សមីការឌីផេរ៉ង់ស្យែលដោយផ្នែក ហើយត្រៀមខ្លួនដើម្បីបន្តទៅដំណោះស្រាយវិភាគ។ ប៉ុន្តែជាដំបូង ចូរយើងលើកយកដំណើរកំសាន្តខ្លីមួយអំពីភាពខុសគ្នានៃភាពខុសគ្នា ហើយចងចាំអត្ថន័យធរណីមាត្រនៃដេរីវេ។

ភាពខុសគ្នា

ភាពខុសគ្នាគឺជាប្រតិបត្តិការនៃការស្វែងរកដេរីវេនៃអនុគមន៍មួយ។

តើដេរីវេប្រើសម្រាប់អ្វី? ដេរីវេនៃអនុគមន៍កំណត់អត្រានៃការផ្លាស់ប្តូរមុខងារ និងប្រាប់យើងពីទិសដៅរបស់វា។ ប្រសិនបើដេរីវេនៅចំណុចមួយគឺវិជ្ជមាន នោះមុខងារនឹងកើនឡើង បើមិនដូច្នេះទេ មុខងារនឹងថយចុះ។ ហើយតម្លៃកាន់តែធំនៃដេរីវេនៃដាច់ខាត អត្រានៃការផ្លាស់ប្តូរតម្លៃមុខងារកាន់តែខ្ពស់ ក៏ដូចជាជម្រាលនៃក្រាហ្វអនុគមន៍កាន់តែខ្ពស់។

ឧទាហរណ៍ នៅក្រោមលក្ខខណ្ឌនៃប្រព័ន្ធកូអរដោនេ Cartesian តម្លៃនៃដេរីវេនៅចំណុច M(0,0) គឺស្មើនឹង +25 មានន័យថានៅចំណុចមួយដែលបានផ្តល់ឱ្យនៅពេលដែលតម្លៃត្រូវបានផ្លាស់ប្តូរ ទៅខាងស្តាំដោយឯកតាធម្មតា តម្លៃ កើនឡើង 25 ឯកតាធម្មតា។ នៅលើក្រាហ្វវាមើលទៅដូចជាការកើនឡើងយ៉ាងខ្លាំងនៃតម្លៃ ពីចំណុចដែលបានផ្តល់ឱ្យ។

ឧទាហរណ៍មួយទៀត។ តម្លៃដេរីវេគឺស្មើគ្នា -0,1 មានន័យថានៅពេលផ្លាស់ទីលំនៅ ក្នុងមួយឯកតាធម្មតា តម្លៃ ថយចុះត្រឹមតែ 0,1 ឯកតាធម្មតា។ ក្នុងពេលជាមួយគ្នានេះ នៅលើក្រាហ្វនៃមុខងារ យើងអាចសង្កេតមើលជម្រាលចុះក្រោមដែលគួរឱ្យកត់សម្គាល់។ គូរភាពស្រដៀងគ្នាជាមួយភ្នំមួយ វាដូចជាយើងកំពុងចុះជម្រាលដ៏ទន់ភ្លន់ពីភ្នំមួយ មិនដូចឧទាហរណ៍មុន ដែលយើងត្រូវឡើងកំពូលភ្នំដ៏ចោតខ្លាំង :)

ដូច្នេះបន្ទាប់ពីបែងចែកមុខងារ ដោយហាងឆេង и យើងកំណត់សមីការឌីផេរ៉ង់ស្យែលផ្នែកលំដាប់ទី 1 ។ បន្ទាប់ពីកំណត់សមីការ យើងនឹងទទួលបានប្រព័ន្ធនៃសមីការពីរ ដោយដំណោះស្រាយដែលយើងនឹងអាចជ្រើសរើសតម្លៃនៃមេគុណ и ដែលតម្លៃនៃនិស្សន្ទវត្ថុដែលត្រូវគ្នានៅចំណុចដែលបានផ្តល់ឱ្យផ្លាស់ប្តូរដោយចំនួនតិចតួចបំផុត ហើយក្នុងករណីនៃដំណោះស្រាយវិភាគមិនផ្លាស់ប្តូរទាល់តែសោះ។ ម្យ៉ាងវិញទៀត មុខងារកំហុសនៅមេគុណដែលបានរកឃើញនឹងឈានដល់កម្រិតអប្បបរមា ដោយហេតុថាតម្លៃនៃដេរីវេដោយផ្នែកនៅចំណុចទាំងនេះនឹងស្មើនឹងសូន្យ។

ដូច្នេះយោងទៅតាមច្បាប់នៃភាពខុសគ្នា សមីការដេរីវេដោយផ្នែកនៃលំដាប់ទី 1 ទាក់ទងនឹងមេគុណ នឹងយកទម្រង់៖

សមីការដេរីវេភាគនៃលំដាប់ទី 1 ទាក់ទងនឹង នឹងយកទម្រង់៖

ជាលទ្ធផល យើងបានទទួលប្រព័ន្ធនៃសមីការដែលមានដំណោះស្រាយវិភាគដ៏សាមញ្ញមួយ៖

ចាប់ផ្តើម{សមីការ*}
ចាប់ផ្តើម{cases}
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}
បញ្ចប់{សមីការ*}

មុននឹងដោះស្រាយសមីការ ចូរយើងផ្ទុកជាមុន ពិនិត្យមើលថាការផ្ទុកត្រឹមត្រូវ និងធ្វើទ្រង់ទ្រាយទិន្នន័យ។

កំពុងផ្ទុក និងធ្វើទ្រង់ទ្រាយទិន្នន័យ

វាគួរតែត្រូវបានកត់សម្គាល់ថាដោយសារតែការពិតដែលថាសម្រាប់ដំណោះស្រាយវិភាគនិងជាបន្តបន្ទាប់សម្រាប់ gradient និង stochastic gradient 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 '********************************************'

ការមើលឃើញ

ឥឡូវនេះ បន្ទាប់ពីយើងបានផ្ទុកទិន្នន័យដំបូង ទីពីរពិនិត្យភាពត្រឹមត្រូវនៃការផ្ទុក ហើយចុងក្រោយធ្វើទ្រង់ទ្រាយទិន្នន័យ យើងនឹងអនុវត្តការមើលឃើញដំបូង។ វិធីសាស្រ្តដែលត្រូវបានប្រើជាញឹកញាប់សម្រាប់ការនេះគឺ គ្រោងគូ បណ្ណាល័យ សេបាន. ក្នុងឧទាហរណ៍របស់យើង ដោយសារចំនួនមានកំណត់ វាគ្មានចំណុចក្នុងការប្រើបណ្ណាល័យទេ។ សេបាន. យើងនឹងប្រើបណ្ណាល័យធម្មតា។ ម៉ាត់ផ្លូលីប ហើយគ្រាន់តែក្រឡេកមើលគ្រោង។

កូដ 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 "ការពឹងផ្អែកនៃប្រាក់ចំណូលប្រចាំខែនៃឆ្នាំ"

ដំណោះស្រាយវិភាគ

ចូរយើងប្រើឧបករណ៍ទូទៅបំផុតនៅក្នុង ពស់ថ្លាន់ និងដោះស្រាយប្រព័ន្ធសមីការ៖

ចាប់ផ្តើម{សមីការ*}
ចាប់ផ្តើម{cases}
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)

នេះជាអ្វីដែលយើងទទួលបាន៖

ដូច្នេះតម្លៃនៃមេគុណត្រូវបានរកឃើញផលបូកនៃគម្លាតការេត្រូវបានបង្កើតឡើង។ ចូរគូរបន្ទាត់ត្រង់នៅលើអ៊ីស្តូក្រាមដែលខ្ចាត់ខ្ចាយដោយអនុលោមតាមមេគុណដែលបានរកឃើញ។

កូដបន្ទាត់តំរែតំរង់

# определим функцию для формирования массива рассчетных значений выручки
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 “គម្លាត, %”

មិនល្អឥតខ្ចោះទេ ប៉ុន្តែយើងបានបញ្ចប់ភារកិច្ចរបស់យើង។

ចូរយើងសរសេរអនុគមន៍ដែលដើម្បីកំណត់មេគុណ и ប្រើបណ្ណាល័យ ណាំភីកាន់តែច្បាស់ យើងនឹងសរសេរមុខងារពីរ៖ មួយប្រើម៉ាទ្រីស pseudoinverse (មិនត្រូវបានណែនាំក្នុងការអនុវត្តទេ ដោយសារដំណើរការគឺស្មុគស្មាញក្នុងការគណនា និងមិនមានស្ថេរភាព) មួយទៀតប្រើសមីការម៉ាទ្រីស។

កូដដំណោះស្រាយវិភាគ (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

ចូរយើងប្រៀបធៀបពេលវេលាដែលបានចំណាយលើការកំណត់មេគុណ и អនុលោមតាមវិធីសាស្រ្តចំនួន ៣ ដែលបានបង្ហាញ។

លេខកូដសម្រាប់គណនាពេលវេលាគណនា

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 ។

ឥឡូវនេះអ្នកអាចបន្តទៅវិធីផ្សេងទៀតដើម្បីស្វែងរកមេគុណ и .

ជម្រាលជម្រាល

ជាដំបូង ចូរយើងកំណត់ថាតើជម្រាលគឺជាអ្វី។ និយាយឱ្យសាមញ្ញ ជម្រាលគឺជាផ្នែកដែលបង្ហាញពីទិសដៅនៃការលូតលាស់អតិបរមានៃមុខងារមួយ។ ដោយភាពស្រដៀងគ្នាជាមួយនឹងការឡើងភ្នំ ដែលជម្រាលបែរមុខទៅកន្លែងដែលចោតបំផុតទៅកំពូលភ្នំ។ ការបង្កើតឧទាហរណ៍ជាមួយភ្នំយើងចងចាំថាតាមពិតយើងត្រូវការជម្រាលភ្នំបំផុតដើម្បីទៅដល់ដីទំនាបឱ្យបានលឿនតាមដែលអាចធ្វើទៅបាន នោះគឺអប្បបរមា - កន្លែងដែលមុខងារមិនកើនឡើងឬថយចុះ។ នៅចំណុចនេះ ដេរីវេនឹងស្មើនឹងសូន្យ។ ដូច្នេះហើយ យើងមិនត្រូវការពណ៌ជម្រាលទេ ប៉ុន្តែជាការប្រឆាំងនឹងពណ៌។ ដើម្បីស្វែងរក antigradient អ្នកគ្រាន់តែត្រូវគុណជម្រាលដោយ -1 (ដកមួយ) ។

ចូរយើងយកចិត្តទុកដាក់លើការពិតដែលថាមុខងារមួយអាចមានអប្បរមាជាច្រើន ហើយបានចុះទៅក្នុងមួយក្នុងចំណោមពួកវាដោយប្រើក្បួនដោះស្រាយដែលបានស្នើឡើងខាងក្រោម យើងនឹងមិនអាចស្វែងរកអប្បបរមាផ្សេងទៀតដែលអាចទាបជាងអ្វីដែលបានរកឃើញនោះទេ។ សម្រាកចុះ នេះមិនមែនជាការគំរាមកំហែងដល់យើងទេ! ក្នុងករណីរបស់យើង យើងកំពុងដោះស្រាយជាមួយនឹងអប្បបរមាតែមួយ ចាប់តាំងពីមុខងាររបស់យើង។ នៅលើក្រាហ្វគឺជាប៉ារ៉ាបូឡាធម្មតា។ ហើយដូចដែលយើងទាំងអស់គ្នាគួរតែដឹងយ៉ាងច្បាស់ពីវគ្គសិក្សាគណិតវិទ្យារបស់សាលារបស់យើង ប៉ារ៉ាបូឡាមានអប្បបរមាតែមួយប៉ុណ្ណោះ។

បន្ទាប់ពីយើងបានរកឃើញថាហេតុអ្វីបានជាយើងត្រូវការជម្រាលមួយ ហើយក៏ថាជម្រាលគឺជាផ្នែកមួយ នោះគឺជាវ៉ិចទ័រដែលមានកូអរដោណេដែលបានផ្តល់ឱ្យដែលជាមេគុណដូចគ្នាយ៉ាងជាក់លាក់។ и យើងអាចអនុវត្តការចុះជម្រាល។

មុនពេលចាប់ផ្តើមខ្ញុំស្នើឱ្យអានប្រយោគពីរបីអំពីក្បួនដោះស្រាយការបន្តពូជ៖

យើងកំណត់ក្នុងលក្ខណៈ pseudo-ចៃដន្យ កូអរដោនេនៃមេគុណ и . ក្នុងឧទាហរណ៍របស់យើង យើងនឹងកំណត់មេគុណនៅជិតសូន្យ។ នេះជាទម្លាប់ធម្មតា ប៉ុន្តែករណីនីមួយៗអាចមានការអនុវត្តរៀងៗខ្លួន។
ពីកូអរដោណេ ដកតម្លៃនៃដេរីវេភាគនៃលំដាប់ទី 1 នៅចំណុច . ដូច្នេះប្រសិនបើដេរីវេគឺវិជ្ជមាន នោះមុខងារនឹងកើនឡើង។ ដូច្នេះដោយការដកតម្លៃនៃដេរីវេ យើងនឹងផ្លាស់ទីក្នុងទិសដៅផ្ទុយនៃការលូតលាស់ ពោលគឺក្នុងទិសដៅនៃតំណពូជ។ ប្រសិនបើនិស្សន្ទវត្ថុអវិជ្ជមាន នោះមុខងារនៅចំណុចនេះថយចុះ ហើយដោយការដកតម្លៃនៃដេរីវេទីវ យើងផ្លាស់ទីក្នុងទិសដៅនៃតំណពូជ។
យើងអនុវត្តប្រតិបត្តិការស្រដៀងគ្នាជាមួយកូអរដោនេ ៖ ដកតម្លៃនៃដេរីវេដោយផ្នែកនៅចំណុច .
ដើម្បីកុំឱ្យលោតពីលើអប្បរមាហើយហោះហើរចូលទៅក្នុងលំហដ៏ជ្រៅវាចាំបាច់ត្រូវកំណត់ទំហំជំហានក្នុងទិសដៅនៃការចុះ។ ជាទូទៅ អ្នកអាចសរសេរអត្ថបទទាំងមូលអំពីរបៀបកំណត់ជំហានឱ្យបានត្រឹមត្រូវ និងរបៀបផ្លាស់ប្តូរវាក្នុងអំឡុងពេលដំណើរការចុះក្នុងគោលបំណងកាត់បន្ថយការចំណាយលើការគណនា។ ប៉ុន្តែឥឡូវនេះ យើងមានភារកិច្ចខុសគ្នាបន្តិចបន្តួច ហើយយើងនឹងបង្កើតទំហំជំហានដោយប្រើវិធីសាស្រ្តវិទ្យាសាស្ត្រនៃ "poke" ឬដូចដែលពួកគេនិយាយនៅក្នុងការនិយាយទូទៅ ជាក់ស្តែង។
នៅពេលដែលយើងមកពីកូអរដោនេដែលបានផ្តល់ឱ្យ и ដកតម្លៃនៃនិស្សន្ទវត្ថុ យើងទទួលបានកូអរដោនេថ្មី។ и . យើងអនុវត្តជំហានបន្ទាប់ (ដក) រួចហើយពីកូអរដោនេដែលបានគណនា។ ដូច្នេះហើយ វដ្តនេះចាប់ផ្តើមម្តងហើយម្តងទៀត រហូតដល់ការបង្រួបបង្រួមដែលត្រូវការត្រូវបានសម្រេច។

ទាំងអស់! ឥឡូវនេះ យើងត្រៀមរួចរាល់ហើយ ដើម្បីស្វែងរកជ្រលងជ្រៅបំផុតនៃជ្រលង Mariana Trench។ តោះចាប់ផ្តើម។

កូដសម្រាប់ការចុះជម្រាល

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

តម្លៃមេគុណ и មិនអាចផ្លាស់ប្តូរបាន។

សូមក្រឡេកមើលពីរបៀបដែលកំហុសបានផ្លាស់ប្តូរអំឡុងពេលចុះជម្រាល នោះគឺរបៀបដែលផលបូកនៃគម្លាតការ៉េបានផ្លាស់ប្តូរជាមួយនឹងជំហាននីមួយៗ។

កូដសម្រាប់គូរផលបូកនៃគម្លាតការ៉េ

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)

ប្រហែលជាយើងកំពុងធ្វើអ្វីមួយខុស ប៉ុន្តែវាជាមុខងារ "សរសេរតាមផ្ទះ" ធម្មតាដែលមិនប្រើបណ្ណាល័យ ណាំភី ដំណើរការលើសពីពេលវេលាគណនានៃមុខងារដោយប្រើបណ្ណាល័យ ណាំភី.

ប៉ុន្តែយើងមិនឈរនៅស្ងៀមទេ ប៉ុន្តែកំពុងឆ្ពោះទៅរកការសិក្សាវិធីដ៏គួរឱ្យរំភើបមួយផ្សេងទៀតដើម្បីដោះស្រាយសមីការតំរែតំរង់លីនេអ៊ែរសាមញ្ញ។ ជួបគ្នា!

ការចុះជម្រាល Stochastic

ដើម្បីយល់ពីគោលការណ៍នៃប្រតិបត្តិការនៃជម្រាលជម្រាល stochastic វាជាការល្អប្រសើរជាងមុនដើម្បីកំណត់ភាពខុសគ្នារបស់វាពីការចុះជម្រាលធម្មតា។ យើងនៅក្នុងករណីនៃ gradient descent នៅក្នុងសមីការនៃដេរីវេនៃ и បានប្រើផលបូកនៃតម្លៃនៃលក្ខណៈពិសេសទាំងអស់ និងចម្លើយពិតដែលមាននៅក្នុងគំរូ (នោះគឺផលបូកនៃទាំងអស់ и ) នៅក្នុង stochastic gradient descent យើងនឹងមិនប្រើតម្លៃទាំងអស់ដែលមាននៅក្នុងគំរូនោះទេ ប៉ុន្តែផ្ទុយទៅវិញ pseudo-random ជ្រើសរើសអ្វីដែលគេហៅថាសន្ទស្សន៍គំរូ ហើយប្រើតម្លៃរបស់វា។

ឧទាហរណ៍ ប្រសិនបើសន្ទស្សន៍ត្រូវបានកំណត់ជាលេខ 3 (បី) នោះយើងយកតម្លៃ и បន្ទាប់មកយើងជំនួសតម្លៃទៅក្នុងសមីការដេរីវេ និងកំណត់កូអរដោណេថ្មី។ បន្ទាប់មក ដោយបានកំណត់កូអរដោណេ យើងម្តងទៀតកំណត់សន្ទស្សន៍គំរូដោយចៃដន្យ ជំនួសតម្លៃដែលត្រូវគ្នានឹងលិបិក្រមទៅក្នុងសមីការឌីផេរ៉ង់ស្យែលផ្នែក និងកំណត់កូអរដោណេតាមវិធីថ្មីមួយ។ и ល។ រហូតដល់ការបញ្ចូលគ្នាប្រែទៅជាពណ៌បៃតង។ នៅ glance ដំបូង វាអាចហាក់ដូចជាវាមិនដំណើរការទាល់តែសោះ ប៉ុន្តែវាធ្វើបាន។ វាជាការពិតដែលថាវាគួរអោយកត់សំគាល់ថាកំហុសមិនថយចុះជាមួយគ្រប់ជំហានទេប៉ុន្តែពិតជាមានទំនោរ។

តើអ្វីទៅជាគុណសម្បត្តិនៃការចុះជម្រាល stochastic ជាងធម្មតា? ប្រសិនបើទំហំគំរូរបស់យើងមានទំហំធំណាស់ ហើយត្រូវបានវាស់ជាតម្លៃរាប់ម៉ឺន នោះវាកាន់តែងាយស្រួលក្នុងការដំណើរការ និយាយថា មួយពាន់ដោយចៃដន្យ ជាជាងគំរូទាំងមូល។ នេះគឺជាកន្លែងដែលការចុះជម្រាល stochastic ចូលមកលេង។ ជាការពិតណាស់ក្នុងករណីរបស់យើង យើងនឹងមិនសម្គាល់ឃើញពីភាពខុសគ្នាច្រើនទេ។

តោះមើលកូដ។

កូដសម្រាប់ការចុះជម្រាល 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])

យើងក្រឡេកមើលមេគុណដោយប្រុងប្រយ័ត្ន ហើយចាប់ខ្លួនយើងដោយសួរសំណួរថា "តើវាអាចទៅជាយ៉ាងណា?" យើងទទួលបានតម្លៃមេគុណផ្សេងទៀត។ и . ប្រហែលជា stochastic gradient descent បានរកឃើញប៉ារ៉ាម៉ែត្រល្អបំផុតសម្រាប់សមីការ? ជាអកុសលទេ។ វាគ្រប់គ្រាន់ហើយក្នុងការមើលផលបូកនៃគម្លាតការ៉េហើយឃើញថាជាមួយនឹងតម្លៃថ្មីនៃមេគុណកំហុសគឺធំជាង។ យើងមិនប្រញាប់ដើម្បីអស់សង្ឃឹមទេ។ ចូរយើងបង្កើតក្រាហ្វនៃការផ្លាស់ប្តូរកំហុស។

កូដសម្រាប់កំណត់ផលបូកនៃគម្លាតការ៉េក្នុងការធ្លាក់ចុះជម្រាល stochastic

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 “ផលបូកនៃគម្លាតការ៉េកំឡុងពេលចុះជម្រាល stochastic”

ក្រឡេកមើលកាលវិភាគអ្វីៗគ្រប់យ៉ាងនឹងចូលកន្លែងហើយឥឡូវនេះយើងនឹងជួសជុលអ្វីៗគ្រប់យ៉ាង។

ដូច្នេះតើមានអ្វីបានកើតឡើង? ខាងក្រោមនេះបានកើតឡើង។ នៅពេលដែលយើងជ្រើសរើសដោយចៃដន្យមួយខែ នោះវាគឺសម្រាប់ខែដែលបានជ្រើសរើសដែលក្បួនដោះស្រាយរបស់យើងស្វែងរកដើម្បីកាត់បន្ថយកំហុសក្នុងការគណនាប្រាក់ចំណូល។ បន្ទាប់មកយើងជ្រើសរើសខែមួយទៀត ហើយធ្វើការគណនាឡើងវិញ ប៉ុន្តែយើងកាត់បន្ថយកំហុសសម្រាប់ខែដែលបានជ្រើសរើសទីពីរ។ ឥឡូវនេះសូមចាំថា ពីរខែដំបូងមានគម្លាតយ៉ាងខ្លាំងពីបន្ទាត់នៃសមីការតំរែតំរង់លីនេអ៊ែរសាមញ្ញ។ នេះមានន័យថានៅពេលដែលណាមួយក្នុងចំណោមពីរខែនេះត្រូវបានជ្រើសរើស ដោយកាត់បន្ថយកំហុសឆ្គងនីមួយៗ ក្បួនដោះស្រាយរបស់យើងនឹងបង្កើនកំហុសយ៉ាងធ្ងន់ធ្ងរសម្រាប់គំរូទាំងមូល។ ដូច្នេះតើត្រូវធ្វើអ្វី? ចម្លើយគឺសាមញ្ញ៖ អ្នកត្រូវកាត់បន្ថយជំហានចុះ។ បន្ទាប់ពីបានទាំងអស់ ដោយកាត់បន្ថយជំហានចុះ កំហុសក៏នឹងឈប់ "លោត" ឡើងលើចុះក្រោម។ ឬផ្ទុយទៅវិញ កំហុស "លោត" នឹងមិនឈប់ទេ ប៉ុន្តែវានឹងមិនដំណើរការលឿនទេ :) សូមពិនិត្យមើល។

កូដដើម្បីដំណើរការ 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 "ផលបូកនៃគម្លាតការ៉េកំឡុងពេលចុះជម្រាល stochastic (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 ជំហានចុងក្រោយ)”

នៅដើមដំបូងនៃតំណពូជ យើងសង្កេតឃើញមានកំហុសខុសប្រក្រតី និងថយចុះយ៉ាងខ្លាំង។ នៅក្នុងការធ្វើឡើងវិញចុងក្រោយនេះ យើងមើលឃើញថា error ទៅជុំវិញតម្លៃ 1,475 ហើយនៅពេលខ្លះសូម្បីតែស្មើនឹងតម្លៃដ៏ប្រសើរនេះ ប៉ុន្តែបន្ទាប់មកវានៅតែឡើង... ខ្ញុំនិយាយម្ដងទៀត អ្នកអាចសរសេរចុះតម្លៃនៃ មេគុណ и ហើយបន្ទាប់មកជ្រើសរើសដែលមានកំហុសតិចបំផុត។ ទោះយ៉ាងណាក៏ដោយ យើងមានបញ្ហាធ្ងន់ធ្ងរជាងនេះ៖ យើងត្រូវអនុវត្ត 80 ពាន់ជំហាន (សូមមើលកូដ) ដើម្បីទទួលបានតម្លៃជិតល្អបំផុត។ ហើយនេះផ្ទុយស្រឡះពីគំនិតនៃការសន្សំពេលវេលាគណនាជាមួយនឹងការធ្លាក់ចុះជម្រាល stochastic ទាក់ទងទៅនឹងការចុះជម្រាល។ តើអ្វីដែលអាចត្រូវបានកែតម្រូវនិងធ្វើឱ្យប្រសើរឡើង? វាមិនពិបាកទេក្នុងការកត់សម្គាល់ថានៅក្នុងជំហានដំបូង យើងកំពុងធ្លាក់ចុះដោយទំនុកចិត្ត ដូច្នេះហើយ យើងគួរតែចាកចេញពីជំហានដ៏ធំមួយនៅក្នុងជំហានដំបូង ហើយកាត់បន្ថយជំហាននៅពេលយើងឆ្ពោះទៅមុខ។ យើងនឹងមិនធ្វើបែបនេះនៅក្នុងអត្ថបទនេះទេ - វាវែងពេកហើយ។ អ្នកដែលប្រាថ្នាអាចគិតដោយខ្លួនឯងថាធ្វើយ៉ាងណាក៏មិនពិបាកដែរ :)

ឥឡូវនេះ ចូរយើងអនុវត្តការចុះជម្រាល 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

តម្លៃបានប្រែទៅជាស្ទើរតែដូចគ្នានឹងពេលដែលចុះក្រោមដោយមិនប្រើ ណាំភី. ទោះយ៉ាងណាក៏ដោយនេះគឺជាឡូជីខល។

ចូរយើងស្វែងយល់ថាតើការបន្តពូជជម្រាល 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)

ចូលទៅក្នុងព្រៃកាន់តែច្រើន ពពកកាន់តែងងឹត៖ ជាថ្មីម្តងទៀត រូបមន្ត "សរសេរដោយខ្លួនឯង" បង្ហាញលទ្ធផលល្អបំផុត។ ទាំងអស់នេះបង្ហាញថា ត្រូវតែមានវិធីកាន់តែល្អិតល្អន់បន្ថែមទៀត ដើម្បីប្រើប្រាស់បណ្ណាល័យ ណាំភីដែលពិតជាបង្កើនល្បឿនប្រតិបត្តិការគណនា។ នៅក្នុងអត្ថបទនេះយើងនឹងមិនរៀនអំពីពួកគេទេ។ នឹងមានរឿងដែលត្រូវគិតនៅពេលទំនេររបស់អ្នក :)

សង្ខេប។

មុននឹងសង្ខេប ខ្ញុំចង់ឆ្លើយសំណួរដែលទំនងកើតចេញពីអ្នកអានជាទីគោរពរបស់យើង។ តាមពិតហេតុអ្វីបានជា "ទារុណកម្ម" បែបនេះជាមួយកូនចៅ ហេតុអ្វីបានជាយើងត្រូវដើរឡើងលើភ្នំ (ភាគច្រើនចុះក្រោម) ដើម្បីស្វែងរកដីទំនាបដ៏មានតម្លៃ ប្រសិនបើយើងមានឧបករណ៍ដ៏មានថាមពល និងសាមញ្ញបែបនេះនៅក្នុងដៃរបស់យើង។ ទម្រង់នៃដំណោះស្រាយវិភាគដែលបញ្ជូនយើងទៅកាន់កន្លែងត្រឹមត្រូវ?

ចម្លើយចំពោះសំណួរនេះស្ថិតនៅលើផ្ទៃ។ ឥឡូវនេះ យើងបានមើលឧទាហរណ៍ដ៏សាមញ្ញមួយ ដែលចម្លើយពិតគឺ អាស្រ័យលើសញ្ញាមួយ។ . អ្នកមិនឃើញរឿងនេះញឹកញាប់ទេក្នុងជីវិត ដូច្នេះសូមស្រមៃថាយើងមានសញ្ញា 2, 30, 50 ឬច្រើនជាងនេះ។ ចូរបន្ថែមតម្លៃរាប់ពាន់នេះ ឬរាប់ម៉ឺនតម្លៃសម្រាប់គុណលក្ខណៈនីមួយៗ។ ក្នុងករណីនេះ ដំណោះស្រាយវិភាគអាចមិនអាចទប់ទល់នឹងការសាកល្បង និងបរាជ័យ។ នៅក្នុងវេន ការចុះជម្រាល និងការប្រែប្រួលរបស់វានឹងយឺតៗ ប៉ុន្តែច្បាស់ជានាំយើងខិតទៅជិតគោលដៅ - អប្បបរមានៃមុខងារ។ ហើយកុំបារម្ភអំពីល្បឿន - យើងប្រហែលជានឹងមើលវិធីដែលអាចឱ្យយើងកំណត់និងកំណត់ប្រវែងជំហាន (នោះគឺល្បឿន)។

ហើយឥឡូវនេះការសង្ខេបជាក់ស្តែង។

ទីមួយ ខ្ញុំសង្ឃឹមថា សម្ភារៈដែលបង្ហាញក្នុងអត្ថបទនេះនឹងជួយចាប់ផ្តើម "អ្នកវិទ្យាសាស្ត្រទិន្នន័យ" ក្នុងការយល់ដឹងពីរបៀបដោះស្រាយសមីការតំរែតំរង់លីនេអ៊ែរសាមញ្ញ (និងមិនត្រឹមតែប៉ុណ្ណោះ) ។

ទីពីរ យើងពិនិត្យមើលវិធីជាច្រើនដើម្បីដោះស្រាយសមីការ។ ឥឡូវនេះអាស្រ័យលើស្ថានភាពយើងអាចជ្រើសរើសមួយដែលសមស្របបំផុតដើម្បីដោះស្រាយបញ្ហា។

ទីបី យើងបានឃើញថាមពលនៃការកំណត់បន្ថែម ពោលគឺប្រវែងជំហានចុះជម្រាល។ ប៉ារ៉ាម៉ែត្រនេះមិនអាចត្រូវបានធ្វេសប្រហែសទេ។ ដូចដែលបានកត់សម្គាល់ខាងលើដើម្បីកាត់បន្ថយការចំណាយលើការគណនាប្រវែងជំហានគួរតែត្រូវបានផ្លាស់ប្តូរក្នុងអំឡុងពេលចុះ។

ទីបួន ក្នុងករណីរបស់យើង មុខងារ "សរសេរតាមផ្ទះ" បានបង្ហាញលទ្ធផលពេលវេលាល្អបំផុតសម្រាប់ការគណនា។ នេះប្រហែលជាដោយសារតែមិនមែនជាការប្រើប្រាស់ជំនាញបំផុតនៃសមត្ថភាពរបស់បណ្ណាល័យ ណាំភី. ប៉ុន្តែត្រូវថាតាមដែលវាអាចធ្វើបាន ការសន្និដ្ឋានខាងក្រោមបង្ហាញខ្លួនឯង។ ម៉្យាងវិញទៀត ជួនកាលវាមានតម្លៃក្នុងការសាកសួរមតិដែលបានបង្កើតឡើង ហើយម្យ៉ាងវិញទៀត វាមិនតែងតែមានតម្លៃធ្វើឱ្យអ្វីៗមានភាពស្មុគស្មាញនោះទេ ផ្ទុយទៅវិញ ជួនកាលវិធីសាមញ្ញជាងក្នុងការដោះស្រាយបញ្ហាគឺមានប្រសិទ្ធភាពជាង។ ហើយចាប់តាំងពីគោលដៅរបស់យើងគឺដើម្បីវិភាគវិធីសាស្រ្តបីក្នុងការដោះស្រាយសមីការតំរែតំរង់លីនេអ៊ែរសាមញ្ញ ការប្រើប្រាស់មុខងារ "សរសេរដោយខ្លួនឯង" គឺគ្រប់គ្រាន់សម្រាប់យើង។