একটি সরল রৈখিক রিগ্রেশন সমীকরণ সমাধান করা

নিবন্ধটি একটি সাধারণ (জোড়া) রিগ্রেশন লাইনের গাণিতিক সমীকরণ নির্ধারণের বিভিন্ন উপায় নিয়ে আলোচনা করে।

এখানে বিবেচিত সমীকরণ সমাধানের সমস্ত পদ্ধতি সর্বনিম্ন বর্গ পদ্ধতির উপর ভিত্তি করে। আমরা নিম্নলিখিত পদ্ধতিগুলি নির্দেশ করি:

• বিশ্লেষণাত্মক সমাধান
• গ্রেডিয়েন্ট ডিসেন্ট
• স্টোকাস্টিক গ্রেডিয়েন্ট ডিসেন্ট

একটি সরল রেখার সমীকরণ সমাধানের প্রতিটি উপায়ের জন্য, নিবন্ধটি বিভিন্ন ফাংশন উপস্থাপন করে, যা প্রধানত লাইব্রেরি ব্যবহার না করেই লেখা হয় সেগুলিতে বিভক্ত। নম্র এবং যেগুলি গণনার জন্য ব্যবহৃত হয় নম্র. এটা দক্ষ ব্যবহার বিশ্বাস করা হয় নম্র কম্পিউটিং খরচ কমাবে.

এই নিবন্ধের সমস্ত কোড লেখা আছে পাইথন এক্সএনইউএমএক্স সঙ্গে Jupyter নোটবুক. সোর্স কোড এবং নমুনা ডেটা ফাইল এখানে পাওয়া যায় গিথুব

নিবন্ধটি নতুনদের এবং যারা ইতিমধ্যেই ধীরে ধীরে কৃত্রিম বুদ্ধিমত্তা - মেশিন লার্নিং-এর একটি খুব বিস্তৃত বিভাগের অধ্যয়নে আয়ত্ত করতে শুরু করেছে তাদের উভয়ের দিকেই বেশি দৃষ্টি নিবদ্ধ করা হয়েছে।

আসুন উপাদানটি ব্যাখ্যা করার জন্য একটি খুব সাধারণ উদাহরণ ব্যবহার করি।

উদাহরণ শর্তাবলী

আমাদের পাঁচটি মান আছে যা আসক্তিকে চিহ্নিত করে Y থেকে X (1 নং টেবিল):

সারণি নং 1 "উদাহরণ শর্তাবলী"

আমরা যে মান অনুমান করা হবে বছরের মাস, এবং - এই মাসে আয়। অন্য কথায়, রাজস্ব বছরের মাসের উপর নির্ভর করে এবং - একমাত্র চিহ্ন যার উপর রাজস্ব নির্ভর করে।

উদাহরণটি তাই, বছরের মাসে রাজস্বের শর্তসাপেক্ষ নির্ভরতার ক্ষেত্রে এবং মানগুলির সংখ্যার ক্ষেত্রে - তাদের মধ্যে খুব কমই রয়েছে। যাইহোক, যেমন একটি সরলীকরণ অনুমতি দেবে, যেমন তারা আঙ্গুলের উপর বলে, ব্যাখ্যা করার জন্য, সর্বদা সহজে নয়, নতুনদের দ্বারা আত্তীকৃত উপাদান। এবং সংখ্যার সরলতা তাদের অনুমতি দেবে যারা উল্লেখযোগ্য শ্রম খরচ ছাড়াই "কাগজের" উদাহরণটি সমাধান করতে চায়।

ধরুন যে উদাহরণে দেওয়া নির্ভরতা ফর্মের একটি সরল (জোড়া) রিগ্রেশনের লাইনের গাণিতিক সমীকরণ দ্বারা বেশ ভালভাবে আনুমানিক করা যেতে পারে:

যেখানে যে মাসে অর্থ গৃহীত হয়েছিল, - মাসের সাথে সম্পর্কিত রাজস্ব, и আনুমানিক লাইনের রিগ্রেশন সহগ।

উল্লেখ্য যে সহগ প্রায়ই আনুমানিক লাইনের ঢাল বা গ্রেডিয়েন্ট হিসাবে উল্লেখ করা হয়; পরিমাণ যা দ্বারা যখন এটি পরিবর্তন হয় .

স্পষ্টতই, উদাহরণে আমাদের কাজ হল সমীকরণে এই ধরনের সহগ নির্বাচন করা и , যেখানে সত্য উত্তরগুলি থেকে মাসগুলিতে আমাদের আনুমানিক রাজস্ব মানের বিচ্যুতি, যেমন নমুনায় উপস্থাপিত মান ন্যূনতম হবে।

সর্বনিম্ন বর্গ পদ্ধতি

সর্বনিম্ন বর্গ পদ্ধতি অনুসারে, বিচ্যুতিটি স্কোয়ার করে গণনা করা উচিত। এই ধরনের একটি কৌশল বিচ্যুতির পারস্পরিক পরিশোধ এড়ানোর অনুমতি দেয়, যদি তাদের বিপরীত লক্ষণ থাকে। উদাহরণস্বরূপ, যদি একটি ক্ষেত্রে, বিচ্যুতি হয় +5 (সহ পাঁচটি), এবং অন্যটিতে -5 (মাইনাস পাঁচ), তাহলে বিচ্যুতির যোগফল পারস্পরিকভাবে বাতিল হবে এবং হবে 0 (শূন্য)। বিচ্যুতির বর্গ করা সম্ভব নয়, তবে মডুলাস বৈশিষ্ট্য ব্যবহার করা সম্ভব এবং তারপরে সমস্ত বিচ্যুতি ধনাত্মক হবে এবং জমা হবে। আমরা এই বিন্দুতে বিস্তারিতভাবে আলোচনা করব না, তবে সহজভাবে নির্দেশ করব যে গণনার সুবিধার জন্য, বিচ্যুতিকে বর্গ করার প্রথাগত।

সূত্রটি এভাবেই দেখায়, যার সাহায্যে আমরা বর্গক্ষেত্র বিচ্যুতির ক্ষুদ্রতম যোগফল (ত্রুটি) নির্ধারণ করব:

যেখানে সত্য উত্তরের আনুমানিক একটি ফাংশন (অর্থাৎ, আমাদের দ্বারা গণনা করা রাজস্ব),

সঠিক উত্তরগুলি (নমুনায় দেওয়া রাজস্ব),

নমুনার সূচক (যে মাসের সংখ্যায় বিচ্যুতি নির্ধারণ করা হয়)

আসুন ফাংশনটি আলাদা করি, আংশিক ডিফারেনশিয়াল সমীকরণগুলি সংজ্ঞায়িত করি এবং একটি বিশ্লেষণাত্মক সমাধানে এগিয়ে যাওয়ার জন্য প্রস্তুত হই। কিন্তু প্রথমে, আসুন পার্থক্য কী সে সম্পর্কে একটি সংক্ষিপ্ত ডিগ্রেশন নেওয়া যাক এবং ডেরিভেটিভের জ্যামিতিক অর্থটি স্মরণ করি।

পৃথকীকরণ

পার্থক্য হল একটি ফাংশনের ডেরিভেটিভ খুঁজে বের করার ক্রিয়াকলাপ।

ডেরিভেটিভ কি জন্য? একটি ফাংশনের ডেরিভেটিভ ফাংশনের পরিবর্তনের হারকে চিহ্নিত করে এবং আমাদের তার দিক নির্দেশ করে। যদি একটি নির্দিষ্ট বিন্দুতে ডেরিভেটিভটি ধনাত্মক হয়, তবে ফাংশনটি বাড়ছে; অন্যথায়, ফাংশনটি হ্রাস পাচ্ছে। এবং মডুলো ডেরিভেটিভের মান যত বেশি হবে, ফাংশনের মানগুলির পরিবর্তনের হার তত বেশি হবে, সেইসাথে ফাংশন গ্রাফের ঢাল তত বেশি হবে।

উদাহরণস্বরূপ, একটি কার্টেসিয়ান স্থানাঙ্ক সিস্টেমের শর্তে, M(0,0) বিন্দুতে ডেরিভেটিভের মান সমান +25 মানে একটি নির্দিষ্ট বিন্দুতে, যখন মান স্থানান্তরিত হয় একটি প্রচলিত ইউনিট, মান দ্বারা ডানদিকে 25টি প্রচলিত ইউনিট দ্বারা বৃদ্ধি পায়। গ্রাফে, এটি মান বৃদ্ধির মোটামুটি খাড়া কোণের মতো দেখায় একটি নির্দিষ্ট বিন্দু থেকে।

আরেকটি উদাহরণ. ডেরিভেটিভের মান হল -0,1 নাড়াচাড়া করার সময় একটি প্রচলিত ইউনিট প্রতি, মান শুধুমাত্র 0,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 '********************************************'

ভিজ্যুয়ালাইজেশন

এখন, আমরা, প্রথমত, ডেটা লোড করার পরে, দ্বিতীয়ত, লোডিংয়ের সঠিকতা পরীক্ষা করে এবং অবশেষে ডেটা ফর্ম্যাট করার পরে, আমরা প্রথম ভিজ্যুয়ালাইজেশনটি সম্পাদন করব। প্রায়শই এই পদ্ধতি ব্যবহার করা হয় পেয়ারপ্লট গ্রন্থাগারগুলি সমুদ্রযুক্ত. আমাদের উদাহরণে, সীমিত সংখ্যার কারণে, লাইব্রেরি ব্যবহার করার কোন মানে হয় না সমুদ্রযুক্ত. আমরা স্বাভাবিক লাইব্রেরি ব্যবহার করব ম্যাটপ্ল্লোব এবং শুধুমাত্র 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 "বছরের মাসের উপর রাজস্ব নির্ভরতা"

বিশ্লেষণাত্মক সমাধান

আমরা সবচেয়ে সাধারণ টুল ব্যবহার করি পাইথন এবং সমীকরণ পদ্ধতি সমাধান করুন:

শুরু{সমীকরণ*}
শুরু
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 (বিয়োগ এক).

আসুন আমরা এই বিষয়টির দিকে মনোযোগ দিই যে একটি ফাংশনে বেশ কয়েকটি মিনিমাম থাকতে পারে এবং নীচের প্রস্তাবিত অ্যালগরিদম অনুসারে সেগুলির একটিতে নেমে আসার পরে, আমরা অন্য ন্যূনতম খুঁজে পাব না, যা পাওয়াটির চেয়ে কম হতে পারে। আরাম করুন, আমরা বিপদে নেই! আমাদের ক্ষেত্রে, আমরা আমাদের ফাংশন থেকে, একটি একক সর্বনিম্ন নিয়ে কাজ করছি গ্রাফে একটি সাধারণ প্যারাবোলা রয়েছে। এবং আমাদের সকলের স্কুলের গণিত কোর্স থেকে খুব ভালভাবে জানা উচিত, একটি প্যারাবোলার শুধুমাত্র একটি ন্যূনতম থাকে।

আমরা কেন একটি গ্রেডিয়েন্ট প্রয়োজন তা খুঁজে বের করার পরে, এবং গ্রেডিয়েন্টটি একটি সেগমেন্ট, অর্থাৎ, প্রদত্ত স্থানাঙ্ক সহ একটি ভেক্টর, যা ঠিক একই সহগ। и আমরা গ্রেডিয়েন্ট ডিসেন্ট বাস্তবায়ন করতে পারি।

শুরু করার আগে, আমি ডিসেন্ট অ্যালগরিদম সম্পর্কে কয়েকটি বাক্য পড়ার পরামর্শ দিচ্ছি:

• আমরা সিউডো-এলোমেলোভাবে সহগগুলির স্থানাঙ্কগুলি নির্ধারণ করি и . আমাদের উদাহরণে, আমরা শূন্যের কাছাকাছি সহগ সংজ্ঞায়িত করব। এটি একটি সাধারণ অভ্যাস, তবে প্রতিটি ক্ষেত্রে এর নিজস্ব অনুশীলন থাকতে পারে।
• সমন্বয় থেকে বিন্দুতে 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()

চার্ট #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 "স্টকাস্টিক গ্রেডিয়েন্ট ডিসেন্টের জন্য বর্গক্ষেত্র বিচ্যুতির সমষ্টি (80k ধাপ)"

সম্ভাবনার উন্নতি হয়েছে, কিন্তু এখনও আদর্শ নয়। অনুমানিকভাবে, এটি এইভাবে সংশোধন করা যেতে পারে। আমরা, উদাহরণস্বরূপ, শেষ 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 গণনার সময় নির্ধারণের জন্য কোড (80k ধাপ)

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/method_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.com/numpy/2.html

উত্স: www.habr.com