سادہ لکیری رجعت کی مساوات کو حل کرنا

مضمون میں ایک سادہ (جوڑا) ریگریشن لائن کی ریاضیاتی مساوات کا تعین کرنے کے کئی طریقوں پر تبادلہ خیال کیا گیا ہے۔

یہاں زیر بحث مساوات کو حل کرنے کے تمام طریقے کم از کم مربع کے طریقہ کار پر مبنی ہیں۔ آئیے مندرجہ ذیل طریقوں کی نشاندہی کرتے ہیں:

• تجزیاتی حل
• تدریجی نزول
• سٹوکاسٹک گریڈینٹ ڈیسنٹ

سیدھی لکیر کی مساوات کو حل کرنے کے ہر طریقہ کے لیے، مضمون مختلف افعال فراہم کرتا ہے، جو بنیادی طور پر ان میں تقسیم ہوتے ہیں جو لائبریری کا استعمال کیے بغیر لکھے جاتے ہیں۔ بے حس اور وہ جو حساب کے لیے استعمال کرتے ہیں۔ بے حس. یہ خیال کیا جاتا ہے کہ ہنر مند استعمال بے حس کمپیوٹنگ کے اخراجات کو کم کرے گا.

مضمون میں دیا گیا تمام کوڈ زبان میں لکھا گیا ہے۔ ازگر 2.7 استعمال کرتے ہوئے Jupyter نوٹ بک. نمونہ ڈیٹا کے ساتھ سورس کوڈ اور فائل کو پوسٹ کیا گیا ہے۔ گیتھب

مضمون کا زیادہ مقصد ابتدائی اور ان لوگوں دونوں کے لیے ہے جنہوں نے مصنوعی ذہانت کے ایک بہت وسیع حصے کے مطالعہ میں عبور حاصل کرنا شروع کر دیا ہے - مشین لرننگ۔

مواد کو واضح کرنے کے لیے، ہم ایک بہت ہی آسان مثال استعمال کرتے ہیں۔

مثال کے حالات

ہمارے پاس پانچ اقدار ہیں جو انحصار کو نمایاں کرتی ہیں۔ Y سے X (ٹیبل نمبر 1):

جدول نمبر 1 "مثال کے حالات"

ہم فرض کریں گے کہ اقدار سال کا مہینہ ہے، اور - اس مہینے کی آمدنی۔ دوسرے الفاظ میں، آمدنی سال کے مہینے پر منحصر ہے، اور - واحد نشانی جس پر آمدنی کا انحصار ہے۔

مثال اتنی ہے، سال کے مہینے پر محصول کے مشروط انحصار کے نقطہ نظر سے، اور اقدار کی تعداد کے نقطہ نظر سے - ان میں سے بہت کم ہیں۔ تاہم، اس طرح کی آسانیاں ممکن بنائے گی، جیسا کہ وہ کہتے ہیں، وضاحت کرنا، ہمیشہ آسانی کے ساتھ نہیں، اس مواد کو جو ابتدائی طور پر ضم کرتے ہیں۔ اور نمبروں کی سادگی بھی ان لوگوں کو اجازت دے گی جو لیبر کے اہم اخراجات کے بغیر کاغذ پر مثال حل کرنا چاہتے ہیں۔

آئیے فرض کریں کہ مثال میں دی گئی انحصار کا تخمینہ فارم کی ایک سادہ (جوڑا) ریگریشن لائن کی ریاضیاتی مساوات کے ذریعہ کیا جا سکتا ہے:

جہاں وہ مہینہ ہے جس میں محصول وصول کیا گیا تھا، - مہینے کے مطابق آمدنی، и تخمینہ شدہ لائن کے ریگریشن گتانک ہیں۔

نوٹ کریں کہ گتانک اکثر تخمینہ شدہ لائن کی ڈھلوان یا میلان کہا جاتا ہے۔ اس رقم کی نمائندگی کرتا ہے جس کے ذریعے جب یہ بدل جاتا ہے .

ظاہر ہے، مثال میں ہمارا کام مساوات میں ایسے گتانکوں کو منتخب کرنا ہے۔ и ، جس پر صحیح جوابات سے ماہانہ حساب سے ہماری آمدنی کی قدروں کا انحراف، یعنی نمونے میں پیش کردہ اقدار کم سے کم ہوں گی۔

کم سے کم مربع طریقہ

کم از کم مربع کے طریقہ کار کے مطابق، انحراف کو اسکوائر کرکے شمار کیا جانا چاہیے۔ یہ تکنیک آپ کو انحرافات کی باہمی منسوخی سے بچنے کی اجازت دیتی ہے اگر ان میں مخالف علامات ہوں۔ مثال کے طور پر، اگر ایک صورت میں، انحراف ہے +5 (جمع پانچ)، اور دوسرے میں -5 (مائنس پانچ)، پھر انحراف کا مجموعہ ایک دوسرے کو منسوخ کر دے گا اور اس کی مقدار 0 (صفر) ہو جائے گی۔ یہ ممکن ہے کہ انحراف کو مربع نہ کیا جائے، لیکن ماڈیولس کی خاصیت کو استعمال کیا جائے اور پھر تمام انحراف مثبت ہوں گے اور جمع ہوں گے۔ ہم اس نکتے پر تفصیل سے غور نہیں کریں گے، لیکن صرف اتنا بتا دیں گے کہ حساب کی سہولت کے لیے، انحراف کو مربع کرنے کا رواج ہے۔

فارمولہ ایسا لگتا ہے جس کے ساتھ ہم مربع انحراف (غلطیوں) کی کم از کم رقم کا تعین کریں گے:

جہاں صحیح جوابات کے تخمینے کا ایک فنکشن ہے (یعنی وہ محصول جس کا ہم نے حساب لگایا ہے)

صحیح جوابات ہیں (نمونہ میں فراہم کردہ آمدنی)،

نمونہ انڈیکس ہے (اس مہینے کی تعداد جس میں انحراف کا تعین کیا جاتا ہے)

آئیے فنکشن کو الگ کریں، جزوی تفریق مساوات کی وضاحت کریں، اور تجزیاتی حل کی طرف بڑھنے کے لیے تیار ہوں۔ لیکن پہلے، آئیے اس بارے میں ایک مختصر سیر کریں کہ تفریق کیا ہے اور مشتق کے ہندسی معنی کو یاد رکھیں۔

تفرق

تفریق کسی فنکشن کے مشتق کو تلاش کرنے کا عمل ہے۔

مشتق کس کے لیے استعمال ہوتا ہے؟ فنکشن کا مشتق فنکشن کی تبدیلی کی شرح کو نمایاں کرتا ہے اور ہمیں اس کی سمت بتاتا ہے۔ اگر کسی مخصوص نقطہ پر مشتق مثبت ہے، تو فنکشن بڑھتا ہے؛ بصورت دیگر، فنکشن کم ہوجاتا ہے۔ اور مطلق مشتق کی قدر جتنی زیادہ ہوگی، فنکشن کی قدروں کی تبدیلی کی شرح اتنی ہی زیادہ ہوگی، اور ساتھ ہی فنکشن گراف کی ڈھلوان بھی اتنی ہی تیز ہوگی۔

مثال کے طور پر، ایک کارٹیشین کوآرڈینیٹ سسٹم کی شرائط کے تحت، نقطہ M(0,0) پر مشتق کی قدر کے برابر ہے + 25 اس کا مطلب یہ ہے کہ کسی مقررہ مقام پر، جب قدر کو منتقل کیا جاتا ہے۔ دائیں طرف روایتی اکائی، قدر 25 روایتی اکائیوں کا اضافہ۔ گراف پر یہ قدروں میں کافی تیزی سے اضافے کی طرح لگتا ہے۔ ایک دیئے گئے نقطہ سے.

ایک اور مثال. مشتق قدر برابر ہے۔ 0,1- اس کا مطلب ہے کہ جب بے گھر ہو جاتا ہے۔ فی ایک روایتی یونٹ، قدر صرف 0,1 روایتی یونٹ سے کم ہوتا ہے۔ ایک ہی وقت میں، فنکشن کے گراف پر، ہم بمشکل نمایاں نیچے کی ڈھلوان کا مشاہدہ کر سکتے ہیں۔ ایک پہاڑ کے ساتھ تشبیہ دیتے ہوئے، ایسا لگتا ہے جیسے ہم پچھلی مثال کے برعکس ایک پہاڑ سے ہلکی ڈھلوان پر بہت آہستہ سے اتر رہے ہیں، جہاں ہمیں بہت اونچی چوٹیوں پر چڑھنا پڑا :)

اس طرح، فنکشن کو مختلف کرنے کے بعد مشکلات سے и ، ہم پہلی ترتیب جزوی تفریق مساوات کی وضاحت کرتے ہیں۔ مساواتوں کا تعین کرنے کے بعد، ہمیں دو مساواتوں کا ایک نظام ملے گا، جس کو حل کر کے ہم عدد کی ایسی قدروں کو منتخب کر سکیں گے۔ и ، جس کے لیے دیے گئے نکات پر متعلقہ مشتقات کی قدریں بہت، بہت کم مقدار میں تبدیل ہوتی ہیں، اور تجزیاتی حل کی صورت میں بالکل بھی تبدیل نہیں ہوتی ہیں۔ دوسرے لفظوں میں، پائے گئے گتانکوں پر غلطی کا فنکشن کم سے کم ہو جائے گا، کیونکہ ان پوائنٹس پر جزوی مشتقات کی قدریں صفر کے برابر ہوں گی۔

لہذا، تفریق کے اصولوں کے مطابق، گتانک کے حوالے سے پہلی ترتیب کی جزوی مشتق مساوات فارم لے گا:

1st آرڈر جزوی مشتق مساوات کے حوالے سے فارم لے گا:

نتیجے کے طور پر، ہمیں مساوات کا ایک نظام ملا جس کا کافی آسان تجزیاتی حل ہے:

شروع کریں{مساوات*}
شروع کریں{کیسز}
na + bsumlimits_{i=1}^nx_i — sumlimits_{i=1}^ny_i = 0

sumlimits_{i=1}^nx_i(a +bsumlimits_{i=1}^nx_i — sumlimits_{i=1}^ny_i) = 0
اختتام{کیسز}
اختتام{مساوات*}

مساوات کو حل کرنے سے پہلے، آئیے پہلے سے لوڈ کریں، چیک کریں کہ لوڈنگ درست ہے، اور ڈیٹا کو فارمیٹ کریں۔

ڈیٹا کو لوڈ اور فارمیٹنگ کرنا

واضح رہے کہ اس حقیقت کی وجہ سے کہ تجزیاتی حل کے لیے، اور اس کے بعد تدریجی اور سٹاکاسٹک گریڈینٹ ڈیسنٹ کے لیے، ہم کوڈ کو دو مختلف حالتوں میں استعمال کریں گے: لائبریری کا استعمال کرتے ہوئے بے حس اور اسے استعمال کیے بغیر، پھر ہمیں مناسب ڈیٹا فارمیٹنگ کی ضرورت ہوگی (کوڈ دیکھیں)۔

ڈیٹا لوڈنگ اور پروسیسنگ کوڈ

# импортируем все нужные нам библиотеки
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import math
import pylab as pl
import random

# графики отобразим в Jupyter
%matplotlib inline

# укажем размер графиков
from pylab import rcParams
rcParams['figure.figsize'] = 12, 6

# отключим предупреждения Anaconda
import warnings
warnings.simplefilter('ignore')

# загрузим значения
table_zero = pd.read_csv('data_example.txt', header=0, sep='t')

# посмотрим информацию о таблице и на саму таблицу
print table_zero.info()
print '********************************************'
print table_zero
print '********************************************'

# подготовим данные без использования NumPy

x_us = []
[x_us.append(float(i)) for i in table_zero['x']]
print x_us
print type(x_us)
print '********************************************'

y_us = []
[y_us.append(float(i)) for i in table_zero['y']]
print y_us
print type(y_us)
print '********************************************'

# подготовим данные с использованием NumPy

x_np = table_zero[['x']].values
print x_np
print type(x_np)
print x_np.shape
print '********************************************'

y_np = table_zero[['y']].values
print y_np
print type(y_np)
print y_np.shape
print '********************************************'

تصور

اب، سب سے پہلے، ڈیٹا کو لوڈ کرنے کے بعد، دوم، لوڈنگ کی درستگی کو چیک کرنے اور آخر میں ڈیٹا کو فارمیٹ کرنے کے بعد، ہم پہلا ویژولائزیشن کریں گے۔ اس کے لیے اکثر استعمال ہونے والا طریقہ ہے۔ جوڑا پلاٹ لائبریریاں سمندری طوفان. ہماری مثال میں، محدود تعداد کی وجہ سے، لائبریری کو استعمال کرنے کا کوئی فائدہ نہیں ہے۔ سمندری طوفان. ہم باقاعدہ لائبریری کا استعمال کریں گے۔ میٹپلوٹلیب اور صرف 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 "انحراف، %"

کامل نہیں، لیکن ہم نے اپنا کام مکمل کر لیا۔

آئیے ایک فنکشن لکھتے ہیں جو گتانک کا تعین کرنے کے لیے и لائبریری کا استعمال کرتا ہے۔ بے حس، زیادہ واضح طور پر، ہم دو فنکشنز لکھیں گے: ایک 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

آئیے گتانکوں کا تعین کرنے میں گزارے گئے وقت کا موازنہ کریں۔ и ، پیش کردہ 3 طریقوں کے مطابق۔

حساب کے وقت کا حساب لگانے کا کوڈ

print ' 33[1m' + ' 33[4m' + "Время выполнения расчета коэффициентов без использования библиотеки NumPy:" + ' 33[0m'
% timeit ab_us = Kramer_method(x_us,y_us)
print '***************************************'
print
print ' 33[1m' + ' 33[4m' + "Время выполнения расчета коэффициентов с использованием псевдообратной матрицы:" + ' 33[0m'
%timeit ab_np = pseudoinverse_matrix(x_np, y_np)
print '***************************************'
print
print ' 33[1m' + ' 33[4m' + "Время выполнения расчета коэффициентов с использованием матричного уравнения:" + ' 33[0m'
%timeit ab_np = matrix_equation(x_np, y_np)

تھوڑی مقدار میں ڈیٹا کے ساتھ، ایک "خود تحریر" فنکشن سامنے آتا ہے، جو Cramer کے طریقہ کار کا استعمال کرتے ہوئے گتانکوں کو تلاش کرتا ہے۔

اب آپ گتانک تلاش کرنے کے دوسرے طریقوں کی طرف بڑھ سکتے ہیں۔ и .

تدریجی نزول

سب سے پہلے، آئیے اس کی وضاحت کرتے ہیں کہ میلان کیا ہے۔ سیدھے الفاظ میں، گریڈینٹ ایک سیگمنٹ ہے جو کسی فنکشن کی زیادہ سے زیادہ نمو کی سمت بتاتا ہے۔ ایک پہاڑ پر چڑھنے کے ساتھ تشبیہ کے ذریعے، جہاں میلان چہرے وہیں ہیں جہاں پہاڑ کی چوٹی پر سب سے زیادہ چڑھنا ہے۔ پہاڑ کے ساتھ مثال کو تیار کرتے ہوئے، ہمیں یاد ہے کہ درحقیقت ہمیں نشیبی علاقے تک جلد سے جلد پہنچنے کے لیے سب سے تیز نزول کی ضرورت ہے، یعنی کم سے کم - وہ جگہ جہاں فنکشن بڑھتا یا گھٹتا ہے۔ اس مقام پر مشتق صفر کے برابر ہوگا۔ لہذا، ہمیں ایک میلان کی ضرورت نہیں ہے، لیکن ایک antigradient کی ضرورت ہے۔ اینٹی گریڈینٹ تلاش کرنے کے لیے آپ کو صرف گریڈینٹ کو اس سے ضرب کرنا ہوگا۔ -1 (مائنس ایک)۔

آئیے اس حقیقت پر توجہ دیں کہ ایک فنکشن میں کئی منیما ہو سکتے ہیں، اور ذیل میں تجویز کردہ الگورتھم کا استعمال کرتے ہوئے ان میں سے کسی ایک میں اترنے کے بعد، ہم کوئی اور کم از کم تلاش نہیں کر پائیں گے، جو کہ پائے جانے والے سے کم ہو سکتا ہے۔ چلو آرام کرو، یہ ہمارے لئے خطرہ نہیں ہے! ہمارے معاملے میں ہم اپنے فنکشن کے بعد سے ایک ہی کم از کم کے ساتھ کام کر رہے ہیں۔ گراف پر ایک باقاعدہ پیرابولا ہے۔ اور جیسا کہ ہم سب کو اپنے اسکول کے ریاضی کے کورس سے اچھی طرح معلوم ہونا چاہیے، ایک پیرابولا میں صرف ایک کم از کم ہوتا ہے۔

جب ہمیں پتہ چلا کہ ہمیں گریڈینٹ کی ضرورت کیوں ہے، اور یہ بھی کہ گراڈینٹ ایک سیگمنٹ ہے، یعنی دیے گئے نقاط کے ساتھ ایک ویکٹر، جو بالکل ایک جیسے کوفیشینٹس ہیں۔ и ہم تدریجی نزول کو نافذ کر سکتے ہیں۔

شروع کرنے سے پہلے، میں نزول الگورتھم کے بارے میں صرف چند جملے پڑھنے کا مشورہ دیتا ہوں:

• ہم ایک چھدم بے ترتیب انداز میں گتانک کے نقاط کا تعین کرتے ہیں۔ и . ہماری مثال میں، ہم صفر کے قریب گتانک کی وضاحت کریں گے۔ یہ ایک عام عمل ہے، لیکن ہر معاملے کی اپنی مشق ہو سکتی ہے۔
• کوآرڈینیٹ سے پوائنٹ پر 1st آرڈر کے جزوی مشتق کی قدر کو گھٹائیں۔ . لہذا، اگر مشتق مثبت ہے، تو فعل بڑھتا ہے۔ لہذا، مشتق کی قدر کو گھٹا کر، ہم ترقی کی مخالف سمت یعنی نزول کی سمت میں چلے جائیں گے۔ اگر مشتق منفی ہے، تو اس مقام پر فعل کم ہو جاتا ہے اور مشتق کی قدر کو گھٹا کر ہم نزول کی سمت بڑھتے ہیں۔
• ہم کوآرڈینیٹ کے ساتھ اسی طرح کا آپریشن کرتے ہیں۔ : نقطہ پر جزوی مشتق کی قدر کو گھٹائیں۔ .
• کم سے کم کودنے اور گہری خلا میں پرواز نہ کرنے کے لئے، یہ ضروری ہے کہ قدم کا سائز نزول کی سمت میں مقرر کیا جائے. عام طور پر، آپ کمپیوٹیشنل اخراجات کو کم کرنے کے لیے قدم کو صحیح طریقے سے سیٹ کرنے اور نزول کے عمل کے دوران اسے تبدیل کرنے کے بارے میں ایک پورا مضمون لکھ سکتے ہیں۔ لیکن اب ہمارے پاس تھوڑا سا مختلف کام ہے، اور ہم "پوک" کے سائنسی طریقہ کا استعمال کرتے ہوئے قدم کا سائز قائم کریں گے یا جیسا کہ وہ عام زبان میں تجرباتی طور پر کہتے ہیں۔
• ایک بار جب ہم دیئے گئے نقاط سے ہیں۔ и مشتقات کی قدروں کو گھٹائیں، ہمیں نئے نقاط ملتے ہیں۔ и . ہم اگلا مرحلہ (گھاٹا) لیتے ہیں، پہلے سے حساب شدہ نقاط سے۔ اور اس طرح سائیکل بار بار شروع ہوتا ہے، جب تک کہ مطلوبہ ہم آہنگی حاصل نہ ہوجائے۔

سب! اب ہم ماریانا ٹرینچ کی سب سے گہری گھاٹی کی تلاش میں جانے کے لیے تیار ہیں۔ آو شروع کریں.

تدریجی نزول کے لیے کوڈ

# напишем функцию градиентного спуска без использования библиотеки NumPy. 
# Функция на вход принимает диапазоны значений x,y, длину шага (по умолчанию=0,1), допустимую погрешность(tolerance)
def gradient_descent_usual(x_us,y_us,l=0.1,tolerance=0.000000000001):
    # сумма значений (все месяца)
    sx = sum(x_us)
    # сумма истинных ответов (выручка за весь период)
    sy = sum(y_us)
    # сумма произведения значений на истинные ответы
    list_xy = []
    [list_xy.append(x_us[i]*y_us[i]) for i in range(len(x_us))]
    sxy = sum(list_xy)
    # сумма квадратов значений
    list_x_sq = []
    [list_x_sq.append(x_us[i]**2) for i in range(len(x_us))]
    sx_sq = sum(list_x_sq)
    # количество значений
    num = len(x_us)
    # начальные значения коэффициентов, определенные псевдослучайным образом
    a = float(random.uniform(-0.5, 0.5))
    b = float(random.uniform(-0.5, 0.5))
    # создаем массив с ошибками, для старта используем значения 1 и 0
    # после завершения спуска стартовые значения удалим
    errors = [1,0]
    # запускаем цикл спуска
    # цикл работает до тех пор, пока отклонение последней ошибки суммы квадратов от предыдущей, не будет меньше tolerance
    while abs(errors[-1]-errors[-2]) > tolerance:
        a_step = a - l*(num*a + b*sx - sy)/num
        b_step = b - l*(a*sx + b*sx_sq - sxy)/num
        a = a_step
        b = b_step
        ab = [a,b]
        errors.append(errors_sq_Kramer_method(ab,x_us,y_us))
    return (ab),(errors[2:])

# запишем массив значений 
list_parametres_gradient_descence = gradient_descent_usual(x_us,y_us,l=0.1,tolerance=0.000000000001)


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


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



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

ہم نے ماریانا ٹرینچ کے بالکل نچلے حصے میں غوطہ لگایا اور وہاں ہمیں ایک جیسی عددی قدریں ملیں۔ и ، جو بالکل وہی ہے جس کی توقع کی جارہی تھی۔

آئیے ایک اور غوطہ لگاتے ہیں، صرف اس بار، ہماری گہرے سمندر کی گاڑی دیگر ٹیکنالوجیز سے بھری ہوگی، یعنی ایک لائبریری۔ بے حس.

تدریجی نزول کے لیے کوڈ (NumPy)

# перед тем определить функцию для градиентного спуска с использованием библиотеки NumPy, 
# напишем функцию определения суммы квадратов отклонений также с использованием NumPy
def error_square_numpy(ab,x_np,y_np):
    y_pred = np.dot(x_np,ab)
    error = y_pred - y_np
    return sum((error)**2)

# напишем функцию градиентного спуска с использованием библиотеки NumPy. 
# Функция на вход принимает диапазоны значений x,y, длину шага (по умолчанию=0,1), допустимую погрешность(tolerance)
def gradient_descent_numpy(x_np,y_np,l=0.1,tolerance=0.000000000001):
    # сумма значений (все месяца)
    sx = float(sum(x_np[:,1]))
    # сумма истинных ответов (выручка за весь период)
    sy = float(sum(y_np))
    # сумма произведения значений на истинные ответы
    sxy = x_np*y_np
    sxy = float(sum(sxy[:,1]))
    # сумма квадратов значений
    sx_sq = float(sum(x_np[:,1]**2))
    # количество значений
    num = float(x_np.shape[0])
    # начальные значения коэффициентов, определенные псевдослучайным образом
    a = float(random.uniform(-0.5, 0.5))
    b = float(random.uniform(-0.5, 0.5))
    # создаем массив с ошибками, для старта используем значения 1 и 0
    # после завершения спуска стартовые значения удалим
    errors = [1,0]
    # запускаем цикл спуска
    # цикл работает до тех пор, пока отклонение последней ошибки суммы квадратов от предыдущей, не будет меньше tolerance
    while abs(errors[-1]-errors[-2]) > tolerance:
        a_step = a - l*(num*a + b*sx - sy)/num
        b_step = b - l*(a*sx + b*sx_sq - sxy)/num
        a = a_step
        b = b_step
        ab = np.array([[a],[b]])
        errors.append(error_square_numpy(ab,x_np,y_np))
    return (ab),(errors[2:])

# запишем массив значений 
list_parametres_gradient_descence = gradient_descent_numpy(x_np,y_np,l=0.1,tolerance=0.000000000001)

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


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

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

عددی قدریں۔ и ناقابل تبدیلی

آئیے دیکھتے ہیں کہ تدریجی نزول کے دوران خرابی کیسے بدلی، یعنی ہر قدم کے ساتھ مربع انحراف کا مجموعہ کیسے تبدیل ہوا۔

مربع انحراف کے مجموعے بنانے کا کوڈ

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

گراف نمبر 4 "گریڈینٹ ڈیسنٹ کے دوران مربع انحراف کا مجموعہ"

گراف پر ہم دیکھتے ہیں کہ ہر قدم کے ساتھ غلطی کم ہوتی جاتی ہے، اور ایک خاص تعداد میں تکرار کے بعد ہم تقریباً افقی لکیر کا مشاہدہ کرتے ہیں۔

آخر میں، آئیے کوڈ پر عمل درآمد کے وقت میں فرق کا اندازہ لگائیں:

تدریجی نزول کے حساب کتاب کے وقت کا تعین کرنے کے لیے کوڈ

print ' 33[1m' + ' 33[4m' + "Время выполнения градиентного спуска без использования библиотеки NumPy:" + ' 33[0m'
%timeit list_parametres_gradient_descence = gradient_descent_usual(x_us,y_us,l=0.1,tolerance=0.000000000001)
print '***************************************'
print

print ' 33[1m' + ' 33[4m' + "Время выполнения градиентного спуска с использованием библиотеки NumPy:" + ' 33[0m'
%timeit list_parametres_gradient_descence = gradient_descent_numpy(x_np,y_np,l=0.1,tolerance=0.000000000001)

شاید ہم کچھ غلط کر رہے ہیں، لیکن پھر یہ ایک سادہ "گھریلو تحریر" فنکشن ہے جو لائبریری کا استعمال نہیں کرتا ہے۔ بے حس لائبریری کا استعمال کرتے ہوئے ایک فنکشن کے حساب وقت کو بہتر کرتا ہے۔ بے حس.

لیکن ہم ابھی تک کھڑے نہیں ہیں، بلکہ سادہ لکیری ریگریشن مساوات کو حل کرنے کے لیے ایک اور دلچسپ طریقہ کا مطالعہ کرنے کی طرف بڑھ رہے ہیں۔ ہم سے ملو!

سٹوکاسٹک گریڈینٹ ڈیسنٹ

اسٹاکسٹک گراڈینٹ ڈیسنٹ کے آپریشن کے اصول کو تیزی سے سمجھنے کے لیے، بہتر ہے کہ اس کے فرق کو عام میلان نزول سے متعین کیا جائے۔ ہم، تدریجی نزول کے معاملے میں، کے مشتقات کی مساوات میں и نمونے میں دستیاب تمام خصوصیات اور حقیقی جوابات کی قدروں کا استعمال کیا ہے (یعنی تمام کی رقم и )۔ اسٹاکسٹک گریڈینٹ ڈیسنٹ میں، ہم نمونے میں موجود تمام اقدار کو استعمال نہیں کریں گے، بلکہ اس کے بجائے، تصادفی طور پر نام نہاد نمونہ انڈیکس کو منتخب کریں گے اور اس کی اقدار کو استعمال کریں گے۔

مثال کے طور پر، اگر اشاریہ نمبر 3 (تین) کا تعین کیا جاتا ہے، تو ہم قدریں لیتے ہیں۔ и ، پھر ہم اقدار کو مشتق مساوات میں بدل دیتے ہیں اور نئے نقاط کا تعین کرتے ہیں۔ اس کے بعد، نقاط کا تعین کرنے کے بعد، ہم دوبارہ تصادفی طور پر نمونے کے اشاریہ کا تعین کرتے ہیں، اشاریہ سے متعلقہ اقدار کو جزوی تفریق مساوات میں بدل دیتے ہیں، اور نقاط کا ایک نئے انداز میں تعین کرتے ہیں۔ и وغیرہ جب تک کنورژن سبز نہ ہو جائے۔ پہلی نظر میں، ایسا نہیں لگتا کہ یہ بالکل کام کر سکتا ہے، لیکن ایسا ہوتا ہے. یہ درست ہے کہ یہ بات قابل توجہ ہے کہ غلطی ہر قدم کے ساتھ کم نہیں ہوتی لیکن ایک رجحان ضرور ہوتا ہے۔

روایتی سے زیادہ سٹاکسٹک گریڈینٹ ڈیسنٹ کے کیا فوائد ہیں؟ اگر ہمارے نمونے کا سائز بہت بڑا ہے اور دسیوں ہزار اقدار میں ماپا جاتا ہے، تو پورے نمونے کے بجائے، ان میں سے ایک بے ترتیب ہزار پر کارروائی کرنا بہت آسان ہے۔ یہ وہ جگہ ہے جہاں اسٹاکسٹک گریڈینٹ ڈیسنٹ کام میں آتا ہے۔ ہمارے معاملے میں، یقیناً، ہم زیادہ فرق محسوس نہیں کریں گے۔

آئیے کوڈ کو دیکھتے ہیں۔

اسٹاکسٹک گریڈینٹ ڈیسنٹ کے لیے کوڈ

# определим функцию стох.град.шага
def stoch_grad_step_usual(vector_init, x_us, ind, y_us, l):
#     выбираем значение икс, которое соответствует случайному значению параметра ind 
# (см.ф-цию stoch_grad_descent_usual)
    x = x_us[ind]
#     рассчитывыаем значение y (выручку), которая соответствует выбранному значению x
    y_pred = vector_init[0] + vector_init[1]*x_us[ind]
#     вычисляем ошибку расчетной выручки относительно представленной в выборке
    error = y_pred - y_us[ind]
#     определяем первую координату градиента ab
    grad_a = error
#     определяем вторую координату ab
    grad_b = x_us[ind]*error
#     вычисляем новый вектор коэффициентов
    vector_new = [vector_init[0]-l*grad_a, vector_init[1]-l*grad_b]
    return vector_new


# определим функцию стох.град.спуска
def stoch_grad_descent_usual(x_us, y_us, l=0.1, steps = 800):
#     для самого начала работы функции зададим начальные значения коэффициентов
    vector_init = [float(random.uniform(-0.5, 0.5)), float(random.uniform(-0.5, 0.5))]
    errors = []
#     запустим цикл спуска
# цикл расчитан на определенное количество шагов (steps)
    for i in range(steps):
        ind = random.choice(range(len(x_us)))
        new_vector = stoch_grad_step_usual(vector_init, x_us, ind, y_us, l)
        vector_init = new_vector
        errors.append(errors_sq_Kramer_method(vector_init,x_us,y_us))
    return (vector_init),(errors)


# запишем массив значений 
list_parametres_stoch_gradient_descence = stoch_grad_descent_usual(x_us, y_us, l=0.1, steps = 800)

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


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

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

ہم گتانکوں کو غور سے دیکھتے ہیں اور خود سے یہ سوال پوچھتے ہیں کہ "یہ کیسے ہو سکتا ہے؟" ہمیں دیگر قابلیت کی قدریں ملیں۔ и . ہو سکتا ہے کہ سٹاکسٹک گریڈینٹ ڈیسنٹ کو مساوات کے لیے زیادہ بہترین پیرامیٹرز مل گئے ہوں؟ بد قسمتی سے نہیں. مربع انحراف کے مجموعے کو دیکھنا اور یہ دیکھنا کافی ہے کہ گتانک کی نئی قدروں کے ساتھ، خرابی بڑی ہے۔ ہمیں مایوسی کی کوئی جلدی نہیں ہے۔ آئیے غلطی کی تبدیلی کا گراف بناتے ہیں۔

سٹاکاسٹک گریڈینٹ ڈیسنٹ میں مربع انحراف کے مجموعے کی منصوبہ بندی کرنے کا کوڈ

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

گراف نمبر 5 "اسٹاکسٹک گریڈینٹ ڈیسنٹ کے دوران مربع انحراف کا مجموعہ"

شیڈول کو دیکھتے ہوئے، سب کچھ اپنی جگہ پر آتا ہے اور اب ہم سب کچھ ٹھیک کریں گے.

تو کیا ہوا؟ مندرجہ ذیل ہوا. جب ہم تصادفی طور پر ایک مہینہ منتخب کرتے ہیں، تو یہ اس منتخب مہینے کے لیے ہوتا ہے کہ ہمارا الگورتھم ریونیو کا حساب لگانے میں غلطی کو کم کرنے کی کوشش کرتا ہے۔ پھر ہم دوسرا مہینہ منتخب کرتے ہیں اور حساب دہراتے ہیں، لیکن ہم دوسرے منتخب مہینے کے لیے غلطی کو کم کرتے ہیں۔ اب یاد رکھیں کہ پہلے دو مہینے سادہ لکیری ریگریشن مساوات کی لائن سے نمایاں طور پر ہٹ جاتے ہیں۔ اس کا مطلب یہ ہے کہ جب ان دو مہینوں میں سے کسی کا انتخاب کیا جاتا ہے، ان میں سے ہر ایک کی غلطی کو کم کرکے، ہمارا الگورتھم پورے نمونے کے لیے غلطی کو سنجیدگی سے بڑھاتا ہے۔ تو کیا کرنا ہے؟ جواب آسان ہے: آپ کو نزول کے قدم کو کم کرنے کی ضرورت ہے۔ بہر حال، نزول کے قدم کو کم کرنے سے، خرابی اوپر اور نیچے "جمپنگ" کو بھی روک دے گی۔ یا اس کے بجائے، "جمپنگ" کی خرابی نہیں رکے گی، لیکن یہ اتنی جلدی نہیں کرے گی :) آئیے چیک کرتے ہیں۔

چھوٹے اضافے کے ساتھ SGD چلانے کے لیے کوڈ

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

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


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



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

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

گراف نمبر 6 "اسٹاکسٹک گریڈینٹ ڈیسنٹ کے دوران مربع انحراف کا مجموعہ (80 ہزار قدم)"

گتانک بہتر ہوئے ہیں، لیکن اب بھی مثالی نہیں ہیں۔ فرضی طور پر، اس کو اس طرح درست کیا جا سکتا ہے۔ مثال کے طور پر، ہم آخری 1000 تکرار میں ان گتانکوں کی قدروں کو منتخب کرتے ہیں جن کے ساتھ کم از کم غلطی ہوئی تھی۔ سچ ہے، اس کے لیے ہمیں خود بھی گتانک کی قدریں لکھنی ہوں گی۔ ہم ایسا نہیں کریں گے بلکہ شیڈول پر توجہ دیں گے۔ یہ ہموار لگ رہا ہے اور خرابی یکساں طور پر کم ہوتی دکھائی دیتی ہے۔ دراصل یہ سچ نہیں ہے۔ آئیے پہلے 1000 تکرار کو دیکھیں اور ان کا آخری سے موازنہ کریں۔

SGD چارٹ کے لیے کوڈ (پہلے 1000 مراحل)

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

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

گراف نمبر 7 "اسکوائرڈ انحراف کا مجموعہ SGD (پہلے 1000 مراحل)"

گراف نمبر 8 "اسکوائرڈ انحراف کا مجموعہ SGD (آخری 1000 مراحل)"

نزول کے بالکل شروع میں، ہم غلطی میں کافی یکساں اور بھاری کمی کا مشاہدہ کرتے ہیں۔ آخری تکرار میں، ہم دیکھتے ہیں کہ خرابی 1,475 کی قدر کے ارد گرد اور ارد گرد جاتی ہے اور کچھ لمحوں میں اس بہترین قدر کے برابر بھی ہوجاتی ہے، لیکن پھر بھی یہ اوپر جاتی ہے... میں دہراتا ہوں، آپ اس کی قدروں کو لکھ سکتے ہیں۔ گتانک и ، اور پھر ان کو منتخب کریں جن کے لیے غلطی کم سے کم ہے۔ تاہم، ہمیں ایک زیادہ سنگین مسئلہ درپیش تھا: ہمیں اقدار کو زیادہ سے زیادہ قریب لانے کے لیے 80 ہزار قدم (کوڈ دیکھیں) اٹھانے پڑے۔ اور یہ پہلے سے ہی تدریجی نزول کے نسبت اسٹاکسٹک گریڈینٹ ڈیسنٹ کے ساتھ حسابی وقت کی بچت کے خیال سے متصادم ہے۔ کیا درست اور بہتر کیا جا سکتا ہے؟ یہ دیکھنا مشکل نہیں ہے کہ پہلی تکرار میں ہم اعتماد کے ساتھ نیچے جا رہے ہیں اور اس لیے ہمیں پہلی تکرار میں ایک بڑا قدم چھوڑنا چاہیے اور آگے بڑھتے ہی قدم کو کم کرنا چاہیے۔ ہم اس مضمون میں ایسا نہیں کریں گے - یہ پہلے ہی بہت طویل ہے. جو لوگ چاہتے ہیں وہ خود سوچ سکتے ہیں کہ یہ کیسے کرنا ہے، یہ مشکل نہیں ہے :)

اب لائبریری کا استعمال کرتے ہوئے اسٹاکسٹک گریڈینٹ ڈیسنٹ پرفارم کرتے ہیں۔ بے حس (اور آئیے ان پتھروں سے ٹھوکر نہ کھائیں جن کی ہم نے پہلے نشاندہی کی تھی)

Stochastic گریڈینٹ ڈیسنٹ کے لیے کوڈ (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

قدریں تقریباً وہی نکلی ہیں جیسے استعمال کیے بغیر نیچے اترنے پر بے حس. تاہم، یہ منطقی ہے.

آئیے معلوم کرتے ہیں کہ اسٹاکسٹک گریڈینٹ ڈیسنٹ میں ہمیں کتنا وقت لگتا ہے۔

ایس جی ڈی کیلکولیشن کے وقت کا تعین کرنے کا کوڈ (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