Gradient Descent

2.2 Gradient Descent

In this part, you will fit the linear regression parameters θ to our dataset using gradient descent.

ARS NOTLARI:

Bu bölümde amaç şehir nüfusu seçildiğinde kârın ne olacağını tahmin etmektir. Elimizdeki şehir nüfusu değerleri ve onlara ait kâr miktarları arasında  y = a + bx şeklinde doğrusal bir ilişki kurabilirsek X değerini seçtiğimizde buna karşı düşen kâr miktarını bulabiliriz.  

Burada sorun elimizdeki kâr değerlerinin doğrusal bir dağılıma sahip olmamasıdır.  Öyle ise amacımız eldeki tüm verileri dikkate alan, toplamda mümkün olan en haz hatalı doğruyu bulmaktır.   

Hinton’un  bahsettiği linear regression parameters θ(doğrusal ilişki parametreleri) y= a + bx doğrusal denklemindeki a ve b değerleridir.

Figure 1: Scatter plot of training data LG1

2.2.1 Update Equations

The objective of linear regression is to minimize the cost function

 

where the hypothesis hθ(x) is given by the linear model

 (y = a + bx  a= θ₀ , b= θ₁ ) 

ARS NOTLARI:

Seçtiğimiz a ve b değerlerine göre oluşan doğru üzerindeki değerler ile gerçek kâr değerleri arasındaki

farkların toplamı yaptığımız a ve b seçiminin maliyetini verir.  Bu toplama maliyet fonksiyonu(cost function)’u  denir.  Kurmaya çalıştığımız doğrusal ilişki’nin amacı maliyet fonksiyonu(cost function)’nu  mümkün olan en küçük değere indirmektir.

Yukarıda J(θ) seçtiğimiz θ değerlerine göre değişen maliyeti gösterir.

h₀(x_i)  seçtiğimiz ilk doğruyu  şehir nüfusuna göre x’in aldığı değerleri belirtir.

( h₀(x_i) - y_i )² seçtiğimiz ilk doğruya göre bulunan kâr değerleri ile y_i gerçek kâr değerleri arasındaki

farktır.

Burada amaç seçilecek her doğru için bu hesaplamayı yaparak en uygun doğruyu bulmaktır.

Hinton’un bahsettiği model bu doğru ve onun denklemidir.

Recall that the parameters of your model are the θ_j values. These are the values you will adjust to minimize cost J(θ). One way to do this is to use the batch gradient descent algorithm.

Modelinizin parametrelerinin θ_j değerleri olduğunu hatırlayınız.  Bunlar J(θ) maliyeti minimize etmek için ayarlayacağımız değerlerdir.  Bu ayarlamayı yapmanın bir yolu gradient descent algoritmasıdır.

In batch gradient descent, each iteration performs the update

 

With each step of gradient descent, your parameters θ_j come closer to the

optimal values that will achieve the lowest cost J(θ)

Batch gradient descent algoritmasında her adım yukarıdaki güncellemeyi yapar. Gradient descent’in her adımıyla, θ_j parametreleriniz en düşük maliyeti sağlayacak optimal değerlere yaklaşacaktır.

ARS NOTLARI:

θ_j değeri  j’inci iterasyonda θ_’nın aldığı değerdir.  θ_j yeni değerini bulmak için,  ( h₀(x_i) - y_i )² ‘nin türevi nin bütün şehirlerde aldığı değerlerin toplamını gene bütün şehirlerin sayısına bölüp bir yaklaşma hızı alfa ile çarparak, θ_j’nin eski değerinden  çıkartır.  Alfanın büyüklüğü sonuca yakınsama hızını etkilediği gibi fazla büyük alınırsa sonucu atlayıp ıraksamaya da yol açabilir.

Şekildeki  j indisi θ_j gradien descent hesaplama, yakınsama adımını, iterasyonu belirtir.  x⁽ⁱ⁾ y⁽ⁱ⁾ ‘deki i değişkeni ise geçmişte ölçüm yapılmış şehir nüfusu-kâr ikililerini belirtir.  Her θ_j yeni bir y = a + bx  a= θ₀ , b= θ_{1 doğrusunu} belirtir.  Amacımız bütün denek noktaları dikkat alındığında bu noktalara en yakın optimal geçen θ₎= θ₀ +θ₁x doğrusunu bulmaktır.

Implementation Note: We store each example as a row in the the X matrix in Octave. To take into account the intercept term (θ₀), we add an additional first column to X and set it to all ones. This allows us to treat θ0 as simply another ‘feature’.

Uygulama Notu: Octave’de Xmatrixi içinde her örnek değeri bir satıra saklıyoruz.  (θ0), intercept terimini hesaba katmak için, X’e ek bir birinci sütun ekliyoruz ve satırlarının hepsinin değerlerini 1 yapıyoruz.  Bu bizim (θ0)’a bir  başka’ özellik’ gibi muamele etmemizi sağlıyor.

2.2.2 Implementation

In ex1.m, we have already set up the data for linear regression. In the following lines, we add another dimension to our data to accommodate the θ₀ intercept term. We also initialize the initial parameters to 0 and the learning rate alpha to 0.01.

X = [ones(m, 1), data(:,1)];         % Add a column of ones to x

theta = zeros(2, 1);

 % initialize fitting parameters

iterations = 1500;

alpha = 0.01;

ex1.m’de doğrusal ilişki için veriyi hazırlamış bulunuyoruz.  Aşağıdaki satırlarda verimize intercept deyimini yerleştirmek için yeni bir sütun ekliyoruz.  Ayrıca başlangıç parametrelerinide 0 ve öğrenme oranı alpha’yı da 0.01 yapıyoruz.

ARS NOTLARI:

X = [ones(m, 1), data(:,1)];   Burada m elde bulunan şehir nüfusu/kâr değerlerinin (öğrenme seti) sayısıdır.

octave:1> data=[1,2;3,4;5,6]

data =

   1   2

   3   4

   5   6

octave:2> m=size(data,1)

m =  3

octave:3> ones(m,1)

ans =

   1

   1

   1

octave:4> data(:,1)

ans =

   1

   3

   5

octave:5> X=[ones(m, 1), data(:,1)];

octave:6> X

X =

   1   1

   1   3

1         5

2.2.3 Computing the cost J(θ)

As you perform gradient descent to learn minimize the cost function J(θ), it is helpful to monitor the convergence by computing the cost. In this section, you will implement a function to calculate J(θ) so you can check the convergence of your gradient descent implementation.

J(θ) Maliyet fonksiyonunu minimize etmeyi öğrenmek için Gradient descent’i çalıştırırken,  o durumdaki  maliyeti hesaplarak yakınsamayı izlemek faydalı olabilir.  Bu kısımda, J(θ)’yı hesaplamak için bir fonksiyon yapacaksınız, öyle ki yaptığınız gradient descent’ in yakınsamasını kontrol edebileceksiniz.

The variables X and y are not scalar values, but matrices whose rows represent the examples from the training set.

X ve y değişkenleri sayı değerleri değil, satırları öğrenme setinin örnekleri olan vektörlerdir.

ARS NOTLARI:

Maliyet, sistemde yapılacak küçük bir değişikliğin sistem çıktısında oluşturacağı değişikliktir.  Bu değişiklik olumlu yönde olabildiği gibi olumsuz yönde  de olabilir.  Bizim amacımız, elimizdeki öğrenme verilerinin hepsini kullanarak, deneme amaçlı seçtiğimiz doğrunun olumlu bir seçim olup olmadığını kontrol etmektir.  İşte bu amaç için maliyeti kontrol eden  J(θ) fonksiyonunu geliştireceğiz.

computeCost.m %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

function J = computeCost(X, y, theta)

%COMPUTECOST Compute cost for linear regression

%   J = COMPUTECOST(X, y, theta) computes the cost of using theta as the

%   parameter for linear regression to fit the data points in X and y

ARSnotlar:

Ana programımız ex1 computeCost.m içinde duran harici  computeCost fonksiyonunu çağırır.

Maliyeti hesaplamak için X şehir nüfusları bilgileri vektörü, y bu şehir-nüfusları için kâr miktarları ve

Maliyetini ölçmek istediğimiz doğruyu belirten θ= θ₀ +θ₁x vektörünü çağırdığımız computeCost fonksiyonuna geçirmemiz gerekir.  Unutmayınız ki X vektörüne intercept sütunu eklemiş durumdayız.

% Initialize some useful values

m = length(y);    % number of training examples

% You need to return the following variables correctly

J = 0;  % J maliyete başlangıç olarak 0 değerini veriniz.

% ============================================

% Instructions: Compute the cost of a particular choice of theta

%               You should set J to the cost.

% Loop implementation

%for i = 1:m,

%            J = J + (((X(i,:) * theta) - y(i)) ^ 2);

%end;

ARSnotları:

m  şehir nüfusları/bunlara karşı düşen kâr miktarları şeklinde elimizde bulunan öğrenme amaçlı ikililerin sayısını belirtir.  Dolayısıyla m defa  J = J + (((X(i,:) * theta) - y(i)) ^ 2); işlemi yapılacak

ve her defasında defa  J = J + ...  şeklinde daha önceki şehir-nüfuslarından kalan maliyet biriktirilecek ve toplam maliyet bulunacaktır. Theta’nın ilk değeri yukarıda

theta = zeros(2, 1);

0+0x ve boyutu _{2 x 1}  şeklinde verilmişti.

X ise X = [ones(m, 1), data(:,1)];     Burada m şehir-nüfus öğrenme örnekleri sayısı,

ones(m, 1),  θ₀ +θ₁x’in θ₀ intercepti nedeniyle eklenmiş sütun ,

data(:,1) ise şehir-nüfus değerlerini içeren input verisidir.

X _{m x 2} boyutundadır.

Böylece yukarıda vermiş olduğumuz maliyet fonksiyonunu gerçekleştirmiş oluruz.

% Vectorized implementation

J = sum(((X * theta) - y) .^ 2); 

J = 1 / (2 * m) * J;   % J= 32.073

end

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

 Once you have completed the function, the next step in ex1.m will run computeCost once using θ initialized to zeros, and you will see the cost printed to the screen. You should expect to see a cost of 32.07. 

% compute and display initial cost

computeCost(X, y, theta)

Bir kere bu fonksiyonu tamamladıktan sonraki adım:  computeCost’u bir defa θ’ya başlangıçta 0 değerlerini vererek  çalıştıracaksınız, ve maliyetin ekrana yazıldığını göreceksiniz.  32.07 maliyetini görmeniz gerekir.

2.2.4 Gradient descent

Next, you will implement gradient descent in the file gradientDescent.m. The loop structure has been written for you, and you only need to supply the updates to θ within each iteration.

Daha sonra, gradientDescent.m dosyası içindeki gradient descent’i yapacaksınız. 

As you program, make sure you understand what you are trying to optimize and what is being updated. Keep in mind that the cost J(θ) is parameterized by the vector θ, not X and y. That is, we minimize the value of J(θ) by changing the values of the vector θ, not by changing X or y.

Neyi optimize ettiğinizi ve neyin güncellendiğini anladığınızdan emin olunuz.  Maliyet J(θ) ‘nın parametresi θ’dır, X ve y değil.  Yani  J(θ) değerini θ  vektörünün değerlerini değiştirerek minimize ediyoruz,  X ve y ‘yi değil.

A good way to verify that gradient descent is working correctly is to look at the value of J(θ) and check that it is decreasing with each step.

Bir gradient descent’in doğru çalıştığını kontrol etmenin iyi bir yolu J(θ) ‘nın değerine bakıp her iterasyon adımında azaldığını gözlemektir.

The starter code for gradientDescent.m calls computeCost on every iteration and prints the cost.

Başlangıçta gradientDescent.m  için verilen kod  her iterasyonda computeCostu çağırır ve maliyeti yazar.

% run gradient descent

theta = gradientDescent(X, y, theta, alpha, iterations);

% print theta to screen

fprintf('Theta found by gradient descent: ');

fprintf('%f %f \n', theta(1), theta(2));

ARSnotları:

gradientDescent fonksiyonu kendisini çağıran yere theta vektörünü _{2 x 1} döndürür.

Alpha öğrenme hızını belirler.

İterations toplam iterasyon sayısını verir.

Çıktı yazdırılırken theta(1), theta(2)); θ₀ +θ₁x değerlerini verir.

gradientDescent.m %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

function [theta, J_history] = gradientDescent(X, y, theta, alpha, num_iters)

%GRADIENTDESCENT Performs gradient descent to learn theta

%   theta = GRADIENTDESENT(X, y, theta, alpha, num_iters) updates theta by

%   taking num_iters gradient steps with learning rate alpha

% Initialize some useful values

m = length(y); % number of training examples

J_history = zeros(num_iters, 1);

ARSnotları:

m değişkeni  y kâr değerlerinin sayısıdır, bu aynı zamanda X şehir-nüfus değerlerinin sayısıdır.

Maliyet değerlerini  J_history vektörü içinde saklıyacağız, bunun uzunluğu toplam iterasyon sayısına (num_iters) eşittir.

for iter = 1:num_iters

    % ====================== YOUR CODE HERE ======================

    % Instructions: Perform a single gradient step on the parameter vector

    %               theta.

                % Nested loop implementation:

                % num_thetas = length(theta);  % theta vektörünün uzunluğu

                % theta_new = zeros(num_thetas,1);  % sonuç theta vektörü başlangıç theta ile aynı boyutta

                % for j = 1:num_thetas

                %            inner_sum = 0;

                %            for i = 1:m

                %                            inner_sum = inner_sum + ((X(i,:) * theta) - y(i)) * X(i,j);

                %            end

                %            theta_new(j) = theta(j) - (alpha / m * inner_sum);

                %end

ARSnotları:

% inner_sum = 0;

                %            for i = 1:m

                %                            inner_sum = inner_sum + ((X(i,:) * theta) - y(i)) * X(i,j);

                %            end

Yukarıda, % Loop implementation kısmında açıklanmıştı.

+ ((X(i,:) * theta) - y(i)) * X(i,j); değerleri  for i=1:m çevrimi içinde bütün şehir-nüfus değerleri

Ve bunlara ilişkin kâr değerleri için inner_sum içinde toplanır.

Bu işlem % for j = 1:num_thetas çevrimi içinde bütün  θ değerleri (θ₀ +θ₁x) için tekrarlanarak sonuç theta(j) - (alpha / m * inner_sum  ile hesaplanıp theta_new (j) içine konur.

    % Vectorized implementation:

                A = X * theta - y;                             % (m x 1 vector)   97 x 2 * 2 x 1  -  97 x 1

                delta = 1 / m * (A' * X)';                % ' ((n+1) x 1 vector)  (1 x 97 * 97 x 2)' = 2 x 1

                theta = theta - (alpha * delta);                 % ' ((n+1) x 1 vector) 2 x 1 - (alpha * 2 x 1)

                % printf(' tttt %s \r\n',"ARS");

                % printf('%4f \r\n',iter);

                 

    % ============================================================

ARSnotları:

X şehir-nüfus değerleri sayısı 97’dir.  X vektörüne bir sütun intercept eklemiştik.  Bunun amacı

θ₀ +θ₁x ile uyumluluk sağlamaktır.  X * theta, 97 x 1 sonucu verir. Bundan kâr değerlerinin vektörünü (97 x 1) çıkartırız.

Delta  = 1 / m * (A' * X)'; yukarıda açıklanan

formulünden geliyor.  Özü, değişim miktarının ait olduğu değerle çarpılarak bütün bu çarpımların toplanması ve bütün değerlerin sayısına bölünmesine dayanır.

Bütün değerler vektör satırlarında ifade edildiği ve dikkate alındığı için bir çevrim gerekmemektedir.

    % Save the cost J in every iteration   

    J_history(iter) = computeCost(X, y, theta);

end

fprintf(' num_iters: %4.2f \r\n', num_iters);

end

ARSnotları:

Hesaplanan maliyet değerleri  iterasyon sayısı bazında    J_history(iter)’ye yazılır.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

Assuming you have implemented gradient descent and computeCost correctly, your value of J(θ) should never increase, and should converge to a steady value by the end of the algorithm.

Eğer gradient descent ve computeCost’u doğru yaptıysanız  J(θ) değeriniz hiç bir zaman artmamalıdır, ve algoritma sonunda sabit bir değere yakınsamalıdır.

After you are finished, ex1.m will use your final parameters to plot the linear fit. The result should look something like Figure 2:

Bitirdikten sonra ex1.m son olarak ulaştığınız parametre değerlerini kullanır.  Sonuç şekil 2 deki gibi olmalıdır.

% Plot the linear fit

hold on;            % keep previous plot visible % eski şekli koru

plot(X(:,2), X*theta, '-') 

legend('Training data', 'Linear regression')

hold off          % don't overlay any more plots on this figure %bu şekil üzerine yeni noktalar koyma

Bulduğunuz en son  θ değerleri (yani doğrunun a+bx) katsayıları  35,000 ve 70,000 kişilik şehirlerde kârın ne olacağını tahmin etmek için kullanılır.

% Predict values for population sizes of 35,000 and 70,000

predict1 = [1, 3.5] *theta;

fprintf('For population = 35,000, we predict a profit of %f\n', predict1*10000);

predict2 = [1, 7] * theta;  % 1 x 2 * 2 x 1 = 1 x 1

fprintf('For population = 70,000, we predict a profit of %f\n',   predict2*10000);

2.3 Debugging

Here are some things to keep in mind as you implement gradient descent:   Octave array indices start from one, not zero. If you’re storing θ₀ and θ₁ in a vector called theta, the values will be theta(1) and theta(2).

Gradient descenti yaparken akılda tutmanız gereken birkaç şey:  Octave dizi(array) indexleri 1’den başlar, 0’dan değil.  Eğer θ₀ ve θ₁’i theta isimli bir vektöre saklıyorsanız değerleri theta(1) ve theta(2) olacaktır.

ˆ If you are seeing many errors at runtime, inspect your matrix operations to make sure that you’re adding and multiplying matrices of compatible dimensions. Printing the dimensions of variables with the size command will help you debug.

Programı çalıştırıken çok sayıda hata görüyorsanız, toplama ve çarpma yaptığınız matrislerin uyumlu boyutlara sahip olduğundan emin olmak için, matris işlemlerinizi gözden geçiriniz.  Değişkenlerin boyutlarını size komutu ile yazdırmanız hataları bulmanıza yardımcı olacaktır.

Figure 2: Training data with linear regression fit  LG2

ˆ By default, Octave interprets math operators to be matrix operators. This is a common source of size incompatibility errors. If you don’t want matrix multiplication, you need to add the “dot” notation to specify this to Octave. For example, A*B does a matrix multiply, while A.*B does an element-wise multiplication.

Default olarak, Octave matematik operatörlerini matrix operatörü olarak yorumlar.  Bu, uyumsuzluk hatalarının genel bir kaynağıdır.  Eğer matrix çarpımı istemiyorsanız, ‘nokta’ notasyonunu kullanınız.

2 * 2 yarine 2 .* 2   a *b yerine a .* b