My Blog Posts, in Reverse Chronological Order
subscribe via RSS
Going Deeper Into Reinforcement Learning: Understanding DeepQNetworks
The Deep QNetwork (DQN) algorithm, as introduced by DeepMind in a NIPS 2013 workshop paper, and later published in Nature 2015 can be credited with revolutionizing reinforcement learning. In this post, therefore, I would like to give a guide to a subset of the DQN algorithm. This is a continuation of an earlier reinforcement learning article about linear function approximators. My contribution here will be orthogonal to my previous post about the preprocessing steps for game frames.
Before I proceed, I should mention upfront that there are already a lot of great blog posts and guides that people have written about DQN. Here are the prominent ones I was able to find and read:
 Denny Britz’s notes and implementation of DQN and DoubleDQN. I have not read the code yet, but I imagine this will be my secondfavorite DQN implementation aside from spragnur’s version.
 Nervana’s “Demystifying Deep Reinforcement Learning, by Tambet Matiisen. This has a useful figure to show intuition on why we want the network to take only the state as input (not the action), and an intuitive argument as to why we don’t want pooling layers with Atari games (as opposed to object recognition tasks).
 Ben Lau’s post on using DQN to play FlappyBird. The part on DQN might be useful. I won’t need to use his code.
 A post from Machine Learning for Artists (huh, interesting) with some source code and corresponding descriptions.
 A long post from Ruben Fiszel, which also covers some of the major extensions of DQN. I will try to write more details on those papers in future blog posts, particularly A3C.
 A post from Arthur Juliani, who also mentions the target network and DoubleDQN.
I will not try to repeat what these great folks have already done. Here, I focus specifically on the aspect of DQN that was the most challenging for me to understand,^{1} which was about how the loss function works. I draw upon the posts above to aid me in this process.
In general, to optimize any function which is complicated, has highdimensional parameters and highdimensional data points, one needs to use an algorithm such as stochastic gradient descent which relies on sampling and then approximating the gradient step . The key to understanding DQN is to understand how we characterize the loss function.
Recall from basic reinforcement learning that the optimal Qvalue is defined from the Bellman optimality conditions:
But is this the definition of a Qvalue (i.e. a value)?
NOPE!
This is something I had to think carefully before it finally hit home to me, and I think it’s crucial to understanding Qvalues. When we refer to , all we are referring to is some arbitrary value. We might pull that value out of a table (i.e. tabular QLearning), or it might be determined based on a linear or neural network function approximator. In the latter case, it’s better to write it as . (I actually prefer writing it as but the DeepMind papers use the other notation, so for the rest of this post, I will use their notation.)
Our GOAL is to get it to satisfy the Bellman optimality criteria, which I’ve written above. If we have “adjusted” our function value so that for all input pairings, it satisfies the Bellman requirements, then we rewrite the function as with the asterisk.
Let’s now define a loss function. We need to do this so that we can perform stochastic gradient descent, which will perform the desired “adjustment” to . What do we want? Given a stateaction pair , the target will be the Bellman optimality condition. We will use the standard squared error loss. Thus, we write the loss as:
But we’re not quite done, right? This is for a specific pair. We want the to be close to the “Bellman” value across all such pairs. Therefore, we take expectations. Here’s the tricky part: we need to take expectations with respect to samples , so we have to consider a “fourtuple”, instead of a tuple, because the target (Bellman) depends on and . The loss function becomes:
Note that I have now added the parameter . However, this actually includes the tabular case. Why? Suppose we have two states and three actions. Thus, the total table size is six, with elements indexed by: . Now let’s define a sixdimensional vector . We will decide to encode each of the six values into one component of the vector. Thus, . In other words, we parameterize the arbitrary function by , and we directly look at to get the Qvalues! Think about how this differs from the linear approximation case I discussed in my last post. Instead of corresponding to one element in the parameter vector , it turns out to be a linear combination of the full along with a stateaction dependent vector .
With the above intuition in mind, we can perform stochastic gradient descent to minimize the loss function. It is over expectations of all samples. Intuitively, we can think of it as a function of an infinite amount of such samples. In practice, though, to approximate the expectation, we can take a finite amount of samples and use that to form the gradient updater.
We can continue with this logic until we get to the smallest possible update case, involving just one sample. What does the update look like? With one sample, we have approximated the loss as:
I have substituted , a single element in , since we assume the tabular case for now. I didn’t do that for the target, since for the purpose of the Bellman optimality condition, we assume it is fixed for now. Since there’s only one component of “visible” in the loss function, the gradient for all components^{2} other than is zero. Hence, the gradient update is:
Guess what? This is exactly the standard tabular QLearning update taught in reinforcement learning courses! I wrote the same exact thing in my MDP/RL review last year. Here it is, reproduced below:
Let’s switch gears to the DQN case, so we express with the implicit assumption that represents neural network weights. In the Nature paper, they express the loss function as:
(I added in an extra that they were missing, and note that their .)
This looks very similar to the loss function I had before. Let’s deconstruct the differences:

The samples come from , which is assumed to be an experience replay history. This helps to break correlation among the samples. Remark: it’s important to know the purpose of experience replay, but nowadays it’s probably out of fashion since the A3C algorithm runs learners in parallel and thus avoids sample correlation across threads.

Aside from the fact that we’re using neural networks instead of a tabular parameterization, the weights used for the target versus the current (presumably nonoptimal) Qvalue are different. At iteration , we assume we have some giant weight vector representing all of the neural network weights. We do not, however, use that same vector to parameterize the network. We fix the targets with the previous weight vector .
These two differences are mentioned in the Nature paper in the following text on the first page:
We address these instabilities with a novel variant of Qlearning, which uses two key ideas. […]
I want to elaborate on the second point in more detail, as I was confused by it for a while. Think back to my tabular QLearning example in this post. The target was parameterized using . When I perform an update using SGD, I updated . If this turns out to be the same component as , then this will automatically update the target. Think of the successor state as being equal to the current state. And, again, during the gradient update, the target was assumed fixed, which is why I did not rewrite into a component of ; it’s as if we are “drawing” the value from the table once for the purposes of computing the target, so the value is ignored when we do the gradient computation. After the gradient update, the value may be different.
DeepMind decided to do it a different way. Instead, we have to fix the weights for some number of iterations, and then allow the samples to accumulate. The argument for why this works is a bit handwavy and I’m not sure if there exists any rigorous mathematical justification. The DeepMind paper says that this reduces correlations with the target. This is definitely different from the tabular case I just described, where one update immediately modifies targets. If I wanted to make my tabular case the same as DeepMind’s scenario, I would update the weights the normal way, but I would also fix the vector , so that when computing targets only, I would draw from instead of the current .
You can see explanations about DeepMind’s special use of the target network that others have written. Denny Britz argues that it leads to more stable training:
Trick 2  Target Network: Use a separate network to estimate the TD target. This target network has the same architecture as the function approximator but with frozen parameters. Every T steps (a hyperparameter) the parameters from the Q network are copied to the target network. This leads to more stable training because it keeps the target function fixed (for a while).
Arthur Juliani uses a similar line of reasoning:
Why not use just use one network for both estimations? The issue is that at every step of training, the Qnetwork’s values shift, and if we are using a constantly shifting set of values to adjust our network values, then the value estimations can easily spiral out of control. The network can become destabilized by falling into feedback loops between the target and estimated Qvalues. In order to mitigate that risk, the target network’s weights are fixed, and only periodically or slowly updated to the primary Qnetworks values. In this way training can proceed in a more stable manner.
I want to wrap up by doing some slight investigation of spragnur’s DQN code which relate to the points above about the target network. (The neural network portion in his code is written using the Theano and Lasagne libraries, which by themselves have some learning curve; I will not elaborate on these as that is beyond the scope of this blog post.) Here are three critical parts of the code to understand:

The
q_network.py
script contains the code for managing the networks. Professor Sprague uses a shared Theano variable to manage the input to the network, calledself.imgs_shared
. What’s key is that he has to make the dimension , where (just like in my last post). So why the +1? This is needed so that he can produce the Qvalues for in the loss function, which uses the successor state rather than the current state (not to mention the previous weights as well!). The Nervana blog post I listed made this distinction, saying that a separate forward pass is needed to compute values for the successor states. By wrapping everything together into one shared variable, spragnur’s code efficiently utilizes memory.Here’s the corresponding code segment:

On a related note, the “variable”
q_vals
contains the Qvalues for the current minibatch, whilenext_q_vals
contains the Qvalues for the successor states. Since the minibatches used in the default setting are dimensional numpy arrays, bothq_vals
andnext_q_vals
can be thought of as arrays with 32 values each. In both cases, they are computed by callinglasagne.layers.get_output
, which has an intuitive name.The code separates the
next_q_vals
cases based on aself.freeze_interval
parameter, which is 1 and 10000 for the NIPS and Nature versions, respectively. For the NIPS version, spragnur uses thedisconnected_grad
function, meaning that the expression is not computed in the gradient. I believe this is similar to what I did before with the tabular Learning case, when I didn’t “convert” to .The Nature version is different. It will create a second network called
self.next_l_out
which is independent of the first networkself.l_out
. During the training process, the code periodically callsself.reset_q_hat()
to update the weights ofself.next_l_out
by copying from the current weights ofself.l_out
.Both of these should accomplish the same goal of having a separate network whose weights are updated periodically. The Nature version is certainly easier to understand.

I briefly want to mention a bit about the evaluation metrics used. The code, following the NIPS and Nature papers, reports the average reward per episode, which is intuitive and what we ultimately want to optimize. The NIPS paper argued that the average reward metric is extremely noisy, so they also reported on the average action value encountered during testing. They collected a random amount of states and for each , tracked the value obtained from that state, and found that the average discounted reward kept increasing. Professor Sprague’s code computes this value in the
ale_agent.py
file in thefinish_testing
method. He seems to do it different from the way the NIPS paper reports it, though, by subsampling a random set of states after each epoch instead of having that random set fixed for all 100 epochs (I don’t seeself.holdout_data
assigned anywhere). But, meh, it does basically the same thing.
I know I said this before, but I really like spragnur’s code.
That’s all I have to say for now regarding DQNs. I hope this post serves as a useful niche in the DQN blogosphere by focusing specifically on how the loss function gets derived. In subsequent posts, I hope to touch upon the major variants of DQN in more detail, particularly A3C. Stay tuned!

The most annoying part of DQN, though, was figuring out how the preprocessing works. As mentioned earlier, I resolved that through a previous post here. ↩

Taking the gradient of a function from a vector to a scalar, such as , involves taking partial derivatives for each component. All components other than in this example here will have derivatives of 0. ↩
Frame Skipping and PreProcessing for Deep QNetworks on Atari 2600 Games
For at least a year, I’ve been a huge fan of the Deep QNetwork algorithm. It’s from Google DeepMind, and they used it to train AI agents to play classic Atari 2600 games at the level of a human while only looking at the game pixels and the reward. In other words, the AI was learning just as we would do!
Last year, I started a personal project related to DQNs and Atari 2600 games, which got me delving into the details of DeepMind’s two papers (from NIPS workshop 2013 and NATURE 2015). One thing that kept confusing me was how to interpret their frame skipping and frame processing steps, because each time I read their explanation in their papers, I realized that their descriptions were rather ambiguous. Therefore, in this post, I hope to clear up that confusion once and for all.
I will use Breakout as the example Atari 2600 game, and the reference for the frame processing will be from the NATURE paper. Note that the NATURE paper is actually rather “old” by deep learning research standards (and the NIPS paper is ancient!!), since it’s missing a lot of improvements such as Prioritized Experience Replay and Double QLearning, but in my opinion, it’s still a great reference for learning DQN, particularly because there’s a great opensource library which implements this algorithm (more on that later).
To play the Atari 2600 games, we generally make use of the Arcade Learning Environment library which simulates the games and provides interfaces for selecting actions to execute. Fortunately, the library allows us to extract the game screen at each time step. I modified some existing code from the Python ALE interface so that I could play the Atari games myself by using the arrow keys and spacebar on my laptop. I took 30 consecutive screenshots from the middle of one of my Breakout games and stitched them together to form the image below. It’s a bit large; right click on it and select “Open Image in New Tab” to see it bigger. The screenshots should be read lefttoright, uptodown, just like if you were reading a book.
Note that there’s no reason why it had to be me playing. I could have easily extracted 30 consecutive frames from the AI playing the game. The point is that I just want to show what a sequence of frames would look like.
I saved the screenshots each time I executed an action using the ALE Python
interface. Specifically, I started with ale = ALEInterface()
and then after each
call to ale.act(action)
, I used rgb_image = ale.getScreenRGB()
. Thus, the
above image of 30 frames corresponds to all of the screenshots that I “saw”
while playing in the span of a halfsecond (though obviously no human would be
able to distinguish among all 30 frames at once). In other words, if you save
each screenshot after every action gets executed from the ALE python library,
there’s no frame skipping.
Pro tip: if you haven’t modified the default game speed, play the game yourself, save the current game screenshot after every action, and check if the total number of frames is roughly equivalent to the number of seconds multiplied by 60.
Now that we have 30 consecutive ingame images, we need to process them so that they are not too complicated or high dimensional for DQN. There are two basic steps to this process: shrinking the image, and converting it into grayscale. Both of these are not as straightforward as they might seem! For one, how do we shrink the image? What size is a good tradeoff for computation time versus richness? And in the particular case of Atari 2600 games, such as in Breakout, do we want to crop off the score at the top, or leave it in? Converting from RGB to grayscale is also – as far as I can tell – an undefined problem, and there are different formulas to do the conversion.
For this, I’m fortunate that there’s a fantastic DQN library opensource on GitHub called deep_q_rl, written by Professor Nathan Sprague. Seriously, it’s awesome! Professor Sprague must have literally gone through almost every detail of the Google DeepMind source code (also opensource, but harder to read) to replicate their results. In addition, the code is extremely flexible; it has separate NIPS and NATURE scripts with the appropriate hyperparameter settings, and it’s extremely easy to tweak the settings.
I browsed the deep_q_rl source code to learn about how Professor Sprague did the downsampling. It turns out that the NATURE paper did a linear scale, thus keeping the scores inside the screenshots. That strikes me as a bit odd; I would have thought that cropping the score entirely would be better, and indeed, that seems to have been what the NIPS 2013 paper did. But whatever. Using the notation of (height,width), the final dimensions of the downsampled images were (84,84), compared to (210,160) for the originals.
To convert RGB images to grayscale, the deep_q_rl code uses the builtin ALE grayscale conversion method, which I’m guessing DeepMind also used.
The result of applying these two preprocessing steps to the 30 images above results in the new set of 30 images:
Applying this to all screenshots encountered in gameplay during DQN training means that the data dimensionality is substantially reduced, and also means the algorithm doesn’t have to run as long. (Believe me, running DQN takes a long time!)
We have all these frames, but what gets fed as input to the “QNetwork”? The NATURE and NIPS paper used a sequence of four game frames stacked together, making the data dimension (4,84,84). (This parameter is called the “phi length”) The idea is that the action agents choose depends on the prior sequence of game frames. Imagine playing Breakout, for instance. Is the ball moving up or down? If the ball is moving down, you better get the paddle in position to bounce it back up. If the ball is moving up, you can wait a little longer or try to move in the opposite direction as needed if you think the ball will eventually reach there.
This raises some ambiguity, though. Is it that we take every four consecutive frames? NOPE. It turns out that there’s a frame skipping parameter, which confusingly enough, the DeepMind folks also set at 4. What this means in practice is that only every fourth screenshot is considered, and then we form the “phi”s, which are the “consecutive” frames that together become the input to the neural network function approximator. Consider the updated sequence of screenshots, with the skipped frames denoted with an “X” over them:
What ends up happening is that the states are four consecutive frames, ignoring all of the “X”ed out screenshots. In the above image, there are only seven nonskipped frames. Let’s denote these as . The DQN algorithm will use as one state. Then for the next state, it uses . And so on.
Crucially, the states are overlapping. This was another thing that wasn’t apparent to me until I browsed Professor Sprague’s code. Did I mention I’m a huge fan of his code?
A remark before we move on: one might be worried that the agent is throwing away a lot of information using the above procedure. In fact, it actually makes a lot of sense to do this. Seeing four consecutive frames without subsampling doesn’t give enough information to discern motion that well, especially after the downsampling process.
There’s one more obscure step that Google DeepMind did: they took the componentwise maximum over two consecutive frames, which helps DQN deal with the problem of how certain Atari games only render their sprites every other game frame. Is this maximum done over all the game screenshots, or only the subsampled ones (every fourth)? It’s the former.
Ultimately, we end up with the revised image below:
I’ve wrapped two consecutive screenshots in yellow boxes, to indicate that we’re taking the pixelbypixel (i.e. componentwise) maximum of the two images, which then get fed into as components for our states . Think of each of the seven yellow boxes above as forming one of the frames. Then everything proceeds as usual.
Whew! That’s all I have to say regarding the preprocessing. If you want to be consistent with the NATURE paper, try to perform the above steps. There’s still a lot of ambiguity, unfortunately, but hopefully this blog post clarifies the major steps.
Aside from what I’ve discussed here, I want to bring up a few additional points of interest:
 OpenAI also uses the Atari 2600 games as their benchmark. However, when we perform an action using OpenAI, the action we choose is performed either 2, 3, or 4 frames in a row, chosen at random. These are at the granularity of a single, true game frame. To clarify, using our method above from the NATURE paper would mean that each action that gets chosen is repeated four times (due to four skipped game frames). OpenAI instead uses 2, 3, or 4 game frames to introduce stochasticity, but doesn’t use the maximum operator across two consecutive images. This means if I were to make a fifth image representing the frames that we keep or skip with OpenAI, it would look like the third image in this blog post, except the consecutive X’s would number 1, 2, or 3 in length, and not just 3. You can find more details in this GitHub issue.
 On a related note regarding stochasticity, ALE has an action repeat probability which is hidden to the programmer’s interface. Each time you call an action, the ALE engine will ignore (!!) the action with probability 25% and simply repeat the previous action. Again, you can find more discussion on the related GitHub issue.
 Finally, as another way to reduce stochasticity, it has become standard to use a human starts metric. This method, introduced in the 2015 paper Massively Parallel Methods for Deep Reinforcement Learning, suggests that humans play out the initial trajectory of the game, and then the AI takes over from there. The NATURE paper did something similar to this metric, except that they chose a random number of noop actions for the computer to execute at the start of each game. That corresponds to their “noop max” hyperparameter, which is described deep in the paper’s appendix.
Why do I spend so much time obsessing over these details? It’s about understanding the problem better. Specifically, what engineering has to be done to make reinforcement learning work? In many cases, the theory of an algorithm breaks down in practice, and substantial tricks are required to get a favorable result. Many nowpopular algorithms for reinforcement learning are based on similar algorithms invented decades ago, but it’s only now that we’ve developed the not just the computational power to run them at scale, but also the engineering tricks needed to get them working.
Back to Blogging
Sorry for my silence in the last few weeks. I was completely preoccupied with preparation for a technical interview, which took place yesterday. I have now made public my interview preparation repository (on GitHub). It contains my code for some of the questions in the famous book Cracking the Coding Interview, 5th edition. Yes, the 5th edition, not the 6th … next time, I really should pay more attention to the version numbers of books before jumping the gun on buying them. But the 5th edition is still good, and I highly recommend using a recent version of the book to anyone who needs to prepare for a coding interview.
The repository only contains a fraction of what I wrote to prepare for the interview. I also had to review a lot of data structures concepts that I forgot. For instance, I never use linked lists in my research code (do any AI researchers use linked lists?!?). Consequently, I kept a Google Document with all of my typed notes from the Berkeley course, CS 61B. The best iteration of the class to review from is the Spring 2014 version, since that’s the most recent version taught by Professor Shewchuk, who has wonderful lecture notes publicly available. (Thank you so much!!)
There’s also been some other stuff going on besides my interview preparation. Most notable pertains to … politics. I was, of course, disappointed with the result at the federal level. I never thought that someone like Donald Trump could possibly become President of the United States, and it’s been painful for me to observe this happen given how strongly I opposed his candidacy from the start. I’m obviously not the only one here who opposed Trump; in the Berkeley computer science department, the faculty and students are nearly unanimously opposed to him, which says a lot given how computer science is supposed to be a nonpolitical field (as opposed to say, economics or political science). I am not aware of a single strong Trump supporter in the entire department, though I would not be surprised if we had a few of them (who are remaining quiet, for now).
While thinking about Trump’s rise to the highest elected office in the world, I began to fantasize myself being in his position. (Yes, I know it will never happen, so you don’t have to remind me.) What would a hypothetical Seita administration look like? I think it would be interesting to lay down some thoughts in a future blog post about the major positions I would take, and what issues would be important to me. Fighting climate change and radical Islamic terrorism come to mind. Hopefully I can write this up in detail over the December/January holiday break.
Then again, maybe it’s better for my education and my sanity if I stick to technical/research posts. Who knows?
Going Deeper Into Reinforcement Learning: Understanding QLearning and Linear Function Approximation
As I mentioned in my review on Berkeley’s Deep Reinforcement Learning class, I have been wanting to write more about reinforcement learning, so in this post, I will provide some comments on QLearning and Linear Function Approximation. I’m hoping these posts can serve as another set of brief RL introductions, similar to Andrej’s excellent post on deep RL.
Last year, I wrote an earlier post on the basics of MDPs and RL. This current one serves as the continuation of that by discussing how to scale RL into settings that are more complicated than simple tabular scenarios but nowhere near as challenging as, say, learning how to play Atari games from highdimensional input. I won’t spend too much time trying to labor though the topics in this post, though. I want to save my effort for the deep variety, which is all the rage nowadays and a topic which I hope to eventually write a lot about for this blog.
To hep write this post, here are two references I used to quickly review QLearning with function approximation.
I read (1) entirely, and (2) only partly, since it is, after all, a full book (note that the authors are in the process of making a newer edition!). Now let’s move on to discuss an important concept: value iteration with function approximation.
Value Iteration with Function Approximation
Value Iteration is probably the first RLassociated algorithm that students learn. It lets us assign values to states , which can then be used to determine optimal policies. I explained the algorithm in my earlier post, but just to be explicit, here’s a slide from my CS 287 class last fall which describes the procedure:
Looks pretty simple, right? For each iteration, we perform updates on our values until convergence. Each iteration, we can also update the policy for each state, if desired, but this is not the crucial part of the algorithm. In fact, since the policy updates don’t impact the maxoperations in the algorithm (as shown above), we can forget about updating and do that just once after the algorithm has converged. This is what Barto and Sutton do in their Value Iteration description.
Unfortunately, as suggested by the slide, (tabular) Value Iteration this is not something we can do in practice beyond the simplest of scenarios due to the curse of dimensionality in . Note that is not usually a problem. Think of Go, for instance: according to reference (1) above, there are states, but just actions to play. In Atari games, the disparity is even greater, with far more states but perhaps just two to five actions per game.
The solution is to obtain features and then represent states with a simple function of those features. We might use a linear function, meaning that
where is a bias term with 1 “absorbed” into for simplicity. This function approximation dramatically reduces the size of our state space from into “” where is the domain for . Rather than determining for all , each iteration our goal is to instead update the weights .
How do we do that? The most straightforward way is to reformulate it as a supervised learning problem. From the tabular version above, we know that the weights should satisfy the Bellman optimality conditions. We can’t use all the states for this update, but perhaps we can use a small subset of them?
This motivates the following algorithm: each iteration in our algorithm with current weight vector , we sample a very small subset of the states and compute the official onestep Bellman backup updates:
Then we find the next set of weights:
which can be done using standard supervised learning techniques. This is, in fact, an example of stochastic gradient descent.
Before moving on, it’s worth mentioning the obvious: the performance of Value Iteration with function approximation is going to depend almost entirely on the quality of the features (along with the function representation, i.e. linear, neural network, etc.). If you’re programming an AI to play PacMan, the states will be the game board, which is far too highdimensional for tabular representations. Features will ideally represent something relevant to PacMan’s performance in the game, such as the distance to the nearest ghost, the distance to the nearest pellet, whether PacMan is trapped, and so on. Don’t neglect the art and engineering of feature selection!
QLearning with Function Approximation
Value Iteration with function approximation is nice, but as I mentioned in my last post, what we really want in practice are values, due to the key fact that
which avoids a costly sum over the states. This will cost us extra in the sense that we have to now use a function with respect to in addition to , but again, this is not usually a problem since the set of actions is typically much smaller than the set of states.
To use Qvalues with function approximation, we need to find features that are functions of states and actions. This means in the linear function regime, we have
What’s tricky about this, however, is that it’s usually a lot easier to reason about features that are only functions of the states. Think of the PacMan example from earlier: it’s relatively easy to think about features by just looking at what’s on the game grid, but it’s harder to wonder about what happens to the value of a state assuming that action is taking place.
For this reason, I tend to use the following “dimension scaling trick” as recommended by reference (1) above, which makes the distinction between different actions explicit. To make this clear, image an MDP with two features and four actions. The features for stateaction pair can be encoded as:
Why the need to use different feature for different actions? Intuitively, if we didn’t do this (and kept with just two nonbias features) then the action would have no effect! But actions do have impacts on the game. To use the PacMan example again, imagine that the PacMan agent has a pellet to its left, so the agent is one move away from being invincible. At the same time, however, there could be a ghost to PacMan’s right! The action that PacMan takes in that state (LEFT or RIGHT) will have a dramatic impact on the resulting reward obtained! It is therefore important to take the actions into account when featurizing Qvalues.
As a reminder before moving on, don’t forget the bias term! They are necessary to properly scale the function values independently of the features.
Online Least Squares Justification for QLearning
I now want to sketch the derivation for QLearning updates to provide intuition for why it works. Knowing this is also important to understand how the training process works for the more advanced DeepQNetwork algorithm/architecture.
Recall the standard QLearning update without function approximation:
Why does this work? Imagine that you have some weight vector at iteration of the algorithm and you want to figure out how to update it. The standard way to do so is with stochastic gradient descent, as mentioned earlier in the Value Iteration case. But what is the loss function here? We need that so we can compute the gradient.
In QLearning, when we approximate a stateaction value , we want it to be equal to the reward obtained, plus the (appropriately discounted) value of playing optimally from thereafter. Denote this “target” value as . In the tabular version, we set the target as
It is infeasible to sum over all states, but we can get a minibatch estimate of this by simply considering the samples we get: . Averaged over the entire run, these will average out to the true value.
Assuming we’re in the function approximation case (though this is not actually needed), and that our estimate of the target is , we can therefore define our loss as:
Thus, our gradient update procedure with step size is
This is how we update the weights for QLearning. Notice that and are vectors, while is a scalar.
Concluding Thoughts
Well, there you have it. We covered:
 Value Iteration with (linear) function approximation, a relatively easytounderstand algorithm that should serve as your first choice if you need to scale up tabular value iteration for a simple reinforcement learning problem.
 QLearning with (linear) function approximation, which approximates values with a linear function, i.e. . From my experience, I prefer to use the statesonly formulation , and then to apply the “dimension scaling trick” from above to make QLearning work in practice.
 QLearning as a consequence of online least squares, which provides a more rigorous rationale for why it makes sense, rather than relying on handwaving arguments.
The scalability benefit of QLearning (or Value Iteration) with linear function approximation may sound great over the tabular versions, but here is the critical question: is a linear function approximator appropriate for the problem?
This is important because a lot of current research on reinforcement learning is applied towards complicated and high dimensional data. A great example, and probably the most popular one, is learning how to play Atari games from raw (210,160,3)dimensional arrays. A linear function is simply not effective at learning values for these problems, because the problems are inherently nonlinear! A further discussion of this is out of the scope of this post, but if you are interested, Andrew Ng addressed this in his talk at the Bay Area Deep Learning School a month ago. Kevin Zakka has a nice blog post which summarizes Ng’s talk.^{1} In the small data regime, many algorithms can achieve “good” performance, with differences arising in large part due to who tuned his/her algorithm the most, but in the highdimensional bigdata regime, the complexity of the model matters. Neural networks can learn and represent far more complicated functions.
Therefore, in my next post, I will introduce and discuss QLearning with neural networks as the function approximation. It will use the Atari games as a running example. Stay tuned!

It’s great that he wrote that, because all the YouTube videos with Ng’s talk (as of now) do not have the autocaptions option enabled. I’m not sure why, and despite the flaws of autocaptions, it would have helped a lot. I tried watching Ng’s talk and gave up after a few minutes since I was unable to understand the words he was saying. ↩
Hypothesis Testing for a Binomial Example
In STAT 210A class, we are now discussing hypothesis testing, which has brought back lots of memories from my very first statistics course (taken in my third semester of undergrad). Think null hypotheses, values, confidence intervals, and power levels, which are often covered in introductory statistics courses. In STAT 210A, though, we take a far more rigorous treatment of the material. Here’s the setting at a high level: we use data to infer which of two competing hypotheses is correct. To formalize it a bit: we assume some model and test:
 , the null hypothesis
 , the alternative hypothesis
While it is not strictly necessary for and , we often assume these are true for simplicity.
We “solve” a hypothesis testing problem by specifying some critical function , specified as
In other words, tells us the probability that we should reject .
The performance of the test is specified by the power function:
A closely related quantity is the significance level of a test:
The level here therefore represents the worst chance (among all the possibilities) of falsely rejecting . Notice that is constrained to be in the null hypothesis region ! The reason why we care about is because often represents the status quo, and we only want to reject it if we are absolutely sure that our evidence warrants it. (In fact, we technically don’t even “accept” the null hypothesis; in many courses, this is referred to as “failing to reject”.)
We may often resort to a randomized test, which was suggested by my definition of above which uses a . This is useful for technical reasons to achieve exact significance levels. Let’s look at an example to make this concrete. Suppose that , and that we are testing
 .
 (so here the hypotheses do not partition).
And, furthermore, that we want to develop a test with a significance level of . (Note: yes, this is related to the abundant usage of 0.05 as a value in many research articles.)
To test, it is convenient to use a likelihood ratio test, which have nice properties that I will not cover here. In our case, we have:
where we have simply plugged in the densities for Binomial random variables and simplified. Intuitively, if this ratio is very large, then it is more likely that we should reject the null hypothesis because describes the data better.
We know that can take on only three values (because ) and that under the null hypothesis (this is important!) the probabilities of taking on , or happen with probability and , respectively.
Knowing this, how do we design the test with the desired significance level? It must be the case that
(There is only one possibility here, so we do not need a “sup” term.)
By using the fact that a likelihood ratio must be defined by a cutoff point where if , we reject, else if we accept (and with equality, we randomize), we see that our test must be and . If we were to equate this with our definitions above, this would be:
with . (The third case never happens here; I just added it to be consistent with our earlier definition.)
And that is why we use randomization. This also gives us a general recipe for designing tests that achieve arbitrary significance levels.
Donald Trump Should Not be Our Next President
I hope Americans can collectively react with disgust to the latest news about Donald Trump and his incendiary comments. This time, it’s a particularly lewd conversation with Billy Bush^{1} where Trump brags about his sexual exploits. You can read about it from the Washington Post and watch the video there.
I haven’t watched the video, because I already knew that I was not supporting Trump, but I hope that this is the nail in the coffin for his campaign. So far, politicians such as Senators John McCain and Kelly Ayotte have finally rescinded their support for Trump. Finally.
Unlike many of the Republican politicians now denouncing Trump, I was against him from day one of his campaign, when he labeled Mexicans as criminals and rapists. As the campaign went on, Trump continued to turn me off by mocking a disabled reporter, saying that a “Mexican” judge couldn’t do his job, belittling the parents of a Muslim solder, praising Putin^{2}, and (obviously) making numerous disparaging comments about women.
Now, yes, people make mistakes about things they say, and a lot of men are insensitive when talking about women. Heck, I remember in eighth grade when another student flipped through our school yearbook and told me to state the girls I liked. Did I make certain comments then that I now regret? Yes.
But the difference is that I have now matured and learned to be more respectful to others. As a consequence, I cannot remember a single instance in the last eight years when I made a disparaging comment about a woman’s body, and I have no plans to do so in the future.
Trump was 59 years old when he made these comments, and he has shown no signs of changing or improving his demeanor.
As a Democratleaning voter, I can probably be expected to oppose Trump, but the truth is that I want to have two healthy political parties in this country to give me two healthy options. The Republican party used to nominate reasonable, competent men such as George H.W. Bush, who understood the power of the free market, who knew how to judiciously use military, who did not deny climate change, and who cared about people with disabilities. That era, sadly, seems to be gone.
I am endorsing Hillary Clinton for President. Whether or not I directly vote for her on my absentee ballot depends on whether the voteswapping service I signed up for follows through. If I get paired up with a third party voter in a swing state, then I’ll vote for whoever that person wants (along with, of course, the condition that the other person votes for Clinton). If I don’t hear back from the vote swapping service, I will just go ahead and explicitly vote for Clinton.
As for other elections that happen now and in the future, I will be applying a simple litmus test for any candidate who I may elect: has that person ever given support to Trump’s presidency? If so, then I will not be voting for that person. Once that filters out the candidates, I can then focus on the real issues that matter.
Ultimately, Hillary Clinton was not my first choice^{3} for President. I do not believe she will help reduce the political correctness in this country. I support the TransPacific Partnership and hope that she will reconsider her opposition. I have some reservations about her tenure as Secretary of State. And I feel ignored when she and other Democrats cater to African American, Hispanic American, and women voters.
But at this stage, we are down to two major candidates and must decide among the better of the two (or the “least awful” if you wish). And for me, that choice is abundantly clear.

Apparently, he’s a cousin of former President George W. Bush. Interesting … ↩

Putin, by the way, is someone who I view even more negatively than Trump. If there was somehow a Putin versus Trump election in the United States (oh no …), I would grind my teeth and vote for Trump. But let’s hope that never happens. ↩
The Expectation of the Minimum of IID Uniform Random Variables
In my STAT 210A class, we frequently have to deal with the minimum of a sequence of independent, identically distributed (IID) random variables. This happens because the minimum of IID variables tends to play a large role in sufficient statistics.
In this post, I’ll briefly go over how to find the minimum of IID uniform random variables. Specifically, suppose that and let . How do we find ? To compute this, observe that
so the next step is to determine . Due to the IID assumption, it doesn’t matter which we use. Note also that to avoid adding cumbersome indicator functions, assume that .
The value is easier to compute because it directly relates to the cumulative distribution function (CDF) of a uniform random variable. For , the CDF is simply if . This means
so that by differentiating with respect to , the density function is (the notation here with the as the subscript is to denote the variable whose density is being defined).
The reason why we need the density is because of the definition of the expectation:
To compute this, we integrate by parts. Set and . We get
Combining this with the extra factor we left out (you didn’t forget that, did you?) we get . Notice that as the expected value of the minimum of these uniform random variables goes to zero. In addition, this expectation is always in for . Thus, the answer passes the smell test and seems reasonable.
GSIing for Berkeley's Deep Neural Networks Class
In news that might be welcome to the students taking CS 294129, “Designing, Visualizing, and Understanding Deep Neural Networks” this semester, I got recruited as the second GSI (Graduate Student Instructor, a.k.a. Teaching Assistant) for the class.
Why do I say this might be good news for the students? First, I hope they realize how much I enjoy teaching. I like to provide hints (but not complete solutions) to students when they need it, because it feels good when students are able to learn and benefit from my presence. I’m also tolerant of students who have to come to office hours frequently, because quite frankly, I was one of those students for a brief time in undergrad (thankfully, since outgrown).
Probably the biggest reason why I think students will like my new GSI position is that, in news that will surprise no one, the class was substantially overenrolled at the start of the semester. My guess is that we had around a hundred students^{1} who wanted to take the class … but no GSI. Fortunately, the class got one GSI a few weeks into the semester, which meant everyone (I hope) on the waitlist got in. Then I became a GSI. The irony is that both of us started as normal students. I like to think of it as “getting promoted as a GSI.” With two of us, it means that students will get their homeworks graded faster. The first one was already due a week ago, and the second one is due next Friday. Gulp.
So what is this class about? It was a lastminute addition to the curriculum for the semester, but fortunately, the class is based on CS 231n from Stanford University, which has already been offered twice. This means we can borrow their three homework assignments, as well as the style of their midterm questions (though I hope we don’t use the exact same questions …). In addition, since we are on a semester system and Stanford is on a quarter system, we can cover slightly more material^{2}, such as Deep Reinforcement Learning, Monte Carlo methods, and current research directions with Deep Learning, which do not appear to be on the CS 231n syllabus.
Incidentally, by looking at the Stanford CS 231n offering for Winter 2016, they had three instructors and eleven teaching assistants. There were apparently 200 final projects for the class, and since students could pair up for those, that corresponds to about 300400 students total (wow!). We certainly don’t have nearly as many students, but there still is not enough course staff to make the studenttostaff ratio match.
Our homework assignments, as mentioned earlier, are borrowed from the Stanford version. I did the first one and am almost done with the second. The assignments are based on Jupyter Notebooks (awesome!) and done entirely in Python. And I’d like to give my congratulations to the CS 231n staff, because the assignments are awesome. They are challenging enough to stimulate the deepest parts of my brain (pun intended), but not so hard enough that I have to constantly ask someone for help, which would be a bit embarrassing for a GSI. One of the things I really like about the assignments is that they give me a taste for how real deep network systems are implemented. In my undergraduate machine learning class, I implemented backpropgation for a very simple, fully connected neural network, but that was a “naive” version, with me iterating through arrays and following a formulaic definition. That worked out fine, but in practice, neural network code must be modular enough (and vectorized!) to allow for effective training on deep networks. Oh, and did I mention that most networks for image recognition are not fully connected but convolutional nets? That makes the implementation much more challenging!
I’m excited to be joining the course staff for CS 294129, and I hope that I and the rest of the students will enjoy the course. Probably the one downside to being a GSI is that I may have to face student complaints (moreso than when I was TAing in undergrad) since GSIs have more grading responsibility.

It’s a bit tough to say how many students we have exactly, since some join after the start date and others drop. The Piazza website says that there are 165 people enrolled, but that also includes students who have dropped the class. ↩

Our textbook is based on the online book by Goodfellow et al. I was hoping to read through the full book at some point, so this class gives me a great opportunity to do that! ↩
On Baba Yetu and the Role Music Plays in Life
No, this isn’t going to turn into a “song of the week” blog post series. But I wanted to mention this particular song along with an accompanying discussion on the role of music in my life.
I should start with the rather obvious fact that I am not a musical person. I was not raised in a musical family. I remember playing the baritone back in elementary school for a year or two, and I quickly backed out as soon as I finished my “music requirements” for school.
As additional evidence of my lack of musical interest, knowledge, and expertise, in my six or seven years of driving, I have never had the music on, ever. I also do not think I have touched an iPod in my life, and I say “think” here because of the possibility that I may have had to accidentally brush one of them when cleaning up after another students’ mess on his/her desk (c’mon, please be tidy!). My use of headphones is restricted to when I show up to talk to my audiologist, who provides me with a headphone to wear as she checks my hearing levels. Does that count?
That’s not to say that people with hearing aids can’t listen to music at all. For instance, I hear music all the time when I watch movies or play games. There are also special earplugs that can work with hearing aids and have hooks to keep them in place.
One can also try to use earbuds “normally.” I know one deaf person who plugs in earbuds directly into his ears. This is only possible, I believe, for those who still have their natural hearing (i.e., without cochlear implants). I could do that because I have some natural hearing remaining. If someone is talking within two inches of my left ear (but not the right), I could probably understand that person. Unfortunately, I am afraid of putting earbuds directly into my ear because I worry that it will damage whatever natural hearing I have.
Recently, I have been trying to listen to more music. In part this is because I don’t want to embarrass myself in front of others when the topic of music comes up, but it’s also because I think I can use music for relaxation or focus. When I work at home, I frequently turn to relaxing nature sounds such as the ones in this YouTube video, but that’s technically not a “real” song.
An example of an actual song that I’ve come to really like over the past few years is Baba Yetu. Here’s a Wikipedia link, and here’s a YouTube link. For those who don’t know, it is the theme music for the popular and awardwinning Civilization IV computer game. The composer, Christopher Tin, used to be Stanford roommates with the lead game developer, Soren Johnson, so that’s how the song ended up there. On the surface, this seems like blatant favoritism, but it was a pretty genius move for both sides because Baba Yetu became the first video game song to win a Grammy Award.
I was a huge Civilization IV fan in high school, and I remember a few times when I allowed the opening music to play completely instead of skipping through it and going straight to the gameplay, as is my custom. I am not sure how to quantify the quality of music, but I can agree with many other listeners that Baba Yetu intuitively has some appealing mystical or supernatural quality to it. I liked it enough in high school so that, during my 12th grade Advanced Placement English Class, when the students presented their favorite book, movie, and song to the class to introduce themselves to each other, Baba Yetu was the song that I presented. Incidentally, my book was Outliers, and my movie was The Dark Knight. And yes, that was AP English … as distressing as that sounds.
I would be remiss if I did not conclude this discussion with the news that Christopher Tin will also be composing the opening music for Civilization VI, slated for an October release! It looks like the designers of Civilization VI are learning from the mistakes of Civilization V after all! The gameplay for Civilization VI, and now the music, look to be far more promising than those of the lackluster Civilization V game. (For more on why I believe this in terms of gameplay, read this article by someone who I agree with a lot regarding computer games.) Unfortunately, I won’t become as good at it as I was with Civilization IV because I can no longer allow computer games to take over my life.
But I sure will try to spare a few minutes to listen to the music for Civilization VI.
Concluding Thoughts on Reviewing for NIPS 2016
I mentioned a few months ago that I volunteered to be a reviewer for NIPS 2016. The NIPS decisions have been out for a few weeks now and a detailed account of the review process has been published.
Overall, I think it was a good experience for me to finally start reviewing academic papers, and I’m really happy that NIPS has so much transparency to help me better understand how it works behind the scenes. From looking at the review process, a number of things immediately caught my attention.
First, wow, NIPS is really large. I would not have expected about 6000 total authors to have submitted 2406 total papers for review. And NIPS used to be a niche conference a few decades ago, right? I wonder how much larger it can realistically become while still being an academic conference. In terms of reviewers, there were 3424 reviewers, again quite an eyepopping number. Also, I was correct on the senior vs volunteer reviewers: it looks like the system was designed to provide six reviewers per paper, with three seniors and three volunteers. I was naturally one of the volunteers. I also noticed that reviewers submitted an average of 4.05 reviews, so my set of papers to review (four) was standard.
In the past, NIPS papers used to be evaluated on a single scale from 1 to 10. This year, the process was more sophisticated with 15 point scales for (a) technical quality, (b) novelty, (c) impact, and (d) writing/clarity. After having some experience with the new scoring scales, I have some mixed feelings about them. This was ostensibly done to make NIPS more scalable, but I’m worried about the workload of the Area Chairs, who have to now spend more time analyzing the reviews instead of looking at a simple numeric score. If the Area Chairs can effectively work with this new scoring scale, then I suppose it is OK. I actually like how it helps me to think more clearly about “novelty” versus “impact.”
In general, (d) is the easiest to determine, especially for me and my “unique” typocatching abilities. Papers with substantial typos and problems in their presentation should go straight in the rejection pile; for one of the papers I reviewed, nearly every reviewer heaped criticism on the writing/clarity, making it an easy rejection. I’m not sure why I spent so much time on that paper, carefully pointing out the flaws, when I should have quickly moved on. I was told by a faculty member that that “spending two hours for a review is a good benchmark, and you can spend a little more if the paper looks publishable.”
Gulp. I spend way more than two hours per paper, even on the one that should have been an obvious rejection. Way more.
Some reviewers were smarter (or lazier?). For each paper I reviewed, there was at least one reviewer who gave the dreaded twoline review. Interestingly enough, from my really small sample size, faculty gave more of those reviews than postdocs and graduate students. (Time for faculty to assign these reviews to their graduate students, I suppose.) While NIPS follows the doubleblind reviewing system, paper reviewers could see the identity and reviews of the other reviewers. We could also give private comments in our original reviews, visible only to other reviewers and the Area Chairs. One of the most distressing aspects of the system is seeing almost every reviewer saying a variant of: “I did not completely check the proofs.” It’s clearly impossible even for a group of six to check all the technical aspects of papers. For this to even happen, at minimum, the six reviewers would have to somehow divide up the task, such as reviewer 1 checking Theorem 1, reviewer 2 checking Theorem 2, and so on.
Fortunately, I could not see the other reviews until after I had submitted mine – a good thing!! Once the reviewing period finished, the conference website provided a private forum where reviewers and Area Chairs could discuss aspects of the papers in depth, but I was kind of fried after this and busy with too much work. A few people labeled as “meta reviewers” (I think these were Area Chairs) tried to encourage some discussion, but most reviewers felt the same as I did and did not have the desire for extensive conversations. In a perfect world, there would especially be a lot of discussion about the author rebuttals, which is a key part of the NIPS reviewing process. Unfortunately, it was really hard for me to motivate myself to read the rebuttals carefully, and I ultimately did not change any of my scores.
From the list of accepted papers, one out of the four papers I reviewed got accepted, which aligns well with the overall acceptance rate for NIPS (this year, it was 568/2406 = 0.236). As an experiment, the NIPS chairs asked reviewers to provide an ordered ranking of only the papers they reviewed. The paper I rated the highest of my four was indeed the one that got in, which is extra assurance that my kind of reviews are not totally out of whack with what others think.
Overall, I think my favorite part of reviewing is when I get to compare my reviews with other people and to read author rebuttals. I generally like it when my reviews hit the same core topics as other reviews, and when authors (in their rebuttals) thank me for catching errors. I hope to continue giving feedback on research papers, whether or not it is part of an official reviewing system.
On Risk and the BiasVariance Tradeoff (From Keener 3.1)
I am currently reading the textbook Theoretical Statistics by Robert W. Keener, and I thought I would write up some notes on Chapter 3, Section 1 of the book. Chapter 3 is titled “Risk, Sufficiency, Completeness, and Ancillarity,” with 3.1 specifically being about the notion of risk.
So what is risk? To understand this, we need to describe the problem setting. The goal in statistical inference is about learning a parameter vector from data, where in general the data consists of points with for some dimension .
A statistic of the data is a function of the data which provides some information about it. Keener denotes data statistics as . Probably the canonical example of a statistic is the mean of the data, or . It is worth pointing out that this only works if the are random vectors, and in addition, that the mean function is manytoone. That is, we can have different datasets that result in the same mean. Thus, the statistic here only provides partial information on the data.
Our problem setting also involves some function of the parameter, which Keener denotes as . The goal of estimation is to find a statistic such that is “close” to . It may not be totally clear why we introduce , but it gives us flexibility; for instance, we might only be interested in one component of so . For now, I find it easiest to just think of as the identity, so and we want our statistic to be close to the real parameter, but throughout this post, I will be sloppy and use and interchangeably (in my defense, Keener does the same thing).
Let’s clarify the above with the boring example of flipping a coin that can land heads with some probability . If we flip the coin 100 times, with each trial independent of the others, then the random variable representing the total number of heads follows a binomial distribution. (Another way to express is therefore where if the trial resulted in heads, and 0 otherwise.) If we want to get a statistic that maps the data to an estimate of , what would be a “good” statistic? The statistic certainly makes sense, since it is the natural proportion of samples! But is this the “best” statistic we have?
To quantify the notion of a “best” statistic, we turn to the concept of risk, which in turn relies on the concept of a loss function . The loss function represents the (nonnegative) penalty in estimating (which again, I treat as here) with . Since the data is random, may sometimes be large with unlucky outcomes of , so we use expectations, which is where the risk comes from:
Note that Keener uses to indicate expectations with , but I find that a little misleading because what is random here is really , not . We assume is fixed … but for Bayesian risk the situation is different. Hence, the above is sometimes referred to as the Frequentist risk.
Let’s continue with the coinflipping example from earlier. Probably the most common loss function is the squared error loss, or . What, then is the risk associated with the estimator ? We apply the definition:
Where we use according to the definition of the expectation of a binomial random variable. To determine we follow the familiar technique of using the formula for the variance:
Solving for , we obtain
Now let’s consider something interesting: what if we use a different estimator, defined as ? Intuitively, this looks to provide more “smoothing” of the estimate to get it closer to . Let’s compute the risk, again assuming the squared loss:
How do we compare the risk of the previous two estimators? It’s not clear at first glance, so we need to plot the curves. Fortunately, Keener already did this with the following image:
In the above, he uses a third estimator, , and also, is the original estimator and .
It is intuitive that is a poor estimator of because it adds 3 (i.e., like adding “three heads”) without doing anything else. In fact, we can rigorously say that is dominated by both and because, throughout the entire support for , the risk associated with is higher than the other estimators. The comparison between and is less straightforward; when the true value is near , we’d prefer for instance, but the reverse is true near 0 or 1.
To wrap up this discussion, I’d like to connect the concept of risk with the biasvariance tradeoff, which introduces two key concepts to know (i.e., bias and variance). The bias of an estimator is defined as , where here we write instead of for simplicity. The variance is simply and usually involves computations involving the variance of directly.
Problem 1 in Chapter 3 of Keener introduces the very interesting fact that the risk of an arbitrary estimator under squared error loss is , or more intuitively, . In fact, I earlier saw this result stated in one of the two papers I discussed in my post on minibatch MCMC methods. In Section 3 of Austerity in MCMC Land: Cutting the MetropolisHastings Budget, the paper states without proof:
The risk can be defined as the mean squared error in , i.e. , where the expectation is taken over multiple simulations of the Markov chain. It is easy to show that the risk can be decomposed as , where is the bias and is the variance.
The first thing I do when I see rules like these is to try an example. Let’s test this out with one of our earlier estimators, . Note that this estimator is unbiased, which means the bias is zero, so we simply need to compute the variance:
and this precisely matches the risk from earlier!
To prove that the risk can be decomposed this way in general, we can do the following (using in place of and in place of to simplify notation):
as desired! In the above, we expanded the terms (also by cleverly adding zero), applied linearity of expectation, applied the fact that is just , and also used that .
Five Years of Blogging
I survived. I have now been blogging for five years.
Technically, it’s been five years and 20 days. Sorry. As nice as it would have been to nail down five years exactly, I had some urgent work to do in the beginning of August. But despite all the constant work that’s being thrown at me (it’s my fault) I have somehow been able to keep cranking out at least one blog post each month for five years^{1}. Given how tough it is to maintain a long commitment to nonessential writing projects, I wonder if any of my early readers (from 2011 to 2013) thought I would last this long.
This is a message towards all readers: I hope you enjoy some of what I write. I have been pleasantly surprised by the amount of comments and emails I get about the blog. These come almost every week, and it’s especially nice when the sender is someone I know or someone who I can easily meet in person most days. It gives us a chance to talk, regardless of whether it’s related to what I wrote or not. I also know that the vast majority of readers won’t be commenting or emailing, so the blog audience is much larger than I think. What’s interesting is that while a lot of people seem to like reading blogs, they don’t like writing one. My efforts in encouraging other people to start their own blogs has failed catastrophically. I think my current success rate is 0 for 20.
Incidentally, I don’t have to follow Rule #1 of the Internet: “don’t read comments.” I hope that I — and the readers — will never have to follow that rule^{2}.
Since this is a special moment in the blog’s history, I decided it was high time to do a few major updates that I had been putting off for ages.

I updated the “About” and “New? Start Here” pages, which have been begging for a doover ever since this blog migrated from Wordpress to Jekyll. The former was pretty easy to fix; for the latter, I decided to try and provide a few examples of my favorite posts. With over 200 posts so far (the exact number, including this one, is 215) I had a wide range to choose from.

I have been rewriting some of my older political posts (see here for one example). Every now and then, I do these changes because I get hives when I read some of my earlier writings. I like to have a reasonably high standard of writing, or at least to what is generally possible within the constraints of a blog post and lack of any editors helping me.
A note regarding political posts: I’ll do my best to avoid these for the near future. Why? I’m getting weary of politics, first of all. Second, almost anyone can blog about poltics with varying degrees of quality, meaning that this blog wouldn’t be as unique as I want it to be. Third, politics causes unnecessary conflict between people with different beliefs, and I am not interested in burning any bridges with the people who I work with. Of course, given the nearuniformity liberalness of the Berkeley faculty and student body (and EECS is no exception in this regard), I can probably get away with writing political posts just by bashing conservatives. On the other hand, I think a lot of people who know me are aware of my selfproclaimed “centrist Democrat” leanings, so it doesn’t quite seem right to do that.^{3}
Regardless of what I believe, whether it is politics or otherwise, I am an even firmer believer in that we must keep an open mind. If I publish blog posts about particularly sensitive subjects, it does not mean I have exhaustively researched the area or that my opinion is fixed. I take pride in the amount that I read nowadays, so if there’s an issue I care about, chances are I’m trying to read up a lot to learn more.

I also updated the DeepRL post related to the class I took last year. I really want to write more about DeepRL here, as that’s an exciting field. It just takes so darn long to write high quality posts like Andrej Karpathy’s recent reinforcement learning guide. I wrote a lot of blog posts related to my notes when I was studying for the AI prelims last summer, and those took a really long time to polish. My goal is to have several smaller posts that together cover a lot of DeepRL and which follow Andrej’s posting style. I have my first reinforcement learning post in draft stage (roughly 50% done) and hope to make it public within two weeks. Or maybe two months, who knows?

I changed this blog to use https instead of http, since I want to use the more secure protocol, and it turns out that the MathJax (which renders LaTeX math for my posts) does not appear with https. I needed to do several things to get this set up properly:

I followed the directions to enforce https on GitHub Pages. It’s literally one checkbox to click, very easy!

In the
_config.yml
file, I changed the site URL tohttps://danieltakeshi.github.io
. This is needed because my HTML code to display figures uses the site URL variable. 
In two places, I had to change the MathJax script so that the link they use has https instead of http. The two locations to add this are in
index.html
and_layouts/post.html
. The former is so that MathJax is visible on the homepage, where one can scroll to see many posts, and the latter is for individual posts when clicking on their titles (or from the archives). Here’s what the script segment looks like:<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeXAMSMML_HTMLorMML"> </script>

Finally, I migrated all comments from http URLs to ones with the same name, but with https instead. This is necessary because Disqus links comments to specific URLs, so if I switched back and forth between http and https, I would see two different comment threads. Fortunately, someone already wrote a great guide on how to use the builtin Disqus URL mapping, and it was straightforward to follow.
Whew! I think that’s it.


I also modified several posts to fix them based on some of the lingering side effects of the WordpresstoJekyll migration. For instance, I find centered text paired with leftcentered images to look egregiously sloppy. The importer I used for the migration process automatically formed image tags, but it did not center them. For that, I have to use the following HTML code:
<p style="textalign:center;"> <img src="https://danieltakeshi.github.io/assets/image_name.png"> </p>
where
image_name.png
should be replaced with whatever image name I am using.I also observed that the importer didn’t always correctly bold or italicize the text. Sometimes the asterisks I need for those would be one space off, but that spacing would throw off the formatting entirely. Ugh. This is always going to be a work in progress, I suppose, especially because I can’t easily write a script to automate it.
So, what’s the plan for the future? At some point I will threaten to quit blogging but not right now as there are many things I still want to write about. With some heavy work ahead of me, I really want to aim for more technical posts to help me learn about challenging topics. I want to write some occasional “guides on X” where X is a concept in computer science, to help out the community.
Last thing: for years, I’ve been trying to get a new name change for the blog, as “Seita’s Place” has to be the lamest blog name of all time. Unfortunately, I can’t come up with anything better.
That’s all for now. Thanks for reading!

As a general rule, if there hasn’t been a blog post in a month and it’s approaching the 25th day of it, I’m scrambling behind the scenes to get something done. ↩

Well, all right, if I can become a highranking politician then the tradeoff might be worth it, but what are the odds of me entering such a toxic field? ↩

(Sarcasm) I expect to be confronted by a bunch of angry Bernie Sanders supporters when I get back to Berkeley. ↩
A Useful Matrix Inverse Equality for Ridge Regression
I was recently reading Stephen Tu’s blog and stumbled upon his matrix inverse equality post which brough back some memories. Here’s the equality: let be an matrix, let , and let represent the identity matrix. Then
Note that both sides are leftmultipled by , so for the purposes of checking equality, there’s no need to have it there, so instead consider
I was asked to prove this as part of a homework assignment in my CS 281A class with Professor Ben Recht a while back. Stephen Tu already has an excellent proof based on Singular Value Decomposition, but I’d like to present an alternative proof that seems even simpler to me. I also want to explain why this equality is important.
First, start with . Then leftmultiply the left hand side (LHS) by and rightmultiply the right hand side (RHS) by to obtain
Note that this doesn’t change the equality, because multiplying a matrix with the identity will not change it, regardless of the multiplication ordering. As a sanity check, the LHS is and the RHS is and both result in a dimensional matrix so the dimensions match up. Next, add to both sides and get
We now “distribute out” an , though the particular to use is different on both sides. We obtain
Next, leftmultiply both sides by and rightmultiply both sides by :
Thus proving the identity.
Now, you can leave it like that and in some cases you’ll be OK. But strictly speaking, you should show that the two inverses above actually exist before using them. When I was writing up this for my homework, I said “the problem implies the inverses exist” because the inverse was already written in the problem statement. In retrospect, however, that was a mistake. Fortunately, the TA didn’t take off any points, though he marked “No, but w/e …”
To make things extra clear, we now show that the inverses exist. Consider . We claim its inverse exist because it is positive definite (and all positive definite matrices are invertible). This is straightforward because for any nonzero , we have
where we use the standard trick, which is everywhere in machine learning and optimization. If you don’t believe me, take EE 227B as I did and you’ll never be able to forget it. By the way, the above shows why we needed , because is not necessarily greater than zero; it could be zero! This is because could be positive semidefinite, but not positive definite.
A similar proof applies for the other inverse, which uses for .
Having proved the equality, why do we care about it? The reason has to do with ridge regression and duality. The problem formulation for ridge regression is
where is the dimensional vector of targets and . Taking the gradient we get
Setting to zero, we find as
Gee, does this formulation of look familiar? Yep! The above is one way of finding , but another way is by invoking the equality to get what is known as the dual form of :
Why do we like this new perspective? First, like any dual solution, it provides us with an alternative method if the “other” way (technically called the primal solution) is harder to compute. In this case, however, I don’t think that’s the main reason why (because this is fairly straightforward either way). I think we like this representation because is a linear combination of the rows of , with coefficients specified by the vector ! The rows of are the elements in our data , so this gives the intuitive interpretation of the optimal solution being some combination of the data elements.
Don't Worry about Walking in Between a Sign Language Conversation
Suppose there are two people talking in sign language. What should you do when you have to walk in between them in order to reach your destination? If the people were talking verbally (say, in English), you would walk through the two without hesitation.
But does sign language cause the etiquette to be different?
I thought about this recently when I was attending a recent tour. As part of it, the attendees listened to a few talks in an auditorium. Since I had a sign language interpreter, I naturally sat in the front corner seat of the room. Fortunately, I didn’t play my usual role of the “human repellent.” Despite there being lots of empty seats, some of the other people actually sat next to me instead of being afraid of the sign language and consequently sitting as far away from me as possible. (I hope that’s the reason why people generally don’t sit next to me …)
I didn’t know anyone else in the tour, so during breaks within the talks, I would strike up some conversations with the sign language interpreter. At the same time, a lot of the other attendees needed to get up and walk to the back of the auditorium, presumably to fetch a new batch of Starbucks coffee. But this meant that many had to cut through me and the sign language interpreter. Throughout the tour, I noticed two classes of people:

Those who walked through our conversation quickly and without hesitation.

Those who paused and nervously glanced at me and the interpreter, wondering about what to do.
I’m here to reassure you that (1) is much better than (2). If you need to walk between us to go somewhere, please do it (quickly).
I think most people who engage in (2) are those who do not have much experience with sign language and “deafness” more generally, so their reaction is certainly understandable (and a sign of politeness, I might add). When this situation happens, usually the sign language interpreter will quickly motion for the person to walk through, and then he or she will do a little sprint and then continue walking.
Perhaps people are worried about some unknown rules of sign language etiquette? If so, don’t worry: I don’t find walking between us to be rude at all, and I have yet to meet anyone who gets bothered by this. It doesn’t interfere with our conversation that much, because (just like in English audio) if a second of the conversation (or audio) gets cut, we can usually fill in the details by means of continuity, which comes with experience using the language.
If there’s a group of people who have to walk between us, then it’s a different story. When that happens, we have to pause the sign language until everyone gets through, but that’s understandable; we don’t want to be jerks and force everyone to take a far more roundabout route.
To state the obvious, though: if there’s a way to get to your destination without cutting through our conversation, you should consider that alternative route, but if that would require squeezing between a twelveinch gap between the wall of the auditorium and the back of my interpreter’s chair and making yourself look silly in the process, please don’t do it. If you would walk between us without hesitation if we were talking in English, then you can safely walk in between a sign language conversation. That doesn’t mean walk, then stop, examine your clothes, fiddle around, and so forth. If you take more than a second, you’ll annoy us. Just act normally, please. That goes for a lot of other things related to deafness that I’ve experienced in my life.
Minecraft for AI Research?
More games are jumping on the AI bandwagon.
We saw IBM’s Deep Blue, which beat chess Grandmaster Gary Kasparov in 1997. Then in 2013, we saw DeepMind’s AI agents^{1} achieve humanlevel performance on many classic Atari 2600 games. Then earlier this year, we saw DeepMind’s next product, AlphaGo, beat Lee Sodol in a widely publicized Go match. You can view the details on DeepMind’s AlphaGo website, which also has the corresponding Nature paper. I have not read it yet (it’s on my TODOlist), but I read and considerably enjoyed their other Nature paper (from 2015) about Atari 2600 games.
Yet it looks like we are not done with AI and games. The news is out that Microsoft Research has made Project Malamo open source! It allows people to use the popular sandbox game Minecraft for AI research. Microsoft has been using it for a few months, as evident by this earlier article, but I only found out about Project Malamo after it became open source. Ironically, I didn’t find this by browsing Microsoft’s website — I found it on the Minecraft forum website.
Their overall goal is stated as follows:
[…] five computer scientists are spending their days trying to get a Minecraft character to climb a hill.
That may seem like a pretty simple job for some of the brightest minds in the field, until you consider this: The team is trying to train an artificial intelligence agent to learn how to do things like climb to the highest point in the virtual world, using the same types of resources a human has when she learns a new task.
That means that the agent starts out knowing nothing at all about its environment or even what it is supposed to accomplish. It needs to understand its surroundings and figure out what’s important – going uphill – and what isn’t, such as whether it’s light or dark. It needs to endure a lot of trial and error, including regularly falling into rivers and lava pits. And it needs to understand – via incremental rewards – when it has achieved all or part of its goal.
Stated succinctly, they want to train the player to get to higher ground in Minecraft, without having to explicitly code that concept. One can formulate this as a reinforcement learning problem using some form of a Markov Decision Process (you can view my earlier article on MDPs here). As in the case for DeepMind’s work, the researchers of Project Malamo want to accomplish this while only relying on information that a human can see. That is, they want the agent to learn like a human would. This is definitely going to be a challenging problem. Minecraft is one of the most openended games ever, and even humans are often unsure of what their objectives are when playing. I’ve had people tell me, “what’s the point of Minecraft?”
The researchers are constraining their focus to “moving uphill”, which helps to narrow down the problem. That still results in a very broad game, and is unlike previous work using Chess, Go, and Atari 2600 games, which have clearer goals for the player. I will be particularly interested in seeing how researchers will compare their results. How do we evaluate the quality of agents? I am also curious about what role deep learning will play in this research.
On a final note, if they want an AI enthusiast who is also a Minecraft enthusiast to serve as a contributor … my contact information is on the “About” page of this website. Unfortunately, I have not played Minecraft in months (maybe a year?!?) and my guess is that a disproportionate share of computer scientists are also Minecraft players.

After they demonstrated their results, Google bought the company, so we commonly call them Google DeepMind. ↩
Donald Trump's Name Sign
When I need to use people’s names in sign language, I have three tactics I can draw upon. The best one is to invoke the person’s “official” sign name. The second tactic is to take the first letter of the person’s first name (or last, depending on context) and gently shake it. I view this as a generic way of signing someone’s name when a sign has not been established. The third tactic is to avoid a sign name all together and fingerspell.
It is not always possible to use the first tactic. When babies are born, we assign English names right away, often having predetermined them beforehand. But finding an appropriate name sign for someone — regardless of whether he or she is deaf or hearing — requires many more years. This is due to an informal rule that a person can only be given a name sign by someone who is “culturally Deaf.” In addition, as a practical manner, most name signs combine the first letter of the person’s first name and a personal characteristic. This is the case for my name sign, which is to form a “D” in one’s dominant hand and then to peck one’s forehead twice. It’s to indicate “intelligence.” Yes, I know it’s embarrassing, and please don’t use it in my presence. I don’t know who gave it to me.
For these reasons, the use of name signs in official ASL conversations is often restricted to people who know each other well. The exception, of course, is with famous people. I got particularly curious about one man’s name sign when one of my high school sign language interpreters suggested it in a recent conversation with me at a local Starbucks. That man is Donald Trump.
A Google search for “Donald Trump name signs” leads to an interesting article from the Washington Post, which describes not only a proposed name sign for Trump, but also signs for other notable politicians: Bernie Sanders, Bill Clinton, Richard Nixon, Ronald Reagan, and Barack Obama. Of all the politicians listed, I have only used Obama’s name sign, which I quite enjoy. It is quick enough to use and represents his name with the beginning “O” along with the hand movement to indicate America’s flag. Quite conveniently, the (sideways) “B” that’s used to represent the flag is also the second letter in “Obama.”
Name signs are hard to get. Other than politicians and religious figures, I can only remember using a name sign for William Shakespeare. It involves moving one’s dominant hand as if one is shaking a small bag (since, you know, “shake” and Shakespeare).
While the Washington Post certainly has a suitable name sign for Trump, I got curious and investigated to see if there were alternatives. You can find plenty of proposals on YouTube videos. Almost all are variations of making fun of Trump’s hair, which should have been obvious in retrospect.
Here is a video I found that, in my opinion, represents the best version of a Trump name sign. It is a variation of the Washington Post’s sign; it repeats the handwaving motion of Trump’s hair. This is fine since it can be done quickly. That video has some other context to it, so for your convenience, here’s my English translation of it:
Hi, Tad! You asked me, what is the sign name for Trump? Interesting. My husband and I discussed this and after a long time, we finally settled on a sign for him. Tonight, at the ASL SLAM [demonstrates sign], I was curious and asked everyone about a name sign for Trump. We had already settled on this one: [demonstrates sign] What do you think? [demonstrates sign again]
Regardless of whether you agree or disagree with his unorthodox policies, you have to admit that this sign is appropriate.
Captioning and Other Accommodations During my Trip to Washington DC
I took a break from paper reviewing to be in Washington DC for a few days. This marked my first time being in the city, and it’s been a pleasure to tour arguably the most important one of our country. My visit coincided with the July 4 weekend, so there was a lot of patriotism on display. Among my itinerary in Washington DC was Capitol Hill and the Smithsonian National Air and Space Museum. Both are governmentcontrolled entities, which means that admission is free (because we pay for it with our taxes^{1}) and that they are expected to provide reasonable accommodations for people with disabilities.
Just to be clear, I don’t want to suggest that the private sector doesn’t do a good job providing accommodations. I do, however, believe that government agencies might be slightly, slightly more sensitive for the need to provide disabilityrelated accommodations. After all, wouldn’t it be an embarrassment if they failed to follow the Americans with Disabilities Act?
Not having done much planning in advance (thank you, paper reviewing!) I didn’t know what to expect with regards to accommodations. Fortunately, my Capitol Hill visit turned out quite well. Despite not having a reservation, I was able to participate in a guided tour of the building. This was split in two parts. The first was a brief introductory video which described our nation’s remarkable history in 1015 minutes. Fortunately, it had open captioning, so I was able to understand it.
The second part was the actual building tour. There were so many people that the guides split us up into five groups, each with our own guide. What was interesting, though, was that we were all provided headsets so that we could hear our tour guide speaking in his microphone (and only our tour guide, not the others). This worked out well when we were in crowded areas with several tour guides talking at once. For me, of course, I wouldn’t have benefited much from the headsets. Fortunately, after inquiring, I got a TCoil necklace, and wow, that really amplified my guide’s voice! It was even louder than what I’m used to with FM systems, and on top of it all, there was no static. As a result, I understood most of what my guide said throughout the tour. Speaking of the actual tour, it was a nice experience looking inside Capitol Hill; we passed by Speaker Paul Ryan’s office, though we obviously didn’t see the Speaker himself. We didn’t get to explore much of the building, unfortunately, and there is still substantial construction going on, obscuring much of the inner Capitol Hill dome. Perhaps later I can try and get a better tour by submitting my name in the lottery for the tours arranged by the California Representatives or Senators? Nonetheless, it was still a good experience for me and I was happy with the tour and the accommodations.
I had a different experience at the Smithsonian Museum. After touring some of the ground floor exhibits, I paid a ticket for one of their “featured films”. I first asked for the standard (nonIMAX) film that was closest to starting, but after I asked, the cashier told me it did not have captions, and she recommended I instead watch A Beautiful Planet, offered in IMAX. Once the doors opened to enter the theater, I lined up with everyone to take our 3D glasses. I found my way into a good seat in the center of the auditorium, and … there were no captions. IMAX films are quite loud, but even so, I could not make out the conversations among the astronauts in the film. I actually fell asleep about ten minutes into it out of boredom, and woke up at the end of the film. I was a bit disappointed that an IMAX film causes me to nap rather than watch a movie (and no, I didn’t even turn off my hearing aids). I wonder: should I have asked for more details on the captioning? I don’t recall the exact words I uttered, but it’s true that I could always have been more specific with my wording. Or was I supposed to get different 3D glasses, kind of like how I got a different kind of “headset” for the tour guide? I wouldn’t be surprised if they had closed captioning glasses. Or now that I think about it, did I simply mishear the person who I asked about this?
Lesson learned: I need to ask more questions, and to plan ahead for these onceinafewyears visits.

Ah, but doesn’t that mean foreigners who visit are freeriding on us? Throughout my entire visit, no one ever asked me to prove my American citizenship. ↩
Currently Reviewing Papers for NIPS 2016
This year, I volunteered to be a NIPS reviewer, since I want to get the experience of reviewing academic papers. It was pretty easy to volunteer: for every paper submitted to NIPS, they asked that at least one of the authors offer to be a reviewer, and preferably not someone who’s already on their list of known reviewers. I’m clearly not among that elite crowd, and I wanted to review anyway, so it was an easy choice for me.
This year, NIPS had around 2500 (!) paper submissions, according to the number I saw in the Conference Management Toolkit website, which is what NIPS uses to manage paper submissions and reviews. I think the exact number I saw was roughly 2450ish, but it’s worth noting that papers with authors who match my conflict of interest domains (especially “berkeley.edu”) wouldn’t appear on this list. When I was submitting my paper bids for reviewing purposes, I couldn’t find the paper I submitted (fortunately!).
For obvious reasons, I can’t divulge too much about the papers I’m reviewing. But I can probably safely say this: I got assigned four papers to review in the span of roughly a month (from June 17 to July 17). So I’m reviewing right now, and decided to write this blog post during one of my breaks. Now that I’ve read all my assigned papers and have moreorless come up with a very highlevel draft conclusion about them, here are four thoughts:

Unfortunately, I’m probably deeply qualified to review … none of the four papers. For two of the papers, I understand much of the main ideas, but I still lack intricate knowledge of the math and algorithms they use, and about the most prevalent related work. For two other papers, I’m close to being lost on them. Therefore, I have made this a rule: for each paper, I will allow myself to read one extra reference for background information. One. So effectively, my reading load for this cycle is eight papers, four to be read indepth and four to be read semiindepth. This raises my curiosity: how do people actually carefully review papers? The vast majority of NIPS papers are extraordinarily specialized and technical, and many still have proofs in appendices. I don’t see how it is humanly possible for me to verify the proofs and make sure the math lines up correctly, especially with an internship that already takes up about 50 hours a week. It can take hours just to verify one simple line of equations in a paper, which might require looking through a previous paper reference, checking Wikipedia for additional background information, and then marking down an annoying typo that got me confused. Can an experienced NIPS reviewer please tell me how he or she reviews papers?

Fortunately, the previous thought might not matter because, despite not having gone through all the technical material so far (I’ve only been reviewing a week!) I feel like I can more or less tell how I feel about the papers. For instance, the amount of formalism and “cleanliness” of the paper gives a good clue about its quality. If the paper is rife with typos and sloppy LaTeX, or if the figures look spectacularly lowquality, that’s just asking for a rejection. (Come on, with matplotlib embedded in Jupyter notebooks, people should be able to produce acceptable figures.) Note that by this, I’m excluding language issues that might arise due to nonnative English speakers writing the paper. It’s not fair to them.

It’s nice reviewing papers without knowing the identity of the authors. NIPS is double blind, which I believe to be a good thing, and I say this as someone who would probably benefit from an open reviewing process. I don’t want to think about the authors’ identities. I have not actively searched so I’m still in the dark about this for all four of my papers. As a reviewer, I like my identity being protected, so I’m reconsidering my earlier thought about making some of the reviews public (sadly, if this were politics, I’d be accused of “waffling”). Unfortunately, for one of my papers, I have a good feeling about who at least one of the authors is based on previous research, despite how I haven’t been in this field very long (and some would argue, have never been in this field). In addition, two of my other papers have a previous reference which is obviously similar to the current work, and since I ended up using those papers as my “background reference” material and seeing practically wordforword similarities … author similarities follow. I’ll keep my guesses in mind and then see how they turn out later in August.

Despite my internship, I would bet I have more time on my hands than most faculty for reviewing, because I have fewer competing priorities and because I would be assigned fewer papers (hopefully … did I?). Thus, I will try to write some really detailed suggestions or at the very least, thoughtprovoking comments/questions, and I think the authors would appreciate that even if their papers don’t get accepted. At all costs, I am not going to be writing those dreaded three line reviews that contribute nothing. Sadly, I frequently see these online at the NIPS proceedings, which makes reviews public for accepted papers. As a result, this period from midJune to midJuly is going to be super busy for me, since I am doing all my reviewing in nights and weekends. I am really trying to make sure my reviews are helpful.
That’s all for now — I need to get back to reviewing.
Some Recent Results on Minibatch Markov Chain Monte Carlo Methods
I have recently been working on minibatch Markov chain Monte Carlo (MCMC) methods for Bayesian posterior inference. In this post, I’d like to give a brief summary of what that means and mention two ICML papers (from 2011 and 2014) that have substantially influenced my thinking.
When we say we do “MCMC for Bayesian posterior inference,” what this typically means is that we have some dataset and a parameter of interest for some . The posterior distribution we wish to estimate (via sampling) is
You’ll notice that we assume the data is conditionally independent given the parameter. In many cases, this is unrealistic, but most of the literature assumes this for simplicity.
After initializing , the procedure for sampling the posterior on step is:
 Draw a candidate
 Compute the acceptance probability (note that the denominators of cancel out):
 Draw , and accept if . This means setting . Otherwise, we set and repeat this loop. This tripped me up earlier. Just to be clear, we generate a sample every iteration, even if it is a repeat of the previous one.
This satisfies “detailed balance,” which roughly speaking, means that if one samples long enough, one will arrive at a stationary distribution matching the posterior, though a burnin period and/or only using samples at regular intervals is often done in practice. The resulting collection of (correlated!) samples for large can be used to compute the value of . Let’s consider a very simple example. Say can take on three values: , , and . If our sampled set is , then since appears two times out of four, we have . The other two probabilities would naturally have each according to the samples.
One issue with the standard procedure above is that in today’s big data world with on the order of billions, it is ridiculously expensive to compute because that involves determining all of the likelihood factors. Remember, this has to be done every iteration! Doing all this just to get one bit of data (whether to accept or not) is not a good tradeoff. Hence, there has been substantial research on how to perform minibatch MCMC on large datasets. In this case, rather than use all data points, we just use a subset of points each iteration. This approximates the target distribution. The downside? It no longer satisfies detailed balance. (I don’t know the details on why, and it probably involves some complicated convergence studies, but I am willing to believe it.)
Just to be clear, we are focusing on getting a distribution, not a point estimate. That’s the whole purpose of Bayesian estimation! A distribution means we need a full probability function that sums to one and is nonnegative; if is one or two dimensional, we can easily plot the posterior estimate (I provide an example of this later in this post). A point estimate means finding one value of , usually the “best”, which we commonly express as the maximum likelihood estimate .
All right, now let’s briefly discuss two papers that tackle the problem of minibatch MCMC.
Bayesian Learning via Stochastic Gradient Langevin Dynamics
This paper appeared in ICML 2011 and proposes using minibatch update methods for Bayesian posterior inference, with a concept known as Langevin Dynamics to inject the correct amount of noise into parameter updates so that the set of sampled parameters converges to the posterior, and not just a mode. To make the distinction clear, let’s see how we can use minibatch updates to converge to a mode — more specifically, the maximum a posteriori estimate. The function we are trying to optimize is listed above. So … we just use stochastic gradient ascent! (We are ascending, not descending, because is a posterior probability, and we want to make its values higher.) This means the update rule is as follows: . Plugging in above, we get
where is a sequence of step sizes.
The above is a stochastic gradient ascent update because we use terms to approximate the gradient value, which is why I inserted an approximation symbol () in the underbrace. Because we only use terms, however, we must multiply the summation by to rescale the value appropriately. Intuitively, all those terms in that summation are negative since they’re log probabilities. If we use instead of terms, that summation is strictly smaller in absolute value. So we must rescale to make the value on the same order of magnitude.
What’s the problem with the above for Bayesian posterior inference? It doesn’t actually do Bayesian posterior inference. The above will mean converges to a single value. We instead want a distribution. So what can we do? We can use Langevin Dynamics, meaning that (for the full batch case) our updates are:
A couple of things are worth noting:
 We use all terms in the summation, so the gradient is in fact exact.
 The injected noise means the values will “bounce around” to approximate a distribution and not converge to a single point.
 The is now constant instead of decreasing, and is balanced so that the variance of the injected noise matches that of the posterior.
 We use instead of as we did earlier. The only difference is that the indicates the randomness in the minibatch. It does not mean that is one scalar element of a vector. In other words, both and are in for some .
For simplicity, the above assumes that . In the general case, these should be multivariate Gaussians, with covariance .
The problem with this, of course, is the need to use all points. So let’s use points, and we have the following update:
where now, we need to vary and decrease towards zero. The reason for this is that as the step size goes to zero, the corresponding (expensive!) MetropolisHastings test has rejection rates that decrease to zero, effectively meaning we can omit it.
Austerity in MCMC Land: Cutting the MetropolisHastings Budget
This paper appeared in ICML 2014, and is also about minibatch MCMC. Here, instead of relying on simulating the physics of the system (as was the case with Stochastic Gradient Langevin Dynamics), they propose reformulating the standard MCMC method with the standard MH test into a sequential hypothesis test. To frame this, they take the log of both sides of the acceptance inequality:
In the first step we also dropped the initial “min” because if the “1” case applies, we will always accept. In the last step we divide both sides by . What is the purpose of this? The above is equivalent to the original MH test. But the right hand side depends on all data points, so what happens if we compute the right hand side using points?
This is the heart of their test. They start out by using a small fraction of the points and compute the right hand side. If the proposed element is so out of whack, then even with just points, we should already know to reject it. (And a similar case holds if is really good.) If we cannot tell whether to accept or reject with some specified confidence threshold, then we increase the minibatch size and test again. Their acceptance test relies on the Central Limit Theorem and the Studentt distribution. The details are in the paper, but the main idea is straightforward: increasing the number of samples increases our certainty as to whether we accept or reject, and we can generally make these decisions with far fewer than samples.
What’s the downside of their algorithm? In the worst case, we might need the entire data in one iteration. This may or may not be a problem, depending on the particular circumstances.
Their philosophy runs deeper than what the above says. Here’s a key quote:
We advocate MCMC algorithms with a “biasknob”, allowing one to dial down the bias at a rate the optimally balances error due to bias and variance.
One other algorithm that adheres to this strategy? Stochastic Gradient Langevin Dynamics! (Not coincidentally, Professor Max Welling is a coauthor on both papers.) Side note: the reason why SGLD is biased is because it omits the MetropolisHastings test. The reason why this algorithm (Adaptive Sampling) is biased is because it makes decisions based on a fraction of the data. So both are biased, but for slightly different reasons.
Putting it All Together: A Code Example
In order to better understand the two papers described above, I wrote some Python code to run SGLD and adaptive sampling. I also implemented the standard (fullbatch) MCMC method for a baseline.
I tested using the experiment in Section 5.1 of the SGLD paper. The parameter is 2D, , and the parameter/data generation process is
and
I’ve pasted all my Python code here. If you put this together in a Jupyter notebook, it should work correctly. If your time is limited, feel free to skip the code and go straight to the output. The code is here mainly for the benefit of current and future researchers who might want a direct implementation of the above algorithms.
The first part of my code imports the necessary libraries and generates the data according to my interpretation of their problem. I am generating 500 points here, whereas the SGLD paper only used 100 points.
Next, I define a bunch of functions that I will need for the future. The most important one is the
log_f
function, which returns the log of the posterior. (Implementing this correctly requires
filling in some missing mathematical details that follow from the formulation of multivariate
Gaussian densities.)
Next, I run three methods to estimate the posterior: standard fullbatch MCMC, Stochastic Gradient Langevin Dynamics, and the Adaptive Sampling method. Code comments clearly separate and indicate these methods in the following code section. Note the following:
 The standard MCMC and Adaptive Sampling methods use a random walk proposal.
 I used 10000 samples for the methods, except that for SGLD, I found that I needed to increase the number of samples (here it’s 30000) since the algorithm occasionally got stuck at a mode.
 The minibatch size for SGLD is 30, and for the Adaptive Sampling method, it starts at 10 (and can increase by 10 up to 500).
With the sampled values in all_1
, all_2
, and all_3
, I can now plot
them using my favorite Python library, matplotlib. I also create a contour plot of what the log
posterior should really look like.
By the way, it was only recently that I found out I could put LaTeX directly in matplotlib text. That’s pretty cool!
Here are the results in a scatter plot where darker spots indicate more points:
It looks like all three methods roughly obtain the same posterior form.
Islam and the Future of Tolerance
I just read Islam and the Future of Tolerance: A Dialogue, by renowned atheist Sam Harris and former jihadistturnedliberalactivist Maajid Nawaz. I had this book on my radar for a while, and decided to read it yesterday in the wake of the tragic news of the recent Orlando shootings. My hope is to better understand what drives people to extremism and how we can reduce the probability of similar attacks from occurring.
I first found out about the book from browsing the website of Sam Harris, one of the four “New Atheists.” Harris and I see eyetoeye on a number of issues. The most obvious one is that we are atheists. In addition, we both support LGBT rights, scientific reasoning, taxing billionaires, and we disapprove of the Iraq war. I do not claim to agree with everything he says, of course. Indeed, some of Harris’s statements have been controversial (as one would expect when dealing with religion). He actually felt compelled to write a blog post to respond to controversy.
As of this writing, Islam and the Future of Tolerance is Harris’ most recent book, but the interesting thing is that it’s actually a dialogue with Maajid Nawaz, listed as the book’s coauthor. Nawaz has a remarkable personal story, which he describes in his 2013 autobiography Radical: My Journey Out Of Islamist Extremism. Nawaz was born in Britain, but after experiencing personal grievances (including racism), he joined the radical Islamist group Hizb utTahrir. After an arrest in Egypt, he turned his life around by rejecting radical Islam. Today, he is of the world’s foremost liberal Muslims and a key challenger to extremism.
Islam and the Future of Tolerance is a conversation between Harris and Nawaz about Islam. Harris is skeptical that Nawaz can achieve the goal of reforming Islam. Harris, however, concedes that people like Nawaz — and not “infidels” like himself — are the ones who have to do the job. How can the faith reformation happen? What will be the future of Islam? That is the subject of their dialogue. Here are some of the highlights of their conversation, outlined according to the section:

The Roots of Extremism. This is a short section where Nawaz provides an abbreviated version of his autobiography.

The Scope of the Problem. Here’s the key takeaway: a primary issue with getting Muslims and nonMuslims to ally together is that the largest group of Muslims, which Harris and Nawaz call “religiously conservative Muslims”, do not wholeheartedly support contemporary liberal human rights. Thus, while those Muslims would be our allies against the Islamic State, they would also resist our efforts in promoting women’s rights, LGBT rights, etc.

The Power of Belief. Harris asks Nawaz how he originally became radicalized. Was it due to “ordinary” grievances that might be corrected with more tolerance (e.g., turning to radical Islam due to racism from nonMuslims?), or due to deeper forces such as martyrdom? I have frequently wondered about this process because, as an atheist, I struggle to understand how something like religion (in its most extreme form) can systematically guide people towards terror, barbarianism, and destruction.

The Betrayal of Liberalism. Both Harris and Nawaz slam liberals for their adherence to “political correctness.” (Donald Trump would be proud of them.) In the previous chapter, Harris rips liberal scholars who say that the West is to blame for the problems in Middle Eastern societies. Harris and Nawaz point out one unfortunate consequence of political correctness: that only rightwing bigots are accurately assessing jihadists nowadays.

The Nature of Islam. Harris argues that most of our human rights progress in the last few centuries is despite the presence of religions such as Judaism, Christianity, and (especially) Islam. There are plenty of religious moderates, but Harris argues that these moderates somehow have to filter out the more dangerous parts of their scripture. Harris concludes that the purest interpretation of reading scripture — and therefore leaving out personal biases — would actually favor the Islamic State:
This is why the approach of a group like the Islamic State has a certain intellectual appeal (which, admittedly, sounds strange to say) because the most straightforward reading of scripture suggests that Allah advises jihadists to take sex slaves from among the conquered, decapitate their enemies, and so forth.
 Finding the Way Forward. Most of this section concerns the fatwa against the Islamic State. Harris and Nawaz, while recognizing that a fatwa is better than no fatwa, have reservations because it belies the true issues with Islamic tolerance. Near the end, Harris and Nawaz talk about the heavily American phenomenon of “being at war with Islam.” Harris admits that he may have played a role in assisting that culture, and Nawaz argues that President Obama must start naming the enemy radical Islam (I believe Nawaz is correct on this, but I also believe too much has been made out of this).
Despite the book’s brevity, I feel like both men were able to make good points. The conversation as a whole, while certainly not being a substitute for a more rigorous study of the role of religion in history, provides some interesting highlights. I learned about several historical events and spent some time browsing the corresponding Wikipedia pages to learn more.
One of my biggest takeaways from the book is that I doubt if liberals are effectively handling the problem of radical Islam. Harris and Nawaz, while both being liberals (in the sense that they would vote Democratic in the United States), would argue that liberals are not doing a good job. But they would also have that opinion of the conservative response.
But there’s something more important I need to mention. I think this conversation is useful because it shows how how people with different religious beliefs can come together and have a friendly, reasonable discussion without ripping each other’s throats. Nawaz is not that religious, but we need to have a starting point for a honest conversations with Muslims, and this dialogue serves that role effectively. In the wake of the Orlando shootings, these conversations give me hope that humanity will grow more peaceful and more tolerant in the coming years. Having an open mind is incredibly important. As Nawaz concludes:
Allow me to to take this opportunity to also thank you, Sam. It isn’t easy for anyone to reach across divides — real or imagined — and try to hold a sensible dialogue amid so much background noise and confusion. You will no doubt be censured by some Islam critics for not insisting that I am in fact a closet jihadist, just as I will be criticized by many Muslims for having this conversation with you.
Thanks to Sam Harris and Maajid Nawaz for having this conversation.