<div id="readability-page-1" class="page"><div>
  
  
  <div>
    <p><span>Written by</span>
    
        hackerwins
    

    
      <span>on&nbsp;</span><time datetime="2019-07-29 00:06:00 +0000">July 29, 2019</time></p><p>
      
        
        <a href="/tags/ML"><nobr>ML</nobr></a>&nbsp;
      
        
        <a href="/tags/CS229a"><nobr>CS229a</nobr></a>&nbsp;
      
    </p>
    <br>
  </div>


  <h2 id="gradient-descent-with-large-datasets">Gradient Descent with Large Datasets</h2>

<h2 id="learning-with-large-datasets">Learning with Large Datasets</h2>

<p>One of the reasons that learning algorithms work so much better now than even say, 5-years ago, is just the amount of data that we have now and that we can train our algorithms on. So why do we want to use such large data sets? We’ve already seen that one of the best ways to get a high performance machine learning system, is if you take a low-bias learning algorithm, and train that on a lot of data.</p>

<p>But learning with large data sets comes with its own unique problems, specifically, computational problems. Let’s say your training set size is M equals 100,000,000.</p><p>

\[\theta_j := \theta_j - \alpha \sum_{i=1}^m (h_\theta(x^{(i)})-y^{(i)}) x_j^{(i)}\]

</p><p>You need to carry out a summation over a hundred million terms, in order to compute these derivatives terms and to perform a single step of decent.</p>

<p>Of course, before we put in the effort into training a model with a hundred million examples, We should also ask ourselves, well, why not use just a thousand examples. Suppose you are facing a supervised learning problem and have a very large dataset (m = 100,000,000).</p>

<p><img src="http://hackerwins.github.io/assets/img/2019-07-29-cs229a-week10/learning-with-large-datasets.png" alt="learning-with-large-datasets.png"></p>

<p>How can you tell if using all of the data is likely to perform much better than using a small subset of the data (say m = 1,000)? Plot a learning curve for a range of values of m and verify that the algorithm has high variance when m is small.</p>

<h2 id="stochastic-gradient-descent">Stochastic gradient descent</h2>

<p>When we have a very large training set, gradient descent becomes a computationally very expensive procedure.</p>

<h3 id="batch-gradient-descent">Batch gradient descent</h3>

<p>Hypothesis:</p><p>

\[h_\theta = \sum_{j=0}^n \theta_jx_j\]

</p><p>Cost function:</p><p>

\[J_{train}(\Theta) = \frac{1}{2m}\sum_{i=1}^{m}(h_\Theta(x^{(i)})-y^{(i)})^2\]

</p><p>Gradient descent Repeat(for every j = 0, …, n):</p><p>

\[\theta_j := \theta_j - \alpha \sum_{i=1}^m (h_\theta(x^{(i)})-y^{(i)}) x_j^{(i)}\]

</p><p>If we have hundred million examples ,then computing this derivative term can be very expensive, because the surprise, summing over all m examples. To give the algorithm a name, this particular version of gradient descent is also called <strong>Batch gradient descent</strong>.</p>

<h3 id="stochastic-gradient-descent-1">Stochastic gradient descent</h3>

<p>Cost function:</p><p>

\[cost(\theta,(x^{(i)}, y^{(i)})) = \frac{1}{2}(h_\Theta(x^{(i)})-y^{(i)})^2 \\ J_{train}(\Theta) = \frac{1}{2m}\sum_{i=1}^{m}cost(\theta,(x^{(i)}, y^{(i)}))\]

</p><p>Gradient descent:</p>

<ol>
  <li>Randomly shuffle training examples</li>
  <li>
    <p>Repeat {</p>

    <p>for i := 1, …, m {</p>

\[\theta_j := \theta_j - \alpha (h_\theta(x^{(i)})-y^{(i)}) x_j^{(i)} \\ (\text{for } j = 0, ..., n)\]

    <p>}</p>
  </li>
</ol>

<p>}</p>

<p>Stochastic gradient descent is a lot like descent but rather than wait to sum up these gradient terms over all m training examples, what we’re doing is we’re taking this gradient term using just one single training example and we’re starting to make progress in improving the parameters already.</p>

<p><img src="http://hackerwins.github.io/assets/img/2019-07-29-cs229a-week10/stochastic-gradient-descent.png" alt="stochastic-gradient-descent.png"></p>

<p>As you run Stochastic gradient descent, what you find is that it will generally move the parameters in the direction of the global minimum, but not always. And so take some more random-looking, circuitous path to watch the global minimum. And in fact as you run Stochastic gradient descent it doesn’t actually converge in the same same sense as Batch gradient descent does and what it ends up doing is wandering around continuously in some region that’s in some region close to the global minimum, but it doesn’t just get to the global minimum and stay there. But in practice this isn’t a problem because, you know, so long as the parameters end up in some region there maybe it is pretty close to the global minimum.</p>

<h3 id="mini-batch-gradient-descent">Mini-batch gradient descent</h3>

<ul>
  <li>Batch gradient descent: Use all m examples in each iteration</li>
  <li>Stochastic gradient descent: Use 1 example in each iteration</li>
  <li>Mini-batch gradient descent: Use b examples in each iteration(typical range: 2~100)</li>
</ul>

<p>So we have again data with 300 million training examples, then what we’re saying is after looking at just the first 10 examples we can start to make progress in improving the parameters theta so we don’t need to scan through the entire training set. We just need to look at the first 10 examples and this will start letting us make progress and then we can look at the second ten examples and modify the parameters a little bit again and so on. So, that is why Mini-batch gradient descent can be faster than batch gradient descent.</p>

<p>So, why do we want to look at b examples at a time rather than look at just a single example at a time as the Stochastic gradient descent? The answer is in vectorization. In particular, Mini-batch gradient descent is likely to outperform Stochastic gradient descent only if you have a good vectorized implementation.</p>

<h2 id="stochastic-gradient-descent-convergence">Stochastic Gradient Descent Convergence</h2>

<p>Back when we were using batch gradient descent, our standard way for making sure that gradient descent was converging was we would plot the optimization cost function as a function of the number of iterations. So that was the cost function and we would make sure that this cost function is decreasing on every iteration.</p>

<p>Batch gradient descent:</p>

<ul>
  <li>
    <p>Plot \(J_{train}(\theta)\) as function of the number of iterations of gradient decent</p>

\[J_{train}(\theta) = \frac{1}{2m}\sum_{i=1}^m(h_\theta(x^{(i)})-y^{(i)})^2\]
  </li>
</ul>

<p>Stochastic gradient descent:</p><p>

\[cost(\theta,(x^{(i)},y^{(i)})) = \frac{1}{2}(h_\theta(x^{(i)})-y^{(i)})^2\]

</p><ul>
  <li>During learning, compute \(cost(\theta, (x^{(i)}, y^{(i)}))\) before updating \(\theta\) using \((x^{(i)}, y^{(i)})\).</li>
  <li>Every 1000 iterations (say), plot \(cost(\theta, (x^{(i)}, y^{(i)}))\) averaged over the last 1000 examples processed by algorithm</li>
</ul>

<p><img src="http://hackerwins.github.io/assets/img/2019-07-29-cs229a-week10/stochastic-gradient-descent-convergence.png" alt="stochastic-gradient-descent-convergence.png"></p>

<p>Typically this process of decreasing alpha slowly is usually not done and keeping the learning rate alpha constant is the more common application of stochastic gradient descent although you will see people use either version.</p>

<p><img src="http://hackerwins.github.io/assets/img/2019-07-29-cs229a-week10/stochastic-gradient-descent-decrease-alpha.png" alt="stochastic-gradient-descent-decrease-alpha.png"></p>

<h2 id="advanced-topic">Advanced Topic</h2>

<h2 id="online-learning">Online Learning</h2>

<p>The online learning setting allows us to model problems where we have a continuous flood or a continuous stream of data coming in and we would like an algorithm to learn from that.</p>

<p><img src="http://hackerwins.github.io/assets/img/2019-07-29-cs229a-week10/online-learning.png" alt="online-learning.png"></p>

<p><img src="http://hackerwins.github.io/assets/img/2019-07-29-cs229a-week10/online-learning-2.png" alt="online-learning-2.png"></p>

<h2 id="map-reduce-and-data-parallelism">Map Reduce and Data Parallelism</h2>

<h3 id="map-reduce">Map-reduce</h3>

<p>Batch gradient descent:</p><p>

\[\theta_j := \theta_j - \alpha \frac{1}{400} \sum_{i=1}^{400}(h_\theta(x^{(i)})-y^{(i)})x_j^{(i)}\]

</p><ul>
  <li>
    <p>Machine 1:</p>

\[(x^{(1)}, y^{(1)}), ..., (x^{(100)}, y^{(100)}) \\ temp_j^{(1)} = \sum_{i=1}^{100} (h_\theta(x^{(i)})-y^{(i)})x_j^{(i)}\]
  </li>
  <li>
    <p>Machine 2:</p>

\[(x^{(101)}, y^{(101)}), ..., (x^{(200)}, y^{(200)}) \\ temp_j^{(2)} = \sum_{i=101}^{200} (h_\theta(x^{(i)})-y^{(i)})x_j^{(i)}\]
  </li>
  <li>
    <p>Machine 3:</p>
  </li>
</ul><p>

\[(x^{(201)}, y^{(201)}), ..., (x^{(300)}, y^{(300)}) \\ temp_j^{(3)} = \sum_{i=201}^{300} (h_\theta(x^{(i)})-y^{(i)})x_j^{(i)}\]

</p><ul>
  <li>Machine 4:</li>
</ul><p>

\[(x^{(301)}, y^{(301)}), ..., (x^{(400)}, y^{(400)}) \\ temp_j^{(4)} = \sum_{i=301}^{400} (h_\theta(x^{(i)})-y^{(i)})x_j^{(i)}\]

</p><p>Combine temp:</p><p>

\[\theta_j := \theta_j - \alpha \frac{1}{400}(temp_j^{(1)} + temp_j^{(2)} + temp_j^{(3)} + temp_j^{(4)})\]

</p><p><img src="http://hackerwins.github.io/assets/img/2019-07-29-cs229a-week10/map-reduce.png" alt="map-reduce.png"></p>

<h3 id="map-reduce-and-summation-over-the-training-set">Map-reduce and summation over the training set</h3>

<p><img src="http://hackerwins.github.io/assets/img/2019-07-29-cs229a-week10/map-reduce-over-training-set.png" alt="map-reduce-over-training-set.png"></p>

<p>Compute forward propagation and back propagation on 1/n of the data to compute the derivative with respect to that 1/n of the data.</p>

<p>More broadly, by taking other learning algorithms and expressing them in sort of summation form or by expressing them in terms of computing sums of functions over the training set, you can use the MapReduce technique to parallelize other learning algorithms as well, and scale them to very large training sets.</p>

<p>Sometimes you can just implement you standard learning algorithm in a vectorized fashion and not worry about parallelization and numerical linear algebra libraries could take care of some of it for you.</p>


</div></div>

hackerwins blog

Youngteac Hong

Gradient Descent with Large Datasets
Learning with Large Datasets
One of the reasons that learning algorithms work so much better now than even say, 5-years ago, is just the amount of data that we have now and that we can train our algorithms on. So why do we want to use such large data sets? We’ve already seen that one of the best ways to get a high performance machine learning system, is if you take a low-bias learning algorithm, and train that on a lot of data.
But learning with large data sets comes with its own unique problems, specifically, computational problems. Let’s say your training set size is M equals 100,000,000.
You need to carry out a summation over a hundred million terms, in order to compute these derivatives terms and to perform a single step of decent.
Of course, before we put in the effort into training a model with a hundred million examples, We should also ask ourselves, well, why not use just a thousand examples. Suppose you are facing a supervised learning problem and have a very large dataset (m = 100,000,000).
How can you tell if using all of the data is likely to perform much better than using a small subset of the data (say m = 1,000)? Plot a learning curve for a range of values of m and verify that the algorithm has high variance when m is small.
Stochastic gradient descent
When we have a very large training set, gradient descent becomes a computationally very expensive procedure.
Batch gradient descent
Hypothesis:
Cost function:
Gradient descent Repeat(for every j = 0, …, n):
If we have hundred million examples ,then computing this derivative term can be very expensive, because the surprise, summing over all m examples. To give the algorithm a name, this particular version of gradient descent is also called Batch gradient descent.
Stochastic gradient descent
Cost function:
Gradient descent:
Randomly shuffle training examples
Repeat {
for i := 1, …, m {
}
  
}
Stochastic gradient descent is a lot like descent but rather than wait to sum up these gradient terms over all m training examples, what we’re doing is we’re taking this gradient term using just one single training example and we’re starting to make progress in improving the parameters already.
As you run Stochastic gradient descent, what you find is that it will generally move the parameters in the direction of the global minimum, but not always. And so take some more random-looking, circuitous path to watch the global minimum. And in fact as you run Stochastic gradient descent it doesn’t actually converge in the same same sense as Batch gradient descent does and what it ends up doing is wandering around continuously in some region that’s in some region close to the global minimum, but it doesn’t just get to the global minimum and stay there. But in practice this isn’t a problem because, you know, so long as the parameters end up in some region there maybe it is pretty close to the global minimum.
Mini-batch gradient descent
Batch gradient descent: Use all m examples in each iteration
Stochastic gradient descent: Use 1 example in each iteration
Mini-batch gradient descent: Use b examples in each iteration(typical range: 2~100)
So we have again data with 300 million training examples, then what we’re saying is after looking at just the first 10 examples we can start to make progress in improving the parameters theta so we don’t need to scan through the entire training set. We just need to look at the first 10 examples and this will start letting us make progress and then we can look at the second ten examples and modify the parameters a little bit again and so on. So, that is why Mini-batch gradient descent can be faster than batch gradient descent.
So, why do we want to look at b examples at a time rather than look at just a single example at a time as the Stochastic gradient descent? The answer is in vectorization. In particular, Mini-batch gradient descent is likely to outperform Stochastic gradient descent only if you have a good vectorized implementation.
Stochastic Gradient Descent Convergence
Back when we were using batch gradient descent, our standard way for making sure that gradient descent was converging was we would plot the optimization cost function as a function of the number of iterations. So that was the cost function and we would make sure that this cost function is decreasing on every iteration.
Batch gradient descent:
Plot \(J_{train}(\theta)\) as function of the number of iterations of gradient decent
Stochastic gradient descent:
During learning, compute \(cost(\theta, (x^{(i)}, y^{(i)}))\) before updating \(\theta\) using \((x^{(i)}, y^{(i)})\).
Every 1000 iterations (say), plot \(cost(\theta, (x^{(i)}, y^{(i)}))\) averaged over the last 1000 examples processed by algorithm
Typically this process of decreasing alpha slowly is usually not done and keeping the learning rate alpha constant is the more common application of stochastic gradient descent although you will see people use either version.
Advanced Topic
Online Learning
The online learning setting allows us to model problems where we have a continuous flood or a continuous stream of data coming in and we would like an algorithm to learn from that.
Map Reduce and Data Parallelism
Map-reduce
Batch gradient descent:
Machine 1:
Machine 2:
Machine 3:
Machine 4:
Combine temp:
Map-reduce and summation over the training set
Compute forward propagation and back propagation on 1/n of the data to compute the derivative with respect to that 1/n of the data.
More broadly, by taking other learning algorithms and expressing them in sort of summation form or by expressing them in terms of computing sums of functions over the training set, you can use the MapReduce technique to parallelize other learning algorithms as well, and scale them to very large training sets.
Sometimes you can just implement you standard learning algorithm in a vectorized fashion and not worry about parallelization and numerical linear algebra libraries could take care of some of it for you.

CS229a - Week 10

댓글