<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Llion Jones on Medium]]></title>
        <description><![CDATA[Stories by Llion Jones on Medium]]></description>
        <link>https://medium.com/@llionj?source=rss-a3ad3e75263b------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*EZU65W4ZpmNM_UNm.</url>
            <title>Stories by Llion Jones on Medium</title>
            <link>https://medium.com/@llionj?source=rss-a3ad3e75263b------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 21:47:53 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@llionj/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[The Reparameterization “Trick”]]></title>
            <link>https://medium.com/@llionj/the-reparameterization-trick-4ff30fe92954?source=rss-a3ad3e75263b------2</link>
            <guid isPermaLink="false">https://medium.com/p/4ff30fe92954</guid>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[tensorflow]]></category>
            <dc:creator><![CDATA[Llion Jones]]></dc:creator>
            <pubDate>Mon, 01 May 2017 06:08:54 GMT</pubDate>
            <atom:updated>2019-06-13T06:12:27.958Z</atom:updated>
            <content:encoded><![CDATA[<h4>As Simple as Possible in TensorFlow</h4><p>A worrying pattern I see when trying to learn about new machine learning concepts is that I will search the internet and be immediately drowned in maths, and walk off being none the wiser. Sometime later, someone will explain it to me or I have an ‘a-ha’ moment and mutter to myself “OoooooH! Why didn’t they just <strong><em>SAY</em></strong> that then?”. I think this is what my articles are going to be about: me explaining things in the way I wished they had been explained to me when I was first trying to learn about the subject. As I explained last time, I personally need concrete examples of an idea applied to a simple version of the problem for things to sink in.</p><p>The reparameterization trick is a perfect example: a basic idea which is often made overly complicated. For instance, look at these <a href="http://stats.stackexchange.com/questions/199605/how-does-the-reparameterization-trick-for-vaes-work-and-why-is-it-important">stack exchange answers</a>, the top Google result for “reparameterization trick”. Did that help? Did we really <em>need</em> equations full of probabilities and integrals, or images of computational graphs full of calculus to explain the idea?!</p><p>So here is it. I am going to show you a concrete example of the reparameterization trick in less than 20 lines of TensorFlow and zero equations, as concise as I could make it. We are going to look at an extremely simple model to learn what the reparametrization is.</p><p>Let’s get started.</p><pre>import tensorflow as tf</pre><p>The model is going to transmit a single real number over a noisy channel. To simulate gaussian noise, the output of the model will be sampled from a gaussian around the input. The only parameter of the model will be the standard deviation of this gaussian.</p><p>So here’s the model, and the loss.</p><pre>delta = tf.get_variable(&#39;delta&#39;, initializer=1.)  # Our only param<br>x = tf.random_uniform((), -1., 1.)  # Input<br>y = tf.random_normal((), mean=x, stddev=delta)  # Output</pre><pre>loss = tf.losses.mean_squared_error(y, x)</pre><p>Now, clearly, if we are optimizing for accuracy when transmitting this real number to the output then the standard deviation of the gaussian should be low, right? That’s another way of saying that the noise should be low. Meaning that the output number is likely to be close to input number, which is what we are optimizing for. Let’s see if we can learn to do this using just pure back propagation. Let’s optimize it:</p><pre>apply_update = tf.train.GradientDescentOptimizer(0.1).minimize(loss)</pre><pre>---------------------------------------------------------------------------<br>ValueError                                Traceback (most recent call last)<br>&lt;ipython-input-4-adda79011a87&gt; in &lt;module&gt;()<br>----&gt; 1 apply_update = tf.train.GradientDescentOptimizer(0.1).minimize(y)<br><br>/usr/local/lib/python2.7/dist-packages/tensorflow/python/training/optimizer.pyc in minimize(self, loss, global_step, var_list, gate_gradients, aggregation_method, colocate_gradients_with_ops, name, grad_loss)<br>    293           &quot;No gradients provided for any variable, check your graph for ops&quot;<br>    294           &quot; that do not support gradients, between variables %s and loss %s.&quot; %<br>--&gt; 295           ([str(v) for _, v in grads_and_vars], loss))<br>    296 <br>    297     return self.apply_gradients(grads_and_vars, global_step=global_step,<br><br>ValueError: No gradients provided for any variable, check your graph for ops that do not support gradients, between variables [&#39;Tensor(&quot;delta/read:0&quot;, shape=(), dtype=float32)&#39;] and loss Tensor(&quot;mean_squared_error/value:0&quot;, shape=(), dtype=float32).</pre><p>Oh no! We have a problem, this doesn’t work, we don’t have any gradients! The specific problem here is that we can’t backpropagate through therandom_normal function. This makes sense right? We are trying to back propagate through a random/stochastic node in the computational graph. It doesn’t make much sense to differentiate in terms of a stochastic node since that means the gradient would technically be a random variable too! What is the gradient of a value that might have been different?</p><p>So let’s … reparametrize! That is, let’s change how the parameters are incorporated into the model. Since random_normal does not have gradients, we simply move the parameters <em>outside</em> of the function:</p><pre>delta = tf.get_variable(&#39;delta&#39;, initializer=1.)<br>x = tf.random_uniform((), -1., 1.)<br>y = <strong>x + </strong>tf.random_normal((), mean=<strong>0.</strong>, stddev=<strong>1.</strong>) <strong>* delta</strong></pre><pre>loss = tf.losses.mean_squared_error(y, x)</pre><p>And <em>that’s it</em>, seriously, <em>that’s it</em>, that’s the Reparameterization Trick! Applied to this specific example at least. We have moved the all the parameters out of the normal distribution, but this does not change the behaviour of our model. For example, adding <strong>x</strong> to a zero centered (zero mean) gaussian is the same as having a gaussian centered at <strong>x</strong>. Now, the gradients don’t need to flow <em>through</em> the random_normal function, since it has no learnable parameters, nor any variable inputs from the rest of the graph. No gradient calculations need to go through this stochastic node so now our model has well defined gradients.</p><p>Let’s try again:</p><pre>apply_update = tf.train.GradientDescentOptimizer(0.1).minimize(loss)</pre><pre>sess = tf.InteractiveSession()<br>sess.run(tf.global_variables_initializer())<br>for _ in range(100):<br>    sess.run(apply_update)<br>print(sess.run(loss))</pre><pre>&gt; 1.08802e-14</pre><p>Success! Our model now learns to make the delta small to reduce the noisiness of the channel to achieve a low loss.</p><pre>sess.run(delta)<br>&gt; 3.461055e-06</pre><p>OK, actually, please forgive me, I lied, for pedagogical reasons. I don’t know what version of TensorFlow they did this in, but the clever folks at Google have actually made random_normal differentiable.</p><pre>out = tf.random_normal((), mean=x, stddev=delta)</pre><p>Works perfectly well… but that rather ruined my story didn’t it! They’ve already reparameterized this function.</p><h3>The Maths Bit</h3><p>Now, that is not the whole story of course. This is the trick applied to a specific simple example. Nevertheless, what I showed you above <em>is </em>the essential idea behind the trick and now you can build on this foundation. You should now be able to tease out this idea from the <a href="http://stats.stackexchange.com/questions/199605/how-does-the-reparameterization-trick-for-vaes-work-and-why-is-it-important">stack exchange answers</a> to get a deeper understanding. But there are other motivations, from a mathematical point of view, as explained there.</p><p>You could stop reading now and leave knowing the basic idea behind the trick, but before I go I want to generalize the idea a bit by showing you what we did above from a mathematical point of view. So, I guess I lied about the equations too…</p><p>What we created above was a <em>probabilistic </em>model. That is, unlike vanilla neural networks, the output of the network is non-deterministic, the output will be different every time we run it. This means that we can no longer just blindly apply gradient descent to the model, and why the initial version of the code above <em>(should have)</em> failed. The reason for this should be clear, the gradient of a model is ‘how the output changes when we change the parameters’, but here we have a model where the output is different whenever we run the model, even if we don’t change the parameters!</p><p>So let’s take another look at the model. The output of the model is described by normal distribution, where 𝓍 is our input and 𝜎 is our standard deviation parameter:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/192/1*83FS15bRToKeLY3wn_R_Kw.gif" /><figcaption>Output of the model</figcaption></figure><p>As mentioned we can’t optimize against this directly, so what we do instead is to try to optimize the most probable output of the model, or what is also known the the expectation.</p><p>Now, the problem is that in most cases we can’t calculate the expectation efficiently in most models (we can in our model since it’s so simple, the expectation of a normal distribution is its mean by definition, which is the input in our case). Therefore we need a way to approximate it. The simplest way of doing this is just taking a lot of samples, you can imagine running the model several times and then just averaging the outputs. The more samples we take, the closer the average will be to the true expected output.</p><p>So how many samples to we need? The more the better but in practice people usually just do <strong>one</strong>!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/288/1*7Awg0jMGbQz6zPvthck7rA.gif" /></figure><p>Which is exactly what we effectively did in the model above. So our loss was</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/175/1*pL1C0t25ShgSJxXw177yPA.gif" /></figure><p>Another way of thinking about it is that we have moved the source of noise outside of the main flow of the network and used the noise as a way to sample from the expectation.</p><p>You should now have an understanding of the basic idea behind the trick and how it applies to probabilistic models. A nice way to build on it might be to go learn about Variational Auto-Encoders (VAEs), which is an example of where this trick is applied in practice.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4ff30fe92954" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Learning to Learn by Gradient Descent by Gradient Descent]]></title>
            <link>https://medium.com/hackernoon/learning-to-learn-by-gradient-descent-by-gradient-descent-4da2273d64f2?source=rss-a3ad3e75263b------2</link>
            <guid isPermaLink="false">https://medium.com/p/4da2273d64f2</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[tensorflow]]></category>
            <dc:creator><![CDATA[Llion Jones]]></dc:creator>
            <pubDate>Sun, 09 Apr 2017 02:11:10 GMT</pubDate>
            <atom:updated>2019-05-22T10:47:57.664Z</atom:updated>
            <content:encoded><![CDATA[<h4>As simple as possible in TensorFlow</h4><p>When I first came across DeepMind’s paper “<a href="https://arxiv.org/abs/1606.04474">Learning to learn by gradient descent by gradient descent</a>”, my reaction was “Wow, how on earth does that work?”. Unfortunately, my first read-through of the paper was not that illuminating, and looking at the <a href="https://github.com/deepmind/learning-to-learn">code</a> was quite daunting.</p><p>Thankfully, I was intrigued enough to force myself to re-read the paper in depth and it actually turned out to be surprisingly simple in the end. Personally, what really helps me when I’m trying to understand something is to create the simplest non-trivial version of the problem and then scale up from there. So here it is, the simplest version of the idea I could create, also <em>no maths equations!</em> I hope you find it illuminating.</p><p>I suggest skimming the paper first but this should all be understandable without.</p><p>The <a href="https://hackernoon.com/tagged/ipython">IPython</a> <a href="https://hackernoon.com/tagged/notebook">Notebook</a> version of this article with syntax highlighting can be found <a href="https://github.com/LlionJ/blog/blob/master/blog/Meta-Learning.ipynb">here</a>. Code was ran on TF v1.0.0-rc1.</p><p>So let’s get started. Time to learn about learning to learn by gradient descent by gradient descent by reading my article!</p><pre>import tensorflow as tf</pre><p>First of all we need a problem for our meta-learning optimizer to solve. Let’s take the simplest experiment from the paper; finding the minimum of a multi-dimensional quadratic function. We are going to randomly scale the parabolas and start at random locations, the solution is always at (0, 0).</p><pre>DIMS = 10  # Dimensions of the parabola</pre><pre>scale = tf.random_uniform([DIMS], 0.5, 1.5)</pre><pre># This represents the network/function we are trying to optimize,<br># the `optimizee&#39; as it&#39;s called in the paper.<br># Actually, it&#39;s more accurate to think of this as the error<br># landscape.<br>def f(x):<br>    x = scale*x<br>    return tf.reduce_sum(x*x)</pre><p>We can’t easily use TensorFlow’s built in optimizers here since the technique requires us to <em>unroll the training loop inside the computation graph</em>, as we’ll see in a bit. So let’s define a couple of simple hand crafted optimizers to test against our learned optimizer. As discussed in the paper, an optimizer is a function <em>g</em> that takes the gradient of a parameter at a given step and returns back the step you should take in parameter space for that parameter. Here’s vanilla gradient descent: (Some optimizers need to keep track of state, here I just pass the param through)</p><pre>def g_sgd(gradients, state, learning_rate=0.1):<br>    return -learning_rate*gradients, state</pre><p>For a stronger baseline let’s use RMSProp:</p><pre>def g_rms(gradients, state, learning_rate=0.1, decay_rate=0.99):<br>    if state is None:<br>        state = tf.zeros(DIMS)<br>    state = decay_rate*state + (1-decay_rate)*tf.pow(gradients, 2)<br>    update = -learning_rate*gradients / (tf.sqrt(state)+1e-5)<br>    return update, state</pre><p>Great, now let’s unroll all the training steps, here <em>learn</em> is a function which takes one of these optimizers and applies it in a loop for number of steps and collects the value of the function <em>f</em> at each point, which we can think of as our loss.</p><pre>TRAINING_STEPS = 20  # This is 100 in the paper</pre><pre>initial_pos = tf.random_uniform([DIMS], -1., 1.)</pre><pre>def learn(optimizer):<br>    losses = []<br>    x = initial_pos<br>    state = None<br>    for _ in range(TRAINING_STEPS):<br>        loss = f(x)<br>        losses.append(loss)<br>        grads, = tf.gradients(loss, x)<br>      <br>        update, state = optimizer(grads, state)<br>        x += update<br>    return losses</pre><p>OK, now let’s test it out.</p><pre>sgd_losses = learn(g_sgd)<br>rms_losses = learn(g_rms)</pre><p>And see what the losses look like.</p><pre>sess = tf.InteractiveSession()<br>sess.run(tf.global_variables_initializer())</pre><pre>import matplotlib<br>import matplotlib.pyplot as plt<br>%matplotlib inline<br>import numpy as np</pre><pre>x = np.arange(TRAINING_STEPS)<br>for _ in range(3): <br>    sgd_l, rms_l = sess.run([sgd_losses, rms_losses])<br>    p1, = plt.plot(x, sgd_l, label=&#39;SGD&#39;)<br>    p2, = plt.plot(x, rms_l, label=&#39;RMS&#39;)<br>    plt.legend(handles=[p1, p2])<br>    plt.title(&#39;Losses&#39;)<br>    plt.show()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/521/1*wlxKOOLQfKrrIDcvVRrk7Q.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/508/1*-F1Im3igGT_jP5rhhvWMfg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/508/1*A_OhBAucKt1aRsyLsnEppQ.png" /></figure><p>RMS Prop outperforms vanilla gradient descent here as expected. Note that nothing out of the ordinary has happened so far, I’ve simply hand rolled my own optimizers and unrolled the entire training into a single computational graph, which is generally not recommended since you would very quickly run out of memory!</p><h4>Meta-Learning</h4><p>Time to put together our meta-learning optimizer, we are going to use the same architecture as in the paper: an LSTM with 2 layers and 20 hidden units.</p><pre>LAYERS = 2<br>STATE_SIZE = 20</pre><pre>cell = tf.contrib.rnn.MultiRNNCell(<br>    [tf.contrib.rnn.LSTMCell(STATE_SIZE) for _ in range(LAYERS)])<br>cell = tf.contrib.rnn.InputProjectionWrapper(cell, STATE_SIZE)<br>cell = tf.contrib.rnn.OutputProjectionWrapper(cell, 1)<br>cell = tf.make_template(&#39;cell&#39;, cell)</pre><pre>def g_rnn(gradients, state):<br>    # Make a `batch&#39; of single gradients to create a <br>    # &quot;coordinate-wise&quot; RNN as the paper describes. <br>    gradients = tf.expand_dims(gradients, axis=1)<br> <br>    if state is None:<br>        state = [[tf.zeros([DIMS, STATE_SIZE])] * 2] * LAYERS<br>    update, state = cell(gradients, state)<br>    # Squeeze to make it a single batch again.<br>    return tf.squeeze(update, axis=[1]), state</pre><p>And <em>that’s it</em>, that’s our meta learner. We can use it in exactly the same way:</p><pre>rnn_losses = learn(g_rnn)<br>sum_losses = tf.reduce_sum(rnn_losses)</pre><blockquote>Now here’s the magic bit, we want <em>sum_losses </em>to be low, since the lower the losses, the better the optimizer right? And because the entire training loop is in the graph we can use Back-Propagation Through Time (BPTT) and a meta-optimizer to minimize this value!</blockquote><p>And this is the main point: <em>sum_losses is differentiable</em>, gradients flow through the graph we’ve defined just fine! TensorFlow is able to work out the gradients of the parameters in our LSTM with respect to this sum of losses. So let’s optimize:</p><pre>def optimize(loss):<br>    optimizer = tf.train.AdamOptimizer(0.0001)<br>    gradients, v = zip(*optimizer.compute_gradients(loss))<br>    gradients, _ = tf.clip_by_global_norm(gradients, 1.)<br>    return optimizer.apply_gradients(zip(gradients, v))</pre><pre>apply_update = optimize(sum_losses)</pre><p>I found gradient clipping to be <em>critical</em> here since the values that go into our meta-learner can be very large at the start of training.</p><pre>sess.run(tf.global_variables_initializer())</pre><pre>ave = 0<br>for i in range(3000):<br>    err, _ = sess.run([sum_losses, apply_update])<br>    ave += err<br>    if i % 1000 == 0:<br>        print(ave / 1000 if i!=0 else ave)<br>        ave = 0<br>print(ave / 1000)</pre><pre>&gt; 223.577606201<br>&gt; 15.9170453466<br>&gt; 4.06150362206<br>&gt; 3.94412120444</pre><p>And see how it does:</p><pre>for _ in range(3): <br>    sgd_l, rms_l, rnn_l = sess.run(<br>        [sgd_losses, rms_losses, rnn_losses])<br>    p1, = plt.plot(x, sgd_l, label=&#39;SGD&#39;)<br>    p2, = plt.plot(x, rms_l, label=&#39;RMS&#39;)<br>    p3, = plt.plot(x, rnn_l, label=&#39;RNN&#39;)<br>    plt.legend(handles=[p1, p2, p3])<br>    plt.title(&#39;Losses&#39;)<br>    plt.show()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/508/1*k8fB4Z5-cVrBNnkxt7UAeA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/508/1*ZSoxtaIQa24h4ZaaX0FK_g.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/521/1*AWwEXN3ymWvD9jMHZavxgw.png" /></figure><p>Success! Looks like it’s doing even better than RMS on this problem. Actually, these graphs are slightly misleading, log scale shows something slightly different:</p><pre>for _ in range(3): <br>    sgd_l, rms_l, rnn_l = sess.run(<br>        [sgd_losses, rms_losses, rnn_losses])<br>    p1, = plt.semilogy(x, sgd_l, label=&#39;SGD&#39;)<br>    p2, = plt.semilogy(x, rms_l, label=&#39;RMS&#39;)<br>    p3, = plt.semilogy(x, rnn_l, label=&#39;RNN&#39;)<br>    plt.legend(handles=[p1, p2, p3])<br>    plt.title(&#39;Losses&#39;)<br>    plt.show()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/534/1*DRfhGLwSEaywl55sxrYUKg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/534/1*iJTXBnEWmuWog5qGQJ57Ng.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/534/1*6Fk3_X2eHMBmldWCZHIlzQ.png" /></figure><p>I think the reason for this, again as discussed in the paper, is that the magnitude of the values being fed into the LSTM can vary wildly and neural networks generally do not perform well when that happens. Here the gradients get so small that it isn’t able to compute sensible updates. The paper uses a solution to this for the bigger experiments; feed in the log gradient and the direction instead. See the paper for details.</p><p>Hopefully, now that you understand how learn to learn by gradient descent by gradient descent you can see the limitations. It doesn’t seem very scalable. I think it is quite telling that the experiments in the paper are very small. It takes 4000 steps for even our toy problem to converge, we had to train a network completely just for one step of optimization for the meta-learner. We would have to optimize a large problem many more times and would take a very long time. Also unrolling the entire training loop in the graph is not feasible for larger problems, although in the paper they only unroll the BPTT to 20 steps. There is also evidence in the paper that the RNN optimizer can generalize from smaller problem to larger problems.</p><p>I have left a lot of details out for simplicity, so reading the paper is worth it for sure. I expect meta-learning to become increasingly more important, for more inspiration I suggest watching <a href="https://www.youtube.com/watch?v=0YLpp_TVhLY&amp;list=PLPwzH56Rdmq4hcuEMtvBGxUrcQ4cAkoSc">these NIPS presentations</a>.</p><figure><a href="http://bit.ly/HackernoonFB"><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0hqOaABQ7XGPT-OYNgiUBg.png" /></a></figure><figure><a href="https://goo.gl/k7XYbx"><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Vgw1jkA6hgnvwzTsfMlnpg.png" /></a></figure><figure><a href="https://goo.gl/4ofytp"><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gKBpq1ruUi0FVK2UM_I4tQ.png" /></a></figure><blockquote><a href="http://bit.ly/Hackernoon">Hacker Noon</a> is how hackers start their afternoons. We’re a part of the <a href="http://bit.ly/atAMIatAMI">@AMI</a> family. We are now <a href="http://bit.ly/hackernoonsubmission">accepting submissions</a> and happy to <a href="/service/mailto:partners@amipublications.com">discuss advertising &amp; sponsorship</a> opportunities.</blockquote><blockquote>If you enjoyed this story, we recommend reading our <a href="http://bit.ly/hackernoonlatestt">latest tech stories</a> and <a href="https://hackernoon.com/trending">trending tech stories</a>. Until next time, don’t take the realities of the world for granted!</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*35tCjoPcvq6LbB3I6Wegqw.jpeg" /></figure><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fupscri.be%2Fdde502%3Fas_embed%3Dtrue&amp;dntp=1&amp;url=https%3A%2F%2Fupscri.be%2Fhackernoon%2F&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=upscri" width="800" height="400" frameborder="0" scrolling="no"><a href="https://medium.com/media/3c851dac986ab6dbb2d1aaa91205a8eb/href">https://medium.com/media/3c851dac986ab6dbb2d1aaa91205a8eb/href</a></iframe><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4da2273d64f2" width="1" height="1" alt=""><hr><p><a href="https://medium.com/hackernoon/learning-to-learn-by-gradient-descent-by-gradient-descent-4da2273d64f2">Learning to Learn by Gradient Descent by Gradient Descent</a> was originally published in <a href="https://medium.com/hackernoon">HackerNoon.com</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>