მარტივი წრფივი რეგრესიის განტოლების ამოხსნა

სტატიაში განხილულია მარტივი (დაწყვილებული) რეგრესიის ხაზის მათემატიკური განტოლების განსაზღვრის რამდენიმე გზა.

აქ განხილული განტოლების ამოხსნის ყველა მეთოდი ეფუძნება უმცირეს კვადრატების მეთოდს. მოდით აღვნიშნოთ მეთოდები შემდეგნაირად:

• ანალიტიკური გადაწყვეტა
• გრადიენტული დაღმართი
• სტოქასტური გრადიენტური დაღმართი

სწორი ხაზის განტოლების ამოხსნის თითოეული მეთოდისთვის, სტატიაში მოცემულია სხვადასხვა ფუნქციები, რომლებიც ძირითადად იყოფა მათზე, რომლებიც დაწერილია ბიბლიოთეკის გამოყენების გარეშე. ნუმპი და ისინი, რომლებიც იყენებენ გამოთვლებს ნუმპი. ითვლება, რომ გამოცდილი გამოყენება ნუმპი შეამცირებს გამოთვლის ხარჯებს.

სტატიაში მოცემული ყველა კოდი იწერება ენაზე პითონი 2.7 გამოყენებით იუპიტერის რვეული. წყაროს კოდი და ფაილი ნიმუშის მონაცემებით არის განთავსებული გითჰუბი

სტატია უფრო მეტად არის გათვლილი როგორც დამწყებებისთვის, ასევე მათთვის, ვინც უკვე თანდათანობით დაიწყო ხელოვნური ინტელექტის ძალიან ფართო განყოფილების - მანქანათმცოდნეობის შესწავლა.

მასალის საილუსტრაციოდ ვიყენებთ ძალიან მარტივ მაგალითს.

პირობების მაგალითი

ჩვენ გვაქვს ხუთი მნიშვნელობა, რომელიც ახასიათებს დამოკიდებულებას Y საწყისი X (ცხრილი No1):

ცხრილი No1 „მაგალითი პირობები“

ჩვენ ვივარაუდებთ, რომ ღირებულებები წელიწადის თვეა და - შემოსავალი ამ თვეში. სხვა სიტყვებით რომ ვთქვათ, შემოსავალი დამოკიდებულია წლის თვეზე და - ერთადერთი ნიშანი, რომელზეც შემოსავალია დამოკიდებული.

მაგალითი ასეა, როგორც წლის თვეზე შემოსავლის პირობითი დამოკიდებულების თვალსაზრისით, ასევე მნიშვნელობების რაოდენობის თვალსაზრისით - ძალიან ცოტაა. თუმცა, ასეთი გამარტივება შესაძლებელს გახდის, როგორც ამბობენ, არა ყოველთვის მარტივად ახსნას მასალა, რომელსაც დამწყებთათვის ითვისებენ. და ასევე რიცხვების სიმარტივე საშუალებას მისცემს მათ, ვისაც სურს გადაჭრას მაგალითი ქაღალდზე, მნიშვნელოვანი შრომის ხარჯების გარეშე.

დავუშვათ, რომ მაგალითში მოცემული დამოკიდებულების მიახლოება შესაძლებელია ფორმის მარტივი (დაწყვილებული) რეგრესიის ხაზის მათემატიკური განტოლებით:

სადაც არის თვე, რომელშიც მიღებულია შემოსავალი, - შემოსავალი თვის შესაბამისი, и არის სავარაუდო ხაზის რეგრესიის კოეფიციენტები.

გაითვალისწინეთ, რომ კოეფიციენტი ხშირად უწოდებენ სავარაუდო ხაზის ფერდობას ან გრადიენტს; წარმოადგენს თანხას, რომლითაც როცა იცვლება .

ცხადია, მაგალითში ჩვენი ამოცანაა განტოლებაში ასეთი კოეფიციენტების შერჩევა и , რომლის დროსაც ხდება ჩვენი გამოთვლილი შემოსავლების მნიშვნელობების გადახრები ჭეშმარიტი პასუხებიდან, ე.ი. ნიმუშში წარმოდგენილი მნიშვნელობები მინიმალური იქნება.

მინიმალური კვადრატის მეთოდი

უმცირესი კვადრატების მეთოდის მიხედვით, გადახრა უნდა გამოითვალოს კვადრატში. ეს ტექნიკა საშუალებას გაძლევთ თავიდან აიცილოთ გადახრების ორმხრივი გაუქმება, თუ მათ აქვთ საპირისპირო ნიშნები. მაგალითად, თუ ერთ შემთხვევაში, გადახრა არის +5 (პლუს ხუთი), ხოლო მეორეში -5 (მინუს ხუთი), მაშინ გადახრების ჯამი გააუქმებს ერთმანეთს და შეადგენს 0 (ნულს). შესაძლებელია არა კვადრატში გადახრა, არამედ გამოიყენოს მოდულის თვისება და მაშინ ყველა გადახრა დადებითი იქნება და დაგროვდება. ჩვენ არ ვისაუბრებთ ამ საკითხზე დეტალურად, მაგრამ უბრალოდ აღვნიშნავთ, რომ გამოთვლების მოხერხებულობისთვის, ჩვეულებრივია გადახრის კვადრატი.

ასე გამოიყურება ფორმულა, რომლითაც განვსაზღვრავთ კვადრატული გადახრების (შეცდომების) უმცირეს ჯამს:

სადაც არის ჭეშმარიტი პასუხების მიახლოების ფუნქცია (ანუ ჩვენ მიერ გამოთვლილი შემოსავალი),

არის ჭეშმარიტი პასუხები (შესავალი მოცემულია ნიმუშში),

არის ნიმუშის ინდექსი (იმ თვის რიცხვი, რომელშიც განისაზღვრება გადახრა)

განვასხვავოთ ფუნქცია, განვსაზღვროთ პარციალური დიფერენციალური განტოლებები და მზად ვიყოთ გადავიდეთ ანალიტიკურ ამონახვაზე. მაგრამ ჯერ მოკლე ექსკურსია გავაკეთოთ იმის შესახებ, თუ რა არის დიფერენციაცია და გავიხსენოთ წარმოებულის გეომეტრიული მნიშვნელობა.

დიფერენციაცია

დიფერენციაცია არის ფუნქციის წარმოებულის პოვნის ოპერაცია.

რისთვის გამოიყენება წარმოებული? ფუნქციის წარმოებული ახასიათებს ფუნქციის ცვლილების სიჩქარეს და გვეუბნება მის მიმართულებას. თუ წარმოებული მოცემულ წერტილში დადებითია, მაშინ ფუნქცია იზრდება, წინააღმდეგ შემთხვევაში ფუნქცია მცირდება. და რაც უფრო დიდია აბსოლუტური წარმოებულის მნიშვნელობა, მით უფრო მაღალია ფუნქციის მნიშვნელობების ცვლილების სიჩქარე, ასევე მით უფრო ციცაბოა ფუნქციის გრაფიკის დახრილობა.

მაგალითად, დეკარტის კოორდინატთა სისტემის პირობებში წარმოებულის მნიშვნელობა M(0,0) წერტილში უდრის + 25 ნიშნავს, რომ მოცემულ მომენტში, როდესაც მნიშვნელობა გადაინაცვლებს მარჯვნივ ჩვეულებრივი ერთეულით, ღირებულება იზრდება 25 ჩვეულებრივი ერთეულით. გრაფიკზე ეს მნიშვნელობების საკმაოდ მკვეთრ ზრდას ჰგავს მოცემული წერტილიდან.

Სხვა მაგალითი. წარმოებული ღირებულება ტოლია -0,1 ნიშნავს, რომ გადაადგილებისას ერთ ჩვეულებრივ ერთეულზე, ღირებულება მცირდება მხოლოდ 0,1 ჩვეულებრივი ერთეულით. ამავდროულად, ფუნქციის გრაფიკზე, ჩვენ შეგვიძლია დავაკვირდეთ ძლივს შესამჩნევი დაღმავალი ფერდობზე. მთასთან ანალოგიის დახატვა, თითქოს ძალიან ნელა ვეშვებით მთიდან ნაზ ფერდობზე, წინა მაგალითისგან განსხვავებით, სადაც ძალიან ციცაბო მწვერვალებზე ასვლა მოგვიწია :)

ამრიგად, ფუნქციის დიფერენცირების შემდეგ შანსებით и , ჩვენ განვსაზღვრავთ 1 რიგის ნაწილობრივი დიფერენციალური განტოლებები. განტოლებების განსაზღვრის შემდეგ მივიღებთ ორი განტოლების სისტემას, რომლის ამოხსნით ჩვენ შევძლებთ კოეფიციენტების ისეთი მნიშვნელობების არჩევას. и , რომლის დროსაც მოცემულ წერტილებში შესაბამისი წარმოებულების მნიშვნელობები იცვლება ძალიან, ძალიან მცირე რაოდენობით, ხოლო ანალიტიკური ამოხსნის შემთხვევაში საერთოდ არ იცვლება. სხვა სიტყვებით რომ ვთქვათ, შეცდომის ფუნქცია აღმოჩენილ კოეფიციენტებზე მიაღწევს მინიმუმს, რადგან ამ წერტილებში ნაწილობრივი წარმოებულების მნიშვნელობები ნულის ტოლი იქნება.

ასე რომ, დიფერენცირების წესების მიხედვით, 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
დასასრული{შემთხვევები}
დასასრული{განტოლება*}

განტოლების ამოხსნამდე წინასწარ ჩავტვირთოთ, შევამოწმოთ ჩატვირთვა სწორია და მონაცემების ფორმატირება.

მონაცემების ჩატვირთვა და ფორმატირება

უნდა აღინიშნოს, რომ იმის გამო, რომ ანალიტიკური გადაწყვეტისთვის, შემდეგ კი გრადიენტული და სტოქასტური გრადიენტული დაღმართისთვის, ჩვენ გამოვიყენებთ კოდს ორ ვარიაციით: ბიბლიოთეკის გამოყენებით ნუმპი და მისი გამოყენების გარეშე, მაშინ დაგვჭირდება მონაცემთა შესაბამისი ფორმატირება (იხ. კოდი).

მონაცემთა ჩატვირთვისა და დამუშავების კოდი

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

გრაფიკი No1 „შემოსავლების დამოკიდებულება წლის თვეზე“

ანალიტიკური გადაწყვეტა

მოდით გამოვიყენოთ ყველაზე გავრცელებული ინსტრუმენტები პითონი და ამოხსენით განტოლებათა სისტემა:

დასაწყისი{განტოლება*}
დასაწყისი{შემთხვევები}
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()

დიაგრამა No2 „სწორი და გათვლილი პასუხები“

თქვენ შეგიძლიათ ნახოთ გადახრის გრაფიკი ყოველი თვისთვის. ჩვენს შემთხვევაში, მისგან რაიმე მნიშვნელოვან პრაქტიკულ მნიშვნელობას არ გამოვიყვანთ, მაგრამ დავაკმაყოფილებთ ჩვენს ცნობისმოყვარეობას იმის შესახებ, თუ რამდენად ახასიათებს მარტივი წრფივი რეგრესიის განტოლება შემოსავლების დამოკიდებულებას წლის თვეზე.

გადახრის დიაგრამის კოდი

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

დიაგრამა No3 „გადახრები, %“

არ არის სრულყოფილი, მაგრამ დავასრულეთ დავალება.

დავწეროთ ფუნქცია, რომელიც კოეფიციენტების დასადგენად и იყენებს ბიბლიოთეკას ნუმპიუფრო ზუსტად, ჩვენ დავწერთ ორ ფუნქციას: ერთი ფსევდოინვერსიული მატრიცის გამოყენებით (პრაქტიკაში არ არის რეკომენდებული, რადგან პროცესი გამოთვლებით რთული და არასტაბილურია), მეორე მატრიცული განტოლების გამოყენებით.

ანალიტიკური გადაწყვეტის კოდი (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 (მინუს ერთი).

მოდით ყურადღება მივაქციოთ იმ ფაქტს, რომ ფუნქციას შეიძლება ჰქონდეს რამდენიმე მინიმუმი და ერთ-ერთ მათგანში ქვემოთ შემოთავაზებული ალგორითმის გამოყენებით, ჩვენ ვერ ვიპოვით სხვა მინიმუმს, რომელიც შეიძლება იყოს უფრო დაბალი ვიდრე ნაპოვნი. მოდი დავისვენოთ, ეს ჩვენთვის საფრთხეს არ წარმოადგენს! ჩვენს შემთხვევაში საქმე გვაქვს ერთ მინიმუმთან, ჩვენი ფუნქციიდან გამომდინარე გრაფიკზე არის რეგულარული პარაბოლა. და როგორც ყველამ კარგად უნდა ვიცოდეთ ჩვენი სკოლის მათემატიკის კურსიდან, პარაბოლას აქვს მხოლოდ ერთი მინიმუმი.

მას შემდეგ რაც გავარკვიეთ, რატომ გვჭირდებოდა გრადიენტი და ასევე, რომ გრადიენტი არის სეგმენტი, ანუ ვექტორი მოცემული კოორდინატებით, რომლებიც ზუსტად იგივე კოეფიციენტებია. и ჩვენ შეგვიძლია განვახორციელოთ გრადიენტური დაღმართი.

დაწყებამდე მე გთავაზობთ მხოლოდ რამდენიმე წინადადების წაკითხვას დაღმართის ალგორითმის შესახებ:

• ფსევდო შემთხვევითი წესით განვსაზღვრავთ კოეფიციენტების კოორდინატებს и . ჩვენს მაგალითში ჩვენ განვსაზღვრავთ კოეფიციენტებს ნულის მახლობლად. ეს ჩვეულებრივი პრაქტიკაა, მაგრამ თითოეულ შემთხვევას შეიძლება ჰქონდეს საკუთარი პრაქტიკა.
• კოორდინატიდან გამოვაკლოთ 1-ლი რიგის ნაწილობრივი წარმოებულის მნიშვნელობა წერტილში . ასე რომ, თუ წარმოებული დადებითია, მაშინ ფუნქცია იზრდება. მაშასადამე, წარმოებულის მნიშვნელობის გამოკლებით, ჩვენ გადავალთ ზრდის საპირისპირო მიმართულებით, ანუ დაღმასვლის მიმართულებით. თუ წარმოებული უარყოფითია, მაშინ ფუნქცია ამ მომენტში მცირდება და წარმოებულის მნიშვნელობის გამოკლებით მივდივართ დაღმართის მიმართულებით.
• ანალოგიურ ოპერაციას ვასრულებთ კოორდინატთან ერთად : გამოვაკლოთ ნაწილობრივი წარმოებულის მნიშვნელობა წერტილში .
• იმისათვის, რომ არ გადახტეთ მინიმუმზე და არ გაფრინდეთ ღრმა სივრცეში, აუცილებელია ნაბიჯის ზომის დაყენება დაღმართის მიმართულებით. ზოგადად, შეგიძლიათ დაწეროთ მთელი სტატია იმის შესახებ, თუ როგორ უნდა დააყენოთ ნაბიჯი სწორად და როგორ შეცვალოთ იგი დაღმართის პროცესში, რათა შემცირდეს გამოთვლითი ხარჯები. მაგრამ ახლა წინ ოდნავ განსხვავებული დავალება გვაქვს და საფეხურის ზომას დავამყარებთ სამეცნიერო მეთოდის „პოკის“ ან, როგორც ამბობენ, ემპირიულად.
• ერთხელ ჩვენ მოცემული კოორდინატებიდან ვართ и გამოვაკლოთ წარმოებულების მნიშვნელობები, მივიღებთ ახალ კოორდინატებს и . ჩვენ ვდგამთ შემდეგ ნაბიჯს (გამოკლებას), უკვე გამოთვლილი კოორდინატებიდან. ასე რომ, ციკლი ისევ და ისევ იწყება, სანამ არ მიიღწევა საჭირო კონვერგენცია.

ყველა! ახლა ჩვენ მზად ვართ წავიდეთ მარიანას თხრილის ყველაზე ღრმა ხეობის მოსაძებნად. Დავიწყოთ.

გრადიენტური დაღმართის კოდი

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

გრაფიკი No4 „გრადიენტული დაღმართის დროს კვადრატული გადახრების ჯამი“

გრაფიკზე ვხედავთ, რომ ყოველი ნაბიჯის გადადგმისას შეცდომა მცირდება და გარკვეული რაოდენობის გამეორების შემდეგ ვაკვირდებით თითქმის ჰორიზონტალურ ხაზს.

და ბოლოს, მოდით შევაფასოთ განსხვავება კოდის შესრულების დროს:

კოდი გრადიენტური დაღმართის გამოთვლის დროის დასადგენად

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

გრაფიკი No5 „გადახრების კვადრატის ჯამი სტოქასტური გრადიენტური დაღმართის დროს“

განრიგს რომ ვუყურებ, ყველაფერი თავის ადგილზე დგება და ახლა ყველაფერს გამოვასწორებთ.

მერე რა მოხდა? მოხდა შემდეგი. როდესაც ჩვენ შემთხვევით ვირჩევთ თვეს, მაშინ სწორედ არჩეული თვისთვის ჩვენი ალგორითმი ცდილობს შეამციროს შეცდომა შემოსავლის გამოთვლაში. შემდეგ ვირჩევთ სხვა თვეს და ვიმეორებთ გამოთვლას, მაგრამ ვამცირებთ შეცდომას მეორე შერჩეული თვისთვის. ახლა გახსოვდეთ, რომ პირველი ორი თვე მნიშვნელოვნად გადახრის მარტივი წრფივი რეგრესიის განტოლების ხაზს. ეს ნიშნავს, რომ ამ ორი თვედან რომელიმეს არჩევისას, თითოეული მათგანის შეცდომის შემცირებით, ჩვენი ალგორითმი სერიოზულად ზრდის შეცდომას მთელი ნიმუშისთვის. ასე რომ, რა უნდა გააკეთოს? პასუხი მარტივია: თქვენ უნდა შეამციროთ დაღმართის საფეხური. ყოველივე ამის შემდეგ, დაღმართის საფეხურის შემცირებით, შეცდომა ასევე შეაჩერებს ზევით და ქვევით "ხტუნვას". უფრო სწორად, "გადახტომის" შეცდომა არ შეჩერდება, მაგრამ ასე სწრაფად არ გააკეთებს :) მოდით შევამოწმოთ.

კოდი 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()

გრაფიკი No6 „გადახრების კვადრატის ჯამი სტოქასტური გრადიენტური დაღმართის დროს (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()

გრაფიკი No7 „SGD კვადრატული გადახრების ჯამი (პირველი 1000 ნაბიჯი)“

გრაფიკი No8 „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