Advanced Machine Learning: CS 281

CS 281: Advanced Machine Learning
taught by Sasha Rush

Fall 2017
Contents
Discrete Models 2
Multivariate Normal Distributions 5
Linear Regression 8
Linear Classification 13
Exponential Families 18
Neural Networks 22
Backpropagation & Directed Graphical Models 25
Undirected Graphical Models 33
Exact Inference: Time Series 40
Exact Inference: Belief Propagation 46
Recurrent Neural Networks 51
Information Theory 55
Mixture Models 59
Mean Field 65
Variational Inference Part 2 69
Loopy BP, Gibbs Sampling, and VI with Gradients 74
Variational Auto-encoders and GANs 78
Monte Carlo Basics 81
Importance Sampling and Particle Filtering 84
1
CS281: Advanced ML September 6, 2017
Lecture 2: Discrete Models

Lecturer: Sasha Rush Scribes: Anna Sophie Hilgard, Diondra Peck
• Discrete models take values from a countable set, e.g. {0,1}, {cold, flu, asthma} and are simpler than
continuous models.
• We will use simple discrete models to develop our tactics such as marginalization and conditioning.
• Today, we will focus coins as a real-world example.
2.1 Bernoulli model

The likelihood is of the form p(heads) = θ.
Easy Prior
Assume we know the coin came from one of 3 unknown manufacturers (later, we’ll have mixture model
estimation, but for now assume these probabilities come from an oracle).
1. θ = 0.4 with probability .1
p(θ ) = 0.1 · δ(θ = 0.4) + 0.8 · δ(θ = 0.5) + 0.1 · δ(θ = 0.6)
Likelihood
Likelihood = p(data|parameters). For the coin example,

N
p(coin flips|θ ) = Bin( N1 | N, θ ) = θ N1 (1 − θ ) N − N1 where N = N0 + N1 = number of flips
N1
Note that the last two terms, the ”score”, is our focus since they are the only terms that depend on θ. The
first term normalizes the distribution.
2.2 Inference
Inference 1: p(θ | x ) (x ∈ N0 , N1 ). How can we estimate θ?
Maximum Likelihood Estimation (MLE)
θ MLE = argmaxθ p( N0 , N1 |θ ) = argmaxθ log [ p( N0 , N1 |θ )]

N
θ MLE = argmaxθ log + N1 logθ + N0 log(1 − θ ) Because the first term is not a function of θ, we can ignore it.
N1
d N N0 N1
= 1+ · (−1) → θ MLE =
dθ θ 1−θ N0 + N1
Note that Inference 6= Decision Making. If we asked you to make a bet on the coin, based on this you could
either
2
1. Always take heads if θ > .5. In this case, p(win) = θ
2. Take heads with probability = θ. In this case, p(win) = θ 2 + (1 − θ )2 [p(is heads) * p(choose heads) +
...]
If θ = 0.6, for option 1, p(win) = θ = 0.6. For option 2, p(win) = θ 2 + (1 − θ ) = 0.52. In this case, the additional
information used in the calculation of option 2 does not result in a better decision.
Maximizing the Posterior (MAP)

Bayes Rule : p(θ |data) ∝ p(data|θ ) p(θ )
• Posterior: p(θ |x)
• Likelihood: p(x|θ )
• Prior: p(θ )
θ MAP = argmaxθ p(θ |x) = argmaxθ log [ p(x|θ ) p(θ )] from Bayes’ Rule: p(θ |x) ∝ p(x|θ ) p(θ )
Consider an example:

N
p(θ = 0.4| N0 , N1 ) ∝ (.4) N1 (1 − .4) N0 (0.1)
N1
p(θ = 0.45| N0 , N1 ) = 0 Due to the sparsity of the prior - similar result for θ = 0.5 and 0.6
θ MAP = θ MLE when we have a uniform prior since the MLE calculation does not explicitly factor a prior
into its calculation.
Full Posterior
R
Partition or Marginal Likelihood: p( N0 , N1 ) = θ p( N0 , N1 , θ ).
p( x |θ ) p(θ )
p(θ | N0 , N1 ) = Note that p( N0 , N1 ) is a very difficult term to compute.
p( N0 , N1 )
Beta Prior
Γ ( α 0 + α 1 ) α1 −1
p ( θ | α0 , α1 ) = θ (1 − θ ) α0 −1 support ∈ [0, 1]
Γ ( α0 ) Γ ( α1 )
From the image of the beta function for different parameters, we can see that it can ether be balanced,
skewed to one side, or tend toward infinity on one side.
With a beta prior:
Γ ( α 0 + α 1 ) α1 −1
p(θ | N0 , N1 ) = θ (1 − θ )α0 −1 θ N1 (1 − θ ) N0 · (constant normalization term w.r.t θ)
Γ ( α0 ) Γ ( α1 )
The key insight is that we get additive terms in the exponent and the resulting distribution looks like an-
other beta. The prior ”counts” (pseudocounts) from the hyperparameters can be interpreted as counts we
have beforehand.
Γ(α0 + α1 ) N1 +α1 −1
p(θ | N0 , N1 ) = θ (1 − θ ) N0 +α0 −1 · (constant normalization term w.r.t θ)
Γ ( α0 ) Γ ( α1 )
3
Figure 2.1: Beta Params
To make this distribution sum to 1, use the known beta normalizer
Γ(α0 + α1 + N0 + N1 ) N1 +α1 −1
p(θ | N0 , N1 ) = θ (1 − θ ) N0 +α0 −1 ∼ Beta(θ | N0 + α0 , N1 + α1 ) (posterior)
Γ(α0 )Γ(α1 )Γ( N0 )Γ( N1 )
The mode of the Beta gives us back θ MAP , but with additional information about the shape of the distribu-
tion. What does the prior that tends to infinity at 1 imply? That in the absence of other information, the
coin is definitely heads.
Predictive Distribution
Z
p( x̂ | N0 , N1 ) = p( x |θ, N0 , N1 ) p(θ | N0 , N1 )dθ
Zθ
= θ p(θ | N0 , N1 )dθ
θ
= Eθ ∼ p(θ | N0 ,N1 ) θ
This is the expectation under the posterior of θ which is the mean of the Beta distribution. Feel free to prove
this as an exercise.
Marginal Likelihood
Z
p( N0 , N1 ) = p( x1 , . . . xn |θ ) p(θ )dθ
θ
Z
Γ(α1 + α1 ) α1 + N1 −1
= θ (1 − θ )α0 + N0 −1
θ Γ ( α0 ) Γ ( α1 )
The first term can be moved outside, as it does not depend on θ. After introducing our normalization term
and making the distribution insidesum to 1,
Γ(α1 + α1 ) Γ( N0 + α0 )Γ( N1 + α1 )
p( N0 , N1 ) =
Γ(α0 )Γ(α1 ) Γ( N0 + N1 + α0 + α1 )
4
2.3 Extensions on the Coin Flip Model: Super Coins
• Many correlated coins: models of binary data, important for discrete graphical models
• Many-sided coins aka dice: models of categorical data, generalization of Bernoulli
2.4 Other Distributions
Bernoulli( x |θ ) = θ x (1 − θ ) x
∏ θk k
x
Categorical( x |θ ) = generalization of Bernoulli
k
(∑ xk )!
∏θ k
x
Multinomial( x |θ ) = generalization of Binomial
∏k xk ! k k
Γ(∑ αk ) α −1
Dirichlet( x |α) =
∏ Γ(αk )
∏ θk k generalization of Beta, often used as a prior
k
Note that the Dirichlet distribution is the conjugate prior of the Categorical and Multinomial distributions.
2.5 Example notebook

See Beta.ipynb
5
Lecture 3: Multivariate Normal Distributions

Lecturer: Sasha Rush Scribes: Christopher Mosch, Lindsey Brown, Ryan Lapcevic
3.1 Examples
Multivariate gaussians are used for modeling in various applications, where knowing mean and variance
is useful:
• radar: mean and variance of approaching objects (like invading aliens)

• weather forecasting: predicting the position of a hurricane, where the uncertainty in the storm’s posi-
tion increases for timepoints farther away
• tracking the likely outcome of a sports game: last year’s superbowl is an example of a failure of
modeling with multivariate gaussians as the Patriots still won after a large Falcons’ lead
3.2 Review: Eigendecomposition

Let Σ be a square, symmetric matrix. Then its eigendecomposition is given by Σ = U T ΛU, where U is
an orthogonal matrix and Λ is a diagonal matrix. In the special case that Σ is positive semidefinite (as is
the case for covariance matrices), denoted Σ 0, all its eigenvalues are nonnegative, Λii ≥ 0, and we can
decompose its inverse as Σ−1 = U T Λ−1 U, where Λii−1 = 1/Λii .
3.3 Multivariate Normal Distributions (MVNs)

Let X be a D-dimensional MVN random vector with mean µ and covariance matrix Σ, denoted X ∼
N (µ, Σ). Then the pdf of X is
1
p( x ) = (2π )− D/2 |Σ|−1/2 exp [− ( x − µ) T Σ−1 ( x − µ)],
2
where for many problems we focus on the quadratic form ( x − µ) T Σ−1 ( x − µ) (which geometrically can be
thought of as distance) and ignore the normalization factor (2π )− D/2 |Σ|−1/2 . The figure below plots the
contours of a bivariate Normal for various µ and Σ (in the figure, ρ denotes the off-diagonal elements of Σ,
given by the covariance of x1 and x2 ).
6
Note that we can decompose Σ as
Σ = ( x − µ ) T Σ −1 ( x − µ )

= ( x − µ ) T U T Λ −1 U ( x − µ )
!
1
= ( x − µ) T
∑ λd Ud U (x − µ)
T
d
1
=∑ ( x − µ)T Ud UdT ( x − µ),
d
λd
where ( x − µ) T Ud can be interpreted as the projection of ( x − µ) onto Ud (which can each be thought of as
univariate gaussians), the eigenvector corresponding to the eigenvalue λd . Since Σ is the weighted sum of
the dot product of such projections (with weights being given by 1/λd , which can be thought of as the scale
1/σ2 ), we can describe the MVN as tiling of univariates.
3.3.1 Manipulating MVNs: Stretches, Rotations, and Shifts

Let x ∼ N (0, I ) and y = Ax + b. We want to consider two ways of obtaining the complete distribution of
y.
• ’Overkill’: We can perform a change of variables1 . Here, we have x = A−1 and |dx/dy| = | A−1 |,
leading to

p(y) = N A−1 (y − b)|0, I | A−1 |
1
= exp [( A−1 (y − b)) T ( A−1 (y − b))]
z
1
= exp [(y − b)T ( A−1 )T ( A−1 )(y − b)]
z
= N (y|b, AA T ),
where z is the normalizing constant.
• Using the properties of MVN, we know that y is also MVN, so is completely specified by its mean and
covariance matrix which can easily be derived,
E(y) = E( Ax + b) = AE( x ) + b cov(y) = AA T .
Thus, we can generate MVN from N (0, I ) via the transformation y = Ax + b, where we set A = UΛ1/2 ,
leading to ΣY = U T ΛU. Then shifts are represented by b, stretches by Λ, and rotations by U.
3.3.2 Detour: MVN in High-Dimensions (D 0)

Let x be a D-dimensional random vector, distributed as N (0, I/D ), where I is the identity. The expected
length of x is given by !

E k x k2 = E ∑ xd2 = Dσd2 = 1,
d
which means that x is expected to be on the boundary of a unit sphere centered at the origin. Moreover, the
variance of the length is
2
2
var k x k = D · E( x ) − E x2
4
= D · (3σ4 − σ4 ) = 2D/D2 = 2/D
1A change of variables can be done in the following way: Let y = f ( x ) and assume f is invertible so that x = f −1 (y). Then
p(y) = p( x )|dx/dy|. This is a technique which will be used often in this course
7
Thus, it is not only expected that x lies on the boundary but as D increases most of its realizations will in
fact fall on the boundary2 .
3.3.3 Key Formulas for MVN: Marginalization and Conditioning

Let X ∼ N (µ, Σ) with
X1 µ1 Σ11 Σ12
X= , µ= , Σ= .
X2 µ2 Σ21 Σ22
Note that Σ is written in block matrix form, rather than scalar entries. It turns out that the marginals, X1
and X2 , are also MVN, and their mean and covariance matrice are given by µ1 and Σ11 and µ2 and Σ22
respectively. A sketch of the proof is provided below.
Z
p ( x1 ) = N ( x |µ, Σ)dx2 ,
x2
which can be written as

Z h i
−1 −1 −1
0.5 exp ( x1 − µ1 ) T Σ11 ( x1 − µ1 ) + 2( x1 − µ1 )T Σ12 ( x2 − µ2 ) + ( x2 − µ2 )T Σ22 ( x2 − µ2 ) dx2 .
x2
Note that this equals Z

p ( x1 ) p( x2 | x1 )dx2 ,
x2
implying that X1 ∼ N (µ1 , Σ11 ).

While the marginals have a simple form, the conditionals are more complicated. (For a complete derivation,
which requires matrix inversion lemmas, refer to Murphy.) It can be shown that X1 | X2 ∼ µ∞|∈ , Σ∞|∈ with
−1 −1
µ1|2 = µ1 + Σ12 Σ22 ( x2 − µ2 ), Σ1|2 = Σ11 − Σ12 Σ22 Σ21 .
3.3.4 Information Form

An alternative formulation, called information form, uses the precision matrix (inverse variance) Λ = Σ−1 .
Partitioning Λ as
Λ11 Λ12
Λ= ,
Λ21 Λ22
the covariance matrices of the conditional distributions have a simple form. For example, the covariance
matrix of X1 given X2 is Λ1|2 = Λ11 . However, the simplicity of the conditional precision comes at the
cost of marginalization (which was simple when using Σ) becoming a more complicated expression (see
Murphy subsection 4.3 for more details).
2 It is left as an exercise to show that this formula holds. Hint: Use the fact that we assumed no covariance.
8
Lecture 4: Linear Regression

Lecturer: Sasha Rush Scribes: Kojin Oshiba, Michael Ge, Aditya Prasad
4.1 Multivariate Normal (MVN)

The multivariate normal distribution of a D-dimensional random vector X is defined as:

− D2 − 21 1 T −1
N ( X |µ, Σ) ∼ (2π ) |Σ| exp − ( X − µ) Σ ( X − µ)
2
Note:
D 1
• (2π )− 2 |Σ|− 2 and − 12 are constants we can ignore in MLE and MAP calculations.
• ( X − µ) T Σ−1 ( X − µ) is a quadratic term.

There are three types of inference we’re interested in doing: MLE, MAP, and prediction.
4.2 Maximum Likelihood of MVN

Let θ = (µ, Σ), where Σ can be approximated as a diagonal/low rank matrix. If there are x1 , . . . , xn obser-
vations, the MLE estimate of µ is
µ∗ = arg max − ∑ logN ( xn |µ, Σ)
µ n
= arg max log(constant) − ∑( xn − µ)T Σ−1 ( xn − µ)

µ n
= arg max − ∑( xn − µ) Σ T −1
( xn − µ)
µ n
Let L = ∑n ( xn − µ) T Σ−1 ( xn − µ).
dL
= Σ n Σ −1 ( x n − µ ) = 0
dµ
Σ
⇔ µ∗MLE = Xn
N
Similarly,
dL
= (exercise) = 0
dΣ
1 1 >
⇔ Σ∗MLE =
N ∑ xn xnT = N
X X
n
dL
For calculating dΣ as an exercise , the following might be helpful:
• d
dA ln | A | = A −1
d
• dA tr ( BA ) = BT
• tr ( ABC ) = tr ( BCA)
9
4.3 Linear-Gaussian Models
Let x be a vector of affine, noisy observations with a prior distribution:
x ∼ N ( m 0 , S0 )
Let y be the outputs:

y| x ∼ N ( Ax + b, Σy )
4.3.1 p( x |y)
We are interested in calculating the posterior distribution: p( x |y).
p( x |y) ∝ p( x ) p(y| x )
(
1 ( x − m0 )> S0−1 ( x − m0 )
= exp
2 +(y − ( Ax + b))> Σ− 1
y ( y − ( Ax + b ))
( > −1 ?? ?
1 x S0 x − 2x > S0−1 m0 + . . .
= exp ?? > −1 ? > −1 ?
2 + x > ( A> Σ− > >
y A ) x − 2x ( A Σy ) y + 2x ( A Σy ) b + . . .
1
The terms containing x are underlined. Double-starred (??) terms are quadratic in x, while single-starred
(?) terms are linear in x. The remaining terms are constants that are swallowed up by the proportional-
ity. By Gaussian-Gaussian conjugacy, we know the resulting distribution should be Gaussian. To find the
parameters, we’ll modify p( x |y) to fit the form of a Normal. This requires completing the square!
4.3.2 Completing the Square

−b b2
ax2 + bx + c → a( x − h)2 + k, h =
,k = c−
2a 4a
We ignore the k term since it too is swallowed up in the proportionality. In application to our problem, we
group the quadratic and linear terms together to calculate our terms for completing the square.
• “a” is S− 1 −1 > −1
N = S0 + A Σ y A
h i
• “h” is m N = S N S0−1 m0 + A> Σ−
y
1 (y − b)
In this more “intuitive” representation, we find that p( x |y) has the form of N (m N , S N ). Murphy also has a
more explicit representation:
• Σ x |y = Σ− > −1
x + A Σy A
1
• µ x |y = Σ x |y [ Σ− > −1
x µ x + A Σ x ( y − b )]
1
4.3.3 p(y)
We now calculate the normalizer term, p(y). Now, x is fixed. y follows the linear model:
y = Ax + b + e
The result is that y follows a Normal distribution with the following form:
p(y) = N (y| Am0 + b, Σy + AΣ x A> )
10
4.3.4 Prior (just for µ)
p ( µ ) = N ( µ | m 0 , S0 )
where m0 , S0 are pseudo mean, pseudo variance. p(µ) is defined Gaussian because Gaussian is the con-
jugate prior of itself. A prior is called a conjugate prior if it has the same distribution as the posterior
distribution.
4.3.5 Posterior (just for µ)

p(µ| X ) ∝ p(µ) p( X |µ) = N (µ|m0 , s0 ) N ( X |µ, Σ)
This is a special case of linear regression. Recall,
• “a” is S− 1 −1 > −1
N = S0 + A Σ y A
h i
• “h” is m N = S N S0−1 m0 + A> Σ− 1
y (y − b)
We let b = 0 and A = I. Then we obtain,
S− 1 −1
N = S0 + Σ
−1
m N = S N [S0−1 m0 + Σ−1 X ]
Hence,
p(µ| X ) = N (m|m N , S N )
4.3.6 Unknown Variance

Similar to µ, we can also define a conjugate prior on Σ, which is Inverse Wishart distribution. It is defined
as:
1 1
IW (Σ|S, ν) = |Σ|−(ν−( D+1)/2) exp{ tr (S−1 Σ−1 )}
2 2
• distribution over positive semi definite Σ with two parameters S, ν.
• pseudo info S = ΣXX T is a psuedo scatter matrix called the scale matrix. ν = nµ is degrees of freedom
where ν − ( D + 1) is the number of observations.
4.4 Linear Regression

In an undergraduate version of the class, we might define the problem as follows: We are given “fixed” set
of inputs, { xi }. We want to “predict” the outputs.
Here, we define the problem as attempting to compute p(y | x, θ). Consider the following example. We
assume that our data is generated as follows:
y = w T x + noise
Further, we assume that the noise (denoted by e) is distributed as Gaussian with mean 0; that is:
e ∼ N (0, σ2 )
Then, we have:
p(y | x, θ ) = N (y | w T x, σ2 )
Note that the bias term here is included as a dimension in w, w0 .
11
4.4.1 Log Likelihood
Consider a data-set that looks like {( xi , yi )}iN=1 . The log-likelihood L(θ) is given by:
L(θ) = log p(data | θ)

N
= ∑ log p(yn | xn , θ)
n =1
N
1
= ∑ log(constant) − 2σ2 (yn − wT xn )2
n =1
Note that data here refers to just the yi ’s. The yn ’s are called the target; the w represents the weights; and
the xn ’s are the observations. The term (yn − w T xn )2 is essentially just the residual sum of squares.
4.4.2 Computing MLE

We want the argmax of the log-likelihood. We therefore have:
N
1
argmaxw L(w) = argmax − ∑ 2σ
( y − w T x n )2
2 n
n =1
= argmaxw − [y − Xw] T [y − Xw]
h i
= argmaxw w T X T Xw − 2w T X T y + constant
There is an analytical solution to this, and we obtain it by simply computing the gradient and setting it to
0.
h i
∂w w T X T Xw − 2w T X T y = 2X T Xw − 2X T y
Setting this to 0, we obtain:
w MLE = ( X T X )−1 X T y
As we will see in homework 1, ( X T X )−1 X T y can be viewed as the projection of y onto the column space of
X.
4.5 Bayesian Linear Regression

In the Bayesian framework, we also introduce a probability distribution on the weights. Here, we choose:
p(w) = N (w | m0 , S0 )
Thus, we have:
p(y | X, w, µ, σ2 ) = N (y | µ + X T w, σ2 I )
We assume that µ = 0.
The posterior then is of the form:
p(w | . . .) ∝ N (w | m0 , S0 )N (y | X T w, σ2 I )
Applying the results obtained above with the linear Gaussian results, with:
b=0
A = XT
Σy = σ2 I
12
Thus, we have:
1
S N −1 = S0 −1 + 2 X T X
σ
−1 T 1
mN = S N S0 m0 + X y 2
σ
Now, we compute the posterior predictive:

Z
p(y | x, y) = N (y | w T x, σ2 )N (w | m N , S N )dw
Using the form for the marginal derived earlier, we have:
p(y | x, y) = N (y | X T m N , σ2 + X T S0 X )
The variance term is particularly interesting because now the variance has dependence on the actual data;
thus, the Bayesian method has thus produced a different result. The mean, however, is the same as the
MAP estimate (x T m N )
4.6 Non Linear Regression

All the examples done so far have been in linear space. To define an adaptive basis, we simply transform
point x with the transormation of our choice:
x → φ( x )
Examples include:
• φ1 ( x ) = sin( x )
• φ2 ( x ) = sin(λx )
• φ3 ( x ) = max(0, x )
• φ( x; w) = max(0, w0 > x )
The last example is the core of neural networks and deep learning where the weights are learned for each
level of w.
13
Lecture 5: Linear Classification

Lecturer: Sasha Rush Scribes: Demi Guo, Artidoro Pagnoni, Luke Melas-Kyriazi, Florian Berlinger
5.1 Classification Introduction

Last time we saw linear regression. In linear regression we were predicting y ∈ R, in classification instead
we deal with a discrete set, for example y ∈ {0, 1} or y ∈ {1, . . . , C }. This distinction only matters for this
lecture, starting from next class we will generalize the topics and treat them as the same thing.
Among the many applications, linear classification is used in sentiment analysis, spam detection, and facial
and image recognition. We will use generative models of the data, which means that we will model both
the x and the y explicitly, and we are not keeping x fixed. In the case of the spam filter earlier, x is the email
body, and y is the label {spam, not spam}. A generative model of the email and labels, we would model
the distribution of x, of the text in the email itself, and not only the distribution of the category y.
We will explore the basic method of Naı̈ve Bayes in detail. Even with a very simple method like Naı̈ve
Bayes with basic features it is possible to perform extremely well on many classification tasks when large
training data sets are available. For example, this simple model performs almost as well (one percent point
difference) as very complex methods on spam detection.
5.2 Naı̈ve Bayes

Note that the term ”Bayes” in Naı̈ve Bayes (NB) does not have to do with Bayesian modeling, or the pres-
ence of priors on parameters. We won’t have any priors for the moment. General Naı̈ve Bayes takes the
following form:
y ∼ Cat(π ) [class distribution]

x|y ∼ ∏ p( x j | y) [class conditional]
j
where y is the class label and comes from a categorical distribution, and x j is a dimension of the input x.
In Naı̈ve Bayes, the form of the class distribution is fixed and parametrized independently from the class
conditional distribution. The ”Naı̈ve” term in ”Naı̈ve Bayes” precisely refers to the conditional indepen-
dence between y and x j |y. Depending of what the data looks like we can choose a different form for the
class conditional distribution.
Here we present three possible choices for the class conditional distribution:
• Multivariate Bernoulli Naı̈ve Bayes:
x j |y ∼ Bern(µ jc ) if y = c
Here y takes values in a set of classes, and µ jc is a parameter associated with a specific feature (or
dimension) in the input and a specific class. We use multivariate Bernoulli when we only allow two
possible values for each feature, therefore x j |y follows a Bernoulli distribution.
We can think of x as living in a hyper cube, with each dimension j having an associated µ for each
class c. From here we get the name multivariate Bernoulli distribution.
• Categorical Naı̈ve Bayes:
x j |y ∼ Cat(µ jc ) if y = c
We use the Categorical Naı̈ve Bayes when we allow different classes for each feature j, so x j |y follows
a Categorical distribution.
14
• Multivariate Normal Naı̈ve Bayes
x|y ∼ N (µc , Σcdiag )
Note that here we use x vector and not a specific feature. Since we impose that Σc is a diagonal matrix,
we have no covariance between features, so this comes down to having an independent normal for
each feature (or dimension) of the output. This is also required by the ”Naı̈ve” assumption of condi-
tional independence. We would use MVN Naı̈ve Bayes when the features take continuous values in
Rn .
5.3 General Naı̈ve Bayes

We consider the data points {( xn , yn )}, without specifying a particular generative model. The likelihood of
each data point is:
p( xn , yn |param) = p(yn |π ) ∏ p( xnj |yn , param) (5.1)
j
(yn =c)
= ∏ πc ∏ ∏ p(xnj |yn )(yn =c) (5.2)
c j c
where in equation (5.2) we assume conditional independence (the ”Naı̈ve” assumption). The term p( xnj |yn )
depends on the generative model used for x and also on the class yn .
We can then solve for the parameters maximizing the likelihood, which is equivalent to maximizing the log
likelihood.
(πMLE , µMLE ) = argmax ∑ log p( xn , yn |param) (5.3)
(π,µ) n
= argmax ∑ Nc log πc + ∑ ∑ ∑ log p( xnj |yn ) (5.4)

(π,µ) c i c n:yn =c
! !
= argmax ∑ Nc log πc + argmax ∑ ∑ ∑ log p( xnj |yn ) (5.5)
(π,µ) c (π,µ) i c n:yn =c
Where Nc = ∑n 1(yn = c), and N = the number of data points.

This factors into two parts (5.10), the first only depending on π the other is the MLE for the class condition
distribution on each feature or dimension of the input. This factorization allows to solve for the maximizing
π and the maximizing parameters for the class conditional separately.
For example, if we use a Multivariate Bernoulli Naı̈ve Bayes generative model we would get the following
parameters from MLE:
Nc
πc = (5.6)
N
∑n:yn =c xnj Ncj
µ jc = = (5.7)
Nc Nc
Again, where Nc = ∑n 1(yn = c), Ncj = ∑n 1(yn = c) xnj and N = number of data points.
5.4 Bayesian Naive Bayes: Add a Prior

Here, instead of working with a single distribution, we are working with multiple distributions. For sim-
plicity, let’s use the following factored prior:
p(π, µ) = p(π ) ∏ ∏ p(µ jc )
j c
where p(π ) represents the prior on class distribution and ∏ j ∏c p(µ jc ) represents prior on class conditional
distribution.
Now, what prior should we use?
15
1. π: Dirichlet (goes with Categorical)
2. µ jc :
(a) Beta (goes with Bernoulli)
(b) Dirichlet (goes with Categorical)
(c) Normal (goes with Normal)
(d) Inverse-Wishart (Iw) (goes with Normal)
Here, what distribution we choose depends on our choice of class conditional distribution.
Recall that we want to use conjugate priors to have a natural update (that’s why we pair them up!). By
using conjugate priors, we will have:
p(π |data) = Dir ( N1 + α1 , · · · , Nc + αc )
p(µ jc |data) = β(( Nc − Njc ) + β 0 , Nc + β 1 )
5.4.1 Intuition
You can think of the αi above as initial pseudocounts. Those pseudocounts give nonzero probability to fea-
tures we haven’t seen before, which is crucial for NLP. For unseen features, you could have a pseudocount
of 1 or 0.5 (Laplace term) or something.
Because of this property, a Bayesian model helps prevents overfitting by introducing such priors: consider
the spam email classification problem mentioned before. Say the word ”subject” (call it feature j) always
occurs in both classes (”spam” and ”not spam”), so we estimate θ̂ jc = 1 (we overfit!) What will happen if
we encounter a new email which does not have this word in it? Our algorithm will crash and burn! This is
another manifestation of the black swan paradox discussed in Book Section 3.3.4.1. Note that this will not
happen if we introduce pseudocounts to all features!
5.5 Posterior Predictive

p(ŷ, x̂ | data) = (integrate over parameters)
Nc + αc
πc MAP = (Dirichlet MAP)
N + ∑c αc
Njc + β 1
µ jc MAP = (Beta MAP)
Nc + β 1 + β 0
(How to derive this? Good exercise!)
5.6 More on Predictive

Now, let’s consider a little bit more about what’s happening in our predictive. Consider the email spam
classification problem: given some features of an email, we want to predict if the email is a spam or not a
spam. We have:
p(y = c| x, data) ∝ πc ∏ p( x j |y) (try to generate observations from class)

j
x
= πc ∏ µ jcj (1 − µ jc )(1− x j ) (informal parametrization)
j
= exp(log πc + ∑ x j log µ jc + (1 − x j ) log(1 − µ jc )) (take exp of log)

j
!
µ jc
= exp log πc + ∑ log(1 − µ jc ) + ∑ x j log
j j
1 − µ jc
16
Figure 5.2: The Sigmoid Function
where the first two term logπc + ∑ j log(1 − µ jc ) is a constant (we call it b for bias), and the last term
µ jc
∑ j x j log 1−µ is linear (we call it θ).
jc
5.7 Multivariate Bernoulli Naive Bayes

For Multivariate Bernoulli NB, we will have:
µ jc
θ jc = log
1 − µ jc
bc = log πc + log(1 − µ jc )
So, we have:
p(y = c | x ) ∝ exp(θcT x + bc )
Thus, in order to determine which class (”spam” or ”not spam”), for each class we simply compute a linear
function with respect to x, and compare the two. Our θx + b is going to be associated with a linear separator
of the data. Even better, for prediction, we can simply compute θ and β (as shown above) using closed form
for both MAP and MLE cases.
5.8 The Sigmoid Function

Before proceeding, we should name our variables to speak about them more easily.
We call µ the ”informal parameters” and θ the ”scores.” In the case of a Multivariate Bernouli model, we
µ
have the map θ jc = log 1−jcµ , which we call the ”log odds.” We may also invert this relationship to find µ
jc
as a function of θ:
µ eθ 1
θ = log =⇒ µ = = = σ(θ )
1−µ 1+e θ 1 + e−θ
We denote this function σ (θ ) as the sigmoid function. The sigmoid function is a map from the real line
to the interval [0, 1], so is useful as a representation of probability. It is also a common building block in
constructing neural networks, as we will see later in the course.
5.9 The Softmax Function

We will now return to the predictive p(y = c| x ) ∝ exp(θcT x + cc ) to try to compute the normalizer Z:
1
p(y = c| x ) = exp(θcT x + bc )
Z
17
Figure 5.3: The Softmax Function
In general, we can compute the normal by summing over all our classes.
Z (θ ) = ∑0 = exp(θcT0 x + bc0 )
c
In practice, this summation is often computationally expensive. However, it is not necessary to compute
this sum if we are only interested in the most likely class label given an input.
We call the resulting probability density function the softmax:
exp(zi )
softmax(z)i =
∑i0 exp(zi0 )
This function generalizes the sigmoid function to multiple classes/dimensions. We call it the ”softmax”
because we may think of it as a smooth, differentiable version of the function which simply returns 1 for
the most likely class (or argmax).
5.10 Discriminative Classification

We may apply the mathematical tools developed in the generative classification setting discussed above
to perform discriminative classification. In discriminative classification, we assume that our inputs x are
fixed, rather than coming from some probability distribution.
We take the maximum likelihood estimate, as in linear regression, given that p(y = c| x ) ∝ exp(θcT x ):
MLE : argmax p(y| x, θ ) = argmax ∑ log softmax(θcT xn )cn
θ θ n
What are the advantages and disadvantages of this approach? The primary disadvantage compared to
methods we have seen earlier is that this maximum likelihood estimate has no closed form. It is also not
clear how we might incorporate our prior (although there is recent work in this area). On the other hand,
this equation is convex and it is easy (at least mathematically, not necessarily computationally) to compute
gradients, so we may use gradient descent.
(
d(·) 1 − softmax(θcT x ) if yn = c
= ∑ xn · (5.8)
dθc n softmax(θcT x ) otherwise
This model is known as logistic regression (even though it is used for classification, not regression) and is
widely used in practice.
More Resources on Optimization
• Convex Optimization by Lieven Vandenberghe and Stephen P. Boyd
18
Lecture 6: Exponential Families

Lecturer: Sasha Rush Scribes: Meena Jagadeesan, Yufeng Ling, Tomoka Kan, Wenting Cai
6.1 Introduction
(Wainwright and Jordan (textbook) presents a more detailed coverage of the material in this lecture.)
This lecture, we will unify all of the fundamentals presented so far:
p(θ ) p( x ) p(y | x )/p( x, y)

Beta, Dir Discrete Classification
MVN, IW MVN Linear Regression
Exponential Families Generalized Linear Models
Undirected Graphic Models Conditional UGM
Variational Inference
We will focus on coming up with a general form for Discrete and MVN through exponential families. We
will also come up with a general form for classification and linear regression through generalized linear
models.
6.2 Definition of Exponential Family

The definition is
1
p( x | θ (µ)) = h( x ) exp{θ T φ( x )}
Z (θ )
= h( x ) exp θ T φ( x ) − A(θ )
where
µ mean parameters
θ (µ) natural / canonical / exponential parameters
Z (θ ) A(θ ) also written as Z (θ (µ)) or Z (µ), the partition function and log partition
φ( x ) sufficient statistics of x, potential functions, “features”
h( x ) scaling term, in most cases, we have h( x ) = 1
Note that there is “minimal form” and “overcomplete form”.
6.3 Examples of Exponential Families

6.3.1 Bernoulli/Categorical
First, we consider the Bernoulli as an exponential family. Like last lecture, we rewrite the distribution as an
exp of log.
Ber( x |µ) = µ x (1 − µ)(1− x)

= exp x log µ + (1 − x ) log(1 − µ)

µ
= |{z} exp log x + log(1 − µ)
1 − µ |{z} | {z }
h( x ) | {z } φ( x ) − A(µ)
θ
19
For the minimal form, we have
h( x ) = 1
φ1 ( x ) = x
µ
θ1 (µ) = log (“log odds”)
1−µ
µ = σ(θ )
A(µ) = − log(1 − µ)
A(θ ) = − log(1 − σ (θ )) = θ + log(1 + e−θ )
For the overcomplete form, we have

x
φ( x ) =
1−x

log µ
θ=
log(1 − µ)
For the Categorical/Multinouilli distribution, we have
 
log µ1
 
θ =  ... 
log µn
where ∑c µc = 1.
Side note: Writing out in overcomplete form usually comes with some restraints.
6.3.2 Univariate Gaussians
1
N ( x | µ, σ2 ) = (2πσ2 )1/2 exp{− ( x − µ )2 }
2σ2
1 1 µ 1
= (2πσ2 )− 2 exp{− 2 x2 + 2 x − 2 µ2 }
| {z } | 2σ {z σ 2σ
} | {z }
A(µ,σ2 )
θ T φ( x ) A(µ,θ 2 )

x
φ( x ) = 2
x
" µ #
θ= σ2
− 2σ1 2
1 1
A(µ, σ2 ) = log(2πσ2 ) + 2 µ2
2 2σ
θ1
µ=−
2θ2
1
σ2 = −
2θ2
1 θ2
A(θ ) = − log(−2θ2 ) − 1
2 4θ2
6.3.3 Bad distributions

Two simple distributions that do not fit this form are the uniform distribution Uniform(0, 1) (check this as
an exercise), and the Student-T distribution.
20
6.4 Properties of Exponential Families
Most inference problems involve a mapping between natural parameters and mean parameters, so this is a
natural framework.
Here are three properties of exponential families:
Property 1 Derivatives of A(θ ) provide us the cumulants of the distribution E(φ( x )), var(φ( x )):
Proof. For univariate, first order:
dA d
= (log Z (θ ))
dθ dθ Z
d
= log exp{θφ}h( x )dx
dθ
| {z }
needed to integrate to 1
R
φ exp{θφ} h( x )dx
= R
exp(θφ)h(z)dx
R
φ exp{θφ} h( x )dx
=
exp( A(θ ))
Z
= φ( x ) exp(θφ( x ) − A(θ ))h( x ) dx
| {z }
p( x )
Z
= φ( x ) p( x )dx
= E(φ( x ))
The same property holds for multivariates (refer to textbook for proof).
Bernoulli:
A(θ ) = θ + log(1 + e−θ )
dA e−θ 1
= 1− −
= = σ(θ ) = µ
dθ 1+e θ 1 + e−θ
| {z }
sigmoid
Univariate Normal Left as exercise.
Property 2 MLE has a nice form (through “moment matching”)

Proof.
!
argmax log p(data | θ ) = argmax ∑θ T
φ( xd ) − N A(θ )
θ θ d
!
= argmaxθ T ∑ φ( xd ) − N A(θ )
| {z }
θ d
| {z } amount of points
sum of sufficient statistics
We take a derivative to obtain:

d (.) dA(θ )
dθ
= ∑ φ( xd ) − N dθ
d
= ∑ φ( xd ) − NE(φ( x ))
d
=0
21
∑ φ( xd )
E(φ( x )) =
N }
| {z
set mean parameter to sample means that gives us MLE
Property 3 Exponential families have conjugate priors.

Proof. We first introduce some notations.
η - parameters
s̄ = ∑ φ(xd )/N
d
p(data | η ) ∝ exp[( N s̄)η − N A(η )]
p(η | N0 , s0 ) ∝ exp[( N0 , s̄0 )η − N0 A(η ) ]
| {z }
not log partition, which has to be a function strictly of parameters
p(η |data) ∝ exp(( N s̄ + N0 s̄0 ) T η − ( N0 + N ) A(η ))
The above two distributions have the same sufficient statistics – so we have a conjugate prior. It also tells
us that it is not a coincidence that we kept obtaining pseudo counts. (More references will be put up to
describe this).
6.5 Definition of Generalized Linear Models

While exponential families generalize p( x ), GLMs generalize p(y| x ).
p(y| x, w) = h(y) exp{θ ( µ( x ) )T φ(y) − A(θ )}

|{z}
predict mean
where µ( x ) = g −1 (w T x + b) where g is an appropriate linear transformation.

|{z}
squashing const
This can be summarized through the following sequence of transformations:
g −1 ( w T x + b )
x −→ µ → θ → p ( y | x ).
6.6 Examples of Generalized Linear Models

We present three examples:
Example 1 Exponential family - Normal distribution with σ2 = 1 and g−1 is the identity function. This
gives us the linear regression
µ = wT x + b R → R.
−1
Example 2 distribution and g is the sigmoid function σ : R → (0, 1).
Exponential family - Bernoulli
Now, µ = σ (w T x + b) and θ = log 1−µ . This is how we define logistic regression. This gives us
µ
p(y | x ) = σ (w T x + b)y (1 − σ (w T x + b))1−y
Example 3 Exponential family - Categorical distribution with g−1 as the softmax function.
µc = softmax(wcT x + bc )c
θc = log µc
22
Lecture 7: Neural Networks

Lecturer: Sasha Rush Scribes: Juntao Wang, Alexander Wei, Kevin Zhang, Aron Szanto
7.1 Introduction
Neural networks have been a hot topic recently in machine learning. But everything we will cover today has
essentially been known since ’70s and ’80s. Since then, there has been in increased focus on this subject due
to its successes after improved computing power, larger datasets, better neural network architectures, and
more careful study in academia. Neural networks have also seen wide adoption in industry in recent years.
Lately, there has also been work trying to integrate other methods of inference into neural networks—we
will take a look at this topic later in this course. We cover neural networks now as a tangentially-related
introduction to graphical models and as an example of combining traditional inference with deep models.
7.1.1 Review of General Linear Models

In the last lecture, we saw that we can learn a mapping between mean parameters and natural parameters
for many general linear models and use squashing functions to change natural parameters into mean pa-
rameters. In general, we describe these models using a transformation µ = g−1 (w> x + b) for some function
g and a distribution y | x.
Example 1 (Linear Regression). Here we have g( x ) = x (the identity function) with y | x ∼ N (w> x + b, σ2 ).
This is the classic model we have already seen.
Example 2 (Linear Classification). In this case, g−1 is the sigmoid function σ, so that µ = σ (w> x + b) with
y | x ∼ Bern(σ (w> x + b)). We can think of the sigmoid function as a smooth approximation to an indicator
variable, so that σ (w> x + b) is simply an estimation of the class of w> x + b.
Example 3 (Softmax Classification). Here g−1 is the softmax function, so that µc = softmax(Wx + b)c where
exp(z )
W is some matrix rather than a vector. Remember that the softmax is defined by softmax(z)c = ∑ 0 exp(cz 0 ) .
c c
Think of the softmax function as a sigmoid approximation to multi-dimension.
7.2 Basis Functions

It can be advantageous to apply models after modifying the data set using a transformation called a ba-
sis. We can have a huge variety of basis functions (some of which we have seen on the problem set),
e.g., φj ( x ) = sin( x ), tanh( x ), ReLU( x ), and so on. Vector examples (i.e., functions on vectors) include
φj ( x ) = max{ x1 , x2 } and φj ( x ) = x1 x2 + x12 . Figuring out a good basis within which to represent data is an
important problem in machine learning.
Example 4. (Basis Function in Speech Recognition) A snippet of speech might be a waveform, and one way
to extract features is to chunk the waveform by time, for each chunk applying a Fourier transform. Then
we would take as features some values of each transformed chunk in the frequency domain. Typically this
process gives 13 features per chunk. These features are then passed to a learning model.
We now consider general linear models in combination with basis functions. Suppose y| x ∼ N (w> φ( x ) +
b, σ2 ), and y| x ∼ Bern(σ (w> φ( x )) + b), where φ gives rise to a basis. We can do MLE just as before, i.e.,
compute argmaxw ∑n log p(yn | xn , w). In general, these will be solvable just as before, e.g., with numerical
optimization—iterative gradient calculation and updates. The form of the MLE depends on the distribution
of y | x. When it is normal, the optimization becomes over sum of squares, when it is Bernoulli, the
optimization becomes over cross-entropy (as discussed in previous classes).
23
Figure 7.4: Fourier transform in speech recognition in Example 4
7.3 Now Let’s Talk About Neural Networks

An adaptive basis function is a model with parameters in the basis functions. Neural networks are specific
adaptive basis functions with particular structures, which we will describe below.
One can think of the function of a neural net as learning the correct basis function(s) for the data—having
the computer come up with the best representation of the data over features of the form φ( x; w, b) =
g−1 (Wx + b), where g−1 = relu, σ, softmax, or another nonlinear function. This procedure can be applied
recursively, e.g., we can define the x that lives inside this basis function to also have its own basis function,
e.g., φ( x; w, b) = g−1 (wφ0 ( x; w0 , b0 ) + b), and so on. This is also why neural networks are often referred to
as “deep learning.” This allows us to do non-linear regression and classification with parameters. Now,
when we do regression and classification, we can have complex models such as
y| x ∼ N (w> tanh(w0 x + b0 ) + b, σ2 )
When we do MLE, we have to take the same argmax over the parameters w, w0 , b0 , b. All that’s changing
is that the function we are optimizing is non-linear, with many parameters, and non-convex. So when we
optimize such functions, we might end up at a local optimum instead of the global optimum. We will see
many techniques for combating the complexities of non-convex optimization.
7.4 Demo
See iPython notebook for demo.
7.5 Graphical Representation

Consider the adaptive basis σ(w> σ (Wx + b0 ) + b). We can represent this graphically with a two-layer,
fully-connected network:
In the literature, the circles are called “neurons,” matrices are “fully connected,” each column is a “layer”
with implied squashing, each line is a parameter. The goal of these networks is to find µ.
“Personally, I find this part—the ‘it’s like a brain!’—pretty silly. It’s just linear algebra separated by nonlin-
ear transformations.” - S. Rush
24
7.5.1 Application Architectures for Neural Networks
In a typical neural network, we have x → Layer 1 → Layer 2 → · · · → Output, where each arrow is a
linear map, and in each layer is a non-linear function. In the class before, we talked about classifying the
MNIST data set—for this simple model, we had 8000 parameters(!). “But that’s nothing—just yesterday I
was working with a model with 1.2 billion parameters.”
Although some of the power of neural networks comes from this flexibility in parameters, much of the
interesting work is done in trying to find better neural network architectures that capture more of the
essence of the data with fewer parameters. For example, the modern approaches to digit classification are
done by convolutional neural networks, where the architecture captures some of the “local” information of
images.
Example 5. [Speech Recognition] Suppose we want to map sounds into classes of saying the digits “one,”
“two,” and so on. Recall that the typical approach is to split speech into chunks and perform Fourier trans-
forms to extract features from each chunk. The problem here is that individual chunks don’t necessarily
map to single digits, since there’s no guarantee the chunk even corresponds to an entire word in speech!
Instead, what is typically done in this case is convolution using a kernel (equivalently, a single weight vector
called wtile ) that spans several chunks. Rather than applying learning on the full Rn·13 data set (where n is
the number of chunks), we multiply each k-chunk stretch of speech by the kernel to obtain ≈ n − k chunks.
Based on our choice of kernel, we can take advantage of sparsity to improve structure in the data set. This
is known as a one-dimensional convolution between the kernel, wtile , and the input φ( x ).
Figure 7.5: Convolution architecture in speech recognition in Example 5
Example 6 (Image Classification). For the case of images, we can do the same as above with two-dimensional
convolution, where have blocks in the image instead of tiles. This lets us pick up on information that is very
local—e.g., or edges or corners in images, informatoin which can then be recombined in later layers with
spectacular success.
Example 7 (Language Classification). Suppose we want to determine whether a movie review was good or
bad. Consider the review “The movie was not very good.” One way to do this to convert words to vector
representations (e.g., via word2vec or glove), since discrete words are difficult to deal with, but vectors let
us have a more continuous approach while taking into account the meaning. We can do things like add
these vectors up over the course of the review (e.g., a bag-of-words approach). An alternative is to take
blocks of words and use a one-dimensional convolution. One advantage of the latter is that it allows you
to pick up on structures such as “not very good,” which wouldn’t be observed in a bag-of-words model,
which may pick up on the words “very” and “good” instead.
Remark. All of these convolution methods exist in PyTorch under nn.conv.
25
Lecture 8: Backpropagation & Directed Graphical Models

Lecturer: Sasha Rush Scribes: Giridhar Anand, Michael Xueyuan Han, Ana-Roxana Pop
8.1 Backpropagation in Neural Networks

8.1.1 Neural networks review
In the last lecture, we defined the mean parameter of a neural network as follows:
µ = σ(w T ReLU(Wx ))
Here, µ parameterizes a Bernoulli distribution, Ber(µ). Suppose we want to find µ such that it maximizes
the likelihood of a single data example ( x, y). Then we compute
µ = argmax log p(y| x ) = arg min (− log p(y | x )) = arg min L

µ µ µ
where L is the loss of the neural network.
8.1.2 Chain rule and backpropagation

We can represent the neural network graphically as follows:
ReLU(Wx)1
x1 ReLU(Wx)2
x2 ReLU(Wx)3 L
x3
ReLU(Wx)4
ReLU(Wx)5
In order to generate this graph, we must perform the following computational operations in order:
v (0) → v (1) → v (2) → v (3) → v (4) → L

x Wv(0) ReLU(v(1) ) w T v (2) σ ( v (3) ) − log v(4)
26
We would like to get the gradient terms v̇(i) ≡ dL(i) for any i, which tell us how each part of the neural
dv
network affects our loss. We can do this by applying the chain rule (of calculus) to get a recursive solution
(by convention, the derivative of a scalar with respect to a vector is represented as a column vector):
T
dL dL dv(i+1)
=
dv(i) dv(i+1) dv(i)
( i +1)
∂L ∂L ∂v j
(i )
=∑ ( i +1)
∂vk j ∂v j ∂v( i )
Since the gradient of each term depends on the gradient of the subsequent term, we can compute the
gradients in reverse while applying the chain rule. This method is known as backpropagation. For each
backward step, we need to remember everything that was computed in the corresponding forward step,
dv(i+1)
namely v(i) , v̇(i+1) , and :
dv(i)
v (0) → v (1) → v (2) → v (3) → v (4) → L

x Wv(0) ReLU(v(1) ) w T v (2) σ ( v (3) ) − log v(4)
v̇(0) ← v̇(1) ← v̇(2) ← v̇(3) ← v̇(4) ←

... ... (v̇(2) )T W σ̇ (v(3) )v̇(4) − (14)
v
8.1.3 Writing software for neural networks

• “blocks” style neural network (e.g. Torch)
Computation is done in “blocks” which are black boxes f that implement the following contract:
output, v(i+1)
input, v(i)
dv(i+1)
dv(i)
grad output, v̇(i+1)
grad input, v̇(i)
We can also augment the black boxes. For instance, if we let f take in parameter W, we can also
dL
compute dW within this function.
• computational graph (e.g. Theano, TensorFlow)
Everything is implemented in terms of primitives, so there are no black boxes:
+, ×, ...
This allows us to optimize the neural network once and run it on many examples.
27
• imperative/autograd systems
These are tape-based systems in which the computational graph can look different for different exam-
ples, but we can still compute gradients using backpropagation. Torch is built on an autograd core,
but higher level functions like the Linear module take on a “blocks” style approach.
8.2 Graphical Models

8.2.1 Directed Graphical Models
The goal of using directed graphical models (DGMs) is to separate out two parts of a model:
1. Conditional Independence
2. Parameters and Parametrization
Figure 8.6: The graphical model of Naive Bayes
In the case of Naive Bayes (see Figure 8.6), we know from a previous lecture that:
• p(y) is probably categorical.
• p( x j |y) could be one of many different distributions, including Categorical, Gaussian, Bernoulli, etc.
We are interested in the following distributions from the underlying data that we have:
• p(y, x): joint distribution
• p( x j ): marginal distribution, or p(y | x ): conditional distribution
The structure of the model will often determine the difficulty of inference. This is the motivation of why we want
to draw these graphs.
On a high level, given p( A, B, C ), we can always apply the chain rule (in probability):
p( A, B, C ) = p( A | B, C ) p( B | C ) p(C )
However, if we write p( A, B, C ) in the way above, we basically assume that all variables depend on each
other. In some cases, this is not necessarily true, and we want to find a factorization as below.
8.2.2 Factorization
If we have the case presented in Figure 8.7, we can rewrite p( A | B, C ) → p( A | B). Having A only depend
on one variable (B) is better than having it depend on two variables (B and C).
28
Figure 8.7: A graph where factorization is possible.
8.2.3 Formalism of DGMs

Formally, for directed graphical models (DGMs) (or Bayes Nets, or causal graphs) we have:
• A graph G = (V, E) where (s, t) ∈ E, s 6= t (V are vertices, E are edges)
• Each node is a random variable.
• Each edge is a conditioning decision.
• The graph is topologically ordered and it is a directed acyclic graph (DAG).

• Notation: pa( x ) represents x’s parents.
8.2.4 Parents notation

Here, A and B are independent of each other, and they are C’s parents (as in Figure 8.8). We can then write:
Figure 8.8: A graph to illustrate the use of parents notation.
p( A, B, C ) = p( A) p( B) p(C | A, B) = p( A) p( B) p(C | pa(C ))
8.2.5 Plate Notation

When we have lots of exchangeable variables (i.e., order is not important), we can use the plate notation.
(n)
We want to graphically represent Naive Bayes on examples ( x j , y(n) ), in which
• y is parameterized on π: p(y(n) | π ), and

(n)
• x j depends on y and µ: p( x j | y, µ)
Since we have n samples of ( x, y), we can use the plate notation, as shown in Figure 8.9.
29
Figure 8.9: A graph to illustrate the use of plate notation.
8.2.6 Caching probabilities

You can save “probabilities” in the model, which is simply caching the values of probabilities with the graph.
In this case (Figure 8.10), variables are discrete. We call C’s probability table conditional probability table (CPT)
since it is conditioned on A, B. Note that the values do not tell us anything about how the distribution is
parameterized. Those are simply the probability values that you can read off from the graph.
Note also that the CPT of p( xi | x1 , · · · , xi−1 ) = O(∏i | xi |) (i.e., exponential growth with the number of
conditional terms).
Figure 8.10: A model with probability tables. The CPT of C is a three-dimensional table.
8.2.7 Examples of Directed Graphical Models

Example 8 (Markov Chain). Figure 8.11 shows an example of a Markov chain graphical model.
Figure 8.11: Markov Chain Graphical Model
Example 9 (Second Order Markov Chain). Figure 8.12 shows an example of a second order Markov chain
graphical model.
30
Figure 8.12: Second Order Markov Chain Graphical Model
Example 10 (Hidden Markov Model). Figure 8.13 shows an example of a hidden Markov graphical model.
Figure 8.13: Hidden Markov Graphical Model
Example 11 (Navie Bayes). Figure 8.14 shows an example of a Naive Bayes graphical model.
Figure 8.14: Naive Bayes Graphical Model
As we have seen in Figure 8.9, we can also incorporate parameters in the DGMs, as it is illustrated in the
next example.
Example 12. In this case (Figure 8.15), we use the same Naive Bayes example with parameters. Here, we
incorporate parameters α ∼ Dirichlet. This is interesting because it combines two types of distributions:
some of them are discrete, but in this example α and π are drawn from continuous distributions, as marked
in the figure below.
31
Figure 8.15: Naive Bayes Graphical Model with Parameters
Figure 8.15 corresponds to a single example. If we have multiple examples, we can use a plate-in-plate
representation as in Figure 8.16.
8.3 Gaussian Directed Models

Gaussian directed models are a special case of DGMs where every one of the variables has the following
distribution:
p( xi | pa( xi )) = N ( xi | µi + ∑ Wij ( x j − µ j ), σi2 )
j=pa( xi )
In the above equation, we transform each of the µi based on the starting mean plus a linear transformation
of their parents (and to simplify things, we subtract the mean of each parent). We have an underlying
generative process where each one of our random variables is a draw from a Gaussian and its children are
a linear transformations of that draw.
This means that, we can rewrite xi as:
xi = µi + ∑ Wij ( x j − µ j ) + σi zi ∀i zi ∼ N (0, 1)
j
Notice that σi zi is just Gaussian random noise.

If we define S = diag(σ ) (where each term will contribute a different corresponding σi ), we can rewrite the
above equation in a matrix form:
( xi − µi ) = W ( x − µ) + Sz
where µ = [µ1 , · · · , µd ] is a vector containing each individual means.
By rearranging the terms, we find:
Sz = ( I − W )( x − µ)
x − µ = ( I − W )−1 Sz
32
Figure 8.16: Naive Bayes Graphical Model with Parameters and Plate-in-Plate Notation
This tells us how the x random variable differs from the mean at each of the different positions.
We know that the Σ term for our covariant matrix is defined as:
h i
Σ ≡ cov [ x − µ] = cov ( I − W )−1 S z
= ( I − W )−1 S cov [z] S(( I − W )−1 )T
= ( I − W )−1 S2 (( I − W )−1 )T
which means that, in general, for Gaussian DGMs we have:
Gaussian DGM ∼ N (µ, ( I − W )−1 S2 (( I − W )−1 ) T )
Remark. We will talk about D-Separation in the next lecture.
33
CS281: Advanced ML October 2, 2017
Lecture 9: Undirected Graphical Models

Lecturer: Sasha Rush Scribes: Chris Hase, Denis Ellenrieder, Shuran Zheng, Rafi Small, Tim Menke
9.1 Left from last lecture: Conditional independence properties of DGMs

When we have a directed graphical model (DGM), how can we “read” the graph and learn about the
independence properties of the variables? To begin we note that conditional independence follows if the
marginal probability factors in the following way:
p( A, B|C ) = p( A|C ) p( B|C ) ⇒ A ⊥ B|C (9.9)
Let B denote observing B, which informs our understanding on how A and C are conditional independent
or not. Our cases are then:
A → B → C,A⊥C (9.10)
A → B → C , A ⊥ C|B (9.11)
A ← B → C,A⊥C (9.12)
A ← B → C , A ⊥ C|B (9.13)
A → B ← C,A⊥C (9.14)
A → B ← C , A ⊥ C|B explaining away (9.15)
Information is being blocked in cases 2, 4, and 5 but flowing freely in all other cases. It’s useful to think
about the concept of “explaining away” to understand what is going on in the last case. ’“Explaining away”
is a common pattern of reasoning in which the confirmation of one cause of an observed or believed event
reduces the need to invoke alternative causes.’
(http://strategicreasoning.org/wp-content/uploads/2010/03/pami93.pdf)
How would a directed graphical model be interesting in practice? One example is probabilistic program-
ming: demonstrated in the IPython notebook “DGM.ipynb”. The demonstration shows how we can con-
vert programs from a directed to an undirected form. We can also specify priors on our features and visu-
alize the flow of the model.
The purpose of creating a DGM is to specify the relationship between variables of interest, in order to to facilitate
understanding of the independence properties.
9.2 Undirected Graphical Models (UGM)

Differences of UGMs as opposed to DGMs:
1. There are no arrows on lines
2. No longer model local probabilistic decisions (the term “local” is important and defined later)
3. UGMs are Markov random fields (similar to exponential families) or conditional random fields (sim-
ilar to generalized linear models)
4. Nice part: The rules are much simpler, especially for conditional independence
5. Downside: The math is much more complicated
6. Sasha’s personal bias: UGMs are much more useful
34
9.2.1 Independence properties
As stated above, we have conditional independence if the marginal probability factors in the following
way:
p( A, B|C ) = p( A|C ) p( B|C ) ⇒ A ⊥ B|C (9.16)
A − B − C,A⊥C (9.17)
A − B − C , A ⊥ C|B (9.18)
(9.19)
We can say that we have “conditional independence” between two nodes given some third node if all paths
between the two nodes are blocked. For our simple example with three nodes, this is when the third node
is in the evidence, that is, when the third node is “seen”.
Here is an example of how independence works in the UGM.
A D
A ⊥ D |S if S blocks all the paths (9.20)

Here: A ⊥ D | B, C (9.21)
Fundamental consequence: Imagine we have a graph with a node A and some complicated connection of
nodes around A. We can make A conditionally independent from all other nodes by conditioning on the
“Markov blanket” of A. The Markov blanket is defined to be the neighbors of A. We will see later in this
class that is is very nice if we can establish these independence properties. We will be able to look at a point
in a graphical model and, if we can condition on the Markov blanket of the node of interest, we can ignore
the rest of the graph.
In the example below, conditioning on the Markov blanket of A means conditioning on B, C, E, and F.
B
E A D
G
F H
9.2.2 Converting directed to undirected graphs

In order to convert directed to undirected graphs, we will use the (socially improperly termed) technique
of moralization, i.e. “marry the parents”.
1 1
2 3 2 3
4 5 4 5
35
To carry out this process, we take all the directed edges and make them undirected. We then create addi-
tional edges by “marrying” the parents of a node. In this case we gain an extra edge between 2 and 3, which
comes from marrying the parents of 4.
Let’s write Naive Bayes out in a directed graphical model:
y y
x1 ... xV x1 ... xV
For this case, the UGM and DGM are the same. However, if we condition the other way, i.e. the features
x1 , ..., x D are on top of the DGM with directed arrows towards y at the bottom, we would need to add
connections in the UGM between all of the features. In the illustrated example, the joint probability having
seen y is
∏ p(xd ) p(y|x1 , ..., xv ). (9.22)

d
9.3 Corner cases

Unfortunately, there are lots of corner cases in UGMs. DGMs and UGMs represent only a subset of all
graphical models. There is some overlap between the UGM and DGM classes within the set of all indepen-
dence structures. In the corner cases, we cannot convert between DGMs and UGMs and retain all of the
independence information encoded within.
All
DGM UGM
We will now consider an example of a UGM and attempt to convert it to a DGM.
B C
Here we have
A ⊥ D | B, C (9.23)
B ⊥ C | A, D (9.24)
(9.25)
One potential DGM we can create is
36
A
B C
In contrast to the UGM, the DGM has the following independence properties.
A ⊥ D | B, C (9.26)
B ⊥ C | A, D (9.27)
Another DGM may be
C B
D A
And now we see that
A ⊥ D | B, C (9.28)
B ⊥ C | A, D (9.29)
So there is no directed graphical model structure that gives us same properties that the original UGM had.
How about another example of a DGM
X Y
This graph has two properties:
(1) X 6 ⊥ Y | Z (9.30)
(2) X ⊥ Y (9.31)
X Y
This graph has neither property 1 nor property 2.
X Y
Here we do have property 1 but not property 2.
37
9.4 Parametrization of UGMs
The following section is some of the harder material that we will cover. However, this is the last time we
are introducing a new model. Thereafter, we will do inference on the models we have discussed.
normal A B
C D
cat
E
Suppose that in this example the nodes within the red circle follow a local normal distribution, but that
the nodes within the blue circle follow a local categorical distribution. The notation relating a node X to
its parents is p( x |pa( x )), where pa(c) refers to the parents, and the conditional probability table is “locally
normalized”, “sums to one”, and is non-negative.
For UGMs we use “global normalization”. All is fine locally as long as the whole global probability sums
up to make whole joint distribution normalized. For this, we treat everything as an exponential family.
n o
p( x1 , ..., xd ) = multivariate exp. fam. = exp θ T φ( x1 , ..., x D ) − A(θ ) (9.32)
Here, θ are the parameters and φ( x1 , ..., x D ) the sufficient statistics. For every “clique” in the graph, we
associate a set of sufficient statistics. A “clique” is defined as a set of nodes that are all connected to each
other. Note: a set of one or two nodes forms a trivial clique.
In the discrete case:
φ( x1 , ..., x D ) = [φc ( xc )...] T (9.33)
Each entry is an indicator of the value set for a clique.
(
1 if clique c has xc = v
φcv ( x ) = (9.34)
0 otherwise
Suppose we have the following UGM in which each node can take on one of k possible discrete outcomes:
K K
This means v ∈ K3 in this example. We also have a Θ associated with each of these values. Since φ( x ) is big
(and awkward), we use the following notation:
θ T φ( x ) = ∑ θ T [0, ..., 0, φc (x), 0, ..., ]T = ∑ θc ( xc ) (9.35)

c c
| {z }
convenient notation
38
Now we write out the whole thing:
 

 


 

 
p( x1 , ..., x D ) = exp
 ∑ θc ( xc ) − A(θ ) (9.36)

 c 

 | {z }
 

(neg) energy
Finally, we can compute the value A(θ ):

A(θ ) = log ∑0 exp{∑ θc ( xc0 )} (9.37)
x c
|{z}
“everything”
The sum over “everything” is our nemesis because it is over something big. And in general, this is NP-
Hard or even #P-Hard. But in practice, the structure of the graph determines the difficulty. Examples of the
“everything” include: all possible images, social network graphs... (How we can exchange the sums over
x 0 and c depends on the structure of the graph.)
9.5 Examples
9.5.1 Example 1: Naive Bayes model
A − B − C , all binary (9.38)
We have two cliques: A − B and B − C

Define features and parameters:
   
1( A = 0, B = 0) θ AB (0, 0)
1( A = 0, B = 1) θ AB (1, 0)
   
1( A = 1, B = 0) θ AB (0, 1)
   
1( A = 1, B = 1)  
φ( x ) =   , θ = θ AB (1, 1) (9.39)
 1( B = 0, C = 0)   θ BC (0, 0) 
   
 1( B = 1, C = 0)   θ BC (1, 0) 
   
 1( B = 0, C = 1)   θ BC (0, 1) 
1( B = 1, C = 1) θ BC (1, 1)
Then we have
p( A = a, B = b, C = c) = exp{θ AB ( a, b) + θ BC (b, c) − A(θ )}, (9.40)

where A(θ ) = log ∑ a0 ,b0 ,c0 exp{θ AB ( a0 , b0 ) + θ BC (b0 , c0 )} .
9.5.2 Example 2: Hidden Markov model
39
Any distribution obeying this structure has an exponential family parametrization. We convert the local
distribution
p ( y 1 ) ∏ p ( y i | y i −1 ) p ( x i | y i ) (9.41)
i
to the globally normalized distribution
p( x, y) = exp{∑ [θi,i−1 (yi , yi−1 ) + θi (yi , xi )] − A(θ )}. (9.42)

i
9.5.3 Example 3: Ising model
X11 X12 X13 X14

↑
θ22
←
θ22
X21 X22 X23 X24
X31 X32 X33 X34
For this example, the shown grid could connect to other such grids. As an example, suppose we want to
detect the foreground and background of an image. For this, we perform a binary classification of each pixel
(0=pixel in background; 1=pixel in foreground). We want to obtain a probability that a pixel is in either class.
The class should depend on the neighboring pixel so that there is consistency among neighboring pixels -
it would be weird if every other pixel is in a different class.
This results in a binary model with neighbor scores. In order to force this to be a probability distribution,
we treat the whole thing as an exponential family:
( )

p( x ) = exp ∑ θij ( xij , xi−1,j ) + θij ( xij , xi,j−1 ) + θij ( xij ) − A(θ ) ,
↑ ←
(9.43)
ij
where A(θ ) = log (∑ x0 exp ∑c θc ( xc0 )). Note that A is again very hard to calculate. Also note that the
↓ → in the diagram are given by other θ ↑ and θ ← so that when we sum over all i and j we
“missing” θ22 and θ22
are not double counting any of the connections.
40
Lecture 10: Exact Inference: Time Series

Lecturer: Sasha Rush Scribes: Max Hopkins, Sebastian Wagner-Carena, Mien Wang, Jamila Pegues
10.1 Prelude
10.1.1 Notation
Recall from Lecture 9 our notation for the joint probability distributions of Undirected Graphical Models
(UGMs). In particular, we have
p( x1 , . . . , x T ) = exp{∑ θc ( xc ) − A(θ )}
c
Here, θc ( xc ) is the score associated with some clique c, and xc is some value assignment on the clique. This
notation is great because it corresponds to exponential families! However, there are a few other notations
you may see around:
p ( x1 , . . . , x T ) ∝ ∏ exp(θc (xc ))
c
= ∏ ψc ( xc ))
c
This latter notation is used by Murphy. ψc ( xc ) are the potentials, and they are simply exp(θc ( xc ). The score
functions θc are then known as the log potentials.
10.1.2 Moralization
Recall from last lecture the process of conversion between a Directed Graphical Model (DGM) and UGM,
known as moralization. Here we consider two diagrams:
The first has joint probability distribution
P( A, B, C, D ) = P( A) P( B| A) P(C | A) P( D | B, C )
After moralization, we have
41
We see that the UGM has two cliques, the c0 = { A, B, C }, and c1 = { B, C, D }. Using the notation above,
this gives us
P( A, B, C, D ) = ψc0 ( A, B, C )ψc1 ( B, C, D )
This form gives a particularly nice parallelism where it is clear that the first three terms
P( A) P( B| A) P(C | A) = ψc0 ( A, B, C )
and
P( D | B, C ) = ψc1 ( B, C, D )
10.1.3 Conditional Independence vs. Parametrization

It is important to keep in mind that DGMs only specify conditional independence. The same DGM’s could
correspond to completely different parametrizations of the random variables. For example, consider Naive
Bayes:
In Lecture 5, we discussed all kinds of Naive Bayes (NB), including Bernoulli, MVN, Categorical, and more.
All of these follow the diagram above, which only specifies the conditional probability distribution
p ( x | y ) = p ( y ) ∏ p ( xi | y )
i
Now consider a conditional model:
Here we are only interested in p(y| x1 , . . . , x T ). Similarly to NB, the parametrizations of this model can take
many forms. For instance, one could use logistic or linear regression, most GLM’s, Neural Networks, or
even convolutional Neural Networks. In fact this is the model on which Alphago functions, where features
x are the tile placements on the board, and y is the output move!
The main point here is that we can stick arbitrary parametrizations into graphical models. These diagrams
just specify the conditional dependence–not the distributions. Further, as long as we specify the graphical
model structure, we will be able to tell how hard inference will be.
10.2 Time Series

In this lecture, we only consider an informal definition of a time series. This structure is marked by collect-
ing data over time, and predicting an output for each data input. We are going to consider a special case,
labeling a time series. Here our we will have x1:T as our input sequence (features), and y1:T as our output
labels. We will begin by providing examples of labeling time series:
Example 13 (OCR). Here we have blocks of pixels, discrete vectors, each which depict a letter. These blocks
are our xi , and each corresponding yi the discrete symbol the xi represents
42
y = {t,h,e, ,d,o,g}
Example 14 (NLP). Here we are given discete words as input variables x, and we wish to predict discrete
y, their parts of speech
x: the dog ate a carrot
y: DT NOUN VERB DT NOUN
Example 15 (Speech Recognition). Recall from previous lectures that our signal may be divided up into
time steps and translated to continues vectors in R13 , these our are continuous input variables x. Our
output for each vector is the phoneme corresponding to the sound.
y = {d,d,d,o,o}
Example 16 (Tracking). Here we are tracking the position of some object with presumed Gaussian noise. In
this case both our input and output variables are continuous. The inputs are our position vectors, and the
output is the predicted correction for noise.
Example 17 (Education). This example is based upon the presentation at the beginning of the class. Our
inputs are given by a kinect tracker and are continuous body positions at snapshots in time. The discrete
output y is whether the body position corresponds to attentive or bored.
y = {attentive, attentive, bored, bored }

Example 18 (Touch-typing). We consider typing on an iphone, where inputs are the continuous position of
keystrokes on the phone. The outputs y are given by discrete letters.
y = {s,t,o,p}
10.3 Markov Models

10.3.1 Hidden Markov Model
43
We discussed several Markov Models in previous lectures. We begin with the Hidden Markov Model (HMM),
which actually predates DGMs. HMMs assume discrete y, though DGMs with the same structure may
have continuous y. This has a fully joint parametrization p(y1:T , x1:T ), where in most cases p(yt |yt−1 ) is
categorical. We can choose the distribution of p( xi |yi ) to fit our given circumstances:
1. p( xi |yi ) is categorical [e.g. parts of speech]
2. p( xi |yi ) is MVN [typing, speech (this uses a mixed gaussian)]
3. p( xi1 , . . . , xiv |yi ) = ∏ p( xiv |yi ) [OCR]
v
The last example here has an embedded Naive Bayes model for each feature x.
HMMs such as the above are often parametrized in the following manner:
10.3.2 State Space Model

While continuous y has the same graphical model, it has completely different usage and was developed
completely separately. This model is called the State Space Model (SSM). This model is often used when
we have a continuous signal disturbed by gaussian noise–this becomes multivariate and we can compute
inference nicely.
10.3.3 Maximum Entropy Markov Model

Yet another Markov Model is the Maxent Markov Model (MEMM). This model assumes we have observed
all features, and flips the direction of the conditioning in the vertical direction.
Thus we are interested in p(y1 , . . . , y T | x1 , . . . , x T ), and p(yt | xt , yt−1 ) is a GLM such as logistic or softmax
regression.
MEMM comes with the distinct advantage that we no longer have to assume our features are independent.
This is particularly useful in, say, tagging parts of speech where can pick an arbitrary feature basis without
worrying about independence. However, the model comes with the downside that there is no closed form,
so we must use SGD, i.e. we isolate each xi and predict yi with logistic regression.
Picking p(yt | xt , yt−1 ) here as an arbitrary neural network is called a Neural Network Markov Model or
NN-Markov Model.
44
10.4 Conditional Random Field Markov Model
While CRF is still a Markov Model, it gets its own subsection due to its importance. The CRF is simply the
UGM of all the above Markov Models:
Recalling Subsection 10.1.1, we write
p(y1:T | x1:T = exp{∑(θth (yt , yt−1 ) + θto (yt , xt )) − A(θ )}

t
Here h and o refer to the labeled arrows in the diagram. This is the general form of any Markov Model.
Note that because we have observed the features x1:T , we may rewrite the Tto (yt , xt ) terms as θto (yt ; xt ). If
we are trying to do inference, we can think of the above after conditioning as simply
This is a simple Markov Chain UGM. In fact after converting to UGM and conditioning on our features, all
Markov models become the above!
Now while we can compute the closed form of the MLE on HMMs, CRF is a bit tricker. However, it is a
member of the exponential family model, and we know the MLE for these families in general.
∑ φ( xd )
E(φ( x )) =
N
Here, φ(y) are the sufficient statistics–but what do these look like? In fact we went over this in a previous
lecture, it is simply a vector of indicator functions for every clique assignment (see Lecture 9). For inference
in particular, we care about
E(1( xc = v))
Then the clique marginals are given by
∑ p( x0 )
x 0 = xc0 =v
∑ p( x 00 )
x 00
However this may be computationally intractable, as the x 00 we sum over is the entire universe! However,
this can be computed efficiently for some models such as chain models
10.5 Bonus: Lecture by Bertrand Schnieder

Bertrand Schnieder gave a snazzy guest lecture on his research, and advertised that the datasets from his
research would be ideal as a base for CS 281 final projects. We take a moment to review his lecture below.
Schnieder was very interested in studying patterns across concepts of collaborative learning. For example,
joint attention refers to when a group of individuals are focused on the same physical object, and is an
important part of language development. Signs of joint attention can be seen in the physical movement of
the individuals involved, such as their eye movements, gestures, and body postures.
Schnieder discussed studies that he and others carried out to explore joint attention. For example, one study
gave forty-two pairs of two participants a task to solve, within a total of forty-five minutes of time. Over
that time period, Schnieder et al. used high-frequency and multi-modal sensors to track different aspects
of movement, including: video, audio, eye movement (tracked at 60Hz), physiological data (like heart rate;
45
tracked at 1-30Hz), and even body posing and coordination (using a Kinect; tracked at 30Hz). Schnieder
pointed out that these sorts of studies provide massive amounts of data. During the lecture, he highlighted
that there are a number of cool CS 281 projects that could arise from datasets like this one. Some projects he
proposed are:
1. Unsupervised machine learning: modeling collaborative learning processes with probabilistic graph-
ical models.
2. Supervised machine learning: training models to make predictions. For instance, training a model to
predict the joint visual attention of two people based on their gestures, head orientation, and speech.
Another example is training a model to predict physiological activity based on features like pupil size
and body posture. With supervised machine learning, however, Schnieder noted that overfitting can
be a dangerous pitfall.
3. Design your own!
Schnieder emphasized that he is open to ideas, and that he highly encourages anyone interested in working
with this data in some way or form to email him at bertrand [email protected].
46
Lecture 11: Exact Inference: Belief Propagation

Lecturer: Sasha Rush Scribes: Ismail Ben Atitallah, Hao Wu, Raphael Rovinov, Ziliang Che, Jiaoyang Huang
11.1 Simple Marchov Chain

For a simple Markov Chain with time limit T and V classes per node:
p(y, t) = exp(∑ θtT (yt−1 , yt ) + θto (yt ) − A(θ ))

t
∝ ∏ ψt (yt−1 , yt )ψt (yt )
t
y1 y2 y3 ... yS ... yT
11.1.1 Distributive Property

Marginal:
p(ys = v) = ∑ ∏ ψt (y0t−1 , y0t )ψ(y0t )/Z(θ )

y1:T,y0 =v t
s
0
= ∑ ψT (y0T ) ∑ ψT −1 (y0t−1 )ψT (y T −1 , y0T ) ∑ . . . ∑ ψ2 (y20 ) ∑ ψ1 (y10 , y20 )ψ1 (y10 )
y0t y T −1 y20 y10
11.1.2 Compute All Marginals with Dynamic Programming
bel− −
t ( yt ) ∝ ψt ( yt )mt−1→t ( yt )
m−
t −1→ t = ∑ ψt−1 (yt−1 , yt )bel−t−1 (yt−1 )
y t −1
m+
t +1→ t = ∑ ψt+1 (yt+1 , yt )ψt+1 (yt+1 )m+t+2→t+1 (yt+1 )
y t +1
p(yt ) = belt (yt ) ∝ mt+1→t (yt )bel−

t (yt )
47
11.2 Other Graphs
p(ys = v) = ∑ ∏ ψc (y0c )
y0 ,y0s =v c
48
Computing this sum product might be hard. Here we define the minimum size of maximum clique indcued
-1 to be the treewidth of the graph.
49
11.2.1 Compute Marginals for treewidh = 1 Graph
Here we derive the generalization of the forward-backward sum-product algorithm

1. Pick a root s, pa( xs ),ch( xs )
2. Upward pass:
ms → t ( x t ) = ∑ ψs−t (xs , xt )bel−s (xs )
xs
bel−
t ( xt ) ∝ ψt ( xt ) ∏ m−
s−t ( xt )
s∈ch(t)
3. Downward pass:
bels ( xs ) ∝ bel−
s ( xs ) ∏ m+
t→s ( xs )
t∈pa(s)
m+
t→s ( xs ) = ∑ ψs − t( xs , xt )ψt ( xt ) ∏ = m−
t ( xt )
xt c∈ch(t),c6=s
11.3 Parallel Protocol for Sum Product
bels ( xs ) ∝ ψs ( xs ) ∏ mt → s ( x s )
t∈nbr(s)
m( s → t ) = ∑ ψs (xs )ψs−t ∏ ( xs )
xs u∈nbr(s),u6=t
11.4 Final Notes

For this lecture we have been ultilizing + and × and distributive property
50
11.4.1 Commutative Semi-ring
+ max ∩
× × ∪
∨ ∨ ∨
marginal argmax satisfying assignment
51
Lecture 12: Recurrent Neural Networks

Lecturer: Sasha Rush Scribes: Alexander Goldberg, Daniel Eaton, George Han, Moritz Graule
12.1 Introduction
Recall the basic structure of a time series model:
y1 y2 y3 ... y t −1 yt
In previous lectures we discussed interpreting such a model as a UGM, with log-potentials given by:
θ ( y t ) + θ ( y t −1 , y t )
What did we gain from this abstraction? Because all of these models have the same comditional inde-
pendence structure, we are able to run the same algorithm for inference on all of these parameterizations
(sum-product). Thus, conditioned on observed data, we may find the exact marginals: p(ys = v)
Perhaps these structures are not necessary? Is exact inference required in cases where there is alot of data?
12.2 RNNs
12.2.1 What is an RNN?
Recall our discussion of using neural networks for classification. The UGM describing this setting is as
follows:
x1 ... xT
We could then choose to parameterize p(y| x1:T ) as a neural network:
p(y| x1:T ) = So f tmax (w T φ( x1:T ; θ ))

where φ was just some linear combination of x1:T passed through a link function. If we wish to apply this
scheme to cases in which x1:T is a sequence we might think to use a φ of the following form:
T
φ( x1:T ; θ ) = tanh(wx) = tanh( ∑ w(t) xt )
t =1
However, the problem with this type of approach is that it is ”time invarient,” that is the same weights are
shared by all of the xt . To see why this is problematic, consider using a bag of words representation for the
Xt and encountering the two sentences: ”The man ate the hot dog.” and ”The hot dog ate the man.” While
these two sentences are saying completely different things, they result in the same value generated by φ.
Recurrent neural networks get around this problem by implementing the following choice of φ:
φ( x1:T ; θ ) = tanh(w(1) xt + w(2) φ( x1:t−1 ; θ ) + b)
where w(1) xt incorperates the current positional input, w(2) φ( x1:t−1 ; θ ) carries information from the previ-
ous inputs, b is the bias and tanh is the chosen nonlinear transformation.
Representing this RNN as a computational graph:
52
h0 h1 h2
...
...
...
x1 x2
where we call ht the RNN hidden state. As you can see, each ht is a nonlinear function of x1:t .
12.2.2 RNN Training

To understand how backpropagation works in RNNs, consider the functions that the NN is composed of:
h1 = tanh(w(1) x1 + w(2) h0 + b)
h2 = tanh(w(1) x2 + w(2) h1 + b)
...
(1)
ht = tanh(w x t + w (2) h t −1 + b )
Notice that the only parameters to optimize in these expressions are w(1) and w(2) , which are shared among
all of the equations. In our normal representation of backpropagation we have:
h1 h2 ht
... loss
x1 x2 x3 xt
Thus the size of the computational graph and the amount of backpropagation necessary will scale with the
length of the input, T. Now, thinking of this situation like a simple feed-forward NN, how many layers does
this network have?
12.2.3 Issues: Network Layers

This network will have T layers, where T is the length of the input, which may be very long. Thus, when
performing back-propagation it is very likely that there will be problems of gradient instability – very high
(exploding) or low (vanishing) values of the gradient somewhere in the back propagation, making it hard
to learn the parameters for low layers.
Consider using tanh as the activation function at each layer. Then, the gradient is close to 0 for very large or
very negative values, which is quite likely to happen somewhere in a network with many layers, so multi-
plying these small gradients together in back-propagation will make the contributions of the beginning of
the sequence to the loss very small. Thus, it could take prohibitively long to learn weights for the beginning
of the sequence. This problem is known as the problem of vanishing gradients.
53
12.2.4 Main idea/trick/hack for vanishing gradients
In order to deal with vanishing gradients, we want to try to pass on more info from low layers while taking
gradients, so we add connections variously called:
• residual connections
• gated connections
• highway connections
• adaptive connections
The idea of residual connections is that we let

ht = ht−1 + tanh w(1) xt + w(2) ht−1 + b
so that taking the gradient at layer t we get more information passed on from the the linear term ht−1
outside of the tanh.
In fact, we can adaptively learn how much the gradient at each time step should be taken
from the previous

time step directly from the cata. Thus, we weight the contributions of the ht and tanh w(2) ht−1 + ... by a
factor λ that is also learned from the data:

ht = λ ht−1 + (1 − λ) tanh w(1) xt + w(2) ht−1 + b

λ = σ w (4) h t −1 + w (3) x t + b
By passing on information directly from previous timesteps, we can prevent vanishing gradients, since the
linear terms pass on more information from previous timesteps. In this sense, the λs function as “memory”
of the previous timesteps. Important RNN variants using this idea are:
• LSTSM (Long short-term memory networks)
• GRU
• ResNet
12.3 Using RNNs

12.3.1 Classification
Our classification algorithm has three stages:
1. Run LSTM
2. Compute Softmax
3. Find maximizing class
This means that in order to make a prediction, we only need to compute
p(yi | x1:T ) = Softmax(w(2) hi )

and multiply across each yi to obtain
T T
p(y1:T | x1:T ) = ∏ p(yi |x1:T ) = ∏ Softmax(w(2) hi )
i =1 i =1
Critically, this means that we do not attempt to model the relationship between the yi at all, and thus we do
not need to assume any distribution over y!
Lets compare this to our alternative approach, which requires full generation. Imagine that any yi is condi-
tional on all of y1:i−1 . Then our DGM (for five nodes) is a fully connected K5 :
54
y0 y1 y2 y3 y4
How can we then compute p(ys = v)? A naive approach would be to literally enumerate all possible
sequences and sum across all possibilities. However, this is very computationally expensive (exponential
in T). Instead, we can speed up this approach by employing a greedy search. Let
ŷ1 = argmaxv p(y1 = v)
Now for each subsequent point yi , we can compute
ŷi = argmaxv p(y1 = v|ŷi−1 )
which is now linear in T, instead of exponential in T.
12.3.2 Applications
RNNs are commonly used for machine language translation and speech recognition. A simple machine
translation model is that of the Encoder-Decoder model.
y1 y1 y2
h1 h2 h3 C h4 h5 h6
Decoder
x1 x2 x3
Encoder
In this model, a sentence from the first language is fed in word by word (each xi ) into the Encoder. This
then runs through a normal RNN setup before being fed into C, which stores the final result of the encoder.
Now in the decoder, another RNN is run in reverse that spits out words in the second, translated, language.
Each translated word yi depends on the current layer in the decoder RNN, hi , C and the last translated
word (to prevent the same word from being generated multiple times).
Remark. We will talk about Information Theory in the next lecture.
55
Lecture 13: Information Theory

Lecturer: Sasha Rush Scribes: Peter Chang, Ruiqi Chen, Joonhee Choi, Joshua Meier, Raphael Rouvinov, Hyungmok Son
13.1 Announcements
The Midterm is next Monday. The list of topics is on the website. It’s open note but not open computer. You
can bring your textbook. They’ll try to bring copies of the textbook for people who don’t have it so they
don’t have to print out copies.
13.2 Introduction
Interestingly, almost all of information theory is laid out in a single paper, written by Claude Shannon in
1948. We often quote Alan Turing as the ’father’ of CS, but for the area we are discussing, that ’father’ is
Shannon. (Aside: Video of device Shannon built called the Ultimate Machine)
Today, we’ll cover the core aspects of information theory and discuss how we’ll use it in this class.
Earlier in this class, we’ve focused on exact methods for inference: MLE, MAP, etc. The one exception was
neural networks, which are not convex.
Exact inference is only tractable in a small subset of models. Given most models are intractable, what do we
do? We use approximate inference. Here, there are two main types of approximation: optimization-based
(which includes coordinate ascent, SGD, and Linear Programming methods) and sample-based. You can
use them together, but they have different histories, so we’ll discuss them separately.
Information theory brings together many of the expectation-maximization methods we’ve seen earlier into
a unified language. In particular, information theory lets us study relative entropy.
13.3 Information theory (Murphy 2.8)
The Information Source spits out bits (call this W), which is passed into the encoder (giving X(W)). The en-
coded bits pass through a noisy channel giving Y, which is passed into a decoder that gives us our target
message.
We don’t know how the noisy channel will act in a deterministic way. But we have a probability distribution
p(Y | X ) describing its behavior. The target message also has a distribution p( x |y) α p( x ) p(y| x ). Where p( x )
represents the source model, and p(y| x ) represents the channel model. We have a simple graphical model
here:
56
Several fields of research are contained in the first diagram. One area of information theory is called channel
coding (Noisy Channel in diagram). It studies how to best encode the data so it is most robust to the noisy
channel. A second area is called source coding - data compression (Source in diagram). It discusses how
we can exploit the way information is naturally represented in the world. For example, compression falls
here. (Aside: Hutter prize).
Example: people in speech recognition use this as an analogy for what they are trying to do. The model of
what a person wants to say is W. The encoding path is the sound the person makes X (w). The decoder is
what we (or the microphone) hear. And the goal, of course, is to uncover the target message.
We can write this analogy:
1. Source: Language
2. Encoder: Talking
3. Noisy Channel: Air
4. Decoder: ears/recognizer
Then, p( X ) represents the source model. If you know a person well, you can anticipate what is going on in
their head, and you know what they are going to say This makes your p( X |Y ) stronger. We multiply this
quantity by p(Y | X ) which represents the noisiness of the channel.
13.4 Definitions
Entropy:
K
∆
H (X) = − ∑ p(x = k) log2 p(x = k) = −Ek [log2 p(x = k)]
k =1
For a given random variable X, entropy measures the ”uncertainty” in the distribution. Entropy maxes out
when we have full uncertainty in the distribution.
57
This comes back to the idea of source coding. If there is full certainty in what can and is sent, then it does
not matter what the encoder/decoder does. The answer is trivial. In contrast, if there is full uncertainty, we
have to work much harder.
The unit of measure of this is called ”bits”(log2 ) or ”shannons” or ”nats” (loge ). The average number of bits
needed to represent a message is less than
H (x) + 1
We won’t prove this, but this is the fundamental link between information and coding.
Shannon Game In his paper, Shannon proposes the ”Shannon Game,” which tries to quantify human
source coding: given a sequence of text, give a probability distribution over the next letter/word.
THE ROOM WAS NOT VERY LIGHT A SMALL OBLONG READING LAMP ON THE DESK SHED GLOW
ON POLISHED .
In English, it takes roughly 80 guesses to get the right answer. We write that the perplexity or ”how confus-
ing the next prediction is” is
2 H (x)
Minimizing perplexity is where the ’power’/advances of RNNs comes from.
Cross Entropy:
1. p - is a true underlying distribution

2. q - another distribution that approximates p
H ( p, q) = − ∑ p( x = k) log q( x = k) = E p [log q( x = k )]
k
Cross entropy tells us expected number of bits to encode true distribution p with q.
We can sample from p to approximate
x˜1 , . . . , x˜N ∼ p( x )
Then, we compute the minimization of the cross entropy.
N
1
minq −
n ∑ log q(x˜n )
n
But this is just the negative log likelihood for categoricals. Last class, we talked about RNNs. We learn q
and compare to p. If we can make it more and more like p, this gives us the ability to do compression and
source modeling better.
Relative entropy (KL-Divergence):
∆ p( x = k ) pk
KL( p||q) = E p log = ∑ pk log = ∑ pk log pk − ∑ pk log qk = − H ( p) + H ( p, q)
p(q = k) k
qk k k
So the relative entropy is the negative entropy of p by itself plus the relative entropy of p and q. It’s a way
of comparing two distributions, but is not a metric - KL( p||q) 6= KL(q|| p)
Theorem. KL( p||q) ≥ 0
Proof. We have that
qk q
−KL( p||q) = E p [log ] ≤ log E p [ k ] = log ∑ qk ( x ) = log 1 = 0
pk pk k
This is only KL( p||q) = 0 when p = q.

Jensen’s Inequality.
f ( E[ x ]) ≤ E[ f ( x )]
58
if f is convex. Mostly using when f = log.
Information Geometry (Working with asymmetrical divergence).
We have some p and want q ∈ Q (set of distributions). There are two options:
1. Forward (moment projection):
argminq∈Q KL( p||q) = − H ( p) + H ( p, q)

Note that H ( p) falls out when minimizing q. So instead, we minimize at H ( p, q), which is the negative log
likelihood. So essentially, we are matching the moments. This equals
− E p log qk
Issues arise when qk → 0 and pk > 0. Forward projection will try to avoid zeros.
2. Reverse (information projection):
argminq∈Q KL(q|| p) = − H (q) + H (q, p) = − H (q) + Eq log pk

This method ”matches the modes”.
Issues arises when pk = 0 and qk = 0. Reverse projection will over predict zeros.
These two approaches fall under a field called Information Geometry. The forward approach is called
moment projection. The backward approach is called information projection. ”Essentially, these are both
methods for computing closeness among different distributions.”
Jensen-Shannon divergence – combine the above: add half of the Forward projection value to half of the
reverse projection value. This approach is popular right now.
This work is highly related to Generative Adversarial Networks (GANs). This metric is important in pro-
ducing non-blurry images. Combining two images looks bad, using a method with mode finding yields a
better image.
13.5 Demo
We did an example iPython notebook (KL.ipynb) in class.
Next class, we will use the reverse projection to get Q. This is called ”variational inference”.
59
Lecture 14: Mixture Models

Lecturer: Sasha Rush Scribes: Eric Dunipace, Andrew Fai, Isaac Xia
14.1 Administrative Announcements

Overview: Second half of class is on Inference, especially on harder problems. There is only one problem
set left, but the bulk of the time will be on the project.
There is some extra time left in the schedule, for which Prof. Rush will poll topics from the class.
14.2 Mixture Models: Introduction

Up until now, we’ve been considering mostly supervised learning, where we had an input x, an output y,
and parameters θ.
Previously when doing MLE, MAP, marginalizing over nodes in a graphical model, we weren’t trying to
find a distribution, we were finding a point-estimation rather than a distribution.
For example, suppose we want to think about models from Naive Bayes:
yn
x1,n ... xV,n

n
µk
with joint probability

V
p(y|π ) ∏ p( x j |y, µ),
j =1
where the priors could be Categorical on p(y|π ) and Bernoulli on each p( x j |y, µ).
In this setting, with data { xi , yi }, we can perform log-likelihood maximization with p({ x }, {y}) to infer the
parameters µ and π.
In a new setting, instead suppose we have the same graphical plate model, but we now do not observe the
categories; instead of yn , we denote these latent variables as zn .
60
π
zn
x1,n ... xV,n

n
µk
which also can be represented with the following undirected graphical model:
zn
x1,n ... xV,n

n
µk
What does this graphical model look like, and what dependencies do we need to consider?
• There’s clearly a dependency on π, but we can’t observe zn .

• There are the µk from the xin .
All of these Naive Bayes models without observed yn are used for different types of clustering. These
models are referred to as mixture models, and can handle multimodality well.
14.3 Types of Mixture Models

Up until now, most models we’ve used have unimodal distributions, e.g. normal distributions.
61
Figure 14.17: Multimodality of Multiple Gaussians vs Unimodality of One Gaussian
Although we won’t limit ourselves to only using continuous mixture models, we’ll be primarily working
with mixtures of Gaussians. Below are examples of mixture models we’ll see more of.
14.3.1 Mixture of Gaussian Modes

We can have a mixture of Gaussian models, by simply mixing different Gaussian conditional distributions
together:
p( x |y) ∼ N (µ, Σ)
An application example is speech recognition, which must deal with different accents (e.g. British vs Amer-
ican) for pronunciations of the same word. In this case, Gaussian mixture models are able to consolidate
the seemingly different pronunciations.
14.3.2 Mixture of Bernoulli/Multinomial Models

We can instead mix together various Bernoulli or Multinomial conditionals.
p( x j |y) ∼ Bern(µ j ) or Multinom(α)
14.4 Math behind Mixture Models

Now, we delve more deeply into the math behind using such mixture models. To start, the models involve
x (data), z (latent variables), π (prior of latent variable), and {µk } (parameters for conditional distribution).
We will use x and z to denote all n observations of the data and latent variables.
The complete data likelihood of the model is then
p( x, z) = ∏ ∏ πk p(xn |µk )znk ,

n k
where znk is shorthand for 1( Zn = k).

To get the marginal likelihood of the data, we can marginalize and sum over all possible values of zn :
p( x ) = ∑ ∏ ∏ πk p(xn |µk )znk = ∏ ∑ ∏ πk p(xn |µk )znk

z n k n z k
|{z}
Hard to compute
Although we pushed the sum into the product, the sum over all possible values of z is still hard to compute.
Our main alternative strategy is thus to utilize the complete data likelihood in order to find p( x ).
Below is a heuristic algorithm to find p( x ):
1. Initialize π and µ randomly.
62
2. Compute the log-likelihood p( x, z|π, µ) = ∑ ∑ znk log πk + znk log p(xn |µk ) using fixed π and µ.
n k
3. Denote qnk = p(zn = k| xn ; ...) as a “hallucinated” distribution over znk ; the origin of qnk is unclear, but
it satisfies the given requirements. We can use this distribution of z ∼ qnk to compute the expectation
of the log-likelihood as:
Ez∼qnk [log p( xn , zn |π, µ)] = ∑ ∑ qnk log πk + qnk log p(xn |µk ).
n k
We can then “hallucinate” parameters through the distribution of znk ! Returning to the graphical
model, recall that it was difficult to actually compute the parameters. Howevere, given some param-
eters π, µ, we can compute a marginal distribution over the z: p(z| x, π, µ).
4. We thus can perform a coordinate ascent algorithm; that is, we optimize one set of parameters, then
the other, then continue to alternate optimization.
This heuristic is summarized below:
1: procedure EM NB(x, z)
2: Initialize π and µ randomly.
3: while π and µ not converged do
4: (Expectation) Compute qnk = p(z| x, π, µ) using fixed π and µ
5: (Maximization) Compute MLE of π and µ using q through Ez∼q [log p( x, z)]
The above is called the Expectation Maximization (EM) Algorithm, where step 4 computes the actual ex-
pectation maximization, and step 5 actually maximizes through the MLE. π will be Categorical and µ will
be the means of the Gaussians themselves here.
14.5 Expectation Maximization Algorithm

The above algorithm can be generalized, and is known as the Expectation Maximization (EM) algorithm.
1: procedure EM(x,z)
2: Initialize π and µ randomly.
3: while π and µ not converged do
πk p( xn |µc )
4: (Expectation) qnk ←
∑ πk0 p( xn |µk0 )
k0
5: (Maximization) Ez∼q [log p( x, z|π, µ)] = ∑ ∑ qnk log πk + qnk log p(xn |µk )
n k
We’ll thinking about this algorithm in the context of information theory. In the maximization step, we have
the first term ∑ ∑ qnk log πk can be thought about as maximizing the πk under the model, with the as-
n k
sumption they were sampled from distribution of qnk .
 
 
∑∑ qnk
|{z}
log  πk
|{z}

n k
Came from qnk guess Want to find πk
So, we can think of qnk as “expected counts” from a distribution. So, the MLE is similar to standard counts
of observations. In particular,
∑ qnk
πk = n .
∑ qnk
n,k
63
Alternatively, we could also use the MAP estimate. The main point is that the prior is embedded in the max
step.
A similar update happens for µ, but will be specific to the actual form of the model p( x |µ).
14.5.1 Assumptions on EM
One key point is that the model yields an easily computable p(z| x, π, µ). If we imagine that p( x |z) is an
arbitrary neural net with continuous output, this could be very difficult. A specific example is a Variational
Autoencoder (VAE), which could be found from Kingsma and Welling.
14.6 Demo on EM
We did a demonstration on Expectation Maximization.
In general, we saw it was pretty hard to even infer the clusters of data especially as the number of true
clusters increased.
Q: How to infer number of true clusters? It’s actually a hard problem, no really good standout way to do this.
Q: Difference between k-means and EM here? k-means will choose q as the highest probability, instead of
assigning a distribution to qnk as EM does.
14.7 Theory behind Expectation Maximization

We’ll discuss why the EM algorithm works; specifically, why qnk eventually converges to p(zn | xn , π, µ).
First, consider the marginal distribution of the data p( x ) = ∏ ∑ p( xn , zn |π, µ). We have that the log-
n zn
marginal is (in terms of entropy)
" #
log p( x ) = ∑ log ∑ p(xn , zn , |π, µ)
n zn
" #
p( xn , zn |π, µ)
= ∑ log ∑ q(zn = k)
n zn q(zn = k )

p( xn , zn |π, µ)
= ∑ log Eq
n q(zn = k )
p( xn , zn |π, µk )
≥ ∑ ∑ q(znk ) log
n k
q(zn )
" # " #
= ∑ ∑ q(znk ) log p(xn , zn |π, µk ) −∑ ∑ q(znk ) log q(zn )
n k n k
= ∑ ∑ qnk log p( xn , zn = k|π, µk ) + ∑ H [q(zn )]
n k n
q(zn = k )
In the second line we only multiplied by 1 = . In the third line, we use the trick of applying
q(zn = k )
Jensen’s inequality when we see the log of an expectation.
In now analyzing the M-step, we are computing
π,µ ← argmax ∑ ∑ qnk log πk + qnk log p( xn |µk )

π,µ n k
where ∑ qnk log πk is the cross-entropy between parameters and expected counts.
k
64
The E-step, we find qnk .
" # " #
p(z| x ) p( x ) p(z| x )
arg min ∑ ∑ q(z) log = arg min ∑ ∑ q(z) log q(z) + const
q n k
q(z) q n k
= arg min ∑ KL (q(z) || p(z| x )) ,
q n
and we can minimize the KL divergence term by setting qnk = p(zn | xn , π, µ) as the same distribution.
65
Lecture 15: Mean Field

Lecturer: Sasha Rush Scribes: Alex Lin, Wei Zhang, Daniel Giebisch, Richard Zhang, Fahad Alhasoun
15.1 Variational Inference

In inference, we’re interested in computing p(z| D ), the marginal distribution of a node z, given D, where
D is all of the evidence in the model. However, very often, direct computation with exact methods is too
difficult. As a result the most feasible approach may be to find a q(z) that reasonably approximates p(z)
where q is easy to compute. Thus, we define
q∗ = argminq∈EASY d(q, p)
where EASY is the set of functions that are easy to compute and find the q* such that by some metric d, q*
is the closest to p (or smallest gap). Note that the function p can be anything.
15.2 Hard models

• Ising model P(y)
Recall the Ising model from a few lectures ago, a grid of nodes connected horizontally and vertically
to adjacent nodes on 4 sides (or 3 on the edges and 2 on the corners). Things in which we may be
interested include the marginal distributions p(yij = 1) and the partition function. Unlike for a tree
structure, direct computation using loopy belief propagation may not converge well for this graph
with cycles, so we will look for a different method.
• Gaussian Mixture Model
π ∼ dir (α)
Θk = (µk , Σk )
Zn ∼ π
Xn |( Zn , Θ) = N (µk , Σk )
Recall the Gaussian Mixture Model from last lecture, an unsupervised learning method that attempts
to categorize data points into clusters. This is nearly the same graphical model as Naive Bayes classi-
fication, except that the classes are not observed, but rather inferred. Again, computation of p( xn ) is
rather difficult because zn are not observed. Therefore, one must find a method that infers the zn in
order to infer p( xn ).
66
15.3 Variational Idea
reverse kl
kl(q||p) I-projection
forward kl
M-projection
kl(p||q)
minq d( p, q) = KL(qk p)
Z
q(z)
= q(z)log
p(z| D )
In trying find the gap function d( p, q) that measures our gap from p to q, one good choice is the KL diver-
gence, but because it is asymmetric, we essentially have 2 options, both of which lead to valid methods:
• KL(qk p)
The reverse KL, I-projection
• KL( pkq)
The forward KL, M-projection
The forward KL method is also known as the Expectation Propagation (EP) method.
15.4 Relationship to EM
Recall the Expectation-Maximization (EM) method from last lecture. Much of the mathematics we will use
resembles that which we have already studied.
Z
log p( D ) = log p( D, z)dz (D is the observed data set)
Zz
= log q(z) p( D, z)/q(z)dz
z

p( D, z)
= log Ez∼q
q( D )

p( D, z)
≥ Ez∼q log (the lower bound, by Jensen’s inequality)
q( D )

p( D, z) p( D, z)
log p( D ) − Eq log = Eq log p( D ) − log
q(z) q(z)

q(z)
= Eq log
p(z| D )
= KL(qk p)
One more remaining issue is that
p(z, D )
p(z| D ) =
p( D )
67
where p( D ) is generally very difficult to compute and the main reason why computing p exactly becomes
an intractable problem. However, for the purposes of finding q, we can ignore p( D ) as just a constant, since
it is independent of z. Thus,

q(z)
min KL(qk p) = min E log
q q p(z, D )
Comparison to EM
• In variational inference, we have coordinate ascent just like in EM, except we try to optimize a lower
bound.
• In variational inference, we pick q from the EASY set. As a result, we don’t have to select point
estimates, but rather we can use entire distributions.
• This is very useful in Bayesian setups.
• We can also combine this with EM and sampling to obtain more sophisticated techniques as well.
15.5 Mean Field

p q
Y
q(z1 , z2 , z3 , z4 , z5 ) = qi (zi )
i
q1 (z1 ) q2 (z2 )
q3 (z3 ) q4 (z4 )
q5 (z5 )
This is an algorithm that optimizes one particular qi , via an expectation over the adjacent variables, while
fixing all of the other q and then iterates this procedure over all of the q. It proceeds as follows:
• We assume we have all q except qi .

• Select q(z) = ∏ qi (zi ) from our EASY set.
• Recall that the goal is to reduce the gap minq KL(qk p). We do this by fitting each qi as
qi∗ ← argminq KL(qk p)
68
where
argminq KL(qk p) = argminqi − H (qi ) − Eq log( p(z))

Z
= argminqi − H (qi ) − (∏ qi (zi )) log p(z) + other ( j 6= i )
z i
(q(z)=∏ qi (zi ))
Z Z
= argminqi − H (qi ) −
zi
qi ( zi ) ∏ qi (zi ) log p(z) + ...
z j :j6=i j6=i
Z
= argminqi − H (qi ) − qi (zi ) log f i (log f i = Eqi [log p(z)])
zi
= argminqi KL(qi k f i ) ( f i is not distribution , but still OK)
qi ∝ exp{ E−qi (log( p(z)))}
Note that E−qi denotes an expectation taken over all the variables except zi .
15.6 Ising Model

p q
We now apply Mean Field Variational Inference to the Ising Model. Note that θvi denotes the log-potential
of vertex i while θ Ei−n denotes the log-potential of the edge from vertex i to vertex n. We compute qi as an
expectation over the 4 neighboring nodes, the Markov blanket. This is then
qi ∝ exp[ Eqi log p(z)]

p(z) ∝ exp[θvT z + z T θ E z]
log qi ( xi ) ∝ E−qi [log p(z)]
= E−qi [θvT z + z T θ E z]
= E−qi [zi θvi + Σn θ Ei−n Zi Zn ]
= Zi θvi + Σn∈neighbor θ Ei−n Zi Eqn [ Zn ]
= Zi θvi + Σn θ Ei−n Zi qn (1)
Therefore
qi ∝ exp[ Zi θvi + Σn θ Ei−n Zi qn (1)]
We can then repeat this procedure over all nodes to update the entire graph. Then we can repeat that over
several epochs until we find good convergence of q.
69
CS281: Advanced ML November 1, 2017
Lecture 16: Variational Inference Part 2

Lecturer: Sasha Rush Scribes: Denis Turcu,Xu Si,Jiayu Yao
16.1 Announcements
• T4 out, due 9/13 at 5pm
• Exams available in office
• OH - today 2:30-4pm (Wednesdays)
• Follow formatting for the abstract of the final project. There were many inconsistencies with the
formatting requirements for the initial proposal.
16.2 Introduction
Last class, we talked about variational inference. This class, we gonna talk about a very different type of
VI. We also will talk about some other types of VI but will not go too much into the details.
Murphy’s book, especially Chapter 22, covers many details on the theory side. The other text, Murphy
referred as ”The Monster”, we put online as a textbook written by Michael Jordan.
16.3 Bayesian GMM

We are going to talk more about variational inference. We also put another reference online called VI: A
Review for Statisticians. It covers in great detail of Bayesian GMM, so let’s write down that model:
π zn
xn µk
We assume:
µk ∼ N (0, σ2 ) ∀ k
1 1
zn ∼ Cat( , . . . , ) ∀ k
k k
xn |zn , µ ∼ N (µzn , 1) ∀ n.
Then we write:
p({ xn }, {zn }, µ) = p(µ) ∏ p(zn ) p( xn |zn , µ).
n
And we get: Z Z
p( x ) = p( x, z, µ) = p(µ) ∏ ∑ p(zn ) p( xn |zn , µ)dµ.
z,µ n zn
Variation setup. Goal:
min KL(q|| p)
q∈ EASY
reverse KL.
We pick EASY as mean field.
70
zn
xn µk
zn µk
Variational parametrization:
q(µ, z) = ∏ q k ( µ k ) ∏ q n ( z n ).
k n
qn (zn ; λzn ) Cat(λzn ).

µ 2 µ 2
qk (µk ; λk , λσk ) N (λk , λσk ).
!
∏ ∏ qn (zn ; λzn ) || p
µ 2
arg min KL(q|| p) = arg min KL qk (µk ; λk , λσk )
q∈ EASY λ n
k
”When we do mean field?”
qi ∼ exp[E−qi log( p(z, x ))]

Brief interlude: coordinate ascent → CAVI (coordinates ascent variational inference). Doing each individual
one at a time.
• Bound we are optimizing is non-convex.
• This method is monotonically increasing.

• Sensitive to initialization → common for random restarts.
Example, deriving the math for GMM can be useful to understand how it works and how we will do mean
field updates. Start from the above, setup the problem:
µk ∼ N (0, σ2 ) ∀ k
1 1
zn ∼ Cat( , . . . , ) ∀ k
k k
x n | z n , µ ∼ N ( µ z n , 1) ∀ n
2
where we also have λzn for hidden switch variable, and λm s
k , λk for the Gaussians.
71
qn (zn ; λzn ) ∝ exp[E−qn log( p(µ, z, x ))]
∝ exp[E−qn log( p( xn |zn , µzn ))]
∝ exp[E−qn − ( xn − µzn )2 /z]
∝ exp[E−qn ( xn µzn − µzn 2 /2)]
∝ exp[ xn E−qn (µzn ) − E−qn (µzn 2 )/2]
zn
xn µzn
2
So we identify E−qn (µzn ) with λm
k =zn and E−qn ( µzn ) with λk , and then we can write:
2 s
k =zn , λk ) ∝ exp [E−qn (log p ( µk ) + ∑ log p ( xn | zn , µ )]

2
qk (µk ; λm s
n
= −µk /(2σ ) + ∑ E(log p( xn |zn , µ))
2 2
n
= −µk /(2σ ) + ∑ E(znk (log p( xn |µk ))
2 2
n
= −µk /(2σ ) + ∑ E−qn (znk )(log p( xn |µk ))
2 2
n
= −µk /(2σ ) + ∑ λznk (−( xn − µzn ))2 /2 + const.
2 2
n
σ2
= (∑ λznk xn )µk − ( + ∑ λznk /2)µk 2 + const.
k
2
Then:
qk (µk ) = exp[θ T φ − A + . . . ],
2
where θ1 = ∑n λznk xn , θ2 = −( σ2 + ∑ λznk /2) and φ1 = µk , φ2 = µk 2 , as in GLM.
For normal distribution, we have:
∑n λznk xn 2 1
λm
k = z , and λsk = .
1/σ + ∑n λnk
2 1/σ + ∑n λznk
2
16.4 Exponential Family

p(z j |z− j , x ) = h(z j )exp(θ T φ(z j ) − A(θ )),
where θ are function of z− j , x. One nice case is UGM:
72
zj
blanket
q(z) = ∏ q(z j )
j
q(z) ∝ exp[E−q j log p(z j |z− j , x )]

∝ exp[log(h) + E(θ )zTj − E( A(θ ))]
∝ h(z j )exp[E(θ ) T z j ]
where E(θ ) T are the natural parameters of the variational approximation
λ j = E[θ (z− j , x )]
16.5 Latent Dirichlet Allocation

• Widely used generative latent variable model
• generative model set up
βk πn
zni
wni
where β k ∼ Dir (η ), πn ∼ Dir (α), zni ∼ Cat(πn ), wni ∼ Cat( β zni )

• Topic molding story:
– n - documents
– i - words
– πn - document topic distribution
– β k - topic-word distribution
73
– zni - topic selected for word i of document n
– wni - word selected for ni.
– λzni - probability for the topic of word i in document n
16.6 Demo
We did an example iPython notebook (TopicModeling.ipynb) in class.
74
Lecture 17: Loopy BP, Gibbs Sampling, and VI with Gradients

Lecturer: Sasha Rush Scribes: Patrick Varin, Lillian Pentecost, André Snoeck, Baojia Tong, Hsuan Lee
17.1 Loopy BP
17.1.1 History
The history of Loopy Believe Propagation (Loopy-BP) began in 1988 with Judea Pearl who tried to analyze
the behavior of the BP algorithm (which gives exact marginal inference on tree) on graphs that are not trees,
like the Ising model. Remember the message passing algorithms is
ms→t ( xt ) = ∑ ψ( xs )ψ( xs , xt ) ∏ mu→s ( xs )

xs u∈NBR(s)−t
bels ( xs ) ∝ ψ( xs ) ∏ mt→s ( xs )
t∈NBR(s)
Note that this algorithm doesn’t require an ordering on the nodes, so it can naturally extend to cyclic graphs.
Around 1998, a decade after Pearl raised the question of the BP algorithm on general graphs, papers study-
ing Turbo coding or Low density parity check (LDPC) codes used the BP algorithm on cyclical graphs with
empirical success, motivating more research. This research drew parallels between loopy-BP and varia-
tional inference.
17.1.2 Implementations
We can implement loopy belief propagation either synchronously or asynchronously
• Synchronous Updates: All of the nodes are updated togethers, so that every node at iteration t de-
pends on it’s Markov blanket at t − 1
– parallelizable
– usually takes more updates
• Asynchronous Updates: The nodes are given an order and updated sequentially
– sequential
– usually converges in fewer updates
Figure 17.18: Message passing example: left (incoming), right (outgoing)
75
These updates look similar to mean field variational inference (VI) with some differences in performance.
• Loopy BP is exact on trees, mean-field variational inference is not.
• Loopy BP is not guaranteed to converge, where VI will.
• If Loopy BP converges it is not guaranteed to converge to a local optimum.
Loopy BP is generally more costly than mean field VI, because it stores node beliefs in addition to edge
messages, whereas mean field VI only stores node parameters. If the graph is large and dense, then Loopy
BP might be very costly.
In practice, because Loopy BP contains more information about the problem than mean field VI it tends to
work better.
17.2 Gibbs Sampling (Preview)

Gibbs Sampling is a different method for approximate inference. It is a special case of Markov Chain Monte
Carlo (MCMC), which will be covered in more detail in coming lectures.
The main idea of Gibbs Sampling is to re-estimate the posteriors for xi assuming that we have we have
explicit point estimates for all the other nodes in the graph (x−i ):
x̃i ∼ P( xi | x̃−i )
Naturally, we only care about the Markov blanket when estimating a particular node. Gibbs sampling is
not a parallel algorithm, the samples have to be generated sequentially. However, we can go through our
graph in any particular order and update each node accordingly.
17.2.1 Example: Gibbs Sampling Topic Modeling

In the following example, we present the Gibbs update associated to the topic modeling that we defined in
Lecture 16. Remember that
β k ∼ Dir (η ) k topics
πn ∼ Dir (α) n documents
zni ∼ Cat(πn ) Draw topic for each word and each document
wni ∼ Dir ( β zni ) Draw a word from a topic
and the full joint distribution is given by
p( β k , πn , {z}, {w}) = ∏ p( βk ) ∏ p(πn ) ∏ p(zni |πn ) p(wni |zni )

k n n,i
See Figure 17.19 for reference.
The updates for Gibbs sampling are similar to those of Mean Field (see Lecture 16), albeit much simpler.
We need to compute the conditional probability for each of the following
zni = k|πn , wni ∝ πnk β k,wni

πn |α, zni = Dir ( ak + ∑ 1(zni = k))
i
β k = d|η, zni = Dir (ηd + ∑ 1(zni = k, wni = d))
i
The last two terms are essentially the full posterior that we saw in lecture 2. Although these updates are
rather simple, it is used in many applications given it works with a wide variety of models. Typically, one
would draw one sample per update. It is not clear whether drawing multiple samples or running more
epochs helps the algorithm converge faster.
76
Figure 17.19: Graphical model associated to topic modeling example
17.3 Variational Inference with Gradients

17.3.1 Introduction
Variational inference with gradients is also referred to as black box variational inference or stochastic varia-
tional inference (SVI) and is actively gaining traction in the ML commnity today. For example, UberAI just
released a new framework on top of pytorch called pyro to support SVI. One reason why this is attractive is
because SVI integrates well with autograd and deep learning.
17.3.2 Aside on Monte Carlo Sampling

If we consider some expectation over a distribution p of some function f (z), as given below for discrete z,
we often find this is intractable to compute.
Ez∼ p [ f (z)] = ∑0 p(z0 ) f (z0 )

z
We can approximate this expectation by sampling some N number of z̃, with each sample represented by
z̃n , which results in the following expression for the expectation:
N
1
Ez∼ p [ f (z)] ≈
N ∑ f (z̃n )
n =1
2
This is much simpler to compute, and it can be shown that the resulting µ̃ satisfies that (µ̃ − µ) ∼ N (0, σN ),
which implies that the variance of the approximation with respect to the true mean decreases with the
number of samples N.
17.3.3 Rough Idea

We will apply gradient optimization to the lower bound on p( x ) that we use to derive the variational objec-
tive. We use the formulation of the Gaussian Mixture Model (GMM) and Mean Field (MF) approximation
with variational parameters, developed in previous lectures, as an example. This is potentially more at-
tractive than coordinate ascent because for a very large dataset compared to the number of classes (i.e.
n >> k in the GMM MF configuration) coordinate ascent requires (1) iterating through all data to perform
updates to the variational parameters and (2) storing variational parameters per-example (the number of
the parameters grows with the size of the dataset).
The two wishes/ideas of this approach will be to (1) update global parameters (λk ) on mini-batches to avoid
the need to iterate over all samples (all λn ) to perform update and (2) avoid storage of a dedicated λn for
each n. The remainder of the lecture will focus on idea (1) above.
77
17.3.4 Deriving the Variational Objective
Letting θ = zn , µk , we would like p( x ) for the GMM MF configuration previously developed. We aim to
maximize the following lower bound (also from previous lecture) in order to approach p( x ), where qλ is
any q with variational parameters λ.
p( x, θ )
p( x ) ≥ Eq [log ]
qλ (θ )
p( x, θ )
max Eq [log ]
q qλ (θ )
Expressing p( x, θ ) = p(θ ) p( x |θ ) and distributing the log, we find the variational objective, and we can
interpret each of the three terms:
max −Eq [log qλ (θ )] + Eq [log p(θ )] + Eq [log p( x |θ )]

q
In the expression above, we can recognize that the first term is just an entropy term, the second term
includes the prior to effectively find a q close to p(θ ) based on cross-entropy, and the third term contains
the likelihood to reflect how well θ predicts the data. Furthermore, we see that the first two terms together
form the negative inverse KL divergence of p and q, so we further simplify to the expression below:
L(λ) = max −KL(q(θ )|| p(θ )) + Eq (log p( x |θ ))

q
In the expression above, the KL divergence will act to tend q towards the prior p(θ ) and the expectation
term will give weight in q to parameters that tend to explain x.
17.3.5 Optimization via Stochastic Gradient Descent (SGD)

Next, we aim to apply optimization via SGD, and the L(λ) given above becomes a loss function; we will
maximize the value of this function by computing the gradient with respect to the parameters we care
about (λ). Here, we will take a mini-batch of x values and compute ∇λ L(λ). However, we notice that the
expectation term in L(λ) over q must be approximated, and the two methods to compute an approximation
are (1) reinforcement and (2) reparameterization. This lecture only covers method (2), reparameterization,
which also appears on HW4.
Reparameterization requires known q of a certain type and removes q from the expectation. Beginning
with the form of the expectation, we can reformulate in terms of a change of variable from distribution q
to the standard normal (letting θ = Az + b) and then apply the Monte Carlo approximation to simplify the
expression and make it computationally tractable:
Eqλ [ p( x |θ )] = Ez∼N (0,1) [ p( x | f λ (z))]
∇λ Ez∼N (0,1) [ p( x | f λ (z))] = Ez∼N (0,1) [∇λ p( x | f λ (z))]
N
1
∇λ Eqλ [ p( x |θ )] ≈
N ∑ ∇λ p(x| f λ (z̃n ))
n =1
78
Lecture 18: Variational Auto-encoders and GANs

Lecturer: Sasha Rush Scribes: Jeff Chang, Michael Els, Zhixian Lei, Yuting Sun, Xincheng You, Srivatsan Srinivasan
Today we are going to go a step forward in Variational Inference. We are going to combine the variational
inference and neural networks.
18.1 Autoencoder
Suppose we receive a signal x from a source. Then we encode x with encoding function Enc
z = Enc( x )
so that z is simpler than x, for example, z can be lower dimension than x or the learned encoding function
itself can be a simple function. The goal is to limit the capacity of the model by parameterising enc and p(),
and to learn them from the data. This leads to the model learning the optimal compression for the data
which only saves the most important information and discards the rest. This encoding is often nonlinear
in practice, for example, people often use neural networks. Then z might be changed to z0 by noise. After
that, we want to recover x by inference:
x̂ = argmaxx0 Pr( x = x 0 |z0 )
This is basically what autoencoder does. For variational autoencoder, we need to parameterize function
Enc and Pr( x = x 0 |z0 ) usually with neural networks. We might want to learn these functions from data.
18.2 Back to Variational Inference

Z
log p( x ) = log p(θ ) p( x |θ )dθ (18.44)
Zθ
= log q(θ )( p(θ )/q(θ )) p( x |θ )dθ (18.45)
θ
p(θ )
≥ Eq log p( x |θ ) (18.46)
q(θ )
= −KL(q(θ )| p(θ )) + Eq [log p( x |θ )] (18.47)
where the first term makes q close to prior p and the second term is the likelihood based on q. There are
two methods to optimization above expression
• Coordinates Ascent (CAVI)
• Stochastic Gradient Descent (SGD)

where CAVI is the method we have introduced in previous lectures and SGD is just directly optimize this
function.
About the choice of q-function, we have following several methods:
• We can make mean field assumption (which requires the full Markov blanket), then q(θ ) = ∏i qi (θ )
79
• We can also do structured mean field. Basically we can divide this graph into several simple sub-
graphs (they can overlap each other). Inside each subgraphs we can do belief propagation using for
example forward-backward algorithm and outside of the subgraphs we use mean field approxima-
tion. This q is closer to the original and has a better bound.
• More generally we can use neural networks, where λ are neural network parameters and we use qλ
to approximate the posterior.
18.3 Variational Autoencoder

We have learned many models in this class. The Ising model is an example that is difficult to do inference
on. There are also models that we can’t use EM on. An example of such a model is illustrated here:
z
µ
x
N
Since the parameters are not fixed, the EM fails in this case. Using this as a motivating example, let’s exam-
ine Variational Autoencoders. In our previous examples for inference, we always consider the conditional
distribution as discrete distribution or just linear Gaussian distribution, and that we can calculate our pos-
terior in a straightforward manner. But in general p(Data|Label) can be non-linear, for example, neural
network. Then p(Label|Data) becomes intractable. In this case, we should make q-function as a neural
network. Suppose z are labels, x are data and µ are parameters. And we assume
Pr( x |z, µ) = softmax(wφ( x; µ))
where φ is a neural network. We use neural networks to compute q functions
qλ (z) = N (w1 φ1 ( x; λ), w2 φ2 ( x; λ))

where φ1 and φ2 are neural networks. w1 and w2 are transformation parameters.
We can interpret this process as autoencoder. We first encode x into a distribution
qλ (z) ∼ N (w1 φ1 ( x; λ), w2 φ2 ( x; λ))

Then upon getting some sample z from qλ (z), we decode x as x̂ where
x̂ = argmaxx log p( x |z)
To make x̂ be close to x, we should optimize the parameter λ by
max −KL(q(θ )|| p(θ )) + Eq log p( x |θ ) + Eq log p( x |θ )
λ
We use gradient method to optimize λ where the gradient can be written as

∇λ − KL(q(θ )|| p(θ )) + ∇λ Eq log p( x |θ )
where the latter term can be approximated via reparameterization
N
1
∇λ Eq log p( x |θ ) ∼
N ∑ ∇λ log p(x| f λ (sn ))
n =1
after we obtain optimized parameter λ from large amount to data x, we will obtain an qλ ( x ) as encoding
function for all x and we can use it for future encoding and recovery and even generate new x from encoding
and decoding processes.
80
18.4 Sampling from other distribution
One typical problem when we want to do optimization is that we don’t know how to compute
∇λ Eqλ [log p( x |θ )]
There are basically two ways to treat this problem

• Reparameterization. We can transform Eqλ to other fixed distribution and sampling on that distribu-
tion by translating the parameter. Then we can move ∇ inside the expectation.
• Reinforce. We can make use of following identity:
∇λ qλ (θ )
∇λ log qλ (θ ) =
qλ (θ )
∇λ qλ (θ ) = qλ (θ )∇λ log qλ (θ )
Then we have
Z
∇λ Eqλ [log p( x |θ )] = ∇λ qλ (θ ) p( x |θ )dθ (18.48)
Z
= qλ (θ )∇λ log qλ (θ ) p( x |θ )dθ (18.49)
= Eqλ [ p( x |θ )∇λ log[qλ (θ )]] (18.50)
Then we succeed to move ∇ inside expectation.

Finally, a few links to learn more on VAEs.
• https://arxiv.org/pdf/1606.05908.pdf
• https://arxiv.org/abs/1312.6114
81
Lecture 19: Monte Carlo Basics

Lecturer: Sasha Rush Scribes: Chang Liu, Jiafeng Chen, Alexander Lin
19.1 History
We started with Monte Carlo in the past few lectures. The main method is to use draw samples from a
proposal distribution and take sample average to approximate expectations.
Z
Ey∼ p(y| x) [ f (y)] = p(y| x ) f (y)dy
N
1
≈
N ∑ f (ỹ(n) )
n =1
where ỹ(n) ∼ p(y| x ). This approach requires the ability to sample y ∼ p(y| x ).
19.2 Univariate Case

Let’s start at the beginning: We know F ( x ) = p(y ≤ x ) and it is univariate.
Assume we can compute F −1 (u), then
p( F u ≤ x ) = p(u ≤ F ( x )) = F ( x )u
where F is the CDF of u ∼ Unif(0, 1). However, this works only for univariate case. What this means is
that, is we wish to sample y ∼ F for some known CDF F, we need only to sample U ∼ Unif and transform
the sample of uniform random variables through F −1 to get a sample of y. Formally,
U ∼ Unif =⇒ F −1 (U ) ∼ F
(This is known as the probability integral transform).
19.3 Normal Samples

We pursue the same strategy as in the univariate case. Given Uniform samples, we wish to apply some
transform to obtain a sample of multivariate random variables of some distribution we are interested in.
We execute this strategy for Normal random variables (this is known as the Box-Muller transformation).
The upshot here is that to sample Normal random variables, we need only to sample Uniform random
variables, which is much easier to do.
Box-Muller Sample z1 , z2 ∼ Unif[−1, 1]. Discard the points outside of the unit circle, so our sample of
{(z1 , z2 )} is uniform on the unit disk. We would like to transform each (z1 , z2 ) into some ( x1 , x2 ) ∼ N (0, I ).
We want to find the right transform such that the Jacobian makes the following hold
Normal PDF Unif disk PDF
z }| { z }| { ∂ ( z1 , z2 )
p ( x1 , x2 ) = p ( z1 , z2 )
∂( x , x ) .
1 2
We may check that
1/2
−2 log r2
x1 = z1
r2
1/2
−2 log r2
x2 = z2 ,
r2
where r2 = z21 + z22 , is the desired transform.
82
19.4 Rejection Sampling
Assume that we have access to the PDF p( x ) or the unnormalized PDF p̃( x ). The idea is to pick a guide
function (valid PDF) q( x ) that is similar to p and easy to compute. We also pick a scale M. We require that
Mq( x ) > p( x )
for all x and that we have access to p( x ) or pe( x ). The algorithm is as follows:
1. Sample xn ∼ q( x )
2. Draw u ∼ Unif[0, 1]
p( xn )
3. If u < Mq( xn )
, then keep xn ; otherwise, rerun from 1.
The interpretation is simple. The algorithm “graphs” p( x ) and the bounding Mq( x ) on a board, then pro-
ceeds to throw darts at the board and accepting those darts that hit below p( x ). The same algorithm works
even if p̃ is unnormalized, since we have the degree of freedom to choose M and thus absorb the normaliz-
ing constant.
p̃( x )
This method works with = p( x ). But why should it work?
Z
ANS This works because for whatever guide function we pick, we can write that guide function to be:
e = ZM
M
19.4.1 Proof of Rejection Sampling
R x0 R 1 p̃( x )
−∞ 0 q ( x ) 1( u ≤ )dudx
Mq( x )
p( x ≤ x0 | xis accepted) =
R∞ R1 p̃( x )
−∞ 0 q ( x ) 1( u ≤ Mq ( x ) ) dudx
1 R x0
−∞ p̃ ( x ) dx
= MR the denominator is probability the acceptance
1 ∞
p̃ ( x ) dx
Z
M −∞
x0
= p( x )dx
−∞
= p ( x ≤ x0 )
19.5 Examples for Rejection Sampling

1. In Bayesian statistics, we often encounter the following problem. We are given p(θ ), p( x |θ ), and we
wish to sample from the posterior p(θ | x ). We can compute the unnormalized posterior p̃(θ | x ) =
p( x |θ ) p(θ ). Set q(θ ) = p(θ ). Choose M = p( x |θ̂ ), where θ̂ is the maximum likelihood estimator.
Then Mq ≥ p. Thus, rejection sampling says the followng. Sample from the prior q(θ ) = p(θ ), roll a
uniform u, and keep those θ ∼ p(θ ) with
p p( x |θ )
u≤ = ≤ 1.
Mq p( x |θ̂ )
2. Let p ∼ N (0, σp2 I ) and q ∼ N (0, σq2 I ) where σq2 > σp2 . Pick
M = (σq /σp ) D ,
where D is the dimension of the Multivariate Normal. Note that M becomes very large when D
becomes large, and so rejection sampling may be inefficient when D is large. If we imagine M as the
metric of which to boost the Gaussians to make random sampling work, due to the known geometry
of Gaussian distributions we can imagine as D increase there will be more and more ”space” between
p and q to fill, thus making Random Sampling quite difficult.
83
19.6 Importance Sampling
We want to approximate the expectation
Z
Ex∼ p ( f ( x )) = f ( x ) p( x ) dx.
So far, we can sample a bunch of points—via, say, rejection sampling—from p and calculate a sample mean
to approximate the true expectation. If the structure of p and the structure of f are very different, so Monte
Carlo methods so far might be inefficient, since it samples from high density areas in p, which may have
very low values of f , and the Monte Carlo may miss areas with high values of f but low probability of
happening.
Consider the integral
Z
p( x ) p( x )
q( x ) f ( x ) dx = Eq f (x) = E p ( f ( x )).
q( x ) q( x )
We may now apply the same Monte Carlo trick to sample from q and take the sample mean of f ( x ) p( x )/q( x ).
What is the benefit of using q? Since we can choose q to be closer to f , then more of the sample we choose
would be around high values of f . Here we don’t need to wait for some low-probability tail event in p to
happen in order to get reliable estimates of E p ( f ( x )). Instead, we can directly look at the tail events via q
and weight the data appropriately using p/q to still maintain asymptotic convergence.
How exactly do we choose q? We want to minimize the variance of f ( x ) p( x )/q( x ) when x ∼ q, since this
allows for faster convergence. Then
" # 2
f ( x ) p( x ) f ( x ) p( x ) 2 f ( x ) p( x )
Var =E − E
q( x ) q( x ) q( x )
| {z }
constant eventually
2 2
f ( x ) p( x ) p( x )| f ( x )|
E ≥ Eq (Jensen’s inequality)
q( x ) q( x )
Z 2
= p( x )| f ( x )| dx
We minimize the lower bound via Jensen’s inequality (similar to what we did in variational inference). The
optimal q is chosen via
| f ( x )| p( x )
q∗ = R .
| f ( x )| p( x ) dx
It may be difficult to normalize q∗ in practice, however.
Z
E p [ f ( x )] = p( x ) f ( x )dx
N
1
≈
N ∑ f ( x̃ (n)
n =1
where x̃ (n) ∼ p( x )
84
Lecture 20: Importance Sampling and Particle Filtering

Lecturer: Sasha Rush Scribes: Shangyan Li, Alex Wu, Nicolò Foppiani, Kevin Liu, Daniel Merchan, Milan Ravenell
20.1 State space models and Kalman Filter

20.1.1 Introduction on state space models
The first topic which has been covered during this lecture is a review about state space models and Kalman
Filter. A state space model (SSM) is a Hidden Markov Model (HMM) with continuous hidden states.
z1 z2 z3 ... zt
x1 x2 x3 ... xt
The model is specified by

z t = g t ( z t −1 , e t )
xt = ht (zt , δt )
where e and δ represent a noise which is added in the transition between two states. zt is usually referred
as the transition model and xt as the observation model.
An important case is where the transition functions are linear-Gaussian, which means:
zt = At (zt−1 + et ) where et ∼ N (0, Qt )
xt = Ct zt + δt where δt ∼ N (0, Rt )
This case is called linear-Gaussian SSM (LG-SSM) or linear dynamical system (LDS).
In most situations we can assume that the process is stationary and considering the model functions inde-
pendent of time label.
In principle this problem can be solved with the architecture developed for graphical models: this is a
directed graphical model in which each variables is Gaussian distributed. Thus the whole model can be
solved raising to a multivariate Gaussian for the whole model.
However this model is historically relevant and thus deserves a proper study.
20.1.2 Kalman Filter

In fact, if we know that p(z1 ) is MVN, then p(zt | x1:t ) will be MVN. Suppose now to have observed x1:t and
we want to compute p(zt | x1:t ).
z1 z2 z3 ... zt
x1 x2 x3 ... xt
85
We can marginalize, obtaining a tree, on which we can apply exact belief propagation (BP).
z1 z2 z3 ... zt
There is a difference with exact belief propagation in the discrete case:

• discrete: Bel(zt ) is an array
• MVN: Bel(zt ) is MVN with ~µ and Σ
The inference algorithm based on MVN BP in this case is called Kalman filter. This is a crucial and popular
algorithm, central to multiple technologies. However, at its core, it just runs the LG formula multiple times
as part of BP.
20.1.3 Example: LG-SSM for tracking application

We have an object moving in the 2-D plane: the hidden state represents the position and velocity at every
timestep, and the observed state is the observed position at the every timestep.
~zt = [z1,t , z2,t , ż1,t , ż2,t ]

At updates zt → zt+1
Ct generates xt given zt : in this case it sets x1,t = z1,t and x2,t = z2,t
et represents the noise related to physics
δt represents the noise generated by the sensors in the observations
20.1.4 Kalman smoothing

Suppose we observed x1:T and we want to infer zt . We can use another variant of BP in which we combine
the messages from the past and from the future: this is called Kalman smoothing.
20.2 Review on importance sampling

20.2.1 Basic Idea
We aim to sample form p to approximate f (z) using MonteCarlo sampling:
86
To approximate integrals of the form:
Z S S
p(z) 1 p(zs )
E p [ f (z)] = q(z)
q(z)
f (z)dz ≈
S ∑ q(zs )
f ( z s
) = ∑ ws f (zs )
i =1 i =1
p(zs )
ws = q(zs )
are importance weights associated with each sample.
20.2.2 Unnormalized Distributions

Frequently will have unnormalized target distribution p̃(z) but not its normalization constant Z p . Similarly,
may have unnormalized proposal q̃(z) and its unknown normalization constant Zq .
p̃(z) q̃(z)
p(z) = and q(z) =
Zp Zq
Substituting into the desired expectation:
Zq Z p̃(z) Zq 1 S
E p [ f (z)] =
Zp
q(z)
q̃(z)
f (z)dz ≈
Zp S ∑ w̃s f (zs )
i =1
p̄(zs )
where w̄s = q̄(zs )
.
Zq
Now, how to compute Zp ? Can also importance sample from q.
Z Z Z S
Zp 1 1 p̃(z) p̃(z) 1
Zq
=
Zq
p̃(z)dz =
Zq
q(z)
q(z)
dz = q(z)
q̃(z)
dz ≈
S ∑ w̃s
i =1
Zp
Substituting the sampled Zq back:
S S
w̃s
E p [ f (z)] ≈ ∑ 0 f ( z s
) = ∑ ws f (zs )
s=1 ∑s0 w̃
s
s =1
Note: This form of importance sampling is convenient as it lets us work with unnormalized distributions.
However, in many cases is much less convenient than, for instance, rejection sampling or MonterCarlo
sampling because it is not fully clear how to use the weights.
Now consider getting samples from p. We need to define p( x ) in terms of E p [ f ( x )] using a δ function that
returns 1 if it’s the value we want, 0 otherwise:
p( x = x 0 ) = E p [δx0 ( x )]
Then, our estimate in terms of importance sampling is:
S
p( x ) = ∑ ws δxs (x)
s =1
But we actually want unweighted samples, which can be obtained through re-sampling: pick x s with
probability ws . In other words, we create a discrete set that approximates the original distribution and then
we draw samples from that discrete set based on a categorical distribution weighted by the ws .
87
20.2.3 Example
Recall from last class, we have:
p( Data|θ ) p(θ )
p(θ | Data) =
p( Data)
p̃(θ | Data) = p( Data|θ ) p(θ )
Notice we drop the normalization term for p̃. Then q(θ ) = p(θ ), which implies that we importance-sample
based on the prior. This gives normalized ws :
p̃(θs )/q(θs ) p( Data|θs )

ws = =
∑s0 p̃(θs )/q(θs ) ∑s0 p( Data|θs0 )
In summary, we run importance-sampling to compute the posterior of the parameters by sampling different
parameters from the priors and then by assigning weights to each of those different parameters based on
likelihood in the data. The resulting samples are unbisased samples from the distribution of interest.
20.3 Particle Filtering/Sequential Monte Carlo

There might be cases of space-state models in which it might not be possible to derive closed-form ex-
pressions based on LG for the update equations. In those cases, a sampling-based approaches offer an
alternative method.
In order to approximate the belief state of an entire sequence, we can use a weighted set of particles as
follows:
Z S
0
p(z1:t = z1:t | x1:t ) = p(z1 , ..., zt | x1:t )δz0 (z)dz ≈ ∑ ŵts δz0 (z1:t
s
)
s =1
where ŵts represents the normalized weight of sample s at time t.
We update the belief state using importance sampling, with the following importance weights.
p(z1:t | x1:t )
wts ∼
q(z1:t | x1:t )
The numerator can be expressed as follows:
p(z1:t | x1:t ) ∝ p(z1:t | xt−1 ) p( x |t|z1:t , yt−1 ) ∝ p( xt |zt ) p(zt |zt−1 ) p(z1:t−1 | x1:t )
where p( xt |zt ), p(zt |zt−1 ), and p(z1:t−1 | x1:t ) correspond to the observation, transition, and recursion of the
sequence, respectively.
Meanwhile, we can express the denominator as
q(z1:t | x1:t ) ∝ q(zt |z1:t−1 , y1:t )q(z1:t−1 | x1:t−1 )
Our importance weights, therefore, simplify to
p( xt |zt ) p(zt |zt−1 ) p(z1:t−1 | x1:t ) p ( x t | z t ) p ( z t | z t −1 ) s

wts ∝ = w
q(zt |z1:t−1 , y1:t )q(z1:t−1 |y1:t−1 ) q(zt |z1:t−1 , y1:t ) t−1
Using this expression, we have the following algorithm to approximate the belief state.
1. Start with particles (wt , zt )(s) .
p ( x | z ) p ( z t | z t −1 ) s
2. At each time step t for particle x, calculate wts = q(zt |zt wt−1 and sample zst ∼ q(zt |z1:t
s
−1 , x t ).
t 1:t−1 ,y1:t )
3. Compute p(zt , x1:t )
88

Advanced Machine Learning: CS 281

Uploaded by

Document Informationclick to expand document information

Copyright:

Available Formats

Advanced Machine Learning: CS 281

Uploaded by

Document Information

Original Description:

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Advanced Machine Learning: CS 281

Uploaded by

Copyright:

Available Formats

CS 281: Advanced Machine Learning

taught by Sasha Rush

Multivariate Normal Distributions 5

Backpropagation & Directed Graphical Models 25

Undirected Graphical Models 33

Exact Inference: Time Series 40

Exact Inference: Belief Propagation 46

Recurrent Neural Networks 51

Variational Inference Part 2 69

Loopy BP, Gibbs Sampling, and VI with Gradients 74

Variational Auto-encoders and GANs 78

Monte Carlo Basics 81

Importance Sampling and Particle Filtering 84

Lecture 2: Discrete Models

2.1 Bernoulli model

Maximum Likelihood Estimation (MLE)

θ MLE = argmaxθ p( N0 , N1 |θ ) = argmaxθ log [ p( N0 , N1 |θ )]

Maximizing the Posterior (MAP)

To make this distribution sum to 1, use the known beta normalizer

• Many-sided coins aka dice: models of categorical data, generalization of Bernoulli

2.4 Other Distributions

2.5 Example notebook

Lecture 3: Multivariate Normal Distributions

• radar: mean and variance of approaching objects (like invading aliens)

3.2 Review: Eigendecomposition

3.3 Multivariate Normal Distributions (MVNs)

3.3.1 Manipulating MVNs: Stretches, Rotations, and Shifts

E(y) = E( Ax + b) = AE( x ) + b cov(y) = AA T .

3.3.2 Detour: MVN in High-Dimensions (D  0)

3.3.3 Key Formulas for MVN: Marginalization and Conditioning

which can be written as

Note that this equals Z

implying that X1 ∼ N (µ1 , Σ11 ).

3.3.4 Information Form

Lecture 4: Linear Regression

4.1 Multivariate Normal (MVN)

• ( X − µ) T Σ−1 ( X − µ) is a quadratic term.

4.2 Maximum Likelihood of MVN

= arg max log(constant) − ∑( xn − µ)T Σ−1 ( xn − µ)

Let L = ∑n ( xn − µ) T Σ−1 ( xn − µ).

Let y be the outputs:

4.3.2 Completing the Square

p(y) = N (y| Am0 + b, Σy + AΣ x A> )

4.3.5 Posterior (just for µ)

We let b = 0 and A = I. Then we obtain,

4.3.6 Unknown Variance

4.4 Linear Regression

Note that the bias term here is included as a dimension in w, w0 .

L(θ) = log p(data | θ)

4.4.2 Computing MLE

Setting this to 0, we obtain:

4.5 Bayesian Linear Regression

Now, we compute the posterior predictive:

Using the form for the marginal derived earlier, we have:

4.6 Non Linear Regression

Lecture 5: Linear Classification

5.1 Classification Introduction

5.2 Naı̈ve Bayes

3.3.2 Detour: MVN in High-Dimensions (D 0)