مقالو ڪيترن ئي طريقن تي بحث ڪري ٿو رياضياتي مساوات جو تعين ڪرڻ لاءِ هڪ سادي (جوڙيل) ريگريشن لائن.
هتي بحث ڪيل مساوات کي حل ڪرڻ جا سڀئي طريقا گهٽ ۾ گهٽ چوڪن جي طريقن تي ٻڌل آهن. اچو ته هيٺين طريقن کي بيان ڪريون:
- تجزياتي حل
- گريجوئيٽ نزول
- Stochastic gradient نزول
سڌي لڪير جي مساوات کي حل ڪرڻ جي هر طريقي لاء، آرٽيڪل مختلف فنڪشن مهيا ڪري ٿو، جيڪي خاص طور تي انهن ۾ ورهايل آهن جيڪي لائبريري استعمال ڪرڻ کان سواء لکيا ويا آهن. نياپي ۽ جيڪي حسابن لاءِ استعمال ڪن ٿا نياپي. اهو يقين آهي ته مهارت جو استعمال نياپي ڪمپيوٽنگ جي خرچن کي گھٽائي ڇڏيندو.
مضمون ۾ ڏنل سڀئي ڪوڊ ٻوليءَ ۾ لکيل آهن سري لنڪس استعمال ڪندي جوپيوٽ نوٽ بڪ. ماخذ ڪوڊ ۽ فائل نموني ڊيٽا سان گڏ پوسٽ ٿيل آهن
مضمون جو وڌيڪ مقصد آهي ٻنهي شروعاتي ۽ انهن لاءِ جيڪي آهستي آهستي مصنوعي ذهانت - مشين لرننگ جي هڪ تمام وسيع حصي جي مطالعي ۾ مهارت حاصل ڪرڻ شروع ڪري چڪا آهن.
مواد کي بيان ڪرڻ لاء، اسان هڪ تمام سادي مثال استعمال ڪندا آهيون.
مثالي حالتون
اسان وٽ پنج قدر آھن جيڪي انحصار کي بيان ڪن ٿا Y от X (ٽيبل نمبر 1):
جدول نمبر 1 ”مثال جا شرط“
اسان فرض ڪنداسين ته قدر سال جو مهينو آهي، ۽ - آمدني هن مهيني. ٻين لفظن ۾، آمدني سال جي مهيني تي منحصر آهي، ۽ - واحد نشاني جنهن تي آمدني منحصر آهي.
مثال ائين آهي، ٻنهي جي نقطي نظر کان، سال جي مهيني تي آمدني جي مشروط انحصار جي نقطي نظر کان، ۽ قدرن جي تعداد جي نقطي نظر کان - انهن مان تمام ٿورا آهن. بهرحال، اهڙي سادگي اهو ممڪن بڻائي سگهندي، جيئن اهي چون ٿا، وضاحت ڪرڻ لاء، هميشه آسانيء سان نه، اهو مواد جيڪو شروعاتي طور تي ملائي ٿو. ۽ انگن جي سادگي پڻ انهن کي اجازت ڏئي ٿي جيڪي ڪاغذ تي مثال حل ڪرڻ چاهيندا آهن بغير اهم مزدور خرچن جي.
اچو ته فرض ڪريون ته مثال ۾ ڏنل انحصار کي فارم جي سادي (جوڙيل) ريگريشن لائن جي رياضياتي مساوات سان چڱيءَ طرح اندازو لڳائي سگهجي ٿو:
جتي اهو مهينو آهي جنهن ۾ آمدني حاصل ڪئي وئي هئي، - مهيني جي مطابق آمدني، и تخميني لڪير جي رجعت جي گنجائش آهن.
نوٽ ڪريو ته coefficient اڪثر ڪري اندازي مطابق لڪير جي سلپ يا گريجوئيٽ سڏيو ويندو آهي؛ رقم جي نمائندگي ڪري ٿو جنهن جي ذريعي جڏهن اهو تبديل ٿئي ٿو .
ظاھر آھي، مثال ۾ اسان جو ڪم آھي مساوات ۾ اھڙين ڪوئفينٽس کي چونڊڻ и , جنهن تي صحيح جوابن کان مهيني جي حساب سان اسان جي آمدني جي قيمتن جي انحراف، يعني. نموني ۾ پيش ڪيل قدر گهٽ ۾ گهٽ هوندا.
گھٽ ۾ گھٽ چورس طريقو
گھٽ ۾ گھٽ چوڪن جي طريقي جي مطابق، انحراف کي چورس ڪرڻ سان حساب ڪيو وڃي. هي ٽيڪنڪ توهان کي انحراف جي باہمي منسوخي کان بچڻ جي اجازت ڏئي ٿي جيڪڏهن اهي مخالف نشانيون آهن. مثال طور، جيڪڏهن هڪ صورت ۾، انحراف آهي +5 (پلس پنج)، ۽ ٻئي ۾ -5 (مائنس پنج)، پوءِ انحرافن جو مجموعو هڪ ٻئي کي رد ڪري ڇڏيندو ۽ رقم 0 (صفر) ٿي ويندي. اهو ممڪن آهي ته انحراف کي چورس نه ڪيو وڃي، پر ماڊيولس جي ملڪيت کي استعمال ڪرڻ ۽ پوء سڀ انحراف مثبت ٿي ويندا ۽ جمع ٿيندا. اسان هن نقطي تي تفصيل سان نه رهنداسين، پر صرف اهو ظاهر ڪنداسين ته حساب جي سهولت لاء، انحراف کي مربع ڪرڻ جو رواج آهي.
اھو اھو آھي جيڪو فارمولا ڏسڻ ۾ اچي ٿو جنھن سان اسين گھٽ ۾ گھٽ رقم جي چورس انحراف (غلطي) جو تعين ڪنداسين:
جتي صحيح جوابن جي لڳ ڀڳ جو ڪم آھي (اھو آھي، آمدني جيڪو اسان ڳڻيو آھي)،
سچا جواب آهن (نموني ۾ مهيا ڪيل آمدني)،
نموني انڊيڪس آهي (مهيني جو تعداد جنهن ۾ انحراف طئي ڪيو ويو آهي)
اچو ته فنڪشن کي مختلف ڪريون، جزوي فرق جي مساواتن کي بيان ڪريون، ۽ تجزياتي حل ڏانهن وڃڻ لاءِ تيار ٿي وڃو. پر پهرين، اچو ته هڪ مختصر سير ڪريون ته تفريق ڇا آهي ۽ نڪتل جي جاميٽري معنيٰ کي ياد ڪريون.
تفاوت
تفريق هڪ فنڪشن جي نڪتل ڳولڻ جو عمل آهي.
derivative ڇا لاء استعمال ڪيو ويو آهي؟ هڪ فنڪشن جو نڪتل فنڪشن جي تبديلي جي شرح کي بيان ڪري ٿو ۽ اسان کي ان جي هدايت کي ٻڌائي ٿو. جيڪڏهن ڏنل نقطي تي نڪتل مثبت آهي، ته پوء ڪم وڌائي ٿو، ٻي صورت ۾، ڪم گھٽجي ٿو. ۽ جيتري قدر مطلق نڪتل جي قدر وڌيڪ هوندي، اوترو ئي اوترو فعلي قدرن جي تبديليءَ جي شرح، ان سان گڏوگڏ فنڪشن گراف جي سلپ اوترو وڌيڪ.
مثال طور، ڪارٽيزئن ڪوآرڊينيٽ سسٽم جي حالتن هيٺ، پوائنٽ M(0,0) تي نڪتل جو قدر برابر آهي. 25 + مطلب ته ڏنل نقطي تي، جڏهن قدر کي منتقل ڪيو ويندو آهي ساڄي طرف روايتي يونٽ طرفان، قدر 25 روايتي يونٽن کان وڌي ٿو. گراف تي اهو ڏسڻ ۾ اچي ٿو ته قدرن ۾ ڪافي تيز اڀار ڏنل نقطي کان.
ٻيو مثال. نڪتل قدر برابر آهي -0,1 مطلب ته جڏهن بي گھر ٿيو في هڪ روايتي يونٽ، قدر صرف 0,1 روايتي يونٽ جي گھٽتائي. ساڳي ئي وقت، فنڪشن جي گراف تي، اسان هڪ مشڪل سان قابل ذڪر هيٺئين سلپ جو مشاهدو ڪري سگهون ٿا. هڪ جبل سان تشبيه ٺاهيندي، ائين لڳندو آهي ڄڻ ته اسان تمام آهستي آهستي ڪنهن جبل کان نرم لهر هيٺ لهي رهيا آهيون، اڳئين مثال جي برعڪس، جتي اسان کي تمام گهڻيون چوٽيون چڙهڻيون هيون :)
اهڙيء طرح، فنڪشن کي مختلف ڪرڻ کان پوء اختلافن سان и ، اسان 1st آرڊر جزوي فرق جي مساوات کي بيان ڪريون ٿا. مساواتن کي طئي ڪرڻ کان پوءِ، اسان کي ٻن مساواتن جو هڪ نظام ملندو، جنهن کي حل ڪرڻ سان اسان ڳڻپ جي اهڙن قدرن کي منتخب ڪري سگهنداسين. и ، جنهن لاءِ ڏنل نقطن تي لاڳاپيل نڪتن جا قدر تمام، تمام ٿوري مقدار ۾ تبديل ٿيندا آهن، ۽ تجزياتي حل جي صورت ۾ بلڪل به تبديل نه ٿيندا آهن. ٻين لفظن ۾، مليل ڪوفيفينٽس تي غلطي جو ڪم گهٽ ۾ گهٽ پهچي ويندو، ڇاڪاڻ ته انهن نقطن تي جزوي نڪتل جا قدر صفر جي برابر هوندا.
تنهن ڪري، تفريق جي ضابطن جي مطابق، 1st آرڊر جي جزوي نڪتل مساوات جي کوٽائي جي حوالي سان فارم وٺي ويندي:
1st آرڊر جزوي نڪتل مساوات جي حوالي سان فارم وٺي ويندي:
نتيجي طور، اسان مساواتن جو ھڪڙو نظام حاصل ڪيو آھي جنھن ۾ ھڪڙو سادي تجزياتي حل آھي:
شروع{مساوات*}
شروعات{ڪيسز}
na + bsumlimits_{i=1}^nx_i — sumlimits_{i=1}^ny_i = 0
sumlimits_{i=1}^nx_i(a +bsumlimits_{i=1}^nx_i — sumlimits_{i=1}^ny_i) = 0
پڇاڙي
آخر{مساوات*}
مساوات کي حل ڪرڻ کان اڳ، اچو ته اڳ لوڊ ڪريون، چيڪ ڪريو ته لوڊ ڪرڻ صحيح آهي، ۽ ڊيٽا کي فارميٽ ڪريو.
ڊيٽا کي لوڊ ڪرڻ ۽ فارميٽ ڪرڻ
اهو ياد رکڻ گهرجي ته حقيقت اها آهي ته تجزياتي حل لاء، ۽ بعد ۾ گريجوئيٽ ۽ اسٽوچسٽڪ گريجوئيٽ نزول لاء، اسان ڪوڊ کي ٻن مختلف قسمن ۾ استعمال ڪنداسين: لائبريري استعمال ڪندي نياپي ۽ ان کي استعمال ڪرڻ کان سواء، پوء اسان کي مناسب ڊيٽا فارميٽنگ جي ضرورت پوندي (ڏسو ڪوڊ).
ڊيٽا لوڊ ڪرڻ ۽ پروسيسنگ ڪوڊ
# импортируем все нужные нам библиотеки
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import math
import pylab as pl
import random
# графики отобразим в Jupyter
%matplotlib inline
# укажем размер графиков
from pylab import rcParams
rcParams['figure.figsize'] = 12, 6
# отключим предупреждения Anaconda
import warnings
warnings.simplefilter('ignore')
# загрузим значения
table_zero = pd.read_csv('data_example.txt', header=0, sep='t')
# посмотрим информацию о таблице и на саму таблицу
print table_zero.info()
print '********************************************'
print table_zero
print '********************************************'
# подготовим данные без использования NumPy
x_us = []
[x_us.append(float(i)) for i in table_zero['x']]
print x_us
print type(x_us)
print '********************************************'
y_us = []
[y_us.append(float(i)) for i in table_zero['y']]
print y_us
print type(y_us)
print '********************************************'
# подготовим данные с использованием NumPy
x_np = table_zero[['x']].values
print x_np
print type(x_np)
print x_np.shape
print '********************************************'
y_np = table_zero[['y']].values
print y_np
print type(y_np)
print y_np.shape
print '********************************************'زير نظر
ھاڻي، اسان کان پوء، پھريون، ڊيٽا کي لوڊ ڪيو، ٻيو، لوڊ ڪرڻ جي صحيحيت کي جانچيو ۽ آخرڪار ڊيٽا کي فارميٽ ڪيو، اسان پھريون ويزنائيزيشن کي انجام ڏينداسين. هن جو طريقو اڪثر استعمال ڪيو ويندو آهي جوڙو لائبريريون سمنڊ جو ڪنارو. اسان جي مثال ۾، محدود تعداد جي ڪري، لائبريري استعمال ڪرڻ ۾ ڪو به مقصد ناهي سمنڊ جو ڪنارو. اسان باقاعده لائبريري استعمال ڪنداسين matplotlib ۽ صرف scatterplot کي ڏسو.
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
پڇاڙي
آخر{مساوات*}
Cramer جي اصول موجب اسان ڳولينداسين عام تعين ڪندڙ، گڏو گڏ determinants جي ذريعي ۽ پاران ، جنهن کان پوءِ، مقرر ڪندڙ کي ورهائيندي عام تعين ڪندڙ تائين - ڳولهيو ڪوفيشيٽ ، ساڳيءَ طرح اسان کوٽائي ڳوليون ٿا .
تجزياتي حل ڪوڊ
# определим функцию для расчета коэффициентов 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 matrix (عملي طور تي سفارش نه ڪئي وئي آهي، ڇاڪاڻ ته اهو عمل پيچيده ۽ غير مستحڪم آهي)، ٻيو هڪ ميٽرڪس مساوات استعمال ڪندي.
تجزياتي حل ڪوڊ (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 (مائنس هڪ).
اچو ته ان حقيقت تي ڌيان ڏيون ته هڪ فنڪشن ۾ ڪيترائي منٽ ٿي سگهن ٿا، ۽ هيٺ ڏنل تجويز ڪيل الگورتھم استعمال ڪندي انهن مان هڪ ۾ داخل ٿيڻ کان پوءِ، اسان ٻي گهٽ ۾ گهٽ ڳولي نه سگهنداسين، جيڪا شايد مليل هڪ کان گهٽ هجي. اچو ته آرام ڪريون، هي اسان کي خطرو ناهي! اسان جي حالت ۾ اسان ھڪڙي ھڪڙي گھٽ ۾ گھٽ ڪم ڪري رھيا آھيون، اسان جي فنڪشن کان وٺي گراف تي هڪ باقاعده پارابولا آهي. ۽ جيئن ته اسان سڀني کي اسان جي اسڪول جي رياضي جي ڪورس کان چڱي طرح ڄاڻڻ گهرجي، هڪ پارابولا صرف هڪ گهٽ ۾ گهٽ آهي.
ان کان پوءِ اسان کي معلوم ٿيو ته اسان کي گريڊيئنٽ جي ضرورت ڇو آهي، ۽ اهو پڻ ته گريڊيئنٽ هڪ ڀاڱو آهي، يعني هڪ ویکٹر جنهن ۾ ڏنل ڪوآرڊينيٽس آهن، جيڪي صحيح طور تي ساڳيا ڪوئفيسيٽ آهن. и اسان تدريسي نزول کي لاڳو ڪري سگھون ٿا.
شروع ڪرڻ کان اڳ، مان نزول الگورتھم بابت صرف چند جملا پڙهڻ جي صلاح ڏيان ٿو:
- اسان pseudo-random انداز ۾ coefficients جي همراهن جو تعين ڪندا آهيون и . اسان جي مثال ۾، اسان صفر جي ويجهو ڪوئفائٽي جو تعين ڪنداسين. اهو هڪ عام رواج آهي، پر هر صورت ۾ ان جي پنهنجي مشق ٿي سگهي ٿي.
- همراهن کان پوائنٽ تي 1st آرڊر جزوي نڪتل جي قيمت کي گھٽايو . تنهن ڪري، جيڪڏهن نڪتل مثبت آهي، پوء فنڪشن وڌائي ٿو. تنهن ڪري، نڪتل جي قدر کي گھٽائڻ سان، اسان ترقي جي مخالف سمت ۾، يعني، نزول جي طرف منتقل ڪنداسين. جيڪڏهن نڪتل ناڪاري آهي، ته پوءِ هن نقطي تي ڪم گهٽجي وڃي ٿو ۽ نڪتل جي قدر کي گھٽائڻ سان اسان نزول جي طرف هلون ٿا.
- اسان ڪوآرڊينيٽ سان ساڳيو آپريشن ڪندا آهيون : پوائنٽ تي جزوي نڪتل جي قيمت کي گھٽايو .
- گهٽ ۾ گهٽ ٽپو نه ڏيڻ ۽ اونهي خلا ۾ اڏامڻ لاءِ، اهو ضروري آهي ته قدم جي سائيز کي نزول جي هدايت ۾ مقرر ڪيو وڃي. عام طور تي، توهان هڪ پورو مضمون لکي سگهو ٿا ته ڪيئن قدم کي صحيح طريقي سان سيٽ ڪيو وڃي ۽ ان کي ڪيئن تبديل ڪجي نزول جي عمل دوران ڪمپيوٽر جي خرچن کي گهٽائڻ لاءِ. پر ھاڻي اسان جي اڳيان ھڪڙو مختلف ڪم آھي، ۽ اسان "پوڪ" جي سائنسي طريقي کي استعمال ڪندي قدم جي ماپ کي قائم ڪنداسين، يا جيئن اھي عام اصطلاح ۾ چوندا آھن، تجرباتي طور تي.
- هڪ دفعو اسان کي ڏنل همراهن مان آهن и derivatives جي قدرن کي گھٽايو، اسان کي نوان ڪوآرڊينيٽس ملن ٿا и . اسان اڳ ۾ ئي حساب ڪيل همراهن مان ايندڙ قدم (ذخيرو) وٺون ٿا. ۽ اهڙيءَ طرح اهو چڪر وري وري شروع ٿئي ٿو، جيستائين گهربل ڪنورجنسي حاصل نه ٿئي.
سڀ! هاڻي اسان ماريانا خندق جي اونهي گھاٽي جي ڳولا ۾ وڃڻ لاءِ تيار آهيون. اچو ته شروع ڪريون.
تدريسي نزول لاءِ ڪوڊ
# напишем функцию градиентного спуска без использования библиотеки 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)
شايد اسان ڪجھ غلط ڪري رھيا آھيون، پر وري اھو ھڪڙو سادو ”گھر ۾ لکيل“ فنڪشن آھي جيڪو لائبريري استعمال نٿو ڪري نياپي لائبريري استعمال ڪندي فنڪشن جي حساب ڪتاب جي وقت کي ختم ڪري ٿو نياپي.
پر اسان اڃا بيٺا نه آهيون، پر هڪ ٻئي دلچسپ طريقي جي مطالعي ڏانهن وڌي رهيا آهيون ته جيئن سادي لينر ريگريشن مساوات کي حل ڪرڻ لاء. اسان سان ملو!
Stochastic gradient نزول
اسٽوچسٽڪ گرڊيئينٽ نزول جي آپريشن جي اصول کي تيزيءَ سان سمجھڻ لاءِ، اھو بھتر آھي ته ان جي فرق کي عام گرڊيئيٽ نزول کان طئي ڪيو وڃي. اسان، تدريسي نزول جي صورت ۾، نڪتلن جي مساواتن ۾ и سڀني خاصيتن جي قدرن جو مجموعو استعمال ڪيو ۽ نموني ۾ موجود سچا جواب (يعني، سڀني جو مجموعو и ). stochastic gradient descent ۾، اسان نمونن ۾ موجود سڀني قدرن کي استعمال نه ڪنداسين، پر ان جي بدران، pseudo-randomly نالي واري نموني انڊيڪس کي چونڊيو ۽ ان جي قدرن کي استعمال ڪريون.
مثال طور، جيڪڏهن انڊيڪس کي طئي ڪيو وڃي ته نمبر 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()گراف نمبر.
شيڊول کي ڏسي، سڀڪنھن شيء کي جاء ۾ اچي ٿو ۽ هاڻي اسان سڀڪنھن شيء کي ٺيڪ ڪندو.
پوءِ ڇا ٿيو؟ هيٺيون ٿيو. جڏهن اسان بي ترتيب طور هڪ مهينو چونڊيندا آهيون، پوءِ اهو چونڊيل مهيني لاءِ هوندو آهي ته اسان جو الگورٿم آمدني جي ڳڻپ ۾ غلطي کي گهٽائڻ جي ڪوشش ڪندو آهي. ان کان پوء اسان هڪ ٻيو مهينو چونڊيو ۽ حساب ڪتاب کي ورجائي، پر اسان ٻئي چونڊيل مهيني لاء غلطي کي گهٽايو. ھاڻي ياد رکو ته پھريون ٻه مھينا خاص طور تي سادي لڪير ريگريشن مساوات جي لائن کان الڳ ٿي ويا آھن. هن جو مطلب اهو آهي ته جڏهن انهن ٻن مهينن مان ڪنهن کي چونڊيو وڃي ٿو، انهن مان هر هڪ جي غلطي کي گهٽائڻ سان، اسان جي الگورتھم پوري نموني جي غلطي کي سنجيده وڌائي ٿو. پوءِ ڇا ڪجي؟ جواب سادو آهي: توهان کي نزول جي قدم کي گهٽائڻ جي ضرورت آهي. آخرڪار، نزول جي قدم کي گهٽائڻ سان، غلطي پڻ بند ٿي ويندي "جمپنگ" مٿي ۽ هيٺ. يا بلڪه، "جمپنگ" غلطي بند نه ٿيندي، پر اهو ايترو جلدي نه ڪندو :) اچو ته چيڪ ڪريو.
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 “Sum of squared deviations SGD (پهرين 1000 مرحلا)”
گراف نمبر 8 “Sum of squared deviations SGD (آخري 1000 مرحلا)”
نزول جي بلڪل شروعات ۾، اسان غلطي ۾ ڪافي يونيفارم ۽ تيز گهٽتائي جو مشاهدو ڪيو. آخري ورهاڱي ۾، اسان ڏسون ٿا ته غلطي 1,475 جي قيمت جي چوڌاري ۽ چوڌاري ٿي وڃي ٿي ۽ ڪجهه لمحن تي هن بهتر قيمت جي برابر آهي، پر پوء اهو اڃا تائين وڌي ٿو ... مان ورجائي ٿو، توهان لکي سگهو ٿا قدر جي قيمت کوٽائي и ، ۽ پوءِ انھن کي چونڊيو جن لاءِ غلطي گھٽ ۾ گھٽ آھي. بهرحال، اسان وٽ هڪ وڌيڪ سنگين مسئلو هو: اسان کي 80 هزار قدم کڻڻا پوندا (ڏسو ڪوڊ) قدرن جي ويجهو حاصل ڪرڻ لاءِ. ۽ اهو اڳ ۾ ئي ڳڻپيوڪر وقت بچائڻ جي خيال سان تضاد رکي ٿو اسٽوچسٽڪ گريجوئيٽ نزول سان لاڳاپيل گرڊيئينٽ نزول سان. ڇا ٿي سگهي ٿو درست ۽ بهتر؟ اهو نوٽ ڪرڻ ڏکيو ناهي ته پهرين ورهاڱي ۾ اسان اعتماد سان هيٺ وڃي رهيا آهيون ۽ ان ڪري، اسان کي پهرين ورهاڱي ۾ هڪ وڏو قدم ڇڏڻ گهرجي ۽ قدم کي گهٽائڻ گهرجي جيئن اسين اڳتي وڌون ٿا. اسان هن مضمون ۾ نه ڪنداسين - اهو اڳ ۾ ئي ڊگهو آهي. جيڪي چاهين ٿا پاڻ لاءِ سوچي سگهن ٿا ته اهو ڪيئن ڪجي، اهو ڏکيو ناهي :)
ھاڻي اچو ته لائبريري کي استعمال ڪندي اسٽوچسٽڪ گريڊيئنٽ ڊيسنٽ انجام ڏيون نياپي (۽ اچو ته انهن پٿرن تي نه هڻون جن جي اسان اڳ ۾ سڃاڻپ ڪئي هئي)
Stochastic Gradient Descent لاءِ ڪوڊ (NumPy)
# для начала напишем функцию градиентного шага
def stoch_grad_step_numpy(vector_init, X, ind, y, l):
x = X[ind]
y_pred = np.dot(x,vector_init)
err = y_pred - y[ind]
grad_a = err
grad_b = x[1]*err
return vector_init - l*np.array([grad_a, grad_b])
# определим функцию стохастического градиентного спуска
def stoch_grad_descent_numpy(X, y, l=0.1, steps = 800):
vector_init = np.array([[np.random.randint(X.shape[0])], [np.random.randint(X.shape[0])]])
errors = []
for i in range(steps):
ind = np.random.randint(X.shape[0])
new_vector = stoch_grad_step_numpy(vector_init, X, ind, y, l)
vector_init = new_vector
errors.append(error_square_numpy(vector_init,X,y))
return (vector_init), (errors)
# запишем массив значений
list_parametres_stoch_gradient_descence = stoch_grad_descent_numpy(x_np, y_np, l=0.001, steps = 80000)
print ' 33[1m' + ' 33[4m' + "Значения коэффициентов a и b:" + ' 33[0m'
print 'a =', round(list_parametres_stoch_gradient_descence[0][0],3)
print 'b =', round(list_parametres_stoch_gradient_descence[0][1],3)
print
print ' 33[1m' + ' 33[4m' + "Сумма квадратов отклонений:" + ' 33[0m'
print round(list_parametres_stoch_gradient_descence[1][-1],3)
print
print ' 33[1m' + ' 33[4m' + "Количество итераций в стохастическом градиентном спуске:" + ' 33[0m'
print len(list_parametres_stoch_gradient_descence[1])
print
قيمتون لڳ ڀڳ هڪجهڙا ٿي ويا جڏهن استعمال ڪرڻ کان سواءِ هيٺ لٿو نياپي. بهرحال، هي منطقي آهي.
اچو ته اهو معلوم ڪريون ته اسٽوچسٽڪ گريجوئيٽ نزول اسان کي ڪيترو وقت ورتو.
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. لڪير رجعت
2. گھٽ ۾ گھٽ چوڪن جو طريقو
3. نڪتل
4. گريجوئيٽ
5. تدريسي نزول
6. NumPy لائبريري
جو ذريعو: www.habr.com