Stat340s13
From Wiki Course Notes
If you use ideas, plots, text, code and other intellectual property developed by someone else in your `wikicoursenote' contribution , you have to cite the original source. If you copy a sentence or a paragraph from work done by someone else, in addition to citing the original source you have to use quotation marks to identify the scope of the copied material. Evidence of copying or plagiarism will cause a failing mark in the course.
Example of citing the original source
Assumptions Underlying Principal Component Analysis can be found here^{[1]}
Important Notes
To make distinction between the material covered in class and additional material that you have add to the course, use the following convention. For anything that is not covered in the lecture write:
In the news recently was a story that captures some of the ideas behind PCA. Over the past two years, Scott Golder and Michael Macy, researchers from Cornell University, collected 509 million Twitter messages from 2.4 million users in 84 different countries. The data they used were words collected at various times of day and they classified the data into two different categories: positive emotion words and negative emotion words. Then, they were able to study this new data to evaluate subjects' moods at different times of day, while the subjects were in different parts of the world. They found that the subjects generally exhibited positive emotions in the mornings and late evenings, and negative emotions midday. They were able to "project their data onto a smaller dimensional space" using PCS. Their paper, "Diurnal and Seasonal Mood Vary with Work, Sleep, and Daylength Across Diverse Cultures," is available in the journal Science.^{[2]}.
Assumptions Underlying Principal Component Analysis can be found here^{[3]}
Introduction, Class 1  Tuesday, May 7
Course Instructor: Ali Ghodsi
Lecture:
001: T/Th 8:309:50am MC1085
002: T/Th 1:002:20pm DC1351
Tutorial:
2:303:20pm Mon M3 1006
Office Hours:
Friday at 10am, M3 4208
Midterm
Monday June 17,2013 from 2:30pm3:20pm
Final
Saturday August 10,2013 from 7:30pm10:00pm
TA(s):
TA  Day  Time  Location 

Lu Cheng  Monday  3:305:30 pm  M3 3108, space 2 
Han ShengSun  Tuesday  4:006:00 pm  M3 3108, space 2 
Yizhou Fang  Wednesday  1:003:00 pm  M3 3108, space 1 
Huan Cheng  Thursday  3:005:00 pm  M3 3111, space 1 
Wu Lin  Friday  11:001:00 pm  M3 3108, space 1 
Four Fundamental Problems
1 Classification: Given input object X, we have a function which will take this input X and identify which 'class (Y)' it belongs to (Discrete Case)
i.e taking value from x, we could predict y.
(For example, if you have 40 images of oranges and 60 images of apples (represented by x), you can estimate a function that takes the images and states what type of fruit it is  note Y is discrete in this case.)
2 Regression: Same as classification but in the continuous case except y is non discrete. Results from regression are often used for prediction,forecasting and etc. (Example of stock prices, height, weight, etc.)
(A simple practice might be investigating the hypothesis that higher levels of education cause higher levels of income.)
3 Clustering: Use common features of objects in same class or group to form clusters.(in this case, x is given, y is unknown; For example, clustering by provinces to measure average height of Canadian men.)
4 Dimensionality Reduction (also known as Feature extraction, Manifold learning): Used when we have a variable in high dimension space and we want to reduce the dimension
Applications
Most useful when structure of the task is not well understood but can be characterized by a dataset with strong statistical regularity
Examples:
 Computer Vision, Computer Graphics, Finance (fraud detection), Machine Learning
 Search and recommendation (eg. Google, Amazon)
 Automatic speech recognition, speaker verification
 Text parsing
 Face identification
 Tracking objects in video
 Financial prediction(e.g. credit cards)
 Fraud detection
 Medical diagnosis
Course Information
Prerequisite: (One of CS 116, 126/124, 134, 136, 138, 145, SYDE 221/322) and (STAT 230 with a grade of at least 60% or STAT 240) and (STAT 231 or 241)
Antirequisite: CM 361/STAT 341, CS 437, 457
General Information
 No required textbook
 Recommended: "Simulation" by Sheldon M. Ross
 Computing parts of the course will be done in Matlab, but prior knowledge of Matlab is not essential (will have a tutorial on it)
 First midterm will be held on Monday, June 17 from 2:30 to 3:30
 Announcements and assignments will be posted on Learn.
 Other course material on: http://wikicoursenote.com/wiki/
 Log on to both Learn and wikicoursenote frequently.
 Email all questions and concerns to UWStat340@gmail.com. Do not use your personal email address! Do not email instructor or TAs about the class directly to their personal accounts!
Wikicourse note (complete at least 12 contributions to get 10% of final mark):
When applying for an account in the wikicourse note, please use the quest account as your login name while the uwaterloo email as the registered email. This is important as the quest id will be used to identify the students who make the contributions.
Example:
User: questid
Email: questid@uwaterloo.ca
After the student has made the account request, do wait for several hours before students can login into the account using the passwords stated in the email. During the first login, students will be ask to create a new password for their account.
As a technical/editorial contributor: Make contributions within 1 week and do not copy the notes on the blackboard.
All contributions are now considered general contributions you must contribute to 50% of lectures for full marks
 A general contribution can be correctional (fixing mistakes) or technical (expanding content, adding examples, etc.) but at least half of your contributions should be technical for full marks.
Do not submit copyrighted work without permission, cite original sources. Each time you make a contribution, check mark the table. Marks are calculated on an honour system, although there will be random verifications. If you are caught claiming to contribute but have not, you will not be credited.
Wikicoursenote contribution form : https://docs.google.com/forms/d/1Sgq0uDztDvtcS5JoBMtWziwH96DrBz2JiURvHPNdxs/viewform
 you can submit your contributions multiple times.
 you will be able to edit the response right after submitting
 send email to make changes to an old response : uwstat340@gmail.com
Tentative Topics
 Random variable and stochastic process generation
 DiscreteEvent Systems
 Variance reduction
 Markov Chain Monte Carlo
Class 2  Thursday, May 9
Generating Random Numbers
Introduction
Simulation is the imitation of a process or system over time. Computational power has introduced the possibility of using simulation study to analyze models used to describe a situation.
In order to perform a simulation study, we should:
1 Use a computer to generate (pseudo*) random numbers (rand in MATLAB).
2 Use these numbers to generate values of random variable from distributions: for example, set a variable in terms of uniform u ~ U(0,1).
3 Using the concept of discrete events, we show how the random variables can be used to generate the behavior of a stochastic model over time. (Note: A stochastic model is the opposite of deterministic model, where there are several directions the process can evolve to)
4 After continually generating the behavior of the system, we can obtain estimators and other quantities of interest.
The building block of a simulation study is the ability to generate a random number. This random number is a value from a random variable distributed uniformly on (0,1). There are many different methods of generating a random number:
Physical Method: Roulette wheel, lottery balls, dice rolling, card shuffling etc.
Numerically/Arithmetically: Use of a computer to successively generate pseudorandom numbers. The
sequence of numbers can appear to be random; however they are deterministically calculated with an
equation which defines pseudorandom.
(Source: Ross, Sheldon M., and Sheldon M. Ross. Simulation. San Diego: Academic, 1997. Print.)
 We use the prefix pseudo because computer generates random numbers based on algorithms, which suggests that generated numbers are not truly random. Therefore pseudorandom numbers is used.
In general, a deterministic model produces specific results given certain inputs by the model user, contrasting with a stochastic model which encapsulates randomness and probabilistic events.
A computer cannot generate truly random numbers because computers can only run algorithms, which are deterministic in nature. They can, however, generate Pseudo Random Numbers
Pseudo Random Numbers are the numbers that seem random but are actually determined by a relative set of original values. It is a chain of numbers preset by a formula or an algorithm, and the value jump from one to the next, making it look like a series of independent random events. The flaw of this method is that, eventually the chain returns to its initial position and pattern starts to repeat, but if we make the number set large enough we can prevent the numbers from repeating too early. Although the pseudo random numbers are deterministic, these numbers have a sequence of value and all of them have the appearances of being independent uniform random variables. Being deterministic, pseudo random numbers are valuable and beneficial due to the ease to generate and manipulate.
When people repeat the test many times, the results will be the closed express values, which make the trials look deterministic. However, for each trial, the result is random. So, it looks like pseudo random numbers.
Mod
Let and , then by Division Algorithm,
,
where q is called the quotient and r the remainder. Hence we can define a binary function
given by which returns the remainder after division by m.
Generally, mod means taking the reminder after division by m.
We say that n is congruent to r mod m if n = mq + r, where m is an integer.
Values are between 0 and m1
if y = ax + b, then .
Example 1:
Example 2:
If
Then equivalently,
If
Then equivalently,
If
Then equivalently,
Example 3:
Note: here is different from the modulo congruence relation in , which is an equivalence relation instead of a function.
The modulo operation is useful for determining if an integer divided by another integer produces a nonzero remainder. But both integers should satisfy n = mq + r, where m, r, q, and n are all integers, and r is smaller than m. The above rules also satisfy when any of m, r, q, and n is negative integer, see the third example.
Mixed Congruential Algorithm
We define the Linear Congruential Method to be , where . Given a seed (i.e. an initial value ), we can obtain values for inductively. The Multiplicative Congruential Method, invented by Berkeley professor D. H. Lehmer, may also refer to the special case where b = 0 and the Mixed Congruential Method is case where
. Their title as "mixed" arises from the fact that it has both a multiplicative and additive term.
An interesting fact about Linear Congruential Method is that it is one of the oldest and bestknown pseudo random number generator algorithms. It is very fast and requires minimal memory to retain state. However, this method should not be used for applications that require high randomness. They should not be used for Monte Carlo simulation and cryptographic applications. (Monte Carlo simulation will consider possibilities for every choice of consideration, and it shows the extreme possibilities. This method is not precise enough.)
"Source: STAT 340 Spring 2010 Course Notes"
First consider the following algorithm
such that: if x_{0} = 5(mod150), x_{n} = 3x_{n − 1}, find x_{1},x_{8},x_{9}.
x_{n} = (3^{n}) * 5(mod150)
x_{1} = 45,x_{8} = 105,x_{9} = 15
Example
Excluding x_{0}, this example generates a series of ones. In general, excluding x_{0}, the algorithm above will always generate a series of the same number less than M. Hence, it has a period of 1. The period can be described as the length of a sequence before it repeats. We want a large period with a sequence that is random looking. We can modify this algorithm to form the Multiplicative Congruential Algorithm.
(a little tip:
Example
This example generates a sequence with a repeating cycle of two integers.
(If we choose the numbers properly, we could get a sequence of "random" numbers. How do we find the value of a,b, and m? At the very least m should be a very large, preferably prime number. The larger m is, the higher the possibility to get a sequence of "random" numbers. This is easier to solve in Matlab. In Matlab, the command rand() generates random numbers which are uniformly distributed on the interval (0,1)). Matlab uses a = 7^{5},b = 0,m = 2^{31} − 1 – recommended in a 1988 paper, "Random Number Generators: Good Ones Are Hard To Find" by Stephen K. Park and Keith W. Miller (Important part is that m should be large and prime)
Note: is an approximation to the value of a U(0,1) random variable.
MatLab Instruction for Multiplicative Congruential Algorithm:
Before you start, you need to clear all existing defined variables and operations:
>>clear all >>close all
>>a=17 >>b=3 >>m=31 >>x=5 >>mod(a*x+b,m) ans=26 >>x=mod(a*x+b,m)
(Note:
1. Keep repeating this command over and over again and you will get random numbers – this is how the command rand works in a computer.
2. There is a function in MATLAB called RAND to generate a random number between 0 and 1.
For example, in MATLAB, we can use rand(1,1000) to generate 1000's numbers between 0 and 1. This is essentially a vector with 1 row, 1000 columns, with each entry a random number between 0 and 1.
3. If we would like to generate 1000 or more numbers, we could use a for loop
(Note on MATLAB commands:
1. clear all: clears all variables.
2. close all: closes all figures.
3. who: displays all defined variables.
4. clc: clears screen.
5. ; : prevents the results from printing.
6. disstool: displays a graphing tool.
>>a=13 >>b=0 >>m=31 >>x(1)=1 >>for ii=2:1000 x(ii)=mod(a*x(ii1)+b,m); end >>size(x) ans=1 1000 >>hist(x)
(Note: The semicolon after the x(ii)=mod(a*x(ii1)+b,m) ensures that Matlab will not print the entire vector of x. It will instead calculate it internally and you will be able to work with it. Adding the semicolon to the end of this line reduces the run time significantly.)
This algorithm involves three integer parameters a,b, and m and an initial value, x_{0} called the seed. A sequence of numbers is defined by .
Note: For some bad a and b, the histogram may not look uniformly distributed.
Note: In MATLAB, hist(x) will generate a graph representing the distribution. Use this function after you run the code to check the real sample distribution.
Example: a = 13,b = 0,m = 31
The first 30 numbers in the sequence are a permutation of integers from 1 to 30, and then the sequence repeats itself so it is important to choose m large to decrease the probability of each number repeating itself too early. Values are between 0 and m − 1. If the values are normalized by dividing by m − 1, then the results are approximately numbers uniformly distributed in the interval [0,1]. There is only a finite number of values (30 possible values in this case). In MATLAB, you can use function "hist(x)" to see if it looks uniformly distributed. We saw that the values between 030 had the same frequency in the histogram, so we can conclude that they are uniformly distributed.
If x_{0} = 1, then
So,
etc.
For example, with a = 3,b = 2,m = 4,x_{0} = 1, we have:
So,
Another Example, a =3, b =2, m = 5, x_0=1 etc.
FAQ:
1.Why is it 1 to 30 instead of 0 to 30 in the example above?
b = 0 so in order to have x_{k} equal to 0, x_{k − 1} must be 0 (since a = 13 is relatively prime to 31). However, the seed is 1. Hence, we will never observe 0 in the sequence.
Alternatively, {0} and {1,2,...,30} are two orbits of the left multiplication by 13 in the group .
2.Will the number 31 ever appear?Is there a probability that a number never appears?
The number 31 will never appear. When you perform the operation , the largest possible answer that you could receive is m − 1. Whether or not a particular number in the range from 0 to m − 1 appears in the above algorithm will be dependent on the values chosen for a,b and m.
Examples:[From Textbook]
, .
Solution:
Comments:
Matlab code: a=5; b=7; m=200; x(1)=3; for ii=2:1000 x(ii)=mod(a*x(ii1)+b,m); end size(x); hist(x)
Typically, it is good to choose m such that m is large, and m is prime. Careful selection of parameters 'a' and 'b' also helps generate relatively "random" output values, where it is harder to identify patterns. For example, when we used a composite (non prime) number such as 40 for m, our results were not satisfactory in producing an output resembling a uniform distribution.
The computed values are between 0 and m − 1. If the values are normalized by dividing by m − 1, their result is numbers uniformly distributed on the interval (similar to computing from uniform distribution).
From the example shown above, if we want to create a large group of random numbers, it is better to have large, prime m so that the generated random values will not repeat after several iterations. Note: the period for this example is 8: from 'x_{2}' to 'x_{9}'.
There has been a research on how to choose uniform sequence. Many programs give you the options to choose the seed. Sometimes the seed is chosen by CPU.
Theorem (extra knowledge)
Let c be a nonzero constant. Then for any seed x0, and LCG will have largest max. period if and only if
(i) m and c are coprime;
(ii) (a1) is divisible by all prime factor of m;
(iii) if and only if m is divisible by 4, then a1 is also divisible by 4.
We want our LCG to have a large cycle. We call a cycle with m element the maximal period. We can make it bigger by making m big and prime. Recall:any number you can think of can be broken into a factor of prime Define coprime:Two numbers X and Y, are coprime if they do not share any prime factors.
Example:
Xn=(15Xn1 + 4) mod 7
(i) m=7 c=4 > coprime;
(ii) a1=14 and a1 is divisible by 7;
(iii) dose not apply.
(The extra knowledge stops here)
In this part, I learned how to use R code to figure out the relationship between two integers division, and their remainder. And when we use R to calculate R with random variables for a range such as(1:1000),the graph of distribution is like uniform distribution.
Summary of Multiplicative Congruential Algorithm
Problem: generate Pseudo Random Numbers.
Plan:
 find integer: a b m(large prime) x_{0}(the seed) .
 x_{k + 1} = (ax_{k} + b)mod m
Matlab Instruction:
>>clear all >>close all >>a=17 >>b=3 >>m=31 >>x=5 >>mod(a*x+b,m) ans=26 >>x=mod(a*x+b,m)
Another algorithm for generating pseudo random numbers is the multiply with carry method. Its simplest form is similar to the linear congruential generator. They differs in that the parameter b changes in the MWC algorithm. It is as follows:
1.) x_{k+1} = ax_{k} + b_{k} mod m
2.) b_{k+1} = floor((ax_{k} + b_{k})/m)
3.) set k to k + 1 and go to step 1
Source
Inverse Transform Method
Now that we know how to generate random numbers, we use these values to sample form distributions such as exponential. However, to easily use this method, the probability distribution consumed must have a cumulative distribution function (cdf) F with a tractable (that is, easily found) inverse F^{ − 1}.
Theorem:
If we want to generate the value of a discrete random variable X, we must generate a random number U, uniformly distributed over (0,1).
Let be a cdf. If , then the random variable given by
follows the distribution function ,
where is the generalized inverse.
Note: F need not be invertible everywhere on the real line, but if it is, then the generalized inverse is the same as the inverse in the usual case. We only need it to be invertible on the range of F(x), [0,1].
Proof of the theorem:
The generalized inverse satisfies the following:
(since X = F^{ − 1}(U) by the inverse method)
(since F is monotonically increasing)
(since for ,
This is the c.d.f. of X.
That is
Finally, , since U is uniform on the unit interval.
This completes the proof.
Therefore, in order to generate a random variable X~F, it can generate U according to U(0,1) and then make the transformation x=F^{ − 1}(U)
Note that we can apply the inverse on both sides in the proof of the inverse transform only if the pdf of X is monotonic. A monotonic function is one that is either increasing for all x, or decreasing for all x. Of course, this holds true for all CDFs, since they are monotonic by definition.
In short, what the theorem tells us is that we can use a random number UfromU(0,1) to randomly sample a point on the CDF of X, then apply the inverse of the CDF to map the given probability to its domain, which gives us the random variable X.
Example 1  Exponential: f(x) = λe^{ − λx}
Calculate the CDF:
= − e^{ − λx} + e^{0} = 1 − e^{ − λx}
Solve the inverse:
Note that 1 − U is also uniform on (0, 1) and thus −log(1 − U) has the same distribution as −logU.
Steps:
Step 1: Draw U ~U[0,1];
Step 2:
EXAMPLE 2 Normal distribution
G(y)=P[Y<=y)
=P[sqr (y) < z < sqr (y)) =integrate from sqr(z) to Sqr(z) 1/sqr(2pi) e ^(z^2/2) dz = 2 integrate from 0 to sqr(y) 1/sqr(2pi) e ^(z^2/2) dz
its the cdf of Y=z^2
pdf g(y)= G'(y) pdf pf x^2 (1)
MatLab Code:
>>u=rand(1,1000); >>hist(u) # this will generate a fairly uniform diagram
#let λ=2 in this example; however, you can make another value for λ >>x=(log(1u))/2; >>size(x) #1000 in size >>figure >>hist(x) #exponential
Example 2  Continuous Distribution:
Calculate the CDF:
Solve for the inverse:
Algorithm:
Steps:
Step 1: Draw U ~ U[0, 1];
Step 2: Compute X = F^{ − }1(U) i.e. for U < 0.5 else
Example 3  F(x) = x^{5}:
Given a CDF of X: F(x) = x^{5}, transform U~U[0,1].
Sol:
Let y = x^{5}, solve for x: . Therefore,
Hence, to obtain a value of x from F(x), we first set 'u' as an uniform distribution, then obtain the inverse function of F(x), and set
Algorithm:
Steps:
Step 1: Draw U ~ rand[0, 1];
Step 2: X=U^(1/5);
Example 4  BETA(1,β):
Given u~U[0,1], generate x from BETA(1,β)
Solution:
F(x) = 1 − (1 − x)^{β},
u = 1 − (1 − x)^{β}
Solve for x:
(1 − x)^{β} = 1 − u,
,
let β=3, use Matlab to construct N=1000 observations from Beta(1,3)
MatLab Code:
>> u = rand(1,1000); x = 1(1u)^(1/3); >> hist(x,50) >> mean(x)
Example 5  Estimating π:
Let's use rand() and Monte Carlo Method to estimate π
N= total number of points
N_{c} = total number of points inside the circle
Prob[(x,y) lies in the circle=
If we take square of size 2, circle will have area =.
Thus
For example, UNIF(a,b)
y = F(x) = (x − a) / (b − a) x = (b − a) * y + a X = a + (b − a) * U
where U is UNIF(0,1)
Limitations:
1. This method is flawed since not all functions are invertible or monotonic: generalized inverse is hard to work on.
2. It may be impractical since some CDF's and/or integrals are not easy to compute such as Gaussian distribution.
We learned how to prove the transformation from cdf to inverse cdf,and use the uniform distribution to obtain a value of x from F(x). We can also use uniform distribution in inverse method to determine other distributions. The probability of getting a point for a circle over the triangle is a closed uniform distribution, each point in the circle and over the triangle is almost the same. Then, we can look at the graph to determine what kind of distribution the graph resembles.
Probability Distribution Function Tool in MATLAB
disttool #shows different distributions
This command allows users to explore different types of distribution and see how the changes affect the parameters on the plot of either a CDF or PDF.
change the value of mu and sigma can change the graph skew side.
Class 3  Tuesday, May 14
Recall the Inverse Transform Method
Let U~Unif(0,1),then the random variable X = F^{1}(u) has distribution F.
To sample X with CDF F(x),
2) X = F^{1}(u)
Note: CDF of a U(a,b) random variable is:
Thus, for U ~ U(0,1), we have and .
More generally, we see that .
For this reason, we had .
Reminder:
This is only for uniform distribution
Note that on a single point there is no mass probability (i.e. u <= 0.5, is the same as u < 0.5) More formally, this is saying that , which equals zero for any continuous random variable
Limitations of the Inverse Transform Method
Though this method is very easy to use and apply, it does have a major disadvantage/limitation:
 We need to find the inverse cdf . In some cases the inverse function does not exist, or is difficult to find because it requires a closed form expression for F(x).
For example, it is too difficult to find the inverse cdf of the Gaussian distribution, so we must find another method to sample from the Gaussian distribution.
In conclusion, we need to find another way of sampling from more complicated distributions
Discrete Case
The same technique can be used for discrete case. We want to generate a discrete random variable x, that has probability mass function:
Algorithm for applying Inverse Transformation Method in Discrete Case (Procedure):
1. Define a probability mass function for x_{i} where i = 1,....,k. Note: k could grow infinitely.
2. Generate a uniform random number U,
3. If , deliver X = x_{o}
4. Else, if , deliver X = x_{1}
5. Repeat the process again till we reached to , deliver X = x_{k}
Note that after generating a random U, the value of X can be determined by finding the interval [F(x_{j − 1}),F(x_{j})] in which U lies.
In summary:
Generate a discrete r.v.x that has pmf:
P(X=xi)=Pi, x0<x1<x2<...
1. Draw U~U(0,1);
2. If F(x(i1))<U<F(xi), x=xi.
Example 3.0:
Generate a random variable from the following probability function:
x  2  1  0  1  2 
f(x)  0.1  0.5  0.07  0.03  0.3 
Answer:
1. Gen U~U(0,1)
2. If U < 0.5 then output 1
else if U < 0.8 then output 2
else if U < 0.9 then output 2
else if U < 0.97 then output 0 else output 1
Example 3.1 (from class): (Coin Flipping Example)
We want to simulate a coin flip. We have U~U(0,1) and X = 0 or X = 1.
We can define the U function so that:
If , then X = 0
and if , then X =1.
This allows the probability of Heads occurring to be 0.5 and is a good generator of a random coin flip.
The answer is:
 Code
>>for ii=1:1000 u=rand; if u<0.5 x(ii)=0; else x(ii)=1; end end >>hist(x)
Note: The role of semicolon in Matlab: Matlab will not print out the results if the line ends in a semicolon and vice versa.
Example 3.2 (From class):
Suppose we have the following discrete distribution:
The cumulative distribution function (cdf) for this distribution is then:
Then we can generate numbers from this distribution like this, given :
"Procedure"
1. Draw U~u (0,1)
2. if U<=0.3 deliver x=0
3. else if 0.3<U<=0.5 deliver x=1
4. else 0.5<U<=1 deliver x=2
Can you find a faster way to run this algorithm? Consider:
The logic for this is that U is most likely to fall into the largest range. Thus by putting the largest range (in this case x >= 0.5) we can improve the run time of this algorithm. Could this algorithm be improved further using the same logic?
 Code (as shown in class)
Use Editor window to edit the code
>>close all >>clear all >>for ii=1:1000 u=rand; if u<=0.3 x(ii)=0; elseif u<=0.5 x(ii)=1; else x(ii)=2; end end >>size(x) >>hist(x)
The algorithm above generates a vector (1,1000) containing 0's ,1's and 2's in differing proportions. Due to the criteria for accepting 0, 1 or 2 into the vector we get proportions of 0,1 &2 that correspond to their respective probabilities. So plotting the histogram (frequency of 0,1&2) doesn't give us the pmf but a frequency histogram that shows the proportions of each, which looks identical to the pmf.
Example 3.3: Generating a random variable from pdf
Example 3.4: Generating a Bernoulli random variable
1. Draw
2.
Example 3.5: Generating Binomial(n,p) Random Variable
Step 1: Generate a random number U.
Step 2: , i = 0, pr = (1 − p)^{n}, F = pr
Step 3: If U<F, set X = i and stop,
Step 4:
Step 5: Go to step 3
 Note: These steps can be found in Simulation 5th Ed. by Sheldon Ross.
 Note: Another method by seeing the Binomial as a sum of n independent Bernoulli random variables, U1, ..., Un. Then set X equal to the number of Ui that are less than or equal to p. To use this method, n random numbers are needed and n comparisons need to be done. On the other hand, the inverse transformation method is simpler because only one random variable needs to be generated and it makes 1 + np comparisons.
Step 1: Generate n uniform numbers U1 ... Un.
Step 2: X = where P is the probability of success.
Example 3.6: Generating a Poisson random variable
"Let X ~ Poi(u). Write an algorithm to generate X. The PDF of a poisson is:
We know that
The ratio is Therefore,
Algorithm:
1) Generate U ~ U(0,1)
2)
3) If U<F, output x
Else,
4) Go to 1"
Acknowledgements: This is an example from Stat 340 Winter 2013
Example 3.7: Generating Geometric Distribution:
Consider Geo(p) where p is the probability of success, and define random variable X such that X is the total number of trials required to achieve the first success. x=1,2,3..... We have pmf: We have CDF: , P(X>x) means we get at least x failures before we observe the first success. Now consider the inverse transform:
Note: Unlike the continuous case, the discrete inversetransform method can always be used for any discrete distribution (but it may not be the most efficient approach)
General Procedure
1. Draw U ~ U(0,1)
2. If deliver x = x_{0}
3. Else if deliver x = x_{1}
4. Else if deliver x = x_{2}
...
Else if deliver x = x_{k}
===Inverse Transform Algorithm for Generating a Binomial(n,p) Random Variable(from textbook)===
step 1: Generate a random number U
step 2: c=p/(1p),i=0, pr=(1p)^{n}, F=pr.
step 3: If U<F, set X=i and stop.
step 4: pr =[c(ni)/(i+1)]pr, F=F+pr, i=i+1.
step 5: Go to step 3.
Problems
Though this method is very easy to use and apply, it does have a major disadvantage/limitation:
We need to find the inverse cdf F^{1}(\cdot) . In some cases the inverse function does not exist, or is difficult to find because it requires a closed form expression for F(x).
For example, it is too difficult to find the inverse cdf of the Gaussian distribution, so we must find another method to sample from the Gaussian distribution.
In conclusion, we need to find another way of sampling from more complicated distributions
Flipping a coin is a discrete case of uniform distribution, and the code below shows an example of flipping a coin 1000 times; the result is close to the expected value 0.5.
Example 2, as another discrete distribution, shows that we can sample from parts like 0,1 and 2, and the probability of each part or each trial is the same.
Example 3 uses inverse method to figure out the probability range of each random varible.
Summary of Inverse Transform Method
Problem:generate types of distribution.
Plan:
Continuous case:
 find CDF F
 find the inverse F^{1}
 Generate a list of uniformly distributed number {x}
 {F^{1}(x)} is what we want
Matlab Instruction
>>u=rand(1,1000); >>hist(u) >>x=(log(1u))/2; >>size(x) >>figure >>hist(x)
Discrete case:
 generate a list of uniformly distributed number {u}
 d_{i}=x_{i} ifX = x_{i}, if
 {d_{i}=x_{i}} is what we want
Matlab Instruction
>>for ii=1:1000 u=rand; if u<0.5 x(ii)=0; else x(ii)=1; end end >>hist(x)
Generalized InverseTransform Method
Valid for any CDF F(x): return X=min{x:F(x) U}, where U~U(0,1)
1. Continues, possibly with flat spots (i.e. not strictly increasing)
2. Discrete
3. Mixed continues discrete
Advantages of InverseTransform Method
Inverse transform method preserves monotonicity and correlation
which helps in
1. Variance reduction methods ...
2. Generating truncated distributions ...
3. Order statistics ...
AcceptanceRejection Method
Although the inverse transformation method does allow us to change our uniform distribution, it has two limits;
 Not all functions have inverse functions (ie, the range of x and y have limit and do not fix the inverse functions)
 For some distributions, such as Gaussian, it is too difficult to find the inverse
To generate random samples for these functions, we will use different methods, such as the AcceptanceRejection Method. This method is more efficient than the inverse transform method. The basic idea is to find an alternative probability distribution with density function f(x);
Suppose we want to draw random sample from a target density function f(x), x∈S_{x}, where S_{x} is the support of f(x). If we can find some constant c(≥1) (In practice, we prefer c as close to 1 as possible) and a density function g(x) having the same support S_{x} so that f(x)≤cg(x), ∀x∈S_{x}, then we can apply the procedure for AcceptanceRejection Method. Typically we choose a density function that we already know how to sample from for g(x).
The main logic behind the AcceptanceRejection Method is that:
1. We want to generate sample points from an unknown distribution, say f(x).
2. We use to generate points so that we have more points than f(x) could ever generate for all x. (where c is a constant, and g(x) is a known distribution)
3. For each value of x, we accept and reject some points based on a probability, which will be discussed below.
Note: If the red line was only g(x) as opposed to (i.e. c=1), then for all values of x if and only if g and f are the same functions. This is because the sum of pdf of g(x)=1 and the sum of pdf of f(x)=1, hence, \,∀x.
Also remember that always generates higher probability than what we need. Thus we need an approach of getting the proper probabilities.
c must be chosen so that for all value of x. c can only equal 1 when f and g have the same distribution. Otherwise:
Either use a software package to test if for an arbitrarily chosen c > 0, or:
1. Find first and second derivatives of f(x) and g(x).
2. Identify and classify all local and absolute maximums and minimums, using the First and Second Derivative Tests, as well as all inflection points.
3. Verify that at all the local maximums as well as the absolute maximums.
4. Verify that at the tail ends by calculating and and seeing that they are both < 1. Use of L'Hopital's Rule should make this easy, since both f and g are p.d.f's, resulting in both of them approaching 0.
5.Efficiency: the number of times N that steps 1 and 2 need to be called(also the number of iterations needed to successfully generate X) is a random variable and has a geometric distribution with success probability , .Thus on average the number of iterations required is given by
c should be close to the maximum of f(x)/g(x), not just some arbitrarily picked large number. Otherwise, the AcceptanceRejection method will have more rejections (since our probability will be close to zero). This will render our algorithm inefficient.
The expected number of iterations of the algorithm required with an X is c.
Note:
1. Value around x_{1} will be sampled more often under cg(x) than under f(x).There will be more samples than we actually need, if is small, the acceptancerejection technique will need to be done to these points to get the accurate amount.In the region above x_{1}, we should accept less and reject more.
2. Value around x_{2}: number of sample that are drawn and the number we need are much closer. So in the region above x_{2}, we accept more. As a result, g(x) and f(x) are comparable.
3. The constant c is needed because we need to adjust the height of g(x) to ensure that it is above f(x). Besides that, it is best to keep the number of rejected varieties small for maximum efficiency.
Another way to understand why the the acceptance probability is , is by thinking of areas. From the graph above, we see that the target function in under the proposed function c g(y). Therefore, is the proportion or the area under c g(y) that also contains f(y). Therefore we say we accept sample points for which u is less then because then the sample points are guaranteed to fall under the area of c g(y) that contains f(y).
There are 2 cases that are possible:
Sample of points is more than enough,
Similar or the same amount of points,
There is 1 case that is not possible:
Less than enough points, such that g(x) is greater than f,
Procedure
 Draw Y~g(.)
 Draw U~u(0,1) (Note: U and Y are independent)
 If (which is P(accepted  y)) then x=y, else return to Step 1
Note: Recall . Thus by comparing u and , we can get a probability of accepting y at these points. For instance, at some points that cg(x) is much larger than f(x), the probability of accepting x=y is quite small.
ie. At X_{1}, low probability to accept the point since f(x) is much smaller than cg(x).
At X_{2}, high probability to accept the point. in Uniform Distribution.
Note: Since U is the variable for uniform distribution between 0 and 1. It equals to 1 for all. The condition depends on the constant c. so the condition changes to
introduce the relationship of cg(x)and f(x),and prove why they have that relationship and where we can use this rule to reject some cases.
and learn how to see the graph to find the accurate point to reject or accept the ragion above the random variable x.
for the example, x1 is bad point and x2 is good point to estimate the rejection and acceptance
Some notes on the constant C
1. C is chosen such that , that is,cg(y) will always dominate f(y). Because of this,
C will always be greater than or equal to one and will only equal to one if and only if the proposal distribution and the target distribution are the same. It is normally best to choose C such that the absolute maxima of both cg(y) and f(y) are the same.
2. is the area of F(y) over the area of cG(y) and is the acceptance rate of the points generated. For example, if then on average, 70 percent of all points generated are accepted.
3. C is the average number of times Y is generated from g .
Theorem
Let be a welldefined pdf, and be a random variable with pdf such that with . If is independent of , then the random variable defined as has pdf , and the condition is denoted by "Accepted".
Proof
Recall the conditional probability formulas:
based on the concept from procedurestep1:
P(y) = g(y)
(the larger the value is, the larger the chance it will be selected)
Therefore:
Here is an alternative introduction of AcceptanceRejection Method
Comments:
AcceptanceRejection Method is not good for all cases. The limitation with this method is that sometimes many points will be rejected. One obvious disadvantage is that it could be very hard to pick the g(y) and the constant c in some cases. We have to pick the SMALLEST C such that else the the algorithm will not be efficient. This is because f(x) / cg(x) will become smaller and probability will go down and many points will be rejected making the algorithm inefficient.
Note: When f(y) is very different than g(y), it is less likely that the point will be accepted as the ratio above would be very small and it will be difficult for U to be less than this small value.
An example would be when the target function (f) has a spike or several spikes in its domain  this would force the known distribution (g) to have density at least as large as the spikes, making the value of c larger than desired. As a result, the algorithm would be highly inefficient.
AcceptanceRejection Method
Example 1 (discrete case)
We wish to generate X~Bi(2,0.5), assuming that we cannot generate this directly.
We use a discrete distribution DU[0,2] to approximate this.
x  0  1  2 
f(x)  1/4  1/2  1/4 
g(x)  1/3  1/3  1/3 
c = f(x) / g(x)  3/4  3/2  3/4 
f(x) / (cg(x))  1/2  1  1/2 
Since we need
We need c = 3 / 2
Therefore, the algorithm is:
1. Generate
2. Set (This is using uniform distribution to generate DU[0,2]
3. If (y = 0) and
If (y = 2) and
Else if y = 1,output = 1
An elaboration of “c”
c is the expected number of times the code runs to output 1 random variable. Remember that when is not satisfied, we need to go over the code again.
Proof
Let f(x) be the function we wish to generate from, but we cannot use inverse transform method to generate directly.
Let g(x) be the helper function
Let kg(x) > = f(x)
Since we need to generate y from g(x),
Pr(selecty) = g(y)
Pr(outputy  selectedy) = Pr(u < f(y) / (cg(y))) = f(y) / (cg(y)) (Since u~Unif(0,1))
Pr(outputy) = Pr(outputy1  selectedy1)Pr(selecty1) + Pr(outputy2  selectedy2)Pr(selecty2) + + Pr(outputyn  selectedyn)Pr(selectyn) = 1 / c
Consider that we are asking for expected time for the first success, it is a geometric distribution with probability of success=1/c
Therefore, E(X) = 1 / (1 / c)) = c
Acknowledgements: Some materials have been borrowed from notes from Stat340 in Winter 2013.
Use the conditional probability to proof if the probability is accepted, then the result is closed pdf of the original one. the example shows how to choose the c for the two function g(x) and f(x).
Example of AcceptanceRejection Method
Generating a random variable having p.d.f.
Since this random variable (which is beta with parameters (2,4)) is concentrated in the interval (0, 1), let us consider the acceptancerejection method with
To determine the constant c such that f(x)/g(x) <= c, we use calculus to determine the maximum value of
Differentiation of this quantity yields
Setting this equal to 0 shows that the maximal value is attained when x = 1/4,
and thus,
Hence,
and thus the simulation procedure is as follows:
1) Generate two random numbers U1 and U2 .
2) If U_{2}<(256/27)*U_{1}*(1U_{1})^{3}, set X=U_{1}, and stop Otherwise return to step 1). The average number of times that step 1) will be performed is c = 135/64.
(The above example is from http://www.cs.bgu.ac.il/~mps042/acceptance.htm, example 2.)
use the derivative to proof the accepetancerejection method, find the local maximum of f(x)/g(x). and we can calculate the best constant c.
Another Example of AcceptanceRejection Method
Generate a random variable from:
Assume g(x) to be uniform over interval (0,1), where 0< x <1
Therefore:
the best constant c is the max(f(x)/(cg(x))) and the c make the area above the f(x) and below the g(x) to be small.
because g(.) is uniform so the g(x) is 1. max(g(x)) is 1
Acknowledgement: this is example 1 from http://www.cs.bgu.ac.il/~mps042/acceptance.htm
Class 4  Thursday, May 16
Goals
 When we want to find target distribution f(x), we need to first find a proposal distribution g(x) that is easy to sample from.
 Relationship between the proposal distribution and target distribution is: , where c is constant. This means that the area of f(x) is under the area of .
 Chance of acceptance is less if the distance between f(x) and is big, and viceversa, we use c to keep below 1 (so ). Therefore, we must find the constant C to achieve this.
 In other words, C is chosen to make sure . However, it will not make sense if C is simply chosen to be arbitrarily large. We need to choose C such that fits f(x) as tightly as possible. This means that we must find the minimum c such that the area of f(x) is under the area of c*g(x).
 The constant c cannot be a negative number.
How to find C:
If f and g are continuous, we can find the extremum by taking the derivative and solve for x_{0} such that:
Thus
Note: This procedure is called the AcceptanceRejection Method.
The AcceptanceRejection method involves finding a distribution that we know how to sample from, g(x), and multiplying g(x) by a constant c so that is always greater than or equal to f(x). Mathematically, we want .
And it means, c has to be greater or equal to . So the smallest possible c that satisfies the condition is the maximum value of
.
But in case of c being too large, the chance of acceptance of generated values will be small, thereby losing efficiency of the algorithm. Therefore, it is best to get the smallest possible c such that .
Important points:
 For this method to be efficient, the constant c must be selected so that the rejection rate is low. (The efficiency for this method is )
 It is easy to show that the expected number of trials for an acceptance is .
 recall the acceptance rate is 1/c. (Not rejection rate)
 Let X be the number of trials for an acceptance,
 The number of trials needed to generate a sample size of N follows a negative binomial distribution. The expected number of trials needed is then cN.
 So far, the only distribution we know how to sample from is the UNIFORM distribution.
Procedure:
1. Choose g(x) (simple density function that we know how to sample, i.e. Uniform so far)
The easiest case is . However, in other cases we need to generate UNIF(a,b). We may need to perform a linear transformation on the variable.
2. Find a constant c such that :, otherwise return to step 1.
Recall the general procedure of AcceptanceRejection Method
 Let
 Let
 If then X=Y; else return to step 1 (This is not the way to find C. This is the general procedure.)
Example:
Generate a random variable from the pdf
We can note that this is a special case of Beta(2,1), where,
Where Γ (n) = (n  1)! if n is positive integer
Aside: Beta function
In mathematics, the beta function, also called the Euler integral of the first kind, is a special function defined by
g = u(0,1)
y = g
Taking x = 1 gives the highest possible c, which is c=2
Note that c is a scalar greater than 1.
cg(x) is proposal dist, and f(x) is target dist.
Note: g follows uniform distribution, it only covers half of the graph which runs from 0 to 1 on yaxis. Thus we need to multiply by c to ensure that can cover entire f(x) area. In this case, c=2, so that makes g run from 0 to 2 on yaxis which covers f(x).
Comment:
From the picture above, we could observe that the area under f(x)=2x is a half of the area under the pdf of UNIF(0,1). This is why in order to sample 1000 points of f(x), we need to sample approximately 2000 points in UNIF(0,1).
And in general, if we want to sample n points from a distritubion with pdf f(x), we need to scan approximately points from the proposal distribution (g(x)) in total.
Step
 Draw y~U(0,1)
 Draw u~U(0,1)
 if then x = y
 Else go to Step 1
Note: In the above example, we sample 2 numbers. If second number (u) is less than or equal to first number (y), then accept x=y, if not then start all over.
Matlab Code
>>close all >>clear all >>ii=1; # ii:numbers that are accepted >>jj=1; # jj:numbers that are generated >>while ii<1000 y=rand; u=rand; jj=jj+1; if u<=y x(ii)=y; ii=ii+1; end end >>hist(x) # It is a histogram >>jj jj = 2024 # should be around 2000
 *Note: The reason that a for loop is not used is that we need to continue the looping until we get 1000 successful samples. We will reject some samples during the process and therefore do not know the number of y we are going to generate.
 *Note2: In this example, we used c=2, which means we accept half of the points we generate on average. Generally speaking, 1/c would be the probability of acceptance, and an indicator of the efficiency of your chosen proposal distribution and algorithm.
 *Note3: We use while instead of for when looping because we do not know how many iterations are required to generate 1000 successful samples. We can view this as a negative binomial distribution so while the expected number of iterations required is n * c, it will likely deviate from this amount. We expect 2000 in this case.
 *Note4: If c=1, we will accept all points, which is the ideal situation. However, this is essentially impossible because if c = 1 then our distributions f(x) and g(x) must be identical, so we will have to be satisfied with as close to 1 as possible.
Use Inverse Method for this Example
 y = x^{2}
 Procedure
 1: Draw
 2:
Matlab Code
>>u=rand(1,1000); >>x=u.^0.5; >>hist(x)
Matlab Tip: Periods, ".",meaning "elementwise", are used to describe the operation you want performed on each element of a vector. In the above example, to take the square root of every element in U, the notation U.^0.5 is used. However if you want to take the square root of the entire matrix U the period, "." would be excluded. i.e. Let matrix B=U^0.5, then B^{T} * B = U. For example if we have a two 1 X 3 matrices and we want to find out their product; using "." in the code will give us their product. However, if we don't use ".", it will just give us an error. For example, a =[1 2 3] b=[2 3 4] are vectors, a.*b=[2 6 12], but a*b does not work since the matrix dimensions must agree.
Example for AR method:
Given , use AR method to generate random number
Let g=U(1,1) and g(x)=1/2
let y ~ f,
The process:
 1: Draw U1 ~ U(0,1)
 2: Draw U2 ~ U(0,1)
 3: let y = U1 * 2 − 1
 4: if , then x=y, note that (3/4(1y^2)/(3/4) is getting from f(y) / (cg(y)) )
 5: else: return to step 1
Example of AcceptanceRejection Method
1. Generate two uniform numbers in the unit interval
2. If , accept as the random variable with pdf , if not return to Step 1
We can also use for a more efficient algorithm
. Use the inverse method to sample from . Generate from and set
1. Generate two uniform numbers in the unit interval
2. If , accept U_{1} as the random variable with pdf f, if not return to Step 1
 Note :the function is called an envelop or majoring function.
To obtain a better proposing function , we can first assume a new and then solve for the normalizing constant by integrating.
In the previous example, we first assume . To find the normalizing constant, we need to solve which gives us k = 2/3. So,.
Possible Limitations
This method could be computationally inefficient depending on the rejection rate. We may have to sample many points before
we get the 1000 accepted points. In the example we did in class relating the f(x) = 2x,
we had to sample around 2070 points before we finally accepted 1000 sample points.
If the form of the proposal distribution, g, is very different from target distribution, f, then c is very large and the algorithm is not computationally efficient.
Acceptance  Rejection Method Application on Normal Distribution
has probability density function of
f(x) = (2/) e^{x2/2}
g(x) = e^{x}
Take h(x) = f(x)/g(x) and solve for h'(x) = 0 to find x so that h(x) is maximum.
Hence x=1 maximizes h(x) => c =
Thus f(y)/cg(y) = e^{(y1)2/2}
learn how to use code to calculate the c between f(x) and g(x).
How to transform U(0,1) to U(a,b)
1. Draw U from U(0,1)
2. Take Y = (b − a)U + a
3. Now Y follows U(a,b)
Example: Generate a random variable z from the Semicircular density .
> Proposal distribution: UNIF(R, R)
> We know how to generate using U˜UNIF(0,1) Let Y = 2RU − R = R(2U − 1), therefore Y follows U( − R,R)
> In order to maximize the function we must maximize the top and minimize the bottom.
Now, we need to find c:
Since c=max[f(x)/g(x)], where
, ,
Thus, we have to maximize R^2x^2.
=> When x=0, it will be maximized.
Therefore, c=4/pi. * Note: This also means that the probability of accepting a point is π / 4.
We will accept the points with limit f(x)/[cg(x)]. Since
 Note: Y= R(2U1)
We can also get Y= R(2U1) by using the formula y = a+(ba)*u, to transform U~(0,1) to U~(a,b). Letting a=R and b=R, and substituting it in the formula y = a+(ba)*u, we get Y= R(2U1).
Thus, * this also means the probability we can accept points
The algorithm to generate random variable x is then:
1. Draw from
2. Draw from
3. If
else return to step 1.
The condition is
One more example about AR method
(In this example, we will see how to determine the value of c when c is a function with unknown parameters instead of a value)
Let f(x) = xe^{ − x},x > 0
Use g(x) = ae^{ − ax} to generate random variable
Solution: First of all, we need to find c
cg(x) > = f(x)
take derivative with respect to x, and set it to 0 to get the maximum,
therefore,
In order to minimize c, we need to find the appropriate a
Take derivative with respect to a and set it to be zero,
We could get
Procedure:
1. Generate u v ~unif(0,1)
2. Generate y from g, since g is exponential with rate 2, let y=0.5*ln(u)
3. If , output y
Else, go to 1
Acknowledgements: The example above is from Stat 340 Winter 2013 notes.
Summary of how to find the value of c
Let , and then we have the following:
1. First, take derivative of h(x) with respect to x, get x_{1};
2. Plug x_{1} into h(x) and get the value(or a function) of c, denote as c_{1};
3. Check the endpoints of x and sub the endpoints into h(x);
4. (if c_{1} is a value, then we can ignore this step) Since we want the smallest value of c such that for all x, we want the unknown parameter that minimizes c.
So we take derivative of c_{1} with respect to the unknown parameter (ie k=unknown parameter) to get the value of k.
Then we submit k to get the value of c_{1}. (Double check that
5. Pick the maximum value of h(x) to be the value of c.
For the two examples above, we need to generate the probability function to uniform distribution, and figure out . If , output y.
Summary of when to use the Accept Rejection Method
1) When the calculation of inverse cdf cannot to be computed or is too difficult to compute.
2) When f(x) can be evaluated to at least one of the normalizing constant.
3) A constant c where
4) A uniform draw
Interpretation of 'C'
We can use the value of c to calculate the acceptance rate by .
For instance, assume c=1.5, then we can tell that 66.7% of the points will be accepted (). We can also call the efficiency of the method is 66.7%.
Likewise, if the minimum value of possible values for C is , of the generated random variables will be accepted. Thus the efficient of the algorithm is 75%.
In order to ensure the algorithm is as efficient as possible, the 'C' value should be as close to one as possible, such that approaches 1 => 100% acceptance rate.
>> close All
>> clear All
>> i=1
>> j=0;
>> while ii<1000
y=rand
u=rand
if u<=y;
x(ii)=y
ii=ii+1
end
end
Class 5  Tuesday, May 21
Recall the example in the last lecture. The following code will generate a random variable required by the question.
 Code
>>close all >>clear all >>ii=1; >>R=1; #Note: that R is a constant in which we can change i.e. if we changed R=4 then we would have a density between 4 and 4 >>while ii<1000 u1 = rand; u2 = rand; y = R*(2*u21); if (1u1^2)>=(2*u21)^2 x(ii) = y; ii = ii + 1; #Note: for beginner programmers that this step increases the ii value for next time through the while loop end end >>hist(x,20) # 20 is the number of bars >>hist(x,30) #30 is the number of bars
calculate process:
(u_{1})^{2} < = (1 − (2u − 1)^{2})
(u_{1})^{2} − 1 < = ( − (2u − 1)^{2})
1 − (u_{1})^{2} > = ((2u − 1)^{2} − 1)
MATLAB tips: hist(x,y) plots a histogram of variable x, where y is the number of bars in the graph.
Discrete Examples
 Example 1
Generate random variable X according to p.m.f
The discrete case is analogous to the continuous case. Suppose we want to generate an X that is a discrete random variable with pmf f(x)=P(X=x). Suppose also that we use the discrete uniform distribution as our target distribution, then g(x) = P(X = x) = 0.2 for all X.
The following algorithm then yields our X:
Step 1 Draw discrete uniform distribution of 1, 2, 3, 4 and 5, .
Step 2 Draw .
Step 3 If , then X = Y ;
Else return to Step 1.
C can be found by maximizing the ratio :. To do this, we want to maximize f(x) and minimize g(x).
Note: In this case f(x) = P(X = x) = 0.3 (highest probability from the discrete probabilities in the question)
Note: The U is independent from y in Step 2 and 3 above. ~The constant c is a indicator of rejection rate or efficiency of the algorithm. It can represent the average number of trials of the algorithm. Thus, a higher c would mean that the algorithm is comparatively inefficient.
the acceptancerejection method of pmf, the uniform probability is the same for all variables, and there are 5 parameters(1,2,3,4,5), so g(x) is 0.2
Remember that we always want to choose cg to be equal to or greater than f, but as close as possible.
limitations: If the form of the proposal dist g is very different from target dist f, then c is very large and the algorithm is not computatively efficient.
 Code for example 1
>>close all >>clear all >>p=[.15 .25 .3 .1 .2]; %This a vector holding the values >>ii=1; >>while ii < 1000 y=unidrnd(5); %generates random numbers for the discrete uniform u=rand; distribution with maximum 5. if u<= p(y)/0.3 x(ii)=y; ii=ii+1; end end >>hist(x)
unidrnd(k) draws from the discrete uniform distribution of integers 1,2,3,...,k If this function is not built in to your MATLAB then we can do simple transformation on the rand(k) function to make it work like the unidrnd(k) function.
The acceptance rate is , so the lower the c, the more efficient the algorithm. Theoretically, c equals 1 is the best case because all samples would be accepted; however it would only be true when the proposal and target distributions are exactly the same, which would never happen in practice.
For example, if c = 1.5, the acceptance rate would be . Thus, in order to generate 1000 random values, on average, a total of 1500 iterations would be required.
A histogram to show 1000 random values of f(x), more random value make the probability close to the express probability value.
 Example 2
p(x=1)=0.1
p(x=2)=0.3
p(x=3)=0.6
Let g be the uniform distribution of 1, 2, or 3
g(x)= 1/3
Hence
1,y~g
2,u~U(0,1)
3, If , set x = y. Else go to 1.
 Code for example 2
>>close all >>clear all >>p=[.1 .3 .6]; %This a vector holding the values >>ii=1; >>while ii < 1000 y=unidrnd(3); %generates random numbers for the discrete uniform distribution with maximum 3 u=rand; if u<= p(y)/0.6 x(ii)=y; ii=ii+1; %else ii=ii+1 end end >>hist(x)
 Example 3
Suppose (Poisson distribution)
First: Try the first few : 0.0498, 0.149, 0.224, 0.224, 0.168, 0.101, 0.0504, 0.0216, 0.0081, 0.0027 for
Proposed distribution: Use the geometric distribution for ;
, choose
Look at for the first few numbers: 0.199 0.797 1.59 2.12 2.12 1.70 1.13 0.647 0.324 0.144 for
We want which is approximately 2.12
The general procedures to generate is as follows:
1. Generate
2.
3. if , set , else go to step 1.
Note: In this case, is extremely difficult to differentiate so we were required to test points. If the function is very easy to differentiate, we can calculate the max as if it were a continuous function then check the two surrounding points for which is the highest discrete value.
 Example 4 (Hypergeometric & Binomial)
Suppose we are given f(x) such that it is hypergeometically distributed, given 10 white balls, 5 red balls, and select 3 balls, let X be the number of red ball selected, without replacement.
Choose g(x) such that it is binomial distribution, Bin(3, 1/3). Find the rejection constant, c
Solution:
For hypergeometric:
For Binomial g(x): P(X=0) = (2/3)^3=0.2963; P(X=1)= 3*(1/3)*(2/3)^2 = 0.4444, P(X=2)=3*(1/3)^2*(2/3)=0.2222, P(X=3)=(1/3)^3=0.03704
Find the value of f/g for each X
X=0: 0.8898; X=1: 1.1127; X=2: 0.9891; X=3: 0.5934
Choose the maximum which is c=1.1127
Looking for the max f(x) is 0.4945 and the max g(x) is 0.4444, so we can calculate the max c is 1.1127. But for the graph, this c is not the best because it does not cover all the point of f(x), so we need to move the c*g(x) graph to cover all f(x), and decreasing the rejection ratio.
Limitation: If the shape of the proposed distribution g is very different from the target distribution f, then the rejection rate will be high (High c value). Computationally, the algorithm is always right; however it is inefficient and requires many iterations.
Here is an example:
In the above example, we need to move c*g(x) to the peak of f to cover the whole f. Thus c will be very large and 1/c will be small.
The higher the rejection rate, more points will be rejected.
More on rejection/acceptance rate: 1/c is the acceptance rate. As c decreases (note: the minimum value of c is 1), the acceptance rate increases. In our last example, 1/c=1/1.5≈66.67%. Around 67% of points generated will be accepted.
which brings the acceptance rate low which leads to very time consuming sampling
AcceptanceRejection Method
Problem: The CDF is not invertible or it is difficult to find the inverse.
Plan:
 Draw y~g(.)
 Draw u~Unif(0,1)
 If then set x=y. Else return to Step 1
x will have the desired distribution.
Matlab Example
close all clear all ii=1; R=1; while ii<1000 u1 = rand; u2 = rand; y = R*(2*u21); if (1u1^2)>=(2*u21)^2 x(ii) = y; ii = ii + 1; end end hist(x,20)
Recall that,
Suppose we have an efficient method for simulating a random variable having probability mass function {q(j),j>=0}. We can use this as the basis for simulating from the distribution having mass function {p(j),j>=0} by first simulating a random variable Y having mass function {q(j)} and then accepting this simulated value with a probability proportional to p(Y)/q(Y).
Specifically, let c be a constant such that p(j)/q(j)<=c for all j such that p(j)>0
We now have the following technique, called the acceptancerejection method, for simulating a random variable X having mass function p(j)=P{X=j}.
Sampling from commonly used distributions
Please note that this is not a general technique as is that of acceptancerejection sampling. Later, we will generalize the distributions for multidimensional purposes.
 Gamma
The CDF of the Gamma distribution Gamma(t,λ) is(t denotes the shape, λ denotes the scale:
, where .
Note that the CDF of the Gamma distribution does not have a closed form.
The gamma distribution is often used to model waiting times between a certain number of events. It can also be expressed as the sum of infinitely many independent and identically distributed exponential distributions. This distribution has two parameters: the number of exponential terms n, and the rate parameter λ. In this distribution there is the Gamma function, Γ which has some very useful properties. "Source: STAT 340 Spring 2010 Course Notes"
Neither Inverse Transformation nor AcceptanceRejection Method can be easily applied to Gamma distribution. However, we can use additive property of Gamma distribution to generate random variables.
 Additive Property
If are independent exponential distributions with hazard rate λ (in other words,
Side notes: if and are independent gamma distributions, then has a distribution of Beta(a,B).
If we want to sample from the Gamma distribution, we can consider sampling from t independent exponential distributions using the Inverse Method for each X_{i} and add them up. Note that this only works the specific set of gamma distributions where t is a positive integer.
According to this property, a random variable that follows Gamma distribution is the sum of i.i.d (independent and identically distributed) exponential random variables. Now we want to generate 1000 values of Gamma(20,10) random variables, so we need to obtain the value of each one by adding 20 values of . To achieve this, we generate a 20by1000 matrix whose entries follow Exp(10) and add the rows together.
...
>>l=1 >>urand(1,1000); >>x=(1/l)*log(u); >>hist(x) >>rand
 Procedure
 Sample independently from a uniform distribution t times, giving
 Use the Inverse Transform Method, , giving
 Use the additive property,
 Note for Procedure
 If , then U and 1 − U will have the same distribution (both follows U(0,1))
 This is because the range for 1 − U is still (0,1), and their densities are identical over this range.
 Let Y = 1 − U, Pr(Y < = y) = Pr(1 − U < = y) = Pr(U > = 1 − y) = 1 − Pr(U < = 1 − y) = 1 − (1 − y) = y, thus
 Code
>>close all >>clear all >>lambda = 1; >>u = rand(20, 1000); Note: this command generate a 20x1000 matrix (which means we generate 1000 number for each X_i with t=20); all the elements are generated by rand >>x = (1/lambda)*log(1u); Note: log(1u) is essentially the same as log(u) only if u~U(0,1) >>xx = sum(x) Note: sum(x) will sum all elements in the same column. size(xx) can help you to verify >>size(sum(x)) Note: see the size of x if we forget it (the answer is 20 1000) >>hist(x(1:)) Note: the graph of the first exponential distribution >>hist(xx)
size(x) and size(u) are both 20*1000 matrix. Since if u~unif(0, 1), u and 1  u have the same distribution, we can substitute 1u with u to simply the equation. Alternatively, the following command will do the same thing with the previous commands.
 Code
>>close all >>clear all >>lambda = 1; >>xx = sum((1/lambda)*log(rand(20, 1000))); ''This is simple way to put the code in one line. Here we can use either log(u) or log(1u) since U~U(0,1); >>hist(xx)
In the matrix rand(20,1000) means 20 row with 1000 numbers for each. use the code to show the generalize the distributions for multidimensional purposes in different cases, such as sum xi (each xi not equal xj), and they are independent, or matrix. Finally, we can see the conclusion is shown by the histogram.
Other Sampling Method: Box Muller
 From cartesian to polar coordinates
 BoxMuller Transformation:
It is a transformation that consumes two continuous uniform random variables X˜U(0,1),Y˜U(0,1) and outputs a bivariate normal random variable with Z_{1}˜N(0,1),Z_{2}˜N(0,1).
Matlab
If X is a matrix,
 X(1,:) returns the first row
 X(:,1) returns the first column
 X(i,j) returns the (i,j)th entry
 sum(X,1) or sum(X) is a summation of the rows of X. The output is a row vector of the sums of each column.
 sum(X,2) is a summation of the columns of X, returning a vector.
 rand(r,c) will generate uniformly distributed random numbers in r rows and c columns.
 The dot operator (.), when placed before a function, such as +,,^, *, and many others specifies to apply that function to every element of a vector or a matrix. For example, to add a constant c to elements of a matrix A, do A.+c as opposed to simply A+c. The dot operator is not required for functions that can only take a number as their input (such as log).
 Matlab processes loops very slow, while it is fast with matrices and vectors, so it is preferable to use the dot operator to and matrices of random numbers than loops if it is possible.
Class 6  Thursday, May 23
Announcement
1. On the day of each lecture, students from the morning section can only contribute the first half of the lecture (i.e. 8:30  9:10 am), so that the second half can be saved for the ones from the afternoon section. After the day of lecture, students are free to contribute anything.
Standard Normal distribution
If X ~ N(0,1) i.e. Standard Normal Distribution  then its p.d.f. is of the form
 Warning : the General Normal distribution is:

which is almost useless in this course

where μ is the mean or expectation of the distribution and σ is standard deviation
 N(0,1) is standard normal. μ =0 and σ=1
Let X and Y be independent standard normal.
Let θ and R denote the Polar coordinate of the vector (X, Y) where and
Note: R must satisfy two properties:
 1. Be a positive number (as it is a length)
 2. It must be from a distribution that has more data points closer to the origin so that as we go further from the origin, less points are generated (the two options are Chisquared and Exponential distribution)
The form of the joint distribution of R and θ will show that the best choice for distribution of R^{2} is exponential.
We cannot use the Inverse Transformation Method since F(x) does not have a closed form solution. So we will use joint probability function of two independent standard normal random variables and polar coordinates to simulate the distribution:
We know that
R^{2} = X^{2} + Y^{2} and where X and Y are two independent standard normal
 Since for independent distributions, their joint probability function is the multiplication of two independent probability functions. It can also be shown using 11 transformation that the joint distribution of R and θ is given by, 11 transformation:
Let d = R^{2}
then It can be shown that the joint density of d / R^{2} and θ is:
Note that consists of two density functions, Exponential and Uniform, so assuming that r and θ are independent
To sample from the normal distribution, we can generate a pair of independent standard normal X and Y by:
1) Generating their polar coordinates
2) Transforming back to rectangular (Cartesian) coordinates.
Alternative Method of Generating Standard Normal Random Variables
Step 1: Generate u_{1} ~Unif(0,1)
Step 2: Generate Y_{1} ~Exp(1),Y_{2}~Exp(2)
Step 3: If ,set V = Y1,otherwise,go to step 1
Step 4: If ,then X = − V
===Expectation of a Standard Normal distribution===
The expectation of a standard normal distribution is 0
Proof:
 Since the first derivative ϕ′(x) is −xϕ(x)
 = 0
Note, more intuitively, because x is an odd function (f(x)+f(x)=0). Taking integral of x will give x^{2} / 2 which is an even function (f(x)=f(x)). This is in relation to the symmetrical properties of the standard normal distribution. If support is from negative infinity to infinity, then the integral will return 0.
Procedure (BoxMuller Transformation Method):
Pseudorandom approaches to generating normal random variables used to be limited. Inefficient methods such as inverse Gaussian function, sum of uniform random variables, and acceptancerejection were used. In 1958, a new method was proposed by George Box and Mervin Muller of Princeton University. This new technique was easy to use and also had the accuracy to the inverse transform sampling method that it grew more valuable as computers became more computationally astute.
The BoxMuller method takes a sample from a bivariate independent standard normal distribution, each component of which is thus a univariate standard normal. The algorithm is based on the following two properties of the bivariate independent standard normal distribution:
if Z = (Z_{1},Z_{2}) has this distribution, then
1. is exponentially distributed with mean 2, i.e.
.
2.Given R^{2}, the point (Z_{1},Z_{2}) is uniformly distributed on the circle of radius R centered at the origin.
We can use these properties to build the algorithm:
1) Generate random number
2) Generate polar coordinates using the exponential distribution of d and uniform distribution of θ,
Note: If U~unif(0,1), then ln(1U)=ln(U)
3) Transform polar coordinates (i.e. R and θ) back to Cartesian coordinates (i.e. X and Y),
.
Alternatively,
and
Note: In steps 2 and 3, we are using a similar technique as that used in the inverse transform method.
The BoxMuller Transformation Method generates a pair of independent Standard Normal distributions, X and Y (Using the transformation of polar coordinates).
If you want to generate a number of independent standard normal distributed numbers (more than two), you can run the BoxMuller method several times.
For example:
If you want 8 independent standard normal distributed numbers, then run the BoxMuller methods 4 times (8/2 times).
If you want 9 independent standard normal distributed numbers, then run the BoxMuller methods 5 times (10/2 times), and then delete one.
Matlab Code
>>close all >>clear all >>u1=rand(1,1000); >>u2=rand(1,1000); >>d=2*log(u1); >>tet=2*pi*u2; >>x=d.^0.5.*cos(tet); >>y=d.^0.5.*sin(tet); >>hist(tet) >>hist(d) >>hist(x) >>hist(y)
Remember: For the above code to work the "." needs to be after the d to ensure that each element of d is raised to the power of 0.5.
Otherwise matlab will raise the entire matrix to the power of 0.5."
Note:
the first graph is hist(tet) and it is a uniform distribution.
The second one is hist(d) and it is a exponential distribution.
The third one is hist(x) and it is a normal distribution.
The last one is hist(y) and it is also a normal distribution.
Attention:There is a "dot" between sqrt(d) and "*". It is because d and tet are vectors.
As seen in the histograms above, X and Y generated from this procedure have a standard normal distribution.
 Code
>>close all >>clear all >>x=randn(1,1000); >>hist(x) >>hist(x+2) >>hist(x*2+2)<br>
Note:
1. randn is random sample from a standard normal distribution.
2. hist(x+2) will be centered at 2 instead of at 0.
3. hist(x*3+2) is also centered at 2. The mean doesn't change, but the variance of x*3+2 becomes nine times (3^2) the variance of x.
Comment:
BoxMuller transformations are not computationally efficient. The reason for this is the need to compute sine and cosine functions. A way to get around this timeconsuming difficulty is by an indirect computation of the sine and cosine of a random angle (as opposed to a direct computation which generates U and then computes the sine and cosine of 2πU.
Alternative Methods of generating normal distribution
1. Even though we cannot use inverse transform method, we can approximate this inverse using different functions.One method would be rational approximation.
2.Central limit theorem : If we sum 12 independent U(0,1) distribution and subtract 6 (which is E(ui)*12)we will approximately get a standard normal distribution.
3. Ziggurat algorithm which is known to be faster than BoxMuller transformation and a version of this algorithm is used for the randn function in matlab.
If Z~N(0,1) and X= μ +Zσ then X~N(μ,σ^{2})
If Z_{1}, Z_{2}... Z_{d} are independent identically distributed N(0,1), then Z=(Z_{1},Z_{2}...Z_{d})^{T} ~N(0, I_{d}), where 0 is the zero vector and I_{d} is the identity matrix.
For the histogram, the constant is the parameter that affect the center of the graph.
Proof of Box Muller Transformation
Definition:
A transformation which transforms from a twodimensional continuous uniform distribution to a twodimensional bivariate normal distribution (or complex normal distribution).
Let U_{1} and U_{2} be independent uniform (0,1) random variables. Then X_{1} = (( − 2lnU_{1})^{.}5) * cos(2πU_{2})
X_{2} = ( − 2lnU_{1})^{0}.5 * sin(2πU_{2}) are independent N(0,1) random variables.
This is a standard transformation problem. The joint distribution is given by
f(x1 ,x2) = f_{u1}, _{u2}(g1^− 1(x1,x2),g2^− 1(x1,x2)) *  J 
where J is the Jacobian of the transformation,
J = ∂u_{1}/∂x_{1},∂u_{1}/∂x_{2} ∂u_{2}/∂x_{1},∂u_{2}/∂x_{2}
where
u_{1} = g_{1} ^1(x1,x2) u_{2} = g_{2} ^1(x1,x2)
Inverting the above transformation, we have
u1 = exp^{(x_{1} ^2+ x_{2} ^2)/2} u2 = (1/2pi)*tan^1 (x_{2}/x_{1})
Finally we get
f(x1,x2) = {exp^((x1^2+x2^2)/2)}/2pi
which factors into two standard normal pdfs.
(The quote is from http://mathworld.wolfram.com/BoxMullerTransformation.html)
(The proof is from http://www.math.nyu.edu/faculty/goodman/teaching/MonteCarlo2005/notes/GaussianSampling.pdf)
General Normal distributions
General normal distribution is a special version of the standard normal distribution. The domain of the general normal distribution is affected by the standard deviation and translated by the mean value.
 The pdf of the general normal distribution is

which is almost useless in this course

where μ is the mean or expectation of the distribution and σ is standard deviation
The probability density must be scaled by 1/sigma so that the integral is still 1.(Acknowledge: https://en.wikipedia.org/wiki/Normal_distribution) The special case of the normal distribution is standard normal distribution, which the variance is 1 and the mean is zero. If X is a general normal deviate, then will have a standard normal distribution.
If Z ~ N(0,1), and we want X~N(μ,σ^{2}), then X = μ + σ * Z Since E(x) = μ + σ * 0 = μ and Var(x) = 0 + σ^{2} * 1
If Z_{1},...Z_{d} ~ N(0,1) and are independent then Z = (Z_{1},..Z_{d})^{T}~ N(0,I_{d}) ie.
 Code
>>close all >>clear all >>z1=randn(1,1000); <generate variable from standard normal distribution >>z2=randn(1,1000); >>z=[z1;z2]; <produce a vector >>plot(z(1,:),z(2,:),'.')
If Z~N(0,Id) and X= then ~
NonStandard Normal Distributions
Example 1: Singlevariate Normal
If X ~ Norm(0, 1) then (a + bX) has a normal distribution with a mean of and a standard deviation of (which is equivalent to a variance of ). Using this information with the BoxMuller transform, we can generate values sampled from some random variable for arbitrary values of .
 Generate a sample u from Norm(0, 1) using the BoxMuller transform.
 Set v = a + bu.
The values for v generated in this way will be equivalent to sample from a distribution. We can modify the MatLab code used in the last section to demonstrate this. We just need to add one line before we generate the histogram:
v = a + b * x;
For instance, this is the histogram generated when b = 15, a = 125:
Example 2: Multivariate Normal
The BoxMuller method can be extended to higher dimensions to generate multivariate normals. The objects generated will be nx1 vectors, and their variance will be described by nxn covariance matrices.
defines the n by 1 vector such that:
 is the average of
 is the variance of
 is the covariance of and
If are normal variables with mean 0 and variance 1, then the vector has mean 0 and variance , where 0 is the zero vector and is the identity matrix. This fact suggests that the method for generating a multivariate normal is to generate each component individually as single normal variables.
The mean and the covariance matrix of a multivariate normal distribution can be adjusted in ways analogous to the single variable case. If , then . Note here that the covariance matrix is symmetric and nonnegative, so its square root should always exist.
We can compute in the following way:
 Generate an n by 1 vector where x_{i} ~ Norm(0, 1) using the BoxMuller transform.
 Calculate using singular value decomposition.
 Set .
The following MatLab code provides an example, where a scatter plot of 10000 random points is generated. In this case x and y have a covariance of 0.9  a very strong positive correlation.
x = zeros(10000, 1); y = zeros(10000, 1); for ii = 1:10000 u1 = rand; u2 = rand; R2 = 2 * log(u1); theta = 2 * pi * u2; x(ii) = sqrt(R2) * cos(theta); y(ii) = sqrt(R2) * sin(theta); end E = [1, 0.9; 0.9, 1]; [u s v] = svd(E); root_E = u * (s ^ (1 / 2)) * u'; z = (root_E * [x y]'); z(1,:) = z(1,:) + 0; z(2,:) = z(2,:) + 3; scatter(z(1,:), z(2,:))
Note: The svd command computes the matrix singular value decomposition.
[u,s,v] = svd(E) produces a diagonal matrix s of the same dimension as E, with nonnegative diagonal elements in decreasing order, and unitary matrices u and v so that E = u*s*v'.
This code generated the following scatter plot:
In Matlab, we can also use the function "sqrtm()" or "chol()" (Cholesky Decomposition) to calculate square root of a matrix directly. Note that the resulting root matrices may be different but this does materially affect the simulation. Here is an example:
E = [1, 0.9; 0.9, 1]; r1 = sqrtm(E); r2 = chol(E);
R code for a multivariate normal distribution:
n=10000; r2<2*log(runif(n)); theta<2*pi*(runif(n)); x<sqrt(r2)*cos(theta); y<sqrt(r2)*sin(theta); a<matrix(c(x,y),nrow=n,byrow=F); e<matrix(c(1,.9,09,1),nrow=2,byrow=T); svde<svd(e); root_e<svde$u %*% diag(svde$d)^1/2; z<t(root_e %*%t(a)); z[,1]=z[,1]+5; z[,2]=z[,2]+ 8; par(pch=19); plot(z,col=rgb(1,0,0,alpha=0.06))
Bernoulli Distribution
The Bernoulli distribution is a discrete probability distribution, which usually describes an event that only has two possible results, i.e. success or failure (x=0 or 1). If the event succeed, we usually take value 1 with success probability p, and take value 0 with failure probability q = 1  p.
P ( x = 0) = q = 1  p
P ( x = 1) = p
P ( x = 0) + P (x = 1) = p + q = 1
If X~Ber(p), its pdf is of the form f(x) = p^{x}(1 − p)^{(1 − x)}, x=0,1
P is the success probability.
The Bernoulli distribution is a special case of binomial distribution, where the variate x only has two outcomes; so that the Bernoulli also can use the probability density function of the binomial distribution with the variate x taking values 0 and 1.
The most famous example for the Bernoulli Distribution would be the "Flip Coin" question, which has only two possible outcomes(Success or Failure) with the same probabilities of 0.5
Let x1,x2 denote the lifetime of 2 independent particles, x1~exp(λ), x2~exp(λ) we are interested in y=min(x1,x2)
Procedure: To simulate the event of flipping a coin, let P be the probability of flipping head and X = 1 and 0 represent flipping head and tail respectively: 1. Draw U ~ Uniform(0,1) 2. If U <= P X = 1 Else X = 0 3. Repeat as necessary
An intuitive way to think of this is in the coin flip example we discussed in a previous lecture. In this example we set p = 1/2 and this allows for 50% of points to be heads or tails.
 Code to Generate Bernoulli(p = 0.3)
i = 1; while (i <=1000) u =rand(); p = 0.3; if (u <= p) x(i) = 1; else x(i) = 0; end i = i + 1; end hist(x)
However, we know that if where each is independent,
So we can sample from binomial distribution using this property.
Note: We can consider Binomial distribution as the sum of n, independent, Bernoulli distributions
 Code to Generate Binomial(n = 20,p = 0.7)
p = 0.7; n = 20; for k=1:5000 i = 1; for i=1:n u=rand(); if (u <= p) y(i) = 1; else y(i) = 0; end end x(k) = sum(y==1); end hist(x)
Note: We can also regard the Bernoulli Distribution as either a conditional distribution or f(x) = p^{x}(1 − p)^{(1 − x)}, x=0,1.
Comments on Matlab: When doing operations on vectors, always put a dot before the operator if you want the operation to be done to every element in the vector. example: Let V be a vector with dimension 2*4 and you want each element multiply by 3.
The Matlab code is 3.*V
some examples for using code to generate distribution.
Class 7  Tuesday, May 28
Universality of the Uniform Distribution/Inverse Method
The inverse method is universal in the sense that we can potentially sample from any distribution where we can find the inverse of the cumulative distribution function.
Procedure:
1) Generate U~Unif (0, 1)
2) Set x = F^{ − 1}(u)
3) X~f(x)
Remark
1) The preceding can be written algorithmically for discrete random variables as
Generate a random number U ~ U(0,1]
If U < p_{0} set X = x_{0} and stop
If U < p_{0} + p_{1} set X = x_{1} and stop
...
2) If the x_{i}, i>=0, are ordered so that x_{0} < x_{1} < x_{2} <... and if we let F denote the distribution function of X, then X will equal x_{j} if F(x_{j1}) <= U < F(x_{j})
Example 1
Let X_{1},X_{2} denote the lifetime of two independent particles:
X_{1}~exp(λ_{1})
X_{2}~exp(λ_{2})
We are interested in y = min(X_{1},X_{2})
Design an algorithm based on the InverseTransform Method to generate samples according to f_{y}(y)
Solution:
x_{1}~exp(λ_{1})
x_{2}~exp(λ_{2})
1 − F_{Y}(y) = P(Y > y) = P(min(X_{1},X_{2}) > y) =
=>
Procedure:
Step1: Generate U~ U(0, 1)
Step2: set
or set
Since it is a uniform distribution, therefore after generate a lot of times 1u and u are the same.
 Matlab Code
>> lambda1 = 1; >> lambda2 = 2; >> u = rand; >> y = log(u)/(lambda1 + lambda2)
If we generalize this example from two independent particles to n independent particles we will have:
X_{1}~exp(λ_{1})
X_{2}~exp(λ_{2})
...
X_{n}~exp(λ_{n})
.
And the algorithm using the inversetransform method as follows:
step1: Generate U~U(0,1)
Step2:
Example 2
Consider U~Unif[0,1)
,
where a>0 and a is a real number
What is the distribution of X?
Solution:
We can find a form for the cumulative distribution function of X by isolating U as U~Unif[0,1) will take values from the range of F(X)uniformly. It then remains to differentiate the resulting form by X to obtain the probability density function.
Example 3
Suppose F_{X}(x) = x^{n}, 0 ≤ x ≤ 1, n ∈ N > 0. Generate values from X.
Solution:
1. Generate
2. Set X = U^{1 / n}
For example, when n = 20,
U = 0.6 => X = U^{1 / 20} = 0.974
U = 0.5 = > X = U^{1 / 20} = 0.966
U = 0.2 => X = U^{1 / 20} = 0.923
Observe from above that the values of X for n = 20 are close to 1, this is because we can view X^{n} as the maximum of n independent random variables X, and is much likely to be close to 1 as n increases. This is because when n is large the exponent tends towards 0. This observation is the motivation for method 2 below.
Recall that
If Y = max (X_{1}, X_{2}, ... , X_{n}), where X_{1}, X_{2}, ... , X_{n} are independent,
F_{Y}(y) = P(Y ≤ y) = P(max (X_{1}, X_{2}, ... , X_{n}) ≤ y) = P(X_{1} ≤ y, X_{2} ≤ y, ... , X_{n} ≤ y) = F_{x1}(y) F_{x2}(y) ... F_{xn}(y)
Similarly if then the cdf of Y is F_{Y} = 1 −
Method 1: Following the above result we can see that in this example, F_{X} = x^{n} is the cumulative distribution function of the max of n uniform random variables between 0 and 1 (since for U~Unif(0, 1), F_{U}(x) =
Method 2: generate X by having a sample of n independent U~Unif(0, 1) and take the max of the n samples to be x. However, the solution given above using inversetransform method only requires generating one uniform random number instead of n of them, so it is a more efficient method.
Generate the Y = max (X1, X2, ... , Xn), Y = min (X1, X2, ... , Xn), pdf and cdf, but (xi and xj are independent) i,j=1,2,3,4,5.....
Example 4 (New)
Now, we are having an similar example as example 1 just doing the maximum way.
Let X_{1},X_{2} denote the lifetime of two independent particles:
We are interested in Z=max(X_{1},X_{2})
Design an algorithm based on the InverseTransform Method to generate samples according to f_{Z}(z)
To sample Z:
, therefore we can generate random variable of Z.
Discrete Case:
u~unif(0,1)
x < 0, S < P_{0}
while u < S
x < x + 1
S < S + P_{0}
Return x
Decomposition Method
The CDF, F, is a composition if F_{X}(x) can be written as:
where
1) p_{i} > 0
2) p_{i} = 1.
3) is a CDF
The general algorithm to generate random variables from a composition CDF is:
1) Generate U,V ~ Unif(0,1)
2) If U < p_{1}, V = ^{1}
3) Else if U < p_{1} + p_{2}, V = ^{1}
4) Repeat from Step 1 (if N randomly generated variables needed, repeat N times)
Explanation
Each random variable that is a part of X contributes to F_{X}(x) every time.
From a sampling point of view, that is equivalent to contributing p_{i} of the time. The logic of this is similar to that of the AcceptReject Method, but instead of rejecting a value depending on the value u takes, we instead decide which distribution to sample it from.
Simplified Version
1) Generate u˜Unif(0,1)
2) Set X = 0,s = P_{0}
3) While u > s,
set X = X + 1 and s = s + P_{x}
4) Return X
Examples of Decomposition Method
Example 1
Let and
Algorithm:
Generate U~Unif(0,1)
If , then we sample from f_{x1}
Else if , we sample from f_{x2}
We can find the inverse CDF of f_{x2} and utilize the Inverse Transform Method in order to sample from f_{x2}
Sampling from f_{x1} is more straightforward since it is uniform over the interval (0,2)
divided f(x) to two pdf of x1 and x2, with uniform distribution, of two range of uniform.
Example 2
We can rewrite f(x) as
Let f_{x1} = e^{ − x}, f_{x2} = 4x, and f_{x3} =
Generate U~Unif(0,1)
If , we sample from f_{x1}
If , we sample from f_{x2}
Else if , we sample from f_{x3}
We can find the inverse CDFs of f_{x1} and f_{x2} and utilize the Inverse Transform Method in order to sample from f_{x1} and f_{x2}
We find F_{x1} = 1 − e^{ − x} and F_{x2} = 2x^{2}
We find the inverses are X = − ln(1 − u) for F_{x1} and for F_{x2}
Sampling from f_{x3} is more straightforward since it is uniform over the interval (0,3)
In general, to write an efficient algorithm for:
We would first calculate
Then Generate
If U < q_{1} sample from f_{1}
else if u < q_{i} sample from f_{i} for 1 < i < n
else sample from f_{n}
when we divided the pdf of different range of f(x1) f(x2) and f(x3), and generate all of them and inverse, U~U(0,1)
Example of Decomposition Method
Let , solve for x.
Algorithm:
Generate
Generate
if
else if
else
Matlab Code:
u=rand # U is v=rand if u<1/3 x=v elseif u<2/3 x=sqrt(v) else x=v^(1/3) end
=== Example of Decomposition Method(new) ===
F_{x}(x) = 1/2*x+1/2*x^{2}, 0<= x<=1
let U =F_{x}(x) = 1/2*x+1/2*x^{2}, solve for x.
P_{1}=1/2, F_{x1}(x)= x, P_{2}=1/2,F_{x2}(x)= x^{2},
Algorithm:
Generate U ~ Unif [0,1)
Generate V~ Unif [0,1)
if 0<u<1/2, x = v
else x = v^{1/2}
Matlab Code:
u=rand v=rand if u<1/2 x=v else x=sqrt(v) end
Extra Knowledge about Decomposition Method
There are different types and applications of Decomposition Method
1. Primal decomposition
2. Dual decomposition
3. Decomposition with constraints
4. More general decomposition structures
5. Rate control
6. Single commodity network ﬂow
For More Details, please refer to http://www.stanford.edu/class/ee364b/notes/decomposition_notes.pdf
Fundamental Theorem of Simulation
Consider two shapes, A and B, where B is a subshape (subset) of A. We want to sample uniformly from inside the shape B. Then we can sample uniformly inside of A, and throw away all samples outside of B, and this will leave us with a uniform sample from within B. (Basis of the AcceptReject algorithm)
The advantage of this method is that we can sample a unknown distribution from a easy distribution. The disadvantage of this method is that it may need to reject many points, which is inefficient.
Inverse each part of partial CDF, the partial CDF is divided by the original CDF, partial range is uniform distribution.
More specific definition of the theorem can be found here.^{[4]}
Matlab code:
close all clear all ii=1; while ii<1000 u=rand y=R*(2*U1) if (1U^2)>=(2*u1)^2 x(ii)=y; ii=ii+1 end
Question 2
Use Acceptance and Rejection Method to sample from f_{X}(x) = b * x^{n} * (1 − x)^{n} , n > 0, 0 < x < 1
Solution: This is a beta distribution, Beta ~
U_{1~Unif[0,1) }
U_{2~Unif[0,1)
}
fx=
The beta distribution maximized at 0.5 with value (1 / 4)^{n}.
So, c = b * (1 / 4)^{n}
Algorithm:
1.Draw U_{1} from U(0,1). U_{2} from U(0,1)
2.If U_{2} < = b * (U_{1})^{n} * (1 − (U_{1}))^{n} / b * (1 / 4)^{n} = (4 * (U_{1}) * (1 − (U_{1})))^{n}
then X=U_1 Else return to step 1.
Discrete Case:
Most discrete random variables do not have a closed form inverse CDF. Also, its CDF is not necessarily onto. This means that not every point in the interval [0,1] has a preimage in the support set of X through the CDF function.
Let X be a discrete random variable where and .
To sample from X, we use the partition method below:
Class 8  Thursday, May 30, 2013
In this lecture, we will discuss algorithms to generate 3 wellknown distributions: Binomial, Geometric and Poisson. For each of these distributions, we will first state its general understanding, probability mass function, expectation and variance. Then, we will derive one or more algorithms to sample from each of these distributions, and implement the algorithms on Matlab.
The Bernoulli distribution
The Bernoulli distribution is a special case of the binomial distribution, where n = 1. X ~ Bin(1, p) has the same meaning as X ~ Ber(p), where p is the probability of success and 1p is the probability of failure (we usually define a variate q, q= 1p). The mean of Bernoulli is p and the variance is p(1p). Bin(n, p), is the distribution of the sum of n independent Bernoulli trials, Bernoulli(p), each with the same probability p, where 0<p<1.
For example, let X be the event that a coin toss results in a "head" with probability p, then X~Bernoulli(p).
P(X=1)= p
P(X=0)= q = 1p
Therefore, P(X=0) + P(X=1) = p + q = 1
Algorithm:
1) Generate
2) If , then x = 1
else x = 0
The answer is:
when
when
3) Repeat as necessary
 Matlab Code
>> p = 0.8 % an arbitrary probability for example >> for i = 1: 100 >> u = rand; >> if u < p >> x(ii) = 1; >> else >> x(ii) = 0; >> end >> end >> hist(x)
The Binomial Distribution
In general, if the random variable X follows the binomial distribution with parameters n and p, we write X ~ Bin(n, p). (Acknowledge: https://en.wikipedia.org/wiki/Binomial_distribution) If X ~ B(n, p), then its pmf is of form:
f(x)=(nCx) p^{x}(1p)^{(nx)}, x=0,1,...n
Or f(x) = (n! / x!(n − x)!) p^{x}(1p)^{(nx)}, x=0,1,...n
Mean (x) = E(x) = np
Variance = np(1 − p)
Generate n uniform random number U_{1},...,U_{n} and let X be the number of U_{i} that are less than or equal to p.
The logic behind this algorithm is that the Binomial Distribution is simply a Bernoulli Trial, with a probability of success of p, repeated n times. Thus, we can sample from the distribution by sampling from n Bernoulli. The sum of these n bernoulli trials will represent one binomial sampling. Thus, in the below example, we are sampling 1000 realizations from 20 Bernoulli random variables. By summing up the rows of the 20 by 1000 matrix that is produced, we are summing up the 20 bernoulli outcomes to produce one binomial sampling. We have 1000 rows, which means we have realizations from 1000 binomial random variables when this sum is done (the output of the sum is a 1 by 1000 sized vector).
To continue with the previous example, let X be the number of heads in a series of n independent coin tosses  where for each toss, the probability of coming up with a head is p  then X~Bin(n, p).
MATLAB tips: to get a pdf f(x), we can use code binornd(N,P). N means number of trials and p is the probability of success. a=[2 3 4],if set a<3, will produce a=[1 0 0]. If you set "a == 3", it will produce [0 1 0]. If a=[2 6 9 10], if set a<4, will produce a=[1 0 0 0], because only the first element (2) is less than 4, meanwhile the rest are greater. So we can use this to get the number which is less than p.
Algorithm for Bernoulli is given as above
Code
>>a=[3 5 8]; >>a<5 ans= 1 0 0 >>rand(20,1000) >>rand(20,1000)<0.4 >>A = sum(rand(20,1000)<0.4) #sum of raws ~ Bin(20 , 0.3) >>hist(A) >>mean(A) Note: `1` in the above code means sum the matrix by column >>sum(sum(rand(20,1000)<0.4)>8)/1000 This is an estimate of Pr[A>8].
remark: a=[2 3 4],if set a<3, will produce a=[1 0 0]. If you set "a == 3", it will produce [0 1 0]. using code to find some value what i want to get from the matrix. It`s useful to define some matrixs.
Relation between Bernoulli Distribution and Binomial Distribution: For instance, we want to find numbers ≤0.3. Uniform collects which is ≤0.3, and Binomial calculates how many numbers are there ≤0.3.
The Geometric Distribution
Geometric distribution is a discrete distribution. There are two types geometric distributions, the first one is the probability distribution of the number of X Bernoulli fail trials, with probability 1p, needed until the first success situation happened, X come from the set { 1, 2, 3, ...}; the other one is the probability distribution of the number Y = X − 1 of failures, with probability 1p, before the first success, Y comes from the set { 0, 1, 2, 3, ... }.
For example,
If the success event showed at the first time, which x=1, then f(x)=p.
If the success event showed at the second time and failed at the first time, which x = 2, then f(x)= p(1p).
If the success event showed at the third time and failed at the first and second time, which x = 3, then f(x)= p(1p)^{2 }. etc.
If the success event showed at the k time and all failed before time k, which implies x = k, then f(k)= p(1p)^{(k1)}
which is,
x Pr
1 P
2 P(1P)
3 P(1P)^{2}
. .
. .
. .
n P(1P)^{(n1)}
Also, the sequence of the outputs of the probability is a geometric sequence.
For example, suppose a die is thrown repeatedly until the first time a "6" appears. This is a question of geometric distribution of the number of times on the set { 1, 2, 3, ... } with p = 1/6.
Generally speaking, if X~G(p) then its pdf is of the form f(x)=(1p)^{(x1)}*p, x=1,2,...
The random variable X is the number of trials required until the first success in a series of independent Bernoulli trials.
Other properties
Probability mass function : P(X=k) = p(1p)^{(k1)}
Tail probability : P(X>n) = (1 − p)^{n}
The CDF : P(X<n) = 1  (1 − p)^{n}
Mean of x = 1/p Var(x) = (1p)/p^2
There are two ways to look at a geometric distribution.
1st Method
We look at the number of trials before the first success. This includes the last trial in which you succeeded. This will be used in our course.
pdf is of form f(x)=>(1p)^{(x1)}*(p), x = 1, 2, 3, ...
2nd Method
This involves modeling the failure before the first success. This does not include the last trial in which we succeeded.
pdf is of form f(x)=> ((1p)^x)*p , x = 0, 1, 2, ....
If Y~Exp(λ) then is geometric.
Choose e^(λ)=1p. Then X ~ geo (p)
P (X > x) = (1p)^{x}(because first x trials are not successful)
NB: An advantage of using this method is that nothing is rejected. We accept all the points, and the method is more efficient. Also, this method is closer to the inverse transform method as nothing is being rejected.
Proof
SInce p = 1 e^{λ} or λ= − log(1 − p)(compare the pdf of exponential distribution and Geometric distribution,we can look at e^{λ} the probability of the fail trial), then
P(X>x) = e^{(λ * x)} = e^{log(1p)*x} = (1p)^{x}
Note that floor(Y)>X > Y >= X+1 (X is an integer)
proof how to use EXP distribution to find P(X>x)=(1p)^x
Suppose X has the exponential distribution with rate parameter λ > 0
the and have geometric distribution on and respectively each with success probability 1 − e^{ − λ}
Proof:
Algorithm:
1) Let λ = − log(1 − p)
2) Generate a Y˜Exp(λ)
3) We can then let
note:
> Y>= X+1
P(Y > = X)
Y ~ Exp (λ)
pdf of Y : λe^{ − λ}
cdf of Y : 1 − e^{ − λ}
cdf P(Y < x) = 1 − e^{ − λx}
P(Y > = x) = 1 − (1 − e^{ − λx}) = e^{ − λx}
e^{ − λ} = 1 − p − > − log(1 − p) = λ
P(Y > = x) = e^{ − λx} = e^{log(1 − p)x} = (1 − p)^{x}
E[x] = 1 / P
Var = (1 − P) / (P^{2})
P(X>x)
=P(floor(y)+1>x)
=P(floor(y)>x1)
=P(y>=x)
use e^{ − λ} = 1 − p to figure out the mean and variance.
Code
>>p=0.4; >>l=log(1p); >>u=rand(1,1000); >>y=(1/l)*log(u); >>x=floor(y)+1; >>hist(x) ===Note:=== mean(x)~E[X]=> 1/p Var(x)~V[X]=> (1p)/p^2 A specific Example: Consider x=5 >> sum(x==5)/1000 > chance that will succeed at fifth trial; >> ans = 0.0780 >> sum(x>10)/1000 > chance that will succeed after 10 trials >> ans = 0.0320
Note that the above mean is the average amount of times you should try until you get a successful case.
EXAMPLE for geometric distribution: Consider the case of rolling a die:
X=the number of rolls that it takes for the number 5 to appear.
We have X ~Geo(1/6), f(x) = (1 / 6) * (5 / 6)^{x − 1}, x=1,2,3....
Now, let => x=floor(Y) +1
Let e^{ − λ} = 5 / 6
P(X > x) = P(Y > = x) (from the class notes)
We have e^{ − λ * x} = (5 / 6)^{x}
Algorithm: let λ = − log(5 / 6)
1) Let Y be e^{λ}, exponentially distributed
2) Set , to generate X
E[x] = 6,Var[X] = 5 / 6 / (1 / 6^{2}) = 30
GENERATING NEGATIVE BINOMIAL RV USING GEOMETRIC RV'S
Property of negative binomial Random Variable:
The negative binomial random variable is a sum of r independent geometric random variables.
Using this property we can formulate the following algorithm:
Step 1: Generate r geometric rv's each with probability p using the procedure presented above.
Step 2: Take the sum of these r geometric rv's. This RV follows NB(r,p)
remark the step 1 and step 2. Looking for the floor Y, and e^(mu)=1p=5/6, and then generate x.
Poisson Distribution
If , its pdf is of the form , where is the rate parameter.
definition:In probability theory and statistics, the Poisson distribution (pronounced [pwasɔ̃]) is a discrete probability distribution that expresses the probability of a given number of events occurring in a fixed interval of time and/or space if these events occur with a known average rate and independently of the time since the last event. The Poisson distribution can also be used for the number of events in other specified intervals such as distance, area or volume. For instance, suppose someone typically gets 4 pieces of mail per day on average. There will be, however, a certain spread: sometimes a little more, sometimes a little less, once in a while nothing at all.[2] Given only the average rate, for a certain period of observation (pieces of mail per day, phonecalls per hour, etc.), and assuming that the process, or mix of processes, that produces the event flow is essentially random, the Poisson distribution specifies how likely it is that the count will be 3, or 5, or 10, or any other number, during one period of observation. That is, it predicts the degree of spread around a known average rate of occurrence. The Derivation of the Poisson distribution section shows the relation with a formal definition.(from Wikipedia)
Understanding of Poisson distribution:
If customers independently come to bank over time, all following exponential distributions with rate λ per unit of time, then X(t) = # of customer in [0,t] ~ Poi(λt)
Its mean and variance are
An useful property: If are independent and , then
A Poisson random variable X can be interpreted as the maximal number of i.i.d. (Independent and Identically Distributed) exponential variables(with parameter λ) whose sum does not exceed 1.
The traditional understanding of the Poisson distribution as the total number of events in a specific interval can be understood here since the above definition simply describes the Poisson as the sum of waiting times for n events in an interval of length 1.
Note: From above, we can use Logarithm Rules log(a) + log(b) = log(ab) to generate the result.
Algorithm:
1) Set n=1, a=1
2) Generate U_{n}˜U(0,1),a = aU_{n}
3) If a > = e^{ − λ} , then n=n+1, and go to Step 2. Else, x=n1
using inversemethod to proof mean and variance of poisson distribution.
MATLAB Code for generating Poisson Distribution
>>l=2; N=1000 >>for ii=1:N n=1; a=1; u=rand; a=a*u; while a>exp(l) n=n+1; u=rand; a=a*u; end x(ii)=n1; end >>hist(x) >>Sum(x==1)/N # Probability of x=1 >>Sum(x>3)/N # Probability of x > 3
Another way to generate random variable from poisson distribution
Note:
Let denote the pmf of .
Then ratio is
Therefore,
Algorithm:
1. Set
2. Set
3. Generate
4. If , output
Else
Go to 4.
This is indeed the inversetransform method, with a clever way to calculate the CDF on the fly.
u=rand(0.1000) hist(x)
Class 9  Tuesday, June 4, 2013
Beta Distribution
The beta distribution is a continuous probability distribution.
PDF:
where and α>0, β>0
Definition:
In probability theory and statistics, the beta distribution is a family of continuous probability distributions defined on the interval [0, 1] parametrized by two positive shape parameters, denoted by α and β, that appear as exponents of the random variable and control the shape of the distribution.
More can be find in the link: ^{[5]}
There are two positive shape parameters in this distribution defined as alpha and beta:
Both parameters are greater than 0, and X is within the interval [0,1].
Alpha is used as exponents of the random variable.
Beta is used to control the shape of the this distribution. We use the beta distribution to build the model of the behavior of random variables, which are limited to intervals of finite length.
For example, we can use the beta distribution to analyze the time allocation of sunshine data and variability of soil properties.
If X~Beta(α,β) then its p.d.f. is of the form
 where and α>0, β>0
and f(x;α,β) = 0 otherwise Note: Γ(α) = (α − 1)! if α is a positive integer.
Note: Gamma Function Properties
If
The mean of the beta distribution is . The variance is The variance of the beta distribution decreases monotonically if α = β and as α = β increases, the variance decreases.
The formula for the cumulative distribution function of the beta distribution is also called the incomplete beta function ratio (commonly denoted by Ix) and is defined as F(x) = I(x)(p,q)
To generate random variables of a Beta distribution, there are multiple cases depending on the value of α and β:
Case 1: If α = 1 and β = 1
 = 1
Note: 0! = 1.
Hence, the distribution is:
If the Question asks for sampling Beta Distribution, we can sample from Uniform Distribution which we already know how to sample from
Algorithm:
Generate U~Unif(0,1)
Case 2: Either α = 1 or β = 1
e.g. α = 1
We don't make any assumption about β except that it is a positive integer.
 β = 1
By integrating f(x), we find the CDF of X is F(x) = x^{α}. As , using the inverse transform method, with U ~ U[0,1].
Algorithm
 1. Generate U~Unif(0,1)
 2. Assign
After we have simplified this example, we can use other distribution methods to solve the problem.
MATLAB Code to generate random n variables using the above algorithm
x = rand(1,n).^(1/alpha)
Case 3:
To sample from beta in general, we use the property that
 if Y_{1} follows gamma (α,1)
 Y_{2} follows gamma (β,1)
Note:
1. α and β are shape parameters here and 1 is the scale parameter.
 then follows Beta (α,β)
2.Exponential:
3.Gamma:
Algorithm
 1. Sample from Y1 ~ Gamma (α,1) α is the shape, and 1 is the scale.
 2. Sample from Y2 ~ Gamma (β,1)
 3. Set
Please see the following example for Matlab code.
Case 4:
Use The AcceptanceRejection Method
The beta density is
where
Assume . Then has the maximum at .
(Please note that we could find the maximum by taking the derivative of f(x), let f'(x)=0 and then use maximum likelihood estimate to find what the maximum value is)
Define
) and choose .
The AR method becomes
1.Generate independent and from until ;
2.Return .
MATLAB Code for generating Beta Distribution
>>Y1 = sum(log(rand(10,1000))) #Gamma(10,1), sum 10 exponentials for each of the 1000 samples >>Y2 = sum(log(rand(5,1000))) #Gamma(5,1), sum 5 exponentials for each of the 1000 samples %NOTE: here, lamda is 1, since the scale parameter for Y1 & Y2 are both 1 >>Y=Y1./(Y1+Y2) #Don't forget to divide elements using "." Where Y follows Beta(10,5) >>figure >>hist(Y1) #Gamma curve >>figure >>hist(Y2) #Gamma curve >>figure >>hist(Y) #Do this to check that the shape fits beta. ~Beta(10,5). >>disttool #Check the beta plot.
This is the histogram of Y, precisely simulated version of Beta (10,5)
This is the pdf of various beta distributions
MATLAB tips: rand(10,1000) produces one 10*1000 matrix and sum(rand(10,1000)) produces a 10*1000 matrix
and each element in the matrix follows CDF of uniform distribution.
Example for the code to explain the beta distribution.
Another MATLAB Code for generating Beta Distribution using AR method
>>alpha = 3 >>beta = 2 >> a = sum (log(rand(alpha,1000))) >> b = sum (log(rand(beta,1000))) >> aandb=sum(log(rand(alpha+beta,1000))) >> t = (alpha  1)/(alpha + beta 2) >> c = (andb/(a*b))*t^(alpha1)*(1t)^(beta1) >> u1 = rand >> u2 = rand >> x = (andb/(a*b))*u1^(alpha1)*(1u1)^(beta1) >> while c*u2>x >> u1 = rand >> u2 = rand >> x = (andb/(a*b))*u1^(alpha1)*(1u1)^(beta1) >> end >> u1
Random Vector Generation
We want to sample from X = (X_{1},X_{2},…,X_{d}), a ddimensional vector from a known pdf f(x) and cdf F(x). We need to take into account the following two cases:
Case 1
if the 's are independent, then
we can sample from each component individually, and then form a vector.
based on the property of independence, we can derive the pdf or pmf of
Case 2
If are not independent
we need to know the conditional distributions of
This is generally a hard problem. Conditional probabilities are not easy to compute, then sampling from these would be based on your statistics knowledge.
In each case, we have to consider the previous cases.
f(x_{1}) is onedimensional, some as f(x_{2}  x_{1}) and all others.
In general, one could consider the covariance matrix C of random variables X_{1},…,X_{d}.
Suppose we now have the Cholesky factor G of C (i.e. C = GG^{T}). In matlab, we use Chol(C)
For any dtuple (i.e random variable generated by respectively)
GX would yield the desired distribution.
Note (Product Rule)
1.) All cases can use this (independent or dependent): f(x) = f(x_{1},x_{2}) = f(x_{1})f(x_{2}  x_{1})
2.) If we determine that x_{1} and x_{2} are independent, then we can use f(x) = f(x_{1},x_{2}) = f(x_{1})f(x_{2})
 ie. If late for class=x_{1} and sick=x_{2}, then these are dependent variables so can only use equation 1 (f(x) = f(x_{1},x_{2}) = f(x_{1})f(x_{2}  x_{1}))
 ie. If late for class=x_{1} and milk is white=x_{2}, then these are independent variables so can use both equations 1 and 2.
the case show the formula of the X = (X1,X2,…,Xd), a ddimensional vector, when they are not independent of each x. we use conditional function to define the probability function of x with ddimensional.
Example
Generate uniform random vectors
1) x = (x_{1}, …, x_{d}) from the ddimensional rectangle
2) D = { (x_{1}, …, x_{d}) : a_{i} <= x_{i} <= b_{i} , i = 1, …, d}
Algorithm:
1) For i = 1 to d
2) U_{i} ~ U(0,1)
3) x_{i} = a_{i} + U(b_{i}a_{i})
4) End
 Note: x_{i} = a_{i} + U(b_{i}a_{i}) denotes X_{i} ~U(a_{i},b_{i})
An example of the 2D case is given below:
>>a=[1 2]; >>b=[4 6]; >>for i=1:2 u(i) = rand(); x(i) = a(i) + (b(i)  a(i))*u(i); end >>hold on => this is to retain current graph when adding new graphs >>rectangle('Position',[1 2 3 4]) => draw the boundary of the rectangle >>axis([0 10 0 10]) => change the size of axes >>plot(x(1),x(2),'.')
Matlab Code:
function x = urectangle (d,n,a,b) for ii = 1:d; u(ii,:) = rand(1,n); x(ii,:) = a+ u(ii,:)*(ba); %keyboard #makes the function stop at this step so you can evaluate the variables end >>x=urectangle(2, 100, 2, 5); >>scatter(x(1,:),x(2,:)) >>x=urectangle(2, 10000, 2, 5); #generate 10000 numbers (instead of 100) >>x=urectangle(3, 10000, 2, 5); #changed to 3dimensional >>scatter3(x(1,:), x(2,:), x(3,:)) >>axis square
Vector AcceptanceRejection Method
The acceptancerejection method can be extended to ndimensional cases, with the same concept:
If a random vector is to be generated uniformly from G, an irregular shape in the nth dimension, and W is a regular shape arbitrarily close to G in the nth dimension, then acceptancerejection method can be applied as follows:
1. Sample from the regular shape W
2. Accept sample points if they are inside G
Example:
Generate a random vector Z that is uniformly distributed over region G
G: ddimensional unit ball,
w: ddimensional hypercube,
Procedure:
Step 1:
Step 2:
Step 3: If
Else go to step 1
it is an example of the vector A/R, regular shape is W likes the proposal distribution g(x), G is the target distribution g(x)
Suppose we sampled from the target area W uniformly, let Aw, Ag indicate the area of W and G, g(x)=1/Aw and f(x)=1/Ag
The following is a picture relating to the example
Matlab code:
u = rand(d,n); z = 1 2 *u; R = sum(z.^2); jj=1; for ii=1:n if R(ii)<=1 x(:,jj)=z(:,ii); jj=jj+1; end end output = x; end
Class 10  Thursday June 6th 2013
MATLAB code for using Acceptance/Rejection Method to sample from a ddimensional unit ball. G: ddimensional unit ball G W: ddimensional Hypercube
1) U1~UNIF(0,1) U2~UNIF(0,1) ... Ud~UNIF(0,1) 2) X1 = 12U1 X2 = 12U2 ... Xd = 12Ud R = sum(Xi^2) 3) If R<=1 X = (X1,X2,...,Xd), else go to step 1
Code:
function output = Unitball(d,n) u = rand(d,n); z = 1 2 *u; R = sum(z.^2); jj=1; for ii=1:n if R(ii)<=1 x(:,jj)=z(:,ii); jj=jj+1; end end output = x; end >> data = Unitball(d, n) >> scatter(data(1,:), data(2,:)) %plot 2d graph R(ii) computes the sum of the square of each element of a vector, so if it is less than 1, then the vector is in the unit ball. x(:,jj) means all the numbers in the jj column. z(:,ii) means all the numbers in the ii column starting from 1st column until the nth column, which is the last one. higher dimension, less efficient and we need more data points Save it with the name of the pattern.
Execution: >>[x]=Unitball(2,10000); >>scatter(x(1,:),x(2,:)); %plot 2D circle >>axis square; %make the xy axis has same size >>size(x) ans = 2 7839 >>scatter(x(1,:),x(2,:))
scatter(x(1,:),x(2,:)) the (x(1,:) means all the numbers in the first row are parameter.
Calculate the efficiency:
>>c=7839/10000 %Efficiency = points accepted / total points c = 0.7839
We can use the above program to calculate how many points in the circle condition are in the square.
Estimate
 We know the radius is 1
 Then the area of the square is (1 − ( − 1))^{2} = 4
 Then the area of the circle is π
 π is approximated to be in the above example
>> 4*size(x,2)/10000 ans = 3.1356 >> [x]=Unitball(3,10000); >> scatter3(x(1,:),x(2,:),x(3,:)) %plot 3d ball >> axis square >> size(x,2)/10000 %returns the size of the dimension of X specified by scalar 2 ans = 0.5231 >> [x]=Unitball(5,10000); >> size(x,2)/10000 ans = 0.1648
3d unit ball
Note that c increases exponentially as d increases, which will result in a lower acceptance rate and more points being rejected. So this method is not efficient for large values of d.
In practice, when we need to vectorlize a high quality image or genes then d would have to be very large. So AR method is not an efficient way to solve the problem.
Efficiency
In the above example, the efficiency of the vector A/R is equal to the ratio
In general, the efficiency can be thought of as the total number of points accepted divided by the total number of points generated.
As the dimension increase, the efficiency of the algorithm will decrease exponentially.
For example, for approximating value of π, when d(dimension) = 2, the efficiency is around 0.7869; when d = 3, the efficiency is around 0.5244; when d = 10, the efficiency is around 0.0026: it is getting close to 0.
A 'C' value of 1 implies an acceptance rate of 100% (most efficient scenario) but as we sample from higher dimensions, 'C' usually gets larger. Thus, when we want to generate high dimension vectors, AcceptanceRejection Method is not efficient to be used.
The end of midterm coverage
Summary of vector acceptancerejection sampling
Problem: f(x_{1},x_{2},...x_{n}) is difficult to sample from
Plan:
Let W represent the sample space covered by f(x_{1},x_{2},...x_{n})
 1.Draw where g has sample space G which is greater than W. g is a distribution that is easy to sample from (i.e. uniform)
 2.if then
else go 1)
x will have the desired distribution.
Stochastic Process
The basic idea of Stochastic Process (also called random process) is a collection of some random variables, , where the set X is called the state space that each variable is in it and T is called the index set.
Definition: In probability theory, a stochastic process /stoʊˈkæstɪk/, or sometimes random process (widely used) is a collection of random variables; this is often used to represent the evolution of some random value, or system, over time. This is the probabilistic counterpart to a deterministic process (or deterministic system). Instead of describing a process which can only evolve in one way (as in the case, for example, of solutions of an ordinary differential equation), in a stochastic or random process there is some indeterminacy: even if the initial condition (or starting point) is known, there are several (often infinitely many) directions in which the process may evolve. (from Wikipedia)
A stochastic process is nondeterministic. This means that even if we know the initial condition(state), and we know some possibilities of the states to follow, the exact value of the final state remains to be uncertain.
We can illustrate this with an example of speech: if "I" is the first word in a sentence, the set of words that could follow would be limited (eg. like, want, am), and the same happens for the third word and so on. The words then have some probabilities among them such that each of them is a random variable, and the sentence would be a collection of random variables.
Also, Different Stochastic Process has different properties.
In the course, we study two Stochastic Process models.
The two stochastic Process models we will study are:
1. Poisson ProcessThis is continuous time counting process that satisfies a couple of properties that are listed in the next section. The Poisson process is understood to be a good model for events such as incoming phone calls, number of traffic accidents, and goals during a game of hockey or soccer. It is also an example of a birthdeath process.
2. Markov Process This is a stochastic process that satisfies the Markov property which can be understood as the memoryless property. The property states that the jump to a future state only depends on the current state of the process, and not of the process's history. This model is used to model random walks exhibited by particles, the health state of a life insurance policyholder, decision making by a memoryless mouse in a maze, etc.
Example
The state space is the set of English words, and x_{t} are words that are said. Another example involves the stock market: the set of all nonnegative numbers is the state space, and x_{t} are stock prices.
stochastic process always has state space and the index set to limit the range.
The state space is the set of cars, while x_{t} are sport cars.
Births in a hospital occur randomly at an average rate
The number of cases of a disease in different towns
Poisson Process
The Poisson process is a discrete counting process which counts the number of
of events and the time that these occur in a given time interval.
e.g traffic accidents , arrival of emails. Emails arrive at random time T_{1},T_{2}...T_{n} for example (2, 7, 3) is the number of emails received on day 1, day 2, day 3. This is a stochastic process and Poisson process with condition.
The probability of observing x events in a given interval is given by P(X = x) = e^{ − λ} * λ^{x} / x! where x = 0; 1; 2; 3; 4; ....
Let N_{t} denote the number of arrivals within the time interval (0,t]
Let N(a,b] denote the number of arrivals in the time interval (a,b]
By definition, N(a,b] = N_{b} − N_{a}
The two random variables N(a,b] and N(c,d] are independent if (a,b] and (c,d] do not intersect.
Definition: An arrival counting process N = (N_{t}) is called (Homogeneous) Poisson Process (PP) with rate λ > 0 if
A. The numbers of points in nonoverlapping intervals are independent.
B. The number of points in interval I(a,b] has a poisson distribution with mean λ(b − a) ,where (ba) represents the length of I.
In particular, observe that if N = (N_{t}) is a Poisson process of rate λ > 0, then the moments are E[N_{t}] = λt and Var[N_{t}] = λt
the rate parameter may change over time; such a process is called a nonhomogeneous Poisson process
Examples
How to generate a multivariate normal with the builtin function "randn": (example)
(please check the general idea at the end of lecture 6 course note.)
z=randn(length(mu),n); %Here length(mu)=2 since s is a 2*2 matrix; s=[1 0.7;0.7 1] A=chol(s)% This only works for a positive definite A, otherwise we need to consider some other form of decomposition x=mu'*ones(1,n) + A*z; %ones(1,n) is a function expand the size of mu from 1*1 %matrix to 1*n matrix;
For example, if we use mu = [2 5], we would get
If we want to use boxmuller to generate a multivariate normal, we could use the code in lecture 6:
d = length(mu); R = chol(Sigma); U1=rand(n,d) U2=rand(d,d) D=2*log(U1) tet=2*pi*U2 Z=(D.^0.5)*cos(tet)' %since in lecture 6, we set up x and y are independent normal %distribution, so in here we can choose either cos and sin X = Z*R + ones(n,1)*mu';
Central Limit Theorem
Theorem: "Given a distribution with mean μ and variance σ², the sampling distribution of the mean approaches a normal distribution with a mean (μ) and a variance σ²/N as N, the sample size, increases". Furthermore, the original distribution can be of any arbitrary shape, the sampling distribution of the mean will approach a normal distribution with a large enough N.^{[6]}
Applying the central limit theorem to simulations, we may revise the definition to be the following: Given certain conditions, the mean of a sufficiently large number of independent random variables, each with a well defined mean and variance, will be approximately normal distributed.(i.e. if we simulate sufficiently many independent observations based on well defined mean and variance, the mean of these observations will follow an approximately normal distribution.)
We illustrate with an example using 1000 observations each of 20 independent exponential random variables.
>> X = exprnd (20,20,1000); % 1000 instances of 20 exponential random numbers with mean 20 >> hist(X(1,:)) >> hist(X(1:2,:)) ... >>hist(X(1:20,:)) > approaches to normal
(The definition of CLT is from http://en.wikipedia.org/wiki/Central_limit_theorem)
Class 11  Tuesday，June 11, 2013
Announcement
Midterm covers up to the middle of last lecture, which means stochastic process will not be on midterm. There won't be any Matlab syntax questions. And Students can contribute to any previous classes. We might however be asked to write down algorithms.
Poisson Process
A Poisson Process is a stochastic approach to count number of events in a certain time period. Strikethrough text
A discrete stochastic variable X is said to have a Poisson distribution with parameter λ > 0 if
 .
where is state space and T is index set.
Properties of Homogeneous Poisson Process
(a) Independence: The numbers of arrivals in nonoverlapping intervals are independent
(b) Homogeneity or Uniformity: The number of arrivals in each interval I(a,b] is Poisson distribution with rate λ(b − a)
(c) Individuality: for a sufficiently short time period of length h, the probability of 2 or more events occurring in the interval is close to 0, or formally
NOTE: it is very important to note that the time between the occurrence of consecutive events (in a Poisson Process) is exponentially distributed with the same parameter as that in the Poisson distribution. This characteristic is used when trying to simulate a Poisson Process.
For a small interval (t,t+h], where h is small
1. The number of arrivals up to time t(N_{t}) is independent of the number of arrival in the interval
2. since when h is small.
λh can be thought of as the probability of observing an arrival in the interval t to t+h.
Similarly, the probability of not observing an arrival in this interval is 1λ h.
Generate a Poisson Process
1. set T_{0} = 0 and n=1
2.
3. (declare an arrival)
4. if stop
else
n=n+1 go to step 2
Since P(N(t,t + h) = 1) = e^{ − λh}λh, we can regard λh as a exponential distribution, and according to what we learnt, .
 Note : Recall that exponential random variable is the waiting time until one event of interested occurs.
Review of Poisson  Example
Let X be the r.v of the number of accidents in an hour, following the Poisson distribution with mean 1.8.
P(X = 0) = e^{ − 1.8}
P(N_{3} > 3  N_{2}) = P(N_{1} > 2)
When we use the inversetransform method, we can assume the poisson process to be an exponential distribution, and get the h function from the inverse method. Sometimes we assume that h is very small.
Multidimensional Poisson Process
The poisson distribution arises as the distribution of counts of occurrences of events in (multidimensional) intervals in multidimensional poisson process in a directly equivalent way to the result for unidimensional processes. This,is D is any region the multidimensional space for which D, the area or volume of the region, is finite, and if N(D) is count of the number of events in D, then
Generating a Homogeneous Poisson Process
Suppose we want to generate the first n events of a Poisson process with rate λ. We showed that the times between successive events are independent exponential random variables, each with rate λ. Therefore, we can first generate n random numbers U_{1}, U_{2},...,U_{n} and use the inverse transform method to find the corresponding exponential variable X_{1}, X_{2},...,X_{n}. Then X_{i} can be interpreted as the time between the (i1)st and the ith event of the process.
The actual time of the jth event is the sum of the first j interarrival times. Therefore, the generated values of the first n event times are , j = 1...n.
Homogeneous poisson process refers to the rate of occurrences remaining constant for all periods of time.
U_{n}~U(0,1)
The waiting time between each occurrence follows the exponential distribution with parameter λ. T_{n} represents the time elapsed at the n^{th} occurence.
1) Set T_{0} = 0 ,and n = 1
2) U_{n} follow U(0,1)
3) T_{n}  T_{n1} = log (U_{n}) (Declare an arrival)
4) if T_{n} >T stop;
else n = n + 1, go to step 2
h is the a range and we assume the probability of every point in this rang is the same by uniform ditribution.(cause h is small) and we test the rang is Tn smaller than T. And log (U_{n})represents that chance that one arrival arrives.
Higher Dimensions:
To sample from higher dimensional Poisson process:
1. Generate a random number N that is Poisson distributed with parameter λ*A_{d}, where A_{d} is the area under the bounded region. (ie A_{2} is area of the region, A_{3} is the volume of the 3d space.
2. Given N=n, generate n random (uniform) points in the region.
At the end, it generates n (cumulative) arrival times, up to time TT.
MatLab Code
T(1)=0; % Matlab does not allow 0 as an index, so we start with T(1). ii=1; l=2; TT=5; while T(ii)<=TT u=rand; ii=ii+1; T(ii)=T(ii1)  (1/l)*log(u); end plot(T, '.')
The following plot is using TT = 50.
The number of points generated every time on average should be λ * TT.
The maximum value of the points should be TT.
when TT be big, the plot of the graph will be linear, when we set the TT be 5 or small number, the plot graph looks like discrete distribution.
Markov chain
"A Markov Chain is a stochastic process where:
1) Each stage has a fixed number of states,
2) the (conditional) probabilities at each stage only depend on the previous state."
Source: "http://math.scu.edu/~cirving/m6_chapter8_notes.pdf"
A Markov Chain is said to be irreducible if for each pair of states i and j there is a positive probability, starting in state i, that the process will ever enter state j.(source:"https://en.wikipedia.org/wiki/Markov_chain")
Markov Chain is the simplification of assumption, for instance, the result of GPA in university depend on the GPA's in high school, middle school, elementary school, etc., but during a job interview after university graduation, the interviewer would most likely to ask about the GPA in university of the interviewee but not the GPA from early years because they assume what happened before are summarized and adequately represented by the information of the GPA earned during university. Therefore, it's not necessary to look back to elementary school. A Markov Chain works the same way, we assume that everything that has occurred earlier in the process is only important for finding out where we are now, the future only depends on the present of where we are now, not the past of how we got here. So the n_{th}random variable would only depend on the n1_{th}term but not all the previous ones. A Markov process exhibits the memoryless property.
Examples of Markov Chain applications in various fields:
 Physics: The movement of a particle (memoryless random walk)
 Finance: The volatility of prices of financial securities or commodities
 Actuarial Science: The pricing and valuation of multiplestate and multiplelives insurance and annuity contracts
 Technology: The Google link analysis algorithm "PageRank"
Definition An irreducible Markov Chain is said to be aperiodic if for some n and some state j.
P * (X_{n} = j  X_{0} = j) > 0 and P * (X_{n + 1}  X_{0} = j) > 0
It can be shown that if the Markov Chain is irreducible and aperiodic then,
Source: From Simulation textbook
Product Rule (Stochastic Process):
In Markov Chain
Concept: The current status of a subject must be relative to the past.However, it will only depend on the previous result only. In other words, if an event occurring tomorrow follows a Markov process it will depend on today and yesterday (the past) is negligible. The past (not including the current state of course) is negligible since its information is believed to have been captured and reflected in the current state.
A Markov Chain is a Stochastic Process for which the distribution of x_{t} depends only on x_{t − 1}.
Given x_{t}, x_{t − 1} and x_{t + 1} are independent. The process of getting x_{n} is drawn as follows. The distribution of x_{n} only depends on the value of x_{n − 1}.
Formal Definition:
The process is a markov chain if:
and
CONTINUOUS TIME MARKOV PROCESS
A continuous time markov process would be one where the time spent in each state is not discrete, but can take
on positive real values. In other words, the index set is the positive real numbers. If the process is homogeneous, then the time spent will have an exponential distribution. In this case we will have a transition rate matrix that captures the rate at which we move between two states. An example will be the homogeneous Poisson process.
Transition Matrix
Transition Probability: P_{ij} = P(X_{t + 1} = j  X_{t} = i) is the onestep transition probability from state i to state j.
Transition Probability: P_{ij}(k) = P(X_{t + 1}(k) = j  X_{t}(k) = i) is the kstep transition probability from state i to state j.
The matrix P whose elements are transition Probabilities P_{ij} is a onestep transition matrix.
Example:
Note: Column 1 corresponds to the state at time t and Column 2 corresponds to the state at time t+1.
The above matrix can be drawn into a state transition diagram
Properties of Transition Matrix:
1.
2. which means the rows of P should sum to 1.
Remark: in general. If equality holds, the matrix is called a doubly stochastic matrix.
In general, one would consider a (finite) set of elements Ω such that:
, the probability of the next state is given according to the distribution
This means our model can be simulated as a sequence of random variables with state space Ω and transition matrix P = [P_{ij}] where
we have to following property (Markov property):
And
Moreover if
(i.e Any two states can be translated somehow)
Then one might consider the periodicity of the chain and derive a notion of cyclic behavior.
Examples of Transition Matrix
The picture is from http://www.google.ca/imgres?imgurl=http://academic.uprm.edu/wrolke/esma6789/graphs/mark13.png&imgrefurl=http://academic.uprm.edu/wrolke/esma6789/mark1.htm&h=274&w=406&sz=5&tbnid=6A8GGaxoPux9kM:&tbnh=83&tbnw=123&prev=/search%3Fq%3Dtransition%2Bmatrix%26tbm%3Disch%26tbo%3Du&zoom=1&q=transition+matrix&usg=__hZR1Cp6PbZ5PfnSjs2zU6LnCiI=&docid=PaQvi1F97P2urM&sa=X&ei=foTxUY3DBrMyQGvq4D4Cg&sqi=2&ved=0CDYQ9QEwAQ&dur=5515)
1.There are four states: 0,1,2, and 3.
Each row adds up to 1, and all the entries are between 0 and 1(since the transition probability is always between 0 and 1).
This matrix means that
 at state 0, can only go to state 1, since probability is 1.
 at state 1, can go to state 0 with a probability of 1/3 and state 2 with a probability of 2/3
 at state 2, can go to state 1 with a probability of 2/3 and state 3 with a probability of 1/3
 at state 3, can only go to state 2, since probability is 1.
2. Consider a Markov chain with state space {0, 1} and transition matrix . Assuming that the chain starts in state 0 at time n = 0, what is the probability that it is in state 1 at time n = 2?
Class 12  Thursday，June 13, 2013
Time Jun 17, 2013 2:30 PM  3:30 PM
Midterm Review
Multiplicative Congruential Algorithm
A Linear Congruential Generator (LCG) yields a sequence of randomized numbers calculated with a linear equation. The method represents one of the oldest and bestknown pseudorandom number generator algorithms.[1] The theory behind them is easy to understand, and they are easily implemented and fast, especially on computer hardware which can provide modulo arithmetic by storagebit truncation.
from wikipedia
Where a, c, m and x_{1} (the seed) are values we must chose before running the algorithm. While there is no set value for each, it is best for m to be large and prime. For example, Matlab uses a = 75,b = 0,m = 231 − 1.
Examples:
1.
... and so on
2.
... and so on
Inverse Transformation Method
For continuous cases:
1. U~U(0,1)
2. X=F^{1}(u)
Note:
In Uniform Distribution P(X < = a) = a
proof:P(X < = x) = P(F^{ − 1}(u) < = x) = P(u < = F(x)) = F(x)
For discrete cases:
1. U~U(0,1)
2. x=x_{i} if F(x_{i1}) < uF(x_{i})
AcceptanceRejection Method
cg(x)>=f(x)
is the efficiency of the method/probability of acceptance
1. Y~g(x)
2. U~U(0,1)
3. If then X=Y
else go to step 1
Proof that this method generates the desired distribution:
Multivariate
f(x_{1},....,x_{n})=f(x_{1})f(x_{2}x_{1})...f(x_{n}x_{n1},...x_{1}) in general we need knowledge of conditional distribution if x_{1}....x_{n} are independent i.e. f(x_{1}...x_{n})=f(x_{1})f(x_{2})...f(x_{n})
Vector A/R Method
This method is not efficient for high dimensional vectors
 Sample uniformly from a space W that contains the sample space G of interest
 Accept if the point is inside G
Steps:
1. Sample uniformly from W
g(x)=, where A_{W} is the area of W.
f(x)=, where A_{G} is the area of G.
2. If the point is inside G, accept the point. Else, reject and repeat step 1.
 = is the efficiency of the algorithm. That is the amount of points accepted over the amount of points rejected. This acceptance rate drops greatly for each dimension added.
Note that decreases exponentially as the dimensional goes up, thus its not efficient for for high dimensional.
Common distribution
Exponential
Models the waiting time until the first success.
Normal
BoxMuller method
1.
2.
3.
To obtain any normal distribution X once a set of standard normal samples Z is generated, apply the following transformations:
In the multivariate case,
Note: Σ^{1 / 2} can be obtained from Cholesky decomposition (chol(A) in MATLAB), which is guaranteed to exist, as Σ is positive semidefinite.
Gamma
Gamma(t,λ)
t: The number of exponentials and the shape parameter
λ: The mean of the exponentials and the scale parameter
Also, Gamma(t,λ) can be expressed into a summation of t exp(λ).
This is a special property of gamma distribution.
Bernoulli
A Bernoulli random variable can only take two possible values: 0 and 1. 1 represents "success" and 0 represents "failure." If p is the probability of success, we have pdf
To generate a Bernoulli random variable we use the following procedure:
where 1 stands for success and 0 stands for failure.
Binomial
The sum of n independent Bernoulli trials
1.
2. ,where is an indicator for a successful trial.
Return to 1
I is an indicator variable if for
Repeat this N times if you need N samples.
The theory behind the algorithm is the fact that the sum of n independent and identically distributed Bernoulli trials, Ber(p), follows a binomial Bin(n,p) distribution.
Example:
Suppose rolling a die, success= lands on 5, fail ow
p=1/6, 1p=5/6, rolling for 10 times, n=10
simulate this binomial distribution.
1) Generate
2)
3)Return to 1)
Beta Distribution
where and α>0, β>0
and
f(x;α,β) = 0 otherwise
Gamma Distribution
Algorithm
 1. Sample from Y1 ~ Gamma (α,1) where α is the shape, and 1 is the scale.
 2. Sample from Y2 ~ Gamma (β,1) where α is the shape, and 1 is the scale.
 3. Set Then Y ~ β(α,β), where we suppose α,β are integers.
Geometric
This distribution models the number of failures before the first success.
X~Geo(p)
f(x) = p * (1 − p)^{x − 1},x = 1,2,........
If Y~Exp(λ) where λ = − log(1 − p)
then X = floor[Y] + 1 is Geo(p)
Proof:
F(x) = P(X < = x)
= 1 − P(X > x)
= 1 − P(floor[Y] + 1 > x) as floor[Y] + 1 > x implies for all realvalued Y
= 1 − P(Y > = x)
= 1 − (1 − P(Y < x))
= 1 − e^{ − λ * x}
= 1 − (1 − p)^{x}, which is the CDF of Geo(p)
The above method can also be viewed with the inverse method since it is not rejecting any points. The following uses inverse method to generate Geo(p).
F(x) = 1 − P(X > x)
since P(X > x) = (1 − p)^{x}
y = 1 − (1 − p)^{x}
y − 1 = − (1 − p)^{x}
1 − y = (1 − p)^{x}
1 − y = (e^{ − λ})^{x} = e^{ − λ * x} since 1 − p = e^{ − λ}
log(1 − y) = − λ * x
x = − 1 / (λ) * log(1 − y)
F^{ − }1(x) = − 1 / (λ) * log(1 − x)
Algorithm:
1. Generate U ~ U(0,1)
2. Generate Y = − 1 / (λ) * log(1 − u) where
3. Set X = [Y] + 1
Note:
If X~Unif (0,1), Y= floor(3X) = [3X]> Y ~ DU[0,2] (DU means discrete uniform)
If X~Unif (0,1), Y= floor(5U)2 = [5U]2 > Y~ DU[2,2]
There is also another intuitive method:
1. Draw U ~ U(0,1)
2. i = 1, Pi = 1  (1  P)^i.
3. If u <= Pi = 1  (1  P)^i, set X = i.
Else, i = i + 1.
Poisson
This distribution models the number of times and event occurs in a given time period
X~Poi(λ)
X is the maximum number of iid Exp(λ) whose sum is less than or equal to 1.
Algorithm
 1. Set n=1, a=1
 2. U_{n} ~ U[0,1] and set a = aU_{n}
 3. If then: n=n+1 and go to Step 2. Else set X=n1.
An alternate way to write an algorithm for Poisson is as followings:
1) x = 0, F = P(X=0) = e^λ = p
2) Generate U ~ U(0,1)
3) If U < F, then output x
4) Else p = (λ/(x+1)) * p
F = F + p
x = x+1
5) else go to step 2
Acknowledgments: from Spring 2012 stat 340 coursenotes
Class 13  Tuesday June 18th 2013
Markov Chain
NStep Transition Matrix: a matrix P_{n} whose elements are the probability of moving from state i to state j in n steps.
P_{n}(i,j) = Pr(X_{m + n} = j  X_{m} = i)
Explanation: (with an example) Suppose there 10 states { 1, 2, ..., 10}, and suppose you are on state 2, then P_{8}(2, 5) represent the probability of moving from state 2 to state 5 in 8 steps.
Onestep transition probability:
The probability of X_{n+1} being in state j given that X_{n} is in state i is called the
onestep transition probability and is denoted by P_{i,j}^{n,n+1}. That is
P_{i,j}^{n,n+1} = Pr(X_{n+1} =j/X_{n} =i)
Example from previous class:
The two step transition probability matrix is:
==
Interpretation:
 If at time 0 we are in state 1, then the probability of us being in state 1 at time 2 is 0.55 and 0.45 for state 2.
 If at time 0 we are in state 2, then the probability of us being in state 1 at time 2 is 0.3 and 0.7 for state 2.
P_{2} = P_{1}P_{1}
P_{3} = P_{1}P_{2}
P_{n} = P_{1}P_{(}n − 1)
The twostep transition probability of moving from state a to state a:
P_{2}(a,a) = Pr(X_{m + 2} = a  X_{m} = a) = Pr(X_{m + 1} = a  X_{m} = a)Pr(X_{m + 2} = a  X_{m + 1} = a) + Pr(X_{m + 1} = b  X_{m} = a)Pr(X_{m + 2} = a  X_{m + 1} = b)
= 0.7(0.7) + 0.3(0.2) = 0.55
Another Example:
The two step transition probability matrix is:
==
This is the twostep transition matrix.
nstep transition matrix
The elements of matrix P_{n} （i.e. the ij_{th} entry P_{ij}) is the probability of moving to state j from state i in n steps
In general P_{n} = P^{n} with and
∑  P_{n}(i,j) = 1 
j 
Note:
The equation above is a special case of the ChapmanKolmogorov equations.
It is true because of the Markov property or the memoryless property of Markov chains, where the probabilities of going forward to the next state
only depends on your current state, not your previous states. By intuition, we can multiply the 1step transition
matrix ntimes to get a nstep transition matrix.
Example: We can see how P_{n} = P^{n} from the following:
Therefore,
P_{n}(i,j) is called nsteps transition probability.
is called the initial distribution.
Example with Markov Chain: Consider a twostate Markov chain {X_{t};t = 0,1,2,...} with states {1,2} and transition probability matrix
Given X_{0} = 1. Compute the following:
a)P(X_{1} = 1  X_{0} = 1) = P(1,1) = 1 / 2
b)P(X_{2} = 1,X_{1} = 1  X_{0} = 1) = P(X_{2} = 1  X_{1} = 1) * P(X_{1} = 1  X_{0} = 1) = 1 / 2 * 1 / 2 = 1 / 4
c)P(X_{2} = 1  X_{0} = 1) = P_{2}(1,1) = 5 / 12
d)
Marginal Distribution of Markov Chain
We represent the probability of all states at time t with a vector
where is the probability of being on state 1 at time t.
and in general, shows the probability of being on state i at time t.
For example, if there are two states a and b, then =(0.1, 0.9) means that the chance of being in state a at time 5 is 0.1 and the chance of being on state b at time 5 is 0.9.
If we generate a chain for many times, the frequency of states at each time shows marginal distribution of the chain at that time.
The vector is called the initial distribution.
(as verified above)
In general,
(P multiplied n times)
where μ_{0} is the initial distribution,
and
N can be negative, if P is invertible.
0 a a b a
1 a b a a
2 b a a b
3 b a b b
4 a a a b
5 a b b a
if we simulate a chain many times, frequency of states at time t show the marginal distribution at time t
Marginal Distribution
In general,
Property: If (for any t less than n), then we say P does not converge.
Stationary Distribution
π is stationary distribution of the chain if πP = π In other words, a stationary distribution is when the markov process that have equal probability of moving to other states as its previous move.
where π is a probability vector π=(π_{i}  ) such that all the entries are nonnegative and sum to 1. It is the eigenvector in this case.
In other words, if X_{0} is draw from π. Then marginally, X_{n} is also drawn from the same distribution π for every n≥0.
The above conditions are used to find the stationary distribution
In matlab, we could use P^{n} to find the stationary distribution.(n is usually larger than 100)
Comments:
As n gets bigger and bigger, μ_{n} will possibly stop changing, so the quantity π _{i} can also be interpreted as the limiting probability that the chain is in the state j
Comments:
1. π may not exist and even if it exists, it may not always be unique.
2. If π exists and is unique, then π_{i} is called the longrun proportion of the process in state i and the stationary distribution is also the limiting distribution of the process.
How long do you have to wait until you reach a steady sate? Ans: There is not clear way to find that out
How do you increase the time it takes to reach the steady state? Ans: Make the probabilities of transition much smaller, to reach from state 0 to state 1 and viceversa p=0.005. And make the probabilities of staying in the same state extremely high. To stay in state 0 or state 1 p=0.995, then the matrix is in a "sticky state"
EXAMPLE : Random Walk on the cycle S={0,1,2}
Suppose
Thus
so
MatLab Code
In Matlab, you can find the stationary distribution by: >> p=[.7 .3;.2 .8] % Input the matrix P p = 0.7000 0.3000 0.2000 0.8000 >> p^2 % one state to another state by 2 steps transition ans = 0.5500 0.4500 0.3000 0.7000 >> mu=[.9 .1] mu = 0.9000 0.1000 >> mu*p % enter mu=mu*P, repeat multiple times until the value of the vector mu remains unchanged ans = 0.6500 0.3500 >> mu=mu*p mu = 0.4002 0.5998 >> mu=mu*p %The vector mu will be your stationary distribution mu = 0.4000 0.6000 >> p^100 % it is limiting distribution of chain which finally gives a stable matrix ans = 0.4000 0.6000 0.4000 0.6000
The definition of stationary distribution is that π is the stationary distribution of the chain if , where π is a probability vector. For every n > = 0.
However, just because X_{n} ~ π for every n > = 0 does not mean every state is independently identically distributed.
Limiting distribution of the chain refers the transition matrix that reaches the stationary state. If the lim(n> infinite)P^n > c, where c is a constant, then, we say this Markov chain is coverage; otherwise, it's not coverage.
Example: Find the stationary distribution of P=
Solution:
Using the stationary distribution property we get,
And since π is a probability vector,
Solving the 4 equations for the 3 unknowns gets,
, , and
Therefore
Example 2: Find the stationary distribution of P=
Solution:
Using the stationary distribution property we get,
And since π is a probability vector,
Solving the 4 equations for the 3 unknowns gets,
, , and
Therefore
The above two examples are designed to solve for the stationary distribution of the matrix P however they also give us the limiting distribution of the matrices as we have mentioned earlier that the stationary distribution is equivalent to the limiting distribution.
Alternate Method of Computing the Stationary Distribution
Recall that if λv = Av, then λ is the eigenvalue of A corresponding to the eigenvector v
By definition of stationary distribution, π = πP
Taking the transpose, π^{T} = (πP)^{T}
then
So π^{T} is an eigenvector of P^{T} with corresponding eigenvalue 1.
the transpose method to calculate the pi matrix probability.
It is thus possible to compute the stationary distribution by taking the eigenvector of the transpose of the transition matrix corresponding to 1, and normalize it such that all elements are nonnegative and sum to one so that the elements satisfy the definition of a stationary distribution. The transformed vector is still an eigenvector since a linear transformation of an eigenvector is still within the eigenspace. Taking the transpose of this transformed eigenvector gives the stationary distribution.
Generating Random Initial distribution
Doubly Stochastic Matrices
We say that the transition matrix is doubly stochastic if both rows and columns sum to 1, i.e.,
It is easy to show that the stationary distribution of an nxn doubly stochastic matrix P is:
Properties of Markov Chain
A Markov chain is a random process usually characterized as memoryless: the next state depends only on the current state and not on the sequence of events that preceded it. This specific kind of "memorylessness" is called the Markov property. Markov chains have many applications as statistical models of realworld processes.
1. Reducibility
State j is said to be accessible from State i (written ) if a system started in State i has a nonzero probability of transitioning into State j at some point. Formally, State j is accessible from State i if there exists an integer such that
This integer is allowed to be different for each pair of states, hence the subscripts in n_{ij}. By allowing n to be zero, every state is defined to be accessible from itself.
2. Periodicity
State i has period k if any return to State i must occur in multiples of k time steps. Formally, the period of a state is defined as
3. Recurrence
State i is said to be transient if, given that we start in State i, there is a nonzero probability that we will never return to i. Formally, let the random variable T_{i} be the first return time to State i (the "hitting time"):
(The properties are from http://www2.math.uu.se/~takis/L/McRw/mcrw.pdf)
CHAPMANKOLMOGOROV EQUATION For all n and m, and any state i and j,
Class 14  Thursday June 20th 2013
Example: Find the stationary distribution of
Solve the system of linear equations to find a stationary distribution
Note that looks similar to eigenvectors/values
π can be considered as an eigenvector of P with eigenvalue = 1. But note that the vector vecu is a column vector and o we need to transform our π into a column vector.
= > π^{T}= P^{T}π^{T}
Then π^{T} is an eigenvector of P^{T} with eigenvalue = 1.
MatLab tips:[V D]=eig(A), where D is a diagonal matrix of eigenvalues and V is a matrix of eigenvectors of matrix A
MatLab Code
P = [1/3 1/3 1/3; 1/4 3/4 0; 1/2 0 1/2] pii = [1/3 4/9 2/9] [vec val] = eig(P') %% P' is the transpose of matrix P vec(:,1) = [0.5571 0.7428 0.3714] %% this is in column form a = vec(:,1) >> a = [0.5571 0.7428 0.3714] %% a is in column form %% Since we want this vector a to sum to 1, we have to scale it b = a/sum(a) >> b = [0.3333 0.4444 0.2222] %% b is also in column form %% Observe that b' = pii
</br>
Limiting distribution
A Markov chain has limiting distribution π if
That is exists and is independent of i.
A Markov Chain is convergent if and only if its limiting distribution exists.
If the limiting distribution π exists, it must be equal to the stationary distribution.
This convergence means that,in the long run(n to infinity),the probability of finding the
Markov chain in state j is approximately π_{j} no matter in which state
the chain began at time 0.
Example:
For a transition matrix
, find stationary distribution.
We have:
this gives
However, there does not exist a limiting distribution. π is stationary but is not limiting.
In general, there are chains with stationery distributions that don't converge, this means that they have stationary distribution but are not limiting.
MatLab Code
MATLAB >> P=[0, 1, 0;0, 0, 1; 1, 0, 0] P = 0 1 0 0 0 1 1 0 0 >> pii=[1/3, 1/3, 1/3] pii = 0.3333 0.3333 0.3333 >> pii*P ans = 0.3333 0.3333 0.3333 >> P^1000 ans = 0 1 0 0 0 1 1 0 0 >> P^10000 ans = 0 1 0 0 0 1 1 0 0 >> P^10002 ans = 1 0 0 0 1 0 0 0 1 >> P^10003 ans = 0 1 0 0 0 1 1 0 0 >> %P^10000 = P^10003 >> % This chain does not have limiting distribution, it has a stationary distribution. This chain does not converge, it has a cycle.
The first condition of limiting distribution is satisfied; however, the second condition where π_{j} has to be independent of i (i.e. all rows of the matrix are the same) is not met.
This example shows the distinction between having a stationary distribution and convergence(having a limiting distribution).Note: π = (1 / 3,1 / 3,1 / 3) is the stationary distribution as π = π * p. However, upon repeatedly multiplying P by itself (repeating the step P^{n} as n goes to infinite) one will note that the results become a cycle (of period 3) of the same sequence of matrices. The chain has a stationary distribution, but does not converge to it. Thus, there is no limiting distribution.
Example:
This chain converges but is not a limiting distribution as the rows are not the same and it doesn't converge to the stationary distribution.
Double Stichastic Matrix: a double stichastic matrix is a matrix whose all colums sum to 1 and all rows sum to 1.
If a given transition matrix is a double stichastic matrix with n colums and n rows, then the stationary distribution matrix has all
elements equals to 1/n.
Example:
For a stansition matrix ,
We have:
π_{0} + π_{1} + π_{2} = 1
The stationary distribution is
The following contents are problematic. Please correct it if possible.
Suppose we're given that the limiting distribution π exists for stochastic matrix P, that is,
WLOG assume P is diagonalizable, (if not we can always consider the Jordan form and the computation below is exactly the same.
Let P = UΣU^{ − 1} be the eigenvalue decomposition of P, where
Suppose where and u_{i} are eigenvectors of P for
By definition:
Therefore since .
Therefore
MatLab Code
>> P=[1/3, 1/3, 1/3; 1/4, 3/4, 0; 1/2, 0, 1/2] % We input a matrix P. This is the same matrix as last class. P = 0.3333 0.3333 0.3333 0.2500 0.7500 0 0.5000 0 0.5000 >> P^2 ans = 0.3611 0.3611 0.2778 0.2708 0.6458 0.0833 0.4167 0.1667 0.4167 >> P^3 ans = 0.3495 0.3912 0.2593 0.2934 0.5747 0.1319 0.3889 0.2639 0.3472 >> P^10 The example of code and an example of stand distribution, then the all the pi probability in the matrix are the same. ans = 0.3341 0.4419 0.2240 0.3314 0.4507 0.2179 0.3360 0.4358 0.2282 >> P^100 % The stationary distribution is [0.3333 0.4444 0.2222] since values keep unchanged. ans = 0.3333 0.4444 0.2222 0.3333 0.4444 0.2222 0.3333 0.4444 0.2222 >> [vec val]=eigs(P') % We can find the eigenvalues and eigenvectors from the transpose of matrix P. vec = 0.5571 0.2447 0.8121 0.7428 0.7969 0.3324 0.3714 0.5523 0.4797 val = 1.0000 0 0 0 0.6477 0 0 0 0.0643 >> a=vec(:,1) % The eigenvectors can be mutiplied by (1) since λV=AV can be written as λ(V)=A(V) a = 0.5571 0.7428 0.3714 >> sum(a) ans = 1.6713 >> a/sum(a) ans = 0.3333 0.4444 0.2222
This is π_{j} = lim[p^{n}]_{(}ij) exist and is independent of i
Another example:
Find the stationary distribution of P=
π = [π_{0}, π_{1}, π_{2}]
The system of equations is:
0.5π_{0} + 1π_{1} + 0π_{2} = π_{0} = > 2π_{1} = π_{0}
0π_{0} + 0π_{1} + 1π_{2} = π_{1} = > π_{1} = π_{2}
0π_{0} + 0.5π_{1} + 0.5π_{2} = π_{2} = > π_{1} = π_{2}
π_{0} + π_{1} + π_{2} = 1
2π_{1} + π_{1} + π_{1} = 4π_{1} = 1, which gives
Also,
So,
Ergodic Chain
A Markov chain is called an ergodic chain if it is possible to go from every state to every state (not necessarily in one move). For instance, note that we can claim a Markov chain is ergodic if it is possible to somehow start at any state i and end at any state j in the matrix. We could have a chain with states 0, 1, 2, 3, 4 where it is not possible to go from state 0 to state 4 in just one step. However, it may be possible to go from 0 to 1, then from 1 to 2, then from 2 to 3, and finally 3 to 4 so we can claim that it is possible to go from 0 to 4 and this would satisfy a requirement of an ergodic chain. The example below will further explain this concept.
Note:if there's a finite number N then every other state can be reached in N steps.
Note:Also note that a Ergodic chain is irreducible (all states communicate) and aperiodic (d = 1). An Ergodic chain is promised to have a stationary and limiting distribution.
Ergodicity: A state i is said to be ergodic if it is aperiodic and positive recurrent. In other words, a state i is ergodic if it is recurrent, has a period of 1 and it has finite mean recurrence time. If all states in an irreducible Markov chain are ergodic, then the chain is said to be ergodic.
Some more:It can be shown that a finite state irreducible Markov chain is ergodic if it has an aperiodic state. A model has the ergodic property if there's a finite number N such that any state can be reached from any other state in exactly N steps. In case of a fully connected transition matrix where all transitions have a nonzero probability, this condition is fulfilled with N=1.
Example
There are three states in this example.
In this case, state a can go to state a, b, or c; state b can go to state a, b, or c; and state c can go to state a, b, or c so it is possible to go from every state to every state. (Although state b cannot directly go into c in one move, it must go to a, and then to c.).
A kbyk matrix indicates that the chain has k states.
 Ergodic Markov chains are irreducible.
 A Markov chain is called a regular chain if some power of the transition matrix has only positive elements.
 Any transition matrix that has no zeros determines a regular Markov chain
 However, it is possible for a regular Markov chain to have a transition matrix that has zeros.
For example, recall the matrix of the Land of Oz
Theorem
An ergodic Markov chain has a unique stationary distribution π. The limiting distribution exists and is equal to π
Note: Ergodic Markov Chain is irreducible, aperiodic and positive recurrent.
Example: Consider the markov chain of , the stationary distribution is obtained by solving πP = π, getting π = [0.5,0.5], but from the assignment we know that it does not converge, ie. there is no limiting distribution, because the Markov chain is not aperiodic and cycle repeats and
Another Example
This matrix means that there are two points in the space, let's call them a and b
Starting from a, the probability of staying in a is 1/4
Starting from a, the probability of going from a to b is 3/4
Starting from b, the probability of going from b to a is 1/5
Starting from b, the probability of staying in b is 4/5
Solve the equation π = πP
π_{0} = .25π_{0} + .2π_{1}
π_{1} = .75π_{0} + .8π_{1}
π_{0} + π_{1} = 1
Solving this system of equations we get:
π is the long run distribution, and this is also a limiting distribution.
We can use the stationary distribution to compute the expected waiting time to return to state 'a'
given that we start at state 'a' and so on.. Formula for this will be :
In the example above this will mean that that expected waiting time for the markov process to return to
state 'a' given that we start at state 'a' is 19/4.
definition of limiting distribution: when the stationary distribution is convergent, it is a limiting distribution.
remark：satisfied balance of π_{i}P_{ij} = P_{ji}π_{j}, so there is other way to calculate the step probability.
MatLab Code
In the following, P is the transition matrix. eye(n) refers to the n by n Identity matrix. L is the Laplacian matrix, L = (I  P). The Laplacian matrix will have at least 1 zero Eigenvalue. For every 0 in the diagonal, there is a component. If there is exactly 1 zero Eigenvalue, then the matrix is connected and has only 1 component. The number of zeros in the Laplacian matrix is the number of parts in your graph/process. If there is more than one zero on the diagonal of this matrix, means there is a disconnect in the graph.
>> P=[1/3, 1/3, 1/3; 1/4, 3/4, 0; 1/2, 0, 1/2] P = 0.3333 0.3333 0.3333 0.2500 0.7500 0 0.5000 0 0.5000 >> eye(3) %%returns 3x3 identity matrix ans = 1 0 0 0 1 0 0 0 1 >> L=(eye(3)P) L = 0.6667 0.3333 0.3333 0.2500 0.2500 0 0.5000 0 0.5000 >> [vec val]=eigs(L) vec = 0.7295 0.2329 0.5774 0.2239 0.5690 0.5774 0.6463 0.7887 0.5774 val = 1.0643 0 0 0 0.3523 0 0 0 0.0000 %% Only one value of zero on the diagonal means the chain is connected >> P=[0.8, 0.2, 0, 0;0.2, 0.8, 0, 0; 0, 0, 0.8, 0.2; 0, 0, 0.1, 0.9] P = 0.8000 0.2000 0 0 0.2000 0.8000 0 0 0 0 0.8000 0.2000 0 0 0.1000 0.9000 >> eye(4) ans = 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 >> L=(eye(4)P) L = 0.2000 0.2000 0 0 0.2000 0.2000 0 0 0 0 0.2000 0.2000 0 0 0.1000 0.1000 >> [vec val]=eigs(L) vec = 0.7071 0 0.7071 0 0.7071 0 0.7071 0 0 0.8944 0 0.7071 0 0.4472 0 0.7071 val = 0.4000 0 0 0 0 0.3000 0 0 0 0 0.0000 0 0 0 0 0.0000 %% Two values of zero on the diagonal means there are two 'islands' of chains
Π satisfies detailed balance if Π_{i}P_{ij} = P_{ji}Π_{j}. Detailed balance guarantees that Π is stationary distribution.
Adjacency matrix  a matrix A that dictates which states are connected and way of portraying which vertices in the matrix are adjacent. Two vertices are adjacent if there exists a path between them of length 1.If we compute A^{2}, we can know which states are connected with paths of length 2.
A Markov chain is called an irreducible chain if it is possible to go from every state to every state (not necessary in one more).
Theorem: An ergodic Markov chain has a unique stationary distribution π. The limiting distribution exists and is equal to π.
Markov process satisfies detailed balance if and only if it is a reversible Markov process
where P is the matrix of Markov transition.
Satisfying the detailed balance condition guarantees that π is stationary distributed.
π satisfies detailed balance if π_{i}P_{ij} = P_{ji}π_{j}
which is the same as the Markov process equation.
Example in the class:
and
Remark：Detailed balance of ， so there is other way to calculate the step probability
π is stationary but is not limiting.
Detailed balance implies that π = π * P as shown in the proof and guarantees that π is stationary distribution.
Class 15  Tuesday June 25th 2013
Announcement
Note to all students, the first half of today's lecture will cover the midterm's solution; however please do not post the solution on the Wikicoursenote.
Detailed balance
Definition (from wikipedia) The principle of detailed balance is formulated for kinetic systems which are decomposed into elementary processes (collisions, or steps, or elementary reactions): At equilibrium, each elementary process should be equilibrated by its reverse process.
Let P be the transition probability matrix of a Markov chain. If there exists a distribution vector π such that , then the Markov chain is said to have detailed balance. A detailed balanced Markov chain must have π given above as a stationary distribution, that is π = πP, where π is a 1 by n matrix and P is a n by n matrix.
need to remember：
Proof:
 Note: Since π_{j} is a sum of column j and we can do this proof for every element in matrix P; in general, we can prove π = πP
Hence π is always a stationary distribution of P(X_{n + 1} = j  X_{n} = i), for every n.
In other terms, P_{ij} = P(X_{n} = j  X_{n − 1} = i), where π_{j} is the equilibrium probability of being in state j and π_{i} is the equilibrium probability of being in state i. P(X_{n − 1} = i) = π_{i} is equivalent to P(X_{n − 1} = i,Xn = j) being symmetric in i and j.
Keep in mind that the detailed balance is a sufficient but not required condition for a distribution to be stationary. i.e. A distribution satisfying the detailed balance is stationary, but a stationary distribution does not necessarily satisfy the detailed balance.
In the stationary distribution π = πP, in the proof the sum of the p is equal 1 so the πP = π.
PageRank (http://en.wikipedia.org/wiki/PageRank)
 PageRank is a probability distribution used to represent the likelihood that a person randomly clicking on links will arrive at any particular page. PageRank can be calculated for collections of documents of any size.
 PageRank is a linkanalysis algorithm developed by and named after Larry Page from Google; used for measuring a website's importance, relevance and popularity.
 PageRank is a graph containing web pages and their links to each other.
 Many social media sites use this (such as Facebook and Twitter)
 It can also be used to find criminals (ie. theives, hackers, terrorists, etc.) by finding out the links.
This is what made Google the search engine of choice over Yahoo, Bing, etc. What made Google's search engine a huge success is not its search function, but rather the algorithm it used to rank the pages. (Ex. If we come up with 100 million search results, how do you list them by relevance and importance so the users can easily find what they are looking for. Most users will not go past the first 3 or so search pages to find what they are looking for. It is this ability to rank pages that allow Google to remain more popular than Yahoo, Bink, AskJeeves, etc.). It should be noted that after using the PageRank algorithm, Google uses other processes to filter results.
The order of importance
1. A web page is more important if many other pages point to it
2. The more important a web page is, the more weight should be assigned to its outgoing links
3. If a webpage has many outgoing links, then its links have less value (ex: if a page links to everyone, like 411, it is not as important as pages that have incoming links)
The first row indicates who gives a link to 1. As shown in the diagram, nothing gives a link to 1, and thus it is all zero. The second row indicates who gives a link to 2. As shown in the diagram, only 1 gives a link to 2, and thus column 1 is a 1 for row 2, and the rest are all zero.
ie: According to the above example
Page 3 is the most important since it has the most links pointing to it, therefore more weigh should be placed on its outgoing links.
Page 4 comes after page 3 since it has the second most links pointing to it
Page 2 comes after page 4 since it has the third most links pointing to it
Page 1 and page 5 are the least important since no links point to them
As page 1 and page 2 have the most outgoing links, then their links have less value compared to the other pages.
C_{j} = The number of outgoing links of page j:
C_{j} =  ∑  L_{ij} 
i 
(i.e. sum of entries in column j)
P_{j} is the rank of page j.
Suppose we have N pages, P is a vector containing ranks of all pages.
 P is a vector.
 P_{i} counts the number of incoming links of page i
P_{i} =  ∑  L_{ij} 
j 
(i.e. sum of entries in row i)
For each row of L, if there is a 1 in the third column, it means page three point to that page.
However, we should not define the rank of the page this way because links shouldn't be treated the same. The weight of the link is based on different factors. One of the factors is the importance of the page that link is coming from. For example, in this case, there are two links going to Page 4: one from Page 2 and one from Page 5. So far, both links have been treated equally with the same weight 1. But we must rerate the two links based on the importance of the pages they are coming from.
A PageRank results from a mathematical algorithm based on the webgraph, created by all World Wide Web pages as nodes and hyperlinks as edges, taking into consideration authority hubs such as cnn.com or usa.gov. The rank value indicates an importance of a particular page. A hyperlink to a page counts as a vote of support. (This would be represented in our diagram as an arrow pointing towards the page. Hence in our example, Page 3 is the most important, since it has the most 'votes of support). The PageRank of a page is defined recursively and depends on the number and PageRank metric of all pages that link to it ("incoming links"). A page that is linked to by many pages with high PageRank receives a high rank itself. If there are no links to a web page, then there is no support for that page (In our example, this would be Page 1 and Page 5). (source:http://en.wikipedia.org/wiki/PageRank#Description)
For those interested in PageRank, here is the original paper by Google cofounders Brin and Page: http://infolab.stanford.edu/pub/papers/google.pdf
Example of Page Rank Application in Real Life
Page Rank checker  This is a free service to check Google™ page rank instantly via online PR checker or by adding a PageRank checking button to the web pages.
(http://www.prchecker.info/check_page_rank.php)
GoogleMatrix G = d * [ (Hyperlink Matrix H) + (Dangling Nodes Matrix A) ] + ((1d)/N) * (NxN Matrix U of all 1's)
(source: https://googledrive.com/host/0B2GQktuwcTiaWw5OFVqT1k3bDA/)
Class 16  Thursday June 27th 2013
Page Rank
 C_{j}: number of outgoing links for page j, where
c_{j} =  ∑  L_{ij} 
i 
P is N by 1 vector contains rank of all N pages; for page i, the rank is P_{i}
pi is the rank of a new created page(that no one knows about) is 0 since L_{i}j is 0
where 0 < d < 1 is constant (in original page rank algorithm d = 0.8), and L_{ij} is 1 if j has link to i, 0 otherwise.
Note that the rank of a page is proportional to the number of its incoming links and inversely proportional to the number of its outgoing links.
Interpretation of the formula:
1) sum of L_{ij} is the total number of incoming links
2) the above sum is weighted by page rank of the pages that contain the link to i (P_{j}) i.e. if a highrank page points to page i, then this link carries more weight than links from lowerrank pages.
3) the sum is then weighted by the inverse of the number of outgoing links from the pages that contain links to i (c_{j}). i.e. if a page has more outgoing links than other pages then its links carry less weight.
4) finally, we take a linear combination of the page rank obtained from above and a constant 1. This ensures that every page has a rank greater than zero.
5) d is the damping factor. It represents the probability a user, at any page, will continue clicking to another page.
If there is no damping (i.e. d=1), then there are no assumed outgoing links for nodes with no links. However, if there is damping (e.g. d=0.8), then these nodes are assumed to have links to all pages in the web.
Note that this is a system of N equations with N unknowns.
c_{j} is the number of outgoing links, less outgoing links means more important.
Let D be a diagonal N by N matrix such that D_{ii} = c_{i}
Note: Ranks are arbitrary, all we want to know is the order. That is, we want to know how important the page rank relative to the other pages and are not interested in the value of the page rank.
Then , P is an iegenvector of matrix A corresponding to an eigenvalue equal to 1.
where e =[1 1 ....]^{T} , i.e. a N by 1 vector.
We assume that rank of all N pages sums to N. The sum of rank of all N pages can be any number, as long as the ranks have certain propotion.
i.e. e^{T} P = N, then
D^{1} will be:
D^{1}
where
= > P = A * P
Explanation of an eigenvector
An eigenvector is a nonzero vector v such that when multiplied by a square matrix, A, the result is a scalar times the vector v itself.
That is, A*v = c*v. Where c is the eigenvalue of A corresponding to the eigenvector v. In our case of Page Rank, the eigenvalue c=1.
We obtain that P = AP where
Thus, P is an eigenvector of P correspond to an eigen value equals 1.
Since,
L is a N*N matrix,
D^{1} is a N*N matrix,
P is a N*1 matrix
Then as a result, LD^{ − 1}P is a N*1 matrix.
N is a N*N matrix, d is a constant between 0 and 1.
P=AP
P is an eigenvector of A with corresponding eigenvalue equal to 1.
P^{T}=P^{T}A^{T}
Notice that all entries in A are nonnegative and each row sums to 1. Hence A satisfies the definition of a transition probability matrix.
P^{T} is the stationary distribution of a Markov Chain with transition probability matrix A^{T}.
We can consider A to be the matrix describing all possible movements following links on the internet, and P^{t} as the probability of being on any given webpage if we were on the internet long enough.
Definition of rank page and proof it steps by steps, it shows with 3 n*n matrix and and one n*1 matrix and a constant d between 0 to 1. p is the stationary distribution so p=Ap.
Damping Factor "d"
The PageRank assumes that any imaginary user who is randomly clicking on links will eventually stop clicking. The probability, at any step, that the person will keep on clicking is a damping factor, d. After many studies, the approximation of d is 0.85. Other values for d have been used in class and may appear on assignments and exams.
In addition, d is a vector of ranks that are arbitrary. For example the rank can be [1 3 2], or [10 30 20], or [0.1 0.3 0.2]. All three of these examples are relative/equivalent since they are ranks, we could even have [1 10 3]. Therefore, d must have a relative rank.
So
Which is equivalent to:
Where is a 1 scalar vector and is a rank vector.
So e^{T}P = N − > (e^{T}P) / N = 1
Examples
Example 1
MATLAB Code d=0.8 N=3 A=(1d)*ones(N)/N+d*L*pinv(D) #pinv: MoorePenrose inverse (pseudoinverse) of symbolic matrix We use the pinv(D) function [pseudoinverse] instead of the inv(D) function because in the case of a noninvertible matrix, it would not crash the program. [vec val]=eigs(A) (eigendecomposition) a=vec(:,1) (find the eigenvector equals to 1) a=a/sum(a) (normalize a) or to show that A transpose is a stationary transition matrix (transpose(A))^200 will be the same as a=a/sum(a)
NOTE: Changing the value of d, does not change the ranking order of the pages.
By looking at each entry after normalizing a, we can tell the ranking order of each page.
c = [1 1 1] since there are 3 pages, each page is one way recurrent to each other and there is only one outgoing for each page. Hence, D is a 3x3 standard diagonal matrix.
Example 2
Matlab code >> L=[0 0 1;1 0 1;0 1 0]; >> C=sum(L); >> D=diag(C); >> d=0.8; >> N=3; >> A=(1d)*ones(N)/N+d*L*pinv(D); >> [vec val]=eigs(A) vec = 0.3707 0.3536 + 0.3536i 0.3536  0.3536i 0.6672 0.3536  0.3536i 0.3536 + 0.3536i 0.6461 0.7071 0.7071 val = 1.0000 0 0 0 0.4000  0.4000i 0 0 0 0.4000 + 0.4000i >> a=vec(:,1) a = 0.3707 0.6672 0.6461 >> a=a/sum(a) a = 0.2201 0.3962 0.3836
NOTE: Page 2 is the most important page because it has 2 incomings. Similarly, page 3 is more important than page 1 because page 3 has the incoming result from page 2.
This example is similar to the first example, but here, page 3 can go back to page 2, so the matrix of the outgoing matrix, the third column of the D matrix is 3 in the third row. And we use the code to calculate the p=Ap. Therefore 2, 3, 1 is the order of importance.
Example 3
d = 0.8
N = 3
this example is the second page have 2 outgoings.
Another Example:
Consider: 1 > ,<2 >3
Example 4
Matlab Code:
>> L=L= [0 1 0 0;1 0 0 0;0 1 0 1;0 0 1 0]; >> C=sum(L); >> D=diag(C); >> d=0.8; >> N=4; >> A=(1d)*ones(N)/N+d*L*pinv(D); >> [vec val]=eigs(A); >> a=vec(:,1); >> a=a/sum(a) a = 0.1029 < Page 1 0.1324 < Page 2 0.3971 < Page 3 0.3676 < Page 4 % Therefore the PageRank for this matrix is: 3,4,2,1
Example 5
Matlab code >> L= [0 1 0 1; 1 0 1 1; 1 0 0 1;1 0 0 0]; >> d = 0.8; >> N = 4; >> C = sum(L); >> D = diag(C); >> A=(1d)*ones(N)/N+d*L*pinv(D); >> [vec val]=eigs(A); >> a=vec(:,1); >> a=a/sum(a) a = 0.3492 0.3263 0.1813 0.1431
Example 6
Matlab Code:
>> d=0.8; >> L=[0 1 0 0 1;1 0 0 0 0;0 1 0 0 0;0 1 1 0 1;0 0 0 1 0]; >> c=sum(L); >> D=diag(c); >> N=5; >> A=(1d)*ones(N)/N+d*L*pinv(D); >> [vec val]=eigs(A); >> a=vec(:,1); >> a=a/sum(a) a = 0.1933 < Page 1 0.1946 < Page 2 0.0919 < Page 3 0.2668 < Page 4 0.2534 < Page 5 % Therefore the PageRank for this matrix is: 4,5,2,1,3
Class 17  Tuesday July 2nd 2013
Markov Chain Monte Carlo (MCMC)
Introduction
It is, in general, very difficult to simulate the value of a random vector X whose component random variables are dependent. We will present a powerful approach for generating a vector whose distribution is approximately that of X. This approach, called the Markov Chain Monte Carlo Methods, has the added significance of only requiring that the mass(or density) function of X be specified up to a multiplicative constant, and this, we will see, is of great importance in applications. (referenced by Sheldon M.Ross,Simulation) The basic idea used here is to generate a Markov Chain whose stationary distribution is the same as the target distribution.
Definition:
Markov Chain A Markov Chain is a special form of stochastic process in which depends only on .
For example,
A random Walk is the best example of a Markov process
Transition Probability:
The probability of going from one state to another state.
Transition Matrix:
For n states, transition matrix P is an matrix with entries as below:
Markov Chain Monte Carlo (MCMC) methods are a class of algorithms for sampling from probability distributions based on constructing a Markov chain that has the desired distribution as its equilibrium distribution. The state of the chain after a large number of steps is then used as a sample of the desired distribution. The quality of the sample improves as a function of the number of steps. (http://en.wikipedia.org/wiki/Markov_chain_Monte_Carlo)</span>
<a style="color:red" href="http://www.eecs.berkeley.edu/Pubs/TechRpts/2010/EECS2010165.pdf">some notes form UCb</a>
One of the main purposes of MCMC : to simulate samples from a joint distribution where the joint random variables are dependent. In general, this is not easily sampled from. Other methods learned in class allow us to simulate i.i.d random variables, but not dependent variables . In this case, we could sample nonindependent random variables using a Markov Chain. Its Markov properties help to simplify the simulation process.
Basic idea: Given a probability distribution π on a set Ω, we want to generate random elements of Ω with distribution π. MCMC does that by constructing a Markov Chain with stationary distribution π and simulating the chain. After a large number of iterations, the Markov Chain will reach its stationary distribution. By sampling from the Markov chain for large amount of iterations, we are effectively sampling from the desired distribution as the Markov Chain would converge to its stationary distribution
Idea: generate a Markov chain whose stationary distribution is the same as target distribution.
Notes
 Regardless of the chosen starting point, the Markov Chain will converge to its stationary distribution (if it exists). However, the time taken for the chain to converge depends on its chosen starting point. Typically, the burnin period is longer if the chain is initialized with a value of low probability density.
 Markov Chain Monte Carlo can be used for sampling from a distribution, estimating the distribution, and computing the mean and optimization (e.g. simulated annealing, more on that later).
 Markov Chain Monte Carlo is used to sample using “local” information. It is used as a generic “problem solving technique” to solve decision/optimization/value problems, but is not necessarily very efficient.
 MCMC methods do not suffer as badly from the "curse of dimensionality" that badly affects efficiency in the acceptancerejection method. This is because a point is always generated at each timestep according to the Markov Chain regardless of how many dimensions are introduced.
 The goal when simulating with a Markov Chain is to create a chain with the same stationary distribution as the target distribution.
 The MCMC method is usually used in continuous cases but a discrete example is given below.
Some properties of the stationary distribution π
π indicates the proportion of time the process spends in each of the states 1,2,...,n. Therefore π satisfies the following two inequalities:

This is because π_{i} is the proportion of time the process spends in state i, and P_{ij} is the probability the process transition out of state i into state j. Therefore, π_{i}p_{ij} is the proportion of time it takes for the process to enter state j. Therefore, π_{j} is the sum of this probability over overall states i.  as π shows the proportion of time the chain is in each state. If we view it as the probability of the chain being in state i at time t for t sufficiently large, then it should sum to one as the chain must be in one of the states.
Motivation example
 Suppose we want to generate a random variable X according to distribution π = (π_{1},π_{2},...,π_{m})
X can take m possible different values from
 We want to generate according to π
Suppose our example is of a bias die.
Now we have m=6, π = [0.1,0.1,0.1,0.2,0.3,0.2],
Suppose X_{t} = i. Consider an arbitrary probability transition matrix Q with entry q_{ij} being the probability of moving to state j from state i. (q_{ij} can not be zero.)
We generate Y = j according to the ith row of Q. Note that the ith row of Q is a probability vector that shows the probability of moving to any state j from the current state i, i.e.P(Y = j) = q_{ij}
In the following algorithm:
q_{ij} is the ij^{th} entry of matrix Q. It is the probability of Y=j given that x_{t} = i.
r_{ij} is the probability of accepting Y as x_{t + 1}.
How to get the acceptance probability?
If π is the stationary distribution, then it must satisfy the detailed balance condition:
If π_{i}P_{ij} = π_{j}P_{ji}
then π is the stationary distribution of the chain
Since P_{ij} = q_{ij}r_{ij}, we have π_{i}q_{ij}r_{ij} = π_{j}q_{ji}r_{ji}.
We want to find a general solution: r_{ij} = a(i,j)π_{j}q_{ji}, where a(i,j) = a(j,i).
Recall
r_{ij} is the probability of acceptance, thus it must be that
1.r_{ij} = a(i,j) π_{j}q_{ji}≤1, then we get: a(i,j)≤ 1 / (π_{j}q_{ji})
2. r_{ji} = a(j,i) π_{i}q_{ij} ≤ 1, then we get: a(j,i) ≤ 1 / (π_{i}q_{ij})
So we choose a(i,j) as large as possible, but it needs to satisfy the two conditions above.
Thus,
Note: 1 is the upper bound to make r_{ij} a probability
Algorithm:
 ( * )P(Y = j) = q_{ij}. is a positive ratio.


 go back to the first step (*)
We can compare this with the AcceptanceRejection model we learned before.
 U ~ Uniform(0,1)
 If U < r_{ij}, then accept.
EXCEPT that a point is always generated at each timestep.
The algorithm generates a stochastic sequence that only depends on the last state, which is a Markov Chain.
Metropolis Algorithm
Proposition: Metropolis works:
The P_{ij}'s from Metropolis Algorithm satisfy detailed balance property w.r.t π . i.e. π_{i}P_{ij} = π_{j}P_{ji}. The new Markov Chain has a stationary distribution π.
Remarks:
1) We only need to know ratios of values of π_{i}'s.
2) The MC might converge to π at varying speeds depending on the proposal distribution and the value the chain is initialized with
This algorithm generates {x_{t}:t = 0,...,m}.
In the long run, the marginal distribution of x_{t} is the stationary distribution
{x_{t}:t = 0,1,...,m} is a Markov chain with probability transition matrix (PTM), P.
This is a Markov Chain since x_{t + 1} only depends on x_{t}, where
q_{ij} is the probability of generating state j;
r_{ij} is the probability of accepting state j as the next state.
Therefore, the final probability of moving from state i to j when i does not equal to j is q_{ij} * r_{ij}.
For the probability of moving from state i to state i, we deduct all the probabilities of moving from state i to any j that are not equal to i, therefore, we get the second probability.
Proof of the proposition:
A good way to think of the detailed balance equation is that they balance the probability from state i to state j with that from state j to state i.
We need to show that the stationary distribition of the Markov Chain is , i.e.
Recall
If a Markov chain satisfies the detailed balance property, i.e. , then is the stationary distribution of the chain.
Proof:
WLOG, we can assume that
LHS:
RHS:
Note that by our assumption, since , its reciprocal
So
Hence LHS=RHS
If we assume that
(essentially )
LHS:
RHS:
Note
by our assumption, since , its reciprocal
So
Hence LHS=RHS which indicates pi_{i} * P_{ij} = pi_{j} * P_{ji}
Note
1) If we instead assume , the proof is similar with LHS= RHS = π_{i}q_{ij}
2) If , then detailed balance is satisfied trivially.
since π_{i}q_{ij}, and π_{j}q_{ji} are smaller than one. so the above steps show the proof of .
Class 18  Thursday July 4th 2013
Last class
Recall: The Acceptance Probability,
1) , and r_{ji} = 1, ()
2) , and rij = 1, ( )
Example: Discrete Case
Consider a biased die, π= [0.1, 0.1, 0.2, 0.4, 0.1, 0.1]
We could use any 6x6 matrix as the proposal distribution
For the sake of simplicity ,using a discrete uniform distribution is the simplest. This is because all probabilities are equivalent, hence during the calculation of r, qxy and qyx will cancel each other out.
Algorithm
1. x_{t} = 5 (sample from the 5th row, although we can initialize the chain from anywhere within the support)
2. Y~Unif[1,2,...,6]
3.
Note: current state i is X_{t}, the candidate state j is Y.
Note: since q_{ij} = q_{ji} for all i and j, that is, the proposal distribution is symmetric, we have
4. U~Unif(0,1)
if , X_{t+1}=Y
else X_{t+1}=X_{t}
go back to 2
Notice how a point is always generated for X_{t+1}, regardless of whether the candidate state Y is accepted
Matlab
pii=[.1,.1,.2,.4,.1,.1]; x(1)=5; for ii=2:1000 Y=unidrnd(6); %%% Unidrnd(x) is a builtin function which generates a number between (0) and (x) r = min (pii(Y)/pii(x(ii1)), 1); u=rand; if u<r x(ii)=Y; else x(ii)=x(ii1); end end hist(x,6) %generate histogram displaying all 1000 points xx = x(501,end); %After 500, the chain will mix well and converge. hist(xx,6) % The result should be better.
NOTE: Generally, we generate a large number of points (say, 1500) and throw away some of the points that were first generated(say, 500). Those first points are called the burnin period. A chain will converge to the limiting distribution eventually, but not immediately. The burnin period is that beginning period before the chain has converged to the desired distribution. By discarding those 500 points, our data set will be more representative of the desired limiting distribution; once the burnin period is over, we say that the chain "mixes well".
Alternate Example: Discrete Case
Consider the weather. If it is sunny one day, there is a 5/7 chance it will be sunny the next. If it is rainy, there is a 5/8 chance it will be rainy the next.
Use a discrete uniform distribution as the proposal distribution, because it is the simplest.
Algorithm
1. Set initial chain state: X_{t} = 1 (i.e. sample from the 1st row, although we could also choose the 2nd row)
2. Sample from proposal distribution: Y~q(yx) = Unif[1,2]
3.
Note: Current state i is X_{t}, the candidate state j is Y. Since q_{ij} = q_{ji} for all i and j, that is, the proposal distribution is symmetric, we have
4. U~Unif(0,1)
If , then
X_{t} = Y
else
X_{t + 1} = X_{t}
end if
5. Go back to step 2
Generalization of the above framework to the continuous case
In place of π use f(x)
In place of r_{ij} use q(y  x)
In place of r_{ij} use r(x,y)
Here, q(yx) is a friendly distribution that is easy to sample, usually a symmetric distribution will be preferable, such that q(y  x) = q(x  y) to simplify the computation for r(x,y).
Remarks
1. The chain may not get to a stationary distribution if the # of steps generated are small. That is it will take a very large amount of steps to step through the whole support
2. The algorithm can be performed with a π that is not even a probability mass function, it merely needs to be proportional to the probability mass function we wish to sample from. This is useful as we do not need to calculate the normalization factor.
For example, if we are given π^{'} = πα = [5,10,11,2,100,1], we can normalize this vector by dividing the sum of all entries s.
However we notice that when calculating r_{ij},
s cancels out in this case. Therefore it is not necessary to calculate the sum and normalize the vector.
This also applies to the continuous case,where we merely need f(x) to be proportional to the pdf of the distribution we wish to sample from.
Metropolis–Hasting Algorithm
Definition:
Metropolis–Hastings algorithm is a Markov chain Monte Carlo (MCMC) method for obtaining a sequence of random samples from a probability distribution for which direct sampling is difficult. The Metropolis–Hastings algorithm can draw samples from any probability distribution P(x), provided you can compute the value of a function f(x) which is proportional to the density of P.
Purpose:
"The purpose of the MetropolisHastings Algorithm is to generate a collection of states according to a desired distribution P(x). P(x) is chosen to be the stationary distribution of a Markov process, π(x)."
Source:(http://en.wikipedia.org/wiki/Metropolis%E2%80%93Hastings_algorithm)
MetropolisHastings is an algorithm for constructing a Markov chain with a given limiting probability distribution. In particular, we consider what happens if we apply the MetropolisHastings algorithm repeatedly to a “proposal” distribution which has already been updated.
The algorithm was named after Nicholas Metropolis and W. K. Hastings who extended it to the more general case in 1970.
q(y  x) is used instead of qi,j. In continuous case, we use these notation which means given state x, what's the probability of y.
Note that the MetropolisHasting algorithm possess some advantageous properties. One of which is that this algorithm "can be used when \pi(x) is known up to the constant of proportionality". The second is that in this algorithm, "we do not require the conditional distribution, which, in contrast, is required for the Gibbs sampler. " Source:https://www.msu.edu/~blackj/Scan_2003_02_12/Chapter_11_Markov_Chain_Monte_Carlo_Methods.pdf
Differences between the discrete and continuous case of the Markov Chain:
1. q(y  x) is used in continuous, instead of q_{ij} in discrete
2. r(x,y) is used in continuous, instead of rij in discrete
3. f is used instead of π
Build the Acceptance Ratio
Before we consider the algorithm there are a couple general steps to follow to build the acceptance ratio:
a) Find the distribution you wish to use to generate samples from
b) Find a candidate distribution that fits the desired distribution, q(yx). (the proposed moves are independent of the current state)
c) Build the acceptance ratio
Assume that f(y) is the target distribution; Choose q(yx) such that it is a friendly distribution and easy to sample from.
Algorithm:
 Set and initialize the chain, i.e. where is some state of the Markov Chain.
 Sample
 Set
 Sample
 If
Else  Increment i by 1 and go to Step 2, i.e.
Note: q(xy) is moving from y to x and q(yx) is moving from x to y.
We choose q(yx) so that it is simple to sample from.
Usually, we choose a normal distribution.
NOTE2: The proposal q(yx) y depends on x (is conditional on x)the current state, this makes sense ,because it's a necessary condition for MC. So the proposal should depend on x (also their supports should match) e.g q(yx) ~ N( x, b^{2}) here the proposal depends on x. If the next state is INDEPENDENT of the current state, then our proposal will not depend on x e.g. (A4 Q2, sampling from Beta(2,2) where the proposal was UNIF(0,1)which is independent of the current state. )
However, it is important to remember that even if generating the proposed/candidate state does not depend on the current state, the chain is still a markov chain.
Comparing with previous sampling methods we have learned, samples generated from MH algorithm are not independent of each other, since we accept future sample based on the current sample. Furthermore, unlike acceptance and rejection method, we are not going to reject any points in MetropolisHastings. In the equivalent of the "reject" case, we just leave the state unchanged. In other words, if we need a sample of 1000 points, we only need to generate the sample 1000 times.
Remarks
Remark 1
A common choice for q(y  x) is a normal distribution centered at x with standard deviation b. Y~N(x,b^{2})
In this case, q(y  x) is symmetric.
i.e.
q(y  x) = q(x  y)
(we want to sample q centered at the current state.)
, (centered at x)
,(centered at y)
so
In this case and therefore
This is true for any symmetric q. In general if q(yx) is symmetric, then this algorithm is called Metropolis.
When choosing function q, it makes sense to choose a distribution with the same support as the distribution you want to simulate. eg. If target is Beta, then can choose q ~ Uniform(0,1)
The chosen q is not necessarily symmetric. Depending on different target distribution, q can be uniform.
Remark 2
The value y is accepted if u<=, so it is accepted with the probability .
Thus, if f(y) > = f(x), then y is always accepted.
The higher that value of the pdf is in the vicinity of a point y_{1} , the more likely it is that a random variable will take on values around y_{1}.
Therefore,we would want a high probability of acceptance for points generated near y_{1}.
Note:
If the proposal comes from a region with low density, we may or may not accept; however, we accept for sure if the proposal comes from a region with high density.
Remark 3
One strength of the MetropolisHastings algorithm is that normalizing constants, which are often quite difficult to determine, can be cancelled out in the ratio r. For example, consider the case where we want to sample from the beta distribution, which has the pdf:
（also notice that Metropolis Hastings is just a special case of Metropolis algorithm)
The beta function, B, appears as a normalizing constant but it can be simplified by construction of the method.
Example
, where is normalization factor and is target distribution.
Then, we have .
And let us take .
Then is symmetric since .
Therefore Y can be simplified.
We get :
.
stands for probility;
is not brobility, so we take:
is probility where
In practice, if elements of π are functions or random variables, we need c to be the normalization factor, the summation/integration over all members of π. This is usually very difficult. Since we are taking ratios, with the MetropolisHasting algorithm, it is not necessary to do this.
For example, to find the relationship between weather temperature and humidity, we only have a proportional function instead of a probability function. To make it into a probability function, we need to compute c, which is really difficult. However, we don't need to compute c as it will be cancelled out during calculation of r.
MATLAB
The Matlab code of the algorithm is the following :
clear all close all clc b=2; x(1)=0; for i=2:10000 y=b*randn+x(i1); r=min((1+x(i1)^2)/(1+y^2),1); u=rand; if u<r x(i)=y; else x(i)=x(i1); end end hist(x,100); %The Markov Chain usually takes some time to converge and this is known as the "burning time".
However, while the data does approximately fit the desired distribution, it takes some time until the chain gets to the stationary distribution. To generate a more accurate graph, we modify the code to ignore the initial points.
MATLAB
b=2; x(1)=0; for ii=2:10500 y=b*randn+x(ii1); r=min((1+x(ii1)^2)/(1+y^2),1); u=rand; if u<=r x(ii)=y; else x(ii)=x(ii1); end end xx=x(501:end) %we don't display the first 500 points because they don't show the limiting behaviour of the Markov Chain hist(xx,100)
If a function f(x) can only take values from , but we need to use normal distribution as the candidate distribution, then we can use , where y is from .
(This is essentially the pdf of the absolute value of a normal distribution centered around x)
Example:
We want to sample from
r = min(exp(2 * (x − y)),1)
MATLAB
x(1)=0; for ii=2:100 y=2*(randn*b+abs(x(ii1))) r=min(exp(2*(xy)),1); u=rand; if u<=r x(ii)=y; else x(ii)=x(ii1); end end
Definition of Burn in:
Typically in a MH Algorithm, a set of values generated at at the beginning of the sequence are "burned" (discarded) after which the chain is assumed to have converged to its target distribution. In the first example listed above, we "burned" the first 500 observations because we believe the chain has not quite reached our target distribution in the first 500 observations. 500 is not a set threshold, there is no right or wrong answer as to what is the exact number required for burnin. Theoretical calculation of the burnin is rather difficult, in the above mentioned example, we chose 500 based on experience and quite arbitrarily.
Burnin time can also be thought of as the time it takes for the chain to reach its stationary distribution. Therefore, in this case you will disregard everything uptil the burnin period because the chain is not stabilized yet.
The Metropolis–Hasting Algorithm is started from an arbitrary initial value x_{0} and the algorithm is run for many iterations until this initial state is "forgotten". These samples, which are discarded, are known as burnin. The remaining
set of accepted values of x represent a sample from the distribution f(x).(http://en.wikipedia.org/wiki/Metropolis%E2%80%93Hastings_algorithm)
Burnin time can also be thought of as the time it takes for the process to reach the stationary distribution pi. Suppose it takes 5 samples after which you reach the stationary distribution. You should disregard the first five samples and consider the remaining samples as representing your target distribution f(x).
Several extensions have been proposed in the literature to speed up the convergence and reduce the so called “burnin” period. One common suggestion is to match the first few moments of q(yx) to f(x).
Aside: The algorithm works best if the candidate density q(yx) matches the shape of the target distribution f(x). If a normal distribution is used as a candidate distribution, the variance parameter b^{2} has to be tuned during the burnin period.
1. If b is chosen to be too small, the chain will mix slowly (smaller proposed move, the acceptance rate will be high and the chain will converge only slowly the f(x)).
2. If b is chosen to be too large, the acceptance rate will be low (larger proposed move and the chain will converge only slowly the f(x)).
Note:
The histogram looks much nicer if we reject the points within the burning time.
Example: Use MH method to generate sample from f(x)=2x
0<x<1, 0 otherwise.
1) Initialize the chain with x_{i} and set i = 0
2) where our proposal function would be uniform [0,1] since it matches our original ones support. =>
3)consider , since q(yx_{i}) and q(x_{i}y) can be cancelled together.
4)X_{i + 1} = Y with prob r(x,y), X_{i + 1} = X_{i}, otherwise
5)i = i + 1, go to 2
Example form wikipedia
Stepbystep instructions
Suppose the most recent value sampled is . To follow the Metropolis–Hastings algorithm, we next draw a new proposal state with probability density , and calculate a value
where
is the likelihood ratio between the proposed sample and the previous sample , and
is the ratio of the proposal density in two directions (from to and vice versa). This is equal to 1 if the proposal density is symmetric. Then the new state is chosen according to the following rules.
The Markov chain is started from an arbitrary initial value and the algorithm is run for many iterations until this initial state is "forgotten". These samples, which are discarded, are known as burnin. The remaining set of accepted values of x represent a sample from the distribution P(x).
The algorithm works best if the proposal density matches the shape of the target distribution from which direct sampling is difficult, that is . If a Gaussian proposal density is used the variance parameter has to be tuned during the burnin period. This is usually done by calculating the acceptance rate, which is the fraction of proposed samples that is accepted in a window of the last samples. The desired acceptance rate depends on the target distribution, however it has been shown theoretically that the ideal acceptance rate for a one dimensional Gaussian distribution is approx 50%, decreasing to approx 23% for an dimensional Gaussian target distribution.^{[7]}
If is too small the chain will mix slowly (i.e., the acceptance rate will be high but successive samples will move around the space slowly and the chain will converge only slowly to ). On the other hand, if is too large the acceptance rate will be very low because the proposals are likely to land in regions of much lower probability density, so will be very small and again the chain will converge very slowly.
Class 19  Tuesday July 9th 2013
Recall: Metropolis–Hasting Algorithm
1) X_{i} = State of chain at time i. Set X_{0} = 0
2) Generate proposal distribution: Y ~ q(yx)
3) Set
4) Generate U ~ U(0,1)
If U < r, then
X_{i + 1} = Y % i.e. we accept Y as the next point in the Markov Chain
else
X_{i + 1} = X_{i}
End if
5) Set i = i + 1. Return to Step 2.
Why can we use this algorithm to generate a Markov Chain?
~ satisfies the Markov Property, as the current state does not depend on previous trials. Note that Y does not have to depend on X_{t1}; the Markov Property is satisfied as long as Y is not dependent on X_{0}, X_{1},..., X_{t2}. Thus, time t will not affect the choice of state.
Choosing b: 3 cases
If y and x have the same domain, say R, we could use normal distribution to model q(y  x). . In the continuous case of MCMC, q(y  x) is the probability of observing y, given you are observing x. We normally assume q(y  x) ~ N(x,b^2). A reasonable choice of b is important to ensure the MC does indeed converges to the target distribution f. If b is too small it is not possible to explore the whole support because the jumps are small. If b is large than the probability of accepting the proposed state y is small, and it is very likely that we reject the possibilities of leaving the current state, hence the chain will keep on producing the initial state of the Markov chain.
To be precise, we are discussing the choice of variance for the proposal distribution.Large b simply implies larger variance for our choice of proposal distribution (Gaussian) in this case. Therefore, many points will be rejected and we will generate same points many times since there are many points that have been rejected.
In this example, q(y  x) = N(x,b^{2})
Demonstrated as follows, the choice of b will be significant in determining the quality of the Metropolis algorithm.
This parameter affects the probability of accepting the candidate states, and the algorithm will not perform well if the acceptance probability is too large or too small, it also affects the size of the "jump" between the sampled Y and the previous state x_{i+1}, as a larger variance implies a larger such "jump".
If the jump is too large, we will have to repeat the previous stage; thus, we will repeat the same point for many times.
MATLAB b=2, b= 0.2, b=20
clear all close all clc b=2 % b=0.2 b=20; x(1)=0; for i=2:10000 y=b*randn+x(i1); r=min((1+x(i1)^2)/(1+y^2),1); u=rand; if u<r x(i)=y; else x(i)=x(i1); end end figure(1); hist(x(5000:end,100)); figure(2); plot(x(5000:end)); %The Markov Chain usually takes some time to converge and this is known as the "burning time" %Therefore, we don't display the first 5000 points because they don't show the limiting behaviour of the Markov Chain generate the Markov Chain with 10000 random variable, using a large b and a small b.
b tells where the next point is going to be. The appropriate b is supposed to explore all the support area.
f(x) is the stationary distribution list of the chain in MH. We generating y using q(yx) and accept it with respect to r.
b too small
If b = 0.02, the chain takes small steps so the chain doesn't explore enough of sample space.
If b = 20, jumps are very unlikely to be accepted; i.e. y is rejected as u > r and Xt + 1 = Xt. i.e and consequent r is very small and very unlikely that u < r, so the current value will be repeated.
Detailed Balance Holds for MetropolisHasting
In metropolishasting, we generate y using q(yx) and accept it with probability r, where
Without loss of generality we assume
Then r(x,y) (probability of accepting y given we are currently in x) is
Now suppose that the current state is y and we are generating x; the probability of accepting x given that we are currently in state y is
This is because and its reverse . Then r(x,y) = 1.
We are interested in the probability of moving from from x to y in the Markov Chain generated by MH algorithm:
P(yx) depends on two probabilities:
1. Probability of generating y, and
2. Probability of accepting y.
The probability of moving to x given the current state is y:
P(x  y) = q(x  y) * r(y,x) = q(x  y)
So does detailed balance hold for MH?
If it holds we should have f(x) * P(y  x) = f(y) * P(x  y).
Lefthand side:
Righthand side:
f(y) * P(x  y) = f(y) * q(x  y)
Thus LHS and RHS are equal and the detailed balance holds for MH algorithm.
Therefore, f(x) is the stationary distribution of the chain.
Class 20  Thursday July 11th 2013
Simulated annealing
Definition: Simulated annealing (SA) is a generic probabilistic metaheuristic for the global optimization problem of locating a good approximation to the global optimum of a given function in a large search space. It is often used when the search space is discrete (e.g., all tours that visit a given set of cities).
(http://en.wikipedia.org/wiki/Simulated_annealing)
"Simulated annealing is a popular algorithm in simulation for minimizing functions." (from textbook)
Simulated annealing is developed to solve the traveling salesman problem: finding the optimal path to travel all the cities needed
It is called "Simulated annealing" because it mimics the process undergone by misplaced atoms in a metal when
its heated and then slowly cooled.
(http://mathworld.wolfram.com/SimulatedAnnealing.html)
It is a probabilistic method proposed in Kirkpatrick, Gelett and Vecchi (1983) and Cerny (1985) for finding the global minimum of a function that may have multiple local minimums.
(http://www.mit.edu/~dbertsim/papers/Optimization/Simulated%20annealing.pdf)
Simulated annealing was developed as an approach for finding the minimum of complex functions
with multiple peaks; where standard hillclimbing approaches may trap the algorithm at a less that optimal peak.
Suppose we generated a point x by an existing algorithm, and we would like to get a "better" point.
(eg. If we have generated a local min of a function and we want the global min)
Then we would use simulated annealing as a method to "perturb" x to obtain a better solution.
Suppose we would like to min h(x), for any arbitrary constant T > 0, this problem is equivalent to max e^{ − h(x) / T}
Note that the exponential function is monotonic.
Consider f proportional to e^{h(x)/T}, sample of this distribution when T is small and
close to the optimal point of h(x). Based on this observation, SA algorithm is introduced as :
1. Set T to be a large number
2. Initialize the chain: set
3. ~
(q should be symmetric)
4.
5. U ~ U(0,1)
6. If U < r, X_{t + 1} = y
else, X_{t + 1} = X_{t}
7. end decrease T, and let i=i+1. Go back to 3. (This is where the difference lies between SA and MH.
(repeat the procedure until T is very small)
Note: q(yx) does not have to be symmetric. If q is nonsymmetric, then the original MH formula is used.
The significance of T
Initially we set T to be large when initializing the chain so as to explore the entire sample space and to avoid the possibility of getting stuck/trapped in one region of the sample space. Then we gradually start decreasing T so as to get closer and closer to the actual solution.
Notice that we have:
Reasons we start with a large T but not a small T at the beginning:
 A point in the tail when T is small would be rejected
 Chances that we reject points get larger as we move from large T to small T
 Large T helps get to the mode of maximum value
Assume T is large
1. h(y) < h(x), e^{(h(x)h(y))/T } > 1, then r = 1, y will always be accepted.
2. h(y) > h(x), e^{(h(x)h(y))/T }< 1, then r < 1, y will be accepted with probability r. Remark:this will help to scape from local minimum, because the algorithm prevents it from reaching and staying in the local minimum forever.
Assume T is small
1. h(y) < h(x), then r = 1, y will always be accepted.
2. h(y) > h(x), e^{(h(x)h(y))/T } approaches to 0, then r goes to 0 and y will almost never be accepted.
All in all, choose a large T to start off with in order for a higher chance that the points can explore.
Note: The variable T is known in practice as the "Temperature", thus the higher T is, the more variability there is in terms of the expansion and contraction of materials. The term "Annealing" follows from here, as annealing is the process of heating materials and allowing them to cool slowly.
Asymptotically this algorithm is guaranteed to generate the global optimal answer, however in practice, we never sample forever and this may not happen.
Example: Consider h(x) = 3x^{2}, 0<x<1
1) Set T to be large, for example, T=100
2) Initialize the chain
3) Set
4)
5)
6) If U < r then X_{t + 1} = y
else,X_{t + 1} = x_{t}
7) Decrease T, go back to 3
MATLAB
Syms x Ezplot('(x3)^2',[6,12]) Ezplot('exp(((x3)^2))', [6, 12])
http://www.wolframalpha.com/input/?i=graph+exp%28%28x3%29%5E2%2F10%29 MATLAB
Note that when T is small, the graph consists of a much higher bump; when T is large, the graph is flatter.
clear all close all T=100; x(1)=randn; ii=1; b=1; while T>0.001 y=b*randn+x(ii); r=min(exp((H(x(ii))H(y))/T),1); u=rand; if u<r x(ii+1)=y; else x(ii+1)=x(ii); end T=0.99*T; ii=ii+1; end plot(x)
Helper function:
an example is for H(x)=(x3)^2
function c=H(x) c=(x3)^2; end
Another Example: h(x) = ((x − 2)^{2} − 4)((x − 4)^{2} − 8)
>>syms x >>ezplot(((x2)^24)*((x4)^28),[1,8])
function c=H(x) c=((x2)^24)*((x4)^28); end
Run earlier code with the new H(x) function
Motivation: Simulated Annealing and the Travelling Salesman Problem
The Travelling Salesman Problem asks:
Given n numbers of cities and the distances between each pair of cities, what is the shortest possible route that visits each city exactly once and returns to the original city? By letting two permutations if one results from an interchange of two of the coordinates of the other, we can use simulated annealing to approximate the best path.
<p>
 An example of a solution of a travelling salesman problem on n=5. This is only one of many solutions, but we want to ensure we find the optimal solution.
 Given n=5 cities, we search for the best route with the minimum distance to visit all cities and return to the starting city.
The idea of using Simulated Annealing algorithm :
Let Y (let Y be all possible combinations of route in terms of cities index) be generated by permutation of all cities. Let the target or objective distribution (f(x)) be the distance of the route given Y.
Then use the Simulated Annealing algorithm to find the minimum value of f(x).
Note: in this case, Q is the permutation of the numbers. There will be may possible paths, especially when n is large. If n is very large, then it will take forever to check all the combination of routes.
 This sort of knowledge would be very useful for those in a situation where they are on a limited budget or must visit many points in a short period of time. For example, a truck driver may have to visit multiple cities in southern Ontario and make it back to his original starting point within a 6hour period.
Disadvantages of Simulated Annealing:
1. This method converges very slowly, and therefore very expensive.
2. This algorithm cannot tell whether it has found the global minimum.
^{[8]}
Class 21  Tuesday July 16, 2013
Gibbs Sampling
Definition
In statistics and in statistical physics, Gibbs sampling or a Gibbs sampler is a Markov chain Monte Carlo (MCMC) algorithm for obtaining a sequence of observations which are approximately from a specified multivariate probability distribution (i.e. from the joint probability distribution of two or more random variables), when direct sampling is difficult.
(http://en.wikipedia.org/wiki/Gibbs_sampling)
The Gibbs sampling method was originally developed by Geman and Geman [1984]. It was later brought into mainstream statistics by Gelfand and Smith [1990] and Gelfand, et al. [1990]
Source: https://www.msu.edu/~blackj/Scan_2003_02_12/Chapter_11_Markov_Chain_Monte_Carlo_Methods.pdf
Gibbs sampling is a general method for probabilistic inference which is often used when dealing with incomplete information. However, generality comes at some computational cost, and for many applications including those involving missing information, there are often alternative methods that have been proven to be more efficient in practice. For example, say we want to sample from a joint distribution p(x_{1},...,x_{k}) (i.e. a posterior distribution). If we knew the full conditional distributions for each parameter (i.e. p(x_{i}  x_{1},x_{2},...,x_{i − 1},x_{i + 1},...,x_{k})), we can use the Gibbs sampler to sample from these conditional distributions.
When utilizing the Gibbs sampler, the candidate state is always accepted as the next state of the chain.(from text book)
 Another Markov Chain Monte Carlo (MCMC) method (first MCMC method introduced in this course is the MH Algorithm)
 a special case of MetropolisHastings sampling where the random value is always accepted, i.e. as long as a point is proposed, it is accepted.
 useful and make it simple and easier for sampling a ddimensional random vector
 then the observations of ddimensional random vectors form a ddimensional Markov Chain and the joint density f(x_{1},x_{2},...,x_{d}) is an invariant distribution for the chain. i.e. for sampling multivariate distributions.
 useful if sampling from conditional pdf, since they are easier to sample, in comparison to the joint distribution.
 Definition of univariate conditional distribution: all the random variables are fixed except for one; we need to use n such univariate conditional distributions to simulate n random variables.
Difference between Gibbs Sampling & MH
Gibbs Sampling generates new value based on the conditional distribution of other components (unlike MH, which does not require conditional distribution).
eg. We are given the following about f(x_{1},x_{2}),f(x_{1}  x_{2}),f(x_{2}  x_{1})
1. let
2.
3. substitute back into first step and repeat the process.
Also, for Gibbs sampling, we will "always accept a candidate point", unlike MH
Source: https://www.msu.edu/~blackj/Scan_2003_02_12/Chapter_11_Markov_Chain_Monte_Carlo_Methods.pdf
Gibbs Sampling as a special form of the Metropolis Hastings algorithm
The Gibbs Sampler is simply a case of the Metropolis Hastings algorithm
here, the proposal distribution is for X = (X_{1},...,X_{n}),
which is simply the conditional distribution of each element conditional on all the other elements in the vector.
similarly
notice that and are identically distributed.
the distribution we wish to simulate from is p(X) = f(X) also, p(Y) = f(Y)
Hence, the acceptance ratio in the MetropolisHastings algorithm is:
so the new point will always be accepted, and no points are rejected and the Gibbs Sampler is an efficient algorithm in that aspect.
Advantages ^{[9]}
 The algorithm has an acceptance rate of 1. Thus, it is efficient because we keep all the points that we sample from.
 It is simple and straightforward if and only if we know the conditional pdf.
 It is useful for highdimensional distributions. (ie. for sampling multivariate PDF)
 It is useful if sampling from conditional PDF are easier than sampling from the joint.
Disadvantages^{[10]}
 We rarely know how to sample from the conditional distributions.
 The probability functions of the conditional probability are usually unknown or hard to sample from.
 The algorithm can be extremely slow to converge.
 It is often difficult to know when convergence has occurred.
 The method is not practical when there are relatively small correlations between the random variables.
Gibbs Sampler Steps:
^{[11]}
Let's suppose that we are interested in sampling from the posterior p(xy), where x is a vector of three parameters, x1, x2, x3.
The steps to a Gibbs Sampler are:
1. Pick a vector of starting value x(0). Any x(0) will converge eventually, but it can be chosen to take fewer iterations
2. Start with any x(order does not matter, but I will start with x1 for convenience). Draw a value x1(1)from the full conditional p(x1x2(0),x3(0),y)
3. Draw a value x2(1) from the full conditional p(x2x1(1),x3(0),y). Note that we must use the updated value of x1(1).
4. Draw a value x3(1) from the full conditional p(x3x1(1),x2(1),y) using both updated values.
5. Draw x2 using x1 and continually using the most updated values.
6. Repeat until we get M draws, we each draw being a vector x(t).
7. Optional burnin or thinning.
Our result is a Markov chain with a bunch of draws of x that are approximately from our posterior.
The Basic idea:
The distinguishing feature of Gibbs sampling is that the underlying Markov chain is constructed from a sequence of conditional distributions. The essential idea is updating one part of the previous element while keeping the other parts fixed  it is useful in many instances where the state variable is a random variable taking values in a general space, not just in R^{n}. (Simulation and the Monte Carlo Method, Reuven Y. Rubinstein)
Note:
1.Other optimizing algorithms introduced such as Simulated Annealing settles on a minimum eventually,which means that if we generate enough observations and plot them in a time series plot, the plot will eventually flatten at the optimal value.
2.For Gibbs Sampling however, when convergence is achieved, instead of staying at the optimal value, the Gibbs Sampler continues to wonder through the target distribution (i.e. will not stay at the optimal point) forever.
Special Example
function gibbs2(n, thin) x_samp = zeros(n,1) y_samp = zeros(n,1) x=0.0 y=0.0 for i=1:n for j=1:thin x=(y^2+4)*randg(3) y=1/(1+x)+randn()/sqrt(2*x+2) end x_samp[i] = x y_samp[i] = y end return x_samp, y_samp end 1 2 julia> @elapsed gibbs2(50000,1000) 7.6084020137786865
Theoretical Example
Gibbs Sampler Application (Inspired by Example 10b in the Ross Simulation (4th Edition Textbook))
Suppose we are a truck driver who randomly puts n basketballs into a 3D storage cube sized so that each edge of the cube is 300cm in length. The basket balls are spherical and have a radius of 25cm each.
Because the basketballs have a radius of 25cm, the centre of each basketball must be at least 50cm away from the centre of another basketball. That is to say, if two basketballs are touching (as close together as possible) their centres will be 50cm apart.
Clearly the distribution of n basketballs will need to conditioned on the fact that no basketball is placed so that its centre is closer than 50cm to another basketball.
This gives:
Beta = P{the centre of no two basketballs are within 50cm of each other}
That is to say, the placement of basketballs is conditioned on the fact that two balls cannot overlap.
This distribution of n balls can be modelled using the Gibbs sampler.
1. Start with n basketballs positioned in the cube so that no two centres are within 50cm of each other
2. Generate a random number U and let I = floor(n*U) + 1
3. Generate another random point X_{k} in the storage box.
4. If X_{k} is not within 50cm of any other point, excluding point X_{I}:
then replace X_{I} by this new point.
Otherwise: return to step 3.
After many iterations, the set of n points will approximate the distribution.
Example1
We want to sample from a target joint distribution f(x_{1}, x_{2}), which is not easy to sample from but the conditional pdfs f(x_{1}x_{2}) & f(x_{2}x_{1}) are very easy to sample from. We can find the stationary distribution (target distribution) using Gibbs sampling:
1. x_{1}* ~ f(x_{1}x_{2}) (here x_{2} is given) => x = [x_{1}* x_{2}]
2. x_{2}* ~ f(x_{2}x_{1}*) (here x_{1}* is generated from above) => x = [x_{1}* x_{2}*]
3. x_{1}* ~ f(x_{1}*x_{2}*) (here x_{2}* is generated from above) => x = [x_{1}* x_{2}* ]
4. x_{2}* ~ f(x_{2}*x_{1}*)
5. Repeat steps 3 and 4 until the chain reaches its stationary distribution [x_{1}* x_{2}*].
Suppose we want to sample from multivariate pdf f(x), where is a ddimentional vector.
Suppose is the current value.
Suppose is the proposed point.
Let represents the conditional pdf of component x_{i}, given other components.
Then Gibbs sampler is as follows:
A simpler illustration of the above example
Consider four variables (w,x,y,z), the sampler becomes
The reference is here
http://web.mit.edu/~wingated/www/introductions/mcmcgibbsintro.pdf
Example2
Suppose we want to sample from a bivariate normal distribution.
(the covariance matrix)
where ρ= 0.9. Then it can be shown that all conditionals are normal of this form:
f(x_{1}x_{2}) = N (u_{1} + r(x_{2}u_{2}), 1r^{2})
f(x_{2}x_{1}) = N (u_{2} + r(x_{1}u_{1}), 1r^{2})
Matlab Code
close all clear all mu = [1;2]; x(:,1) = [1;1]; % covariance matrix r = 0.9; % covariance matrix for ii = 1:1000 x(1, ii+1) = sqrt(1r^2)*randn + (mu(1) + r*(x(2,ii)  mu(2))); % N (u1 + r(x2u2), 1r2) x(2, ii+1) = sqrt(1r^2)*randn + (mu(2) + r*(x(1,ii+1)  mu(1))); % N (u2 + r(x1u1), 1r2) end plot(x(1,:),x(2,:),'.')
Example3
Consider the flowing bivariate normal distribution.
(the covariance matrix)
where ρ= 0.5. Then it can be shown that all conditionals are normal of this form:
x_{1,t + 1}  x_{2,t}˜N(ρx_{2,t},1 − ρ^{2})
x_{2,t + 1}  x_{1,t}˜N(ρx_{1,t},1 − ρ^{2})
Matlab Code:
close all clear all mu = [0;0]; x(:,1) = [1;1]; r = 0.5; for ii = 1:1000 x(1, ii+1) = sqrt(1r^2)*randn + r*(x(2,ii)); x(2, ii+1) = sqrt(1r^2)*randn + r*(x(1,ii+1)); end z=x(:,501:end); hist(z(:),100);
Additional Example (Adapted from Assignment 5 Question 2)
Suppose we want to sample from the following two dimensional pdf:
One can show that , is a normalize constant , but is not required.
Method 1  apply MetropolisHastings
A simple choice of the proposal distribution is for some parameter a > 0, and l_{2} is the identity matrix of dimension 2.
i.e., A random walk sampler : Y= x + Z, where
Since q(.) is symmetric, then we have
Simply put it , given :
and
where Using a = 2 (moderate tuning parameter)
Algorithm
1. Initiate
2. Generate independently,, and for the nth steps.
3. Calculate
4. Generate , if , return , else .
Method 2  apply MetropolisHastings  Gibbs sampling
Note that we can rearrange the function as follow:
where c is a function of
Similarly, we can express the function as :
where c is a function of
Now, we can see that
Algorithm
1. sampling from
2. and repeat the procedures.
3.
Matlab Code:
n=10^4; %% generate 10^4 chains x1(1) =1; x2(1) = 0 ; %% initialize the chain %%Note that we take steps of 2 %%This is so that we can store the initial result, and the improved result for i = 2 :2: n; sig_x1 = sqrt(1/(1+x2(i1)^2)); mu_x1 = 4/(1+x2(i1)^2); x1(i) = normrnd(mu_x1,sig_x1); %% generate from the conditional density x2(i) = x2(i1); sig_x2 = sqrt(1/(1+x1(i)^2)); mu_x2 = 4/(1+x1(i)^2); i=i+1; x2(i) = normrnd(mu_x2, sig_x2); x1(i) = x1(i1); end scatter(x1(1000:n),(x2(1000:n)),'.'); hold on; [ x , y ] = meshgrid( 1:.2:7 , 1:0.2:7); c = 1/202126.335877; z = c .* exp( ( x .^2+ y .^2+ y .^2 .* x .^2 8.* x 8.* y ) /2); contour( x , y , z );
Result:
Class 22, Thursday, July 18, 2013
Assignment Hint: Question 2
Matlab Code
syms x syms y ezplot(x^2 +2) ezsurf(exp(x given ~ 2 ...)/i) this gives a n dimensional plot
ezsurf(fun) creates a graph of fun(x,y) using the surf function. fun is plotted over the default domain: 2π < x < 2π, 2π < y < 2π.
http://www.mathworks.com/help/matlab/ref/ezsurf.html
Example: ezsurf((x+y)^2+(xy)^3)
Generate CDF of N(0,1) distribution
Define h(x) to be an indicator function such that h(X < x) = 1 and 0 otherwise.
Example: Face recognition
X is a greyscale image of the person and Y is the person.
Here,We have a 100 x 100 grid where each cell is a number from 0 to 255 representing the darkness of the cell (from white to black).
Let x be a vector of length 100*100=10,000 and y be a vector with each element being a picture of a person's face.
Compare Pr{xy} and Pr{yx}.
 A frequentist would say X is a random variable and Y is not, so they would use Pr{xy} (given that y is Tom, how likely is it that x is an image of Tom?).
, y is person and x is how likely the picture is of this person. Here, y is known.
 Frequentist: probability is objective quantity which is proportional to events.
i.e. Flip a coin many times, half of the time, it will be heads, and the other half it will be tails. (Physics)
Bayesian approach
A Bayesian would ask, given some image, how likely is it that the person in the image is Tom? They would use P(YX).
Here, everything is a random variable.
Proof:
 Bayesian: Probability is subjective, which states someone's belief.
i.e. The chance of raining tomorrow is 40%. (A Frequentist would not say this because no one can observe tomorrow a thousand times.)
Generating Normally Distributed Random Number(MATLAB)
y = randn(m,n) returns "m x n" matrix of random values from standard normal distribution.
y = randn(n) returns "n x n" matrix of random values instead.
Note: m & n must be positive values; otherwise, negative numbers will be treated as 0.
http://www.mathworks.com/help/matlab/ref/randn.html
Matlab
y = randn(2,4) ans = 0.5377 2.2588 0.3188 0.4336 1.8339 0.8622 1.3077 0.3426
Randsample (MATLAB)
y = randsample(n,k,true,w) or y = randsample(population,k,true,w) returns a weighted sample which is taken with replacement, using a vector of positive weights w with length n. The probability that the integer i is selected for an entry of y is w(i)/sum(w). Usually, w is a vector of probabilities. randsample does not support weighted sampling without replacement. http://www.mathworks.com/help/stats/randsample.html
Matlab:
y = randsample(8,1,true,w) >> [1 3 5 2 8 7 4 6]
Variance reduction
Definition
 Variance reduction is a procedure used to increase the precision of the estimates that can be obtained for a given number of iterations. Every output random variable from the simulation is associated with a variance which limits the precision of the simulation results.
 In order to make a simulation statistically efficient,(i.e. to obtain a greater precision and smaller confidence intervals for the output random variable of interest),variance reduction techniques can be used. The main ones are: Common random numbers, antithetic variates, control variates, importance sampling and stratified sampling), We will only be learning one of the methods  importance sampling. Importance sampling is used to generate more statistically significant points rather than generating those points that do not have any value, such as generating in the middle of the bell curve rather than at the tail end of the bell curve. http://en.wikipedia.org/wiki/Variance_reduction
It can be seen that the integral is just the expectation of h(x) with respect to g(x), where is a weight . In the case where , a greater weight for will be assigned.
^{[12]} Variance reduction uses the fact that the variance of a finite integral is zero.
We would like to use simulation for this algorithm. We can use Monte Carlo Integration framework from previous classes.
. The motivation is that a lot of integrals need to be calculated.
Some addition knowledge:
Common Random Numbers: The common random numbers variance reduction technique is a popular and useful variance reduction technique which applies when we are comparing at least two alternative configurations (of a system) instead of investigating a single configuration.
Case 1 Basic Monte Carlo Integration
Idea:Evaluating an integral means calculating the area under the desired curve f(x).
The Monte Carlo Integration method evaluates the area under the curve by computing the area randomly many times and then take average of the results. ^{[13]}
Detailed Explanation:
The original Monte Carlo approach was a method developed by physicists to use random number generation to compute integrals. Suppose we wish to compute a complex integral
If we can decompose h(x) into the product of a function f(x) and a probability density function p(x)defined over the interval (a,b), then we note that
so that the integral can be expressed as an expectation of f(x) over the density p(x). Thus, if we draw a large number x1, x2,..,xn of random variables from the density p(x), then
This is referred to as Monte Carlo Integration. http://web.mit.edu/~wingated/www/introductions/mcmcgibbsintro.pdf
Suppose we have an integral of this form
where w(x) = h(x)(b − a) , and
Note: f(x) is the pdf of a uniform distribution .
Therefore, we can estimate I by
where
As n approaches infinity, approches I
This idea is illustrated as follows:
In the illustration, since we are using uniform distribution as our p(x), we have p(x_{i})=1 / (b − a).
Example
where
In this question, w(x) = h(x)(b − a) = x^{4}(1 − 0) = x^{4}
Matlab Code:
>> n = 1000; >> x = rand(1, n); >> w = x.^4; >> sum (w)/n ans = 0.2051
Example
where
Matlab Code:
>> n = 1000; >> for i=1:n; x = 2*rand + 2; %xi~Unif(2,4) w(i) = 2*sin(x)/x end; >> sum(w)/n ans = 0.1382
Example
Consider
where
It evaluates to 4/3, now to simulate this, here is the code:
Matlab Code:
>> n = 1000; >> x = rand(1, n); >> w = x.^2+2*x; >> sum (w)/n ans = 1.3717
Note: when n is larger then your answer will be more precise
Example
Consider
The exact answer is (e^1  e^0) = 2.718281828  1 = 1.718281828 Comparing to the simulation, the matlab code is as follows:
Matlab Code:
>> n = 100000; >> x = rand(1, n); >> w = exp(x); >> sum (w)/n ans = 1.7178
The answer 1.7178 is really close enough to the exact answer e  1 = 1.71828182846. The accuracy will increase if n is larger, for example n=100000000.
Multiple Variables Example
Consider
The exact answer is (e  1)^2. The matlab code is similar to the above example, with an additional variable:
Matlab Code:
>> n = 100000; >> x = rand(1, n); >> y = rand(1, n); >> w = exp(x+y); >> sum (w)/n ans = 2.9438
Note that this is close to the exact answer (e  1)^2 = 2.95249.
Case 2
We can generalize this idea. Suppose we wish to compute
If f(x) is uniform, this will be same as case 1 for general f
x_{i} ~ f(x)
Note: as n approaches infinity > I
Example. Find for f = e^{ − x}
where
Matlab Code:
n = 1000; u = rand(1,n); x = log(u) %% Inverse transform method for generating exp(1); sum(sqrt(x))/n;
Tips:
It is important to know when Case 2 is appropriate to be used when evaluating a integral using simulation. Normally case 2 can be distinguished from case 1 if the bounds of the integral are improper i.e either the lower, upper or both the bounds approach infinity.
Now, when it is identified that Case 2 should be used, understand that f(x) must be a pdf. That is integral of f(x) should equal 1, when evaluating along the bounds of the integral. If this is not true we cannot use the summation formula and need to modify the integral to make sure we have a pdf inside the integral.
Example. Use simulation to approximate the following integral . The exact value for this integral is around 93.163.
Solution
where
where
Matlab Code:
close all clear all n=10000; u=rand(1,n); %xi~U[2,2] x=4*u2; s=exp(x+x.^2); 4*sum(s)/n >>93.2680
Example
Let
Compute cdf at point x=2.
By definition,
We only have two methods for simulating integration, one is a definite integral assuming f is uniform, and the other an indefinite integral for any f. Since we are already given the pdf, we have to use the second method. However, since we currently have a definite integral, we must define h(x) as an indicator function to obtain an indefinite integral (thereby allowing us to use the second method).
If
then
Now use where .
This gives
Matlab Code:
n = 1000 x = randn(1,n) sum(x<2)/n
Similarly, cdf at point x = 0 is .
Note:If we want to compute cdf when x has a small value, for example 3, the probability that h(x) equals 1 is small,
so the variance can be large. As x gets smaller, we can increase the sample size to make our simulation more accurate.
special example from:http://www.math.wsu.edu/faculty/genz/416/lect/l086.pdf
What is the variance of estimation?
Suppose that f(x) is the function that we want to estimate and
The range for f(x) is from 0 to (e.g. if we take x_{i}=N to N where i from 1 to 2N)
The variance of our estimate would be:
Class 23, Tuesday July 23
Importance Sampling
Start with
=
where
Recall the definition of crude Monte Carlo Integration:
If and hence , then we have the basis of other variance reduction techniques. Now we consider what happens if X is not uniformly distributed.
In the control variate case, we change the formula b adding and subtracting a known function h(x): basically, by adding zero to the integral, keeping it unbiased and allowing us to have an easier time of solving it. In importance sampling, we will instead multiply by 1. The known function in this case will be g(x), which is selected under a few assumptions.
There are cases where another distribution gives a better fit to integral to approximate, and results in a more accurate estimate; importance sampling is useful here.
Motivation:
 Consider
 There are cases in which we do not know how to sample from f(x) because the distribution of f(x) is complex; or it's very difficult to sample from f.
 There are cases in which h(x) is a rare event with respect to f.
Importance sampling is useful to overcome these cases.
 rare event is the event when you sample from its distribution, you rarely get an satisfied sample.
 Importance sampling can solve the cases listed above. It makes use of some functions that are easier to sample from.
 Importance sampling is a variance reduction technique that can be used in the Monte Carlo method. Although it is not exactly like a Markov Chain Monte Carlo (MCMC) algorithm, it also approximately samples a vector where the mass function is specified up to some constant.
 The idea behind importance sampling is that, certain values of the input random variables in a simulation have more impact on the parameter being estimated than the others. If these "important" values are emphasized by being sampled more frequently, then the estimator variance can be reduced.
 Hence, the basic methodology in importance sampling is to choose a distribution which "encourages" the important values. This use of "biased" distributions will result in a biased estimator if it is applied directly in the simulation. (http://en.wikipedia.org/wiki/Importance_sampling)
 However, the simulation outputs are weighted to correct for the use of the biased distribution, and this ensures that the new importance sampling estimator is unbiased. (http://en.wikipedia.org/wiki/Importance_sampling)
Example:
 Bit Error Rate on a channel.
The bit error rate (BER) is the number of bit errors over the total number of bits during a specific time. BER has no unit associated to it. BER is often written as a percentage.
 Failure Probability of a reliable system.
 A well chosen distribution can result in saving huge amount of runningtime for importance sampling algorithm.
Recall , where the preceding is an ndimensional integral over all possible values of x.
We have , where , and we know this integral since g(x) is a known distribution (we can assume g(x) = b − a) and I is the expectation of w(x) with respect to g(x), or ;
As n approaches infinity, approaches I
Note:
Even though the uniform distribution sampling method only works for a definite integral, you can use still uniform distribution sampling method for I in the case of indefinite integral  this can be done by manipulating the function to adjust the integral range, such that the integral becomes definite.
w(x) is called the Importance Function.
 A good importance function will be large when the integrand is large and small otherwise.
This is the importance sampling estimator of I, and is unbiased. That is, the estimation procedure is to generate i.i.d. samples from g(x), and for each sample which exceeds the upper bound of the integral, the estimate is incremented by the weight W, evaluated at the sample value. The results are averaged over N trials.
http://en.wikipedia.org/wiki/Importance_sampling
Choosing a good fit biased distribution is the key of importance sampling.
Note that g(x) is selected under the following assumptions:
1. g(x) (or at least a constant times g(x)) is a pdf.
2. We have a way to generate from g(x) (known function that we know how to generate using software).
3. ~ constant => hence small variability
4. g(x) should not be 0 at the same time as f(x) "too often" (From Stat340w13 and Course Note Material)
5. g(x) is another density function whose support is the same as that of f(x)
6. g(x) should have thicker tails compare to f to ensure f(x)/g(x) is reasonably small.
7. g(x) should have a similar shape to f(x) in general.
Example 1:
, where
Define
then,.
Therefore, where
which gives
Note:
h(x) is acting as an indicator variable which follows a Bernoulli distribution with p = P(x<=1).
h(x) is used to count the points greater than 1.
Consider again.
Importance sampling is used to overcome the following two cases:
 cases we don't know how to sample from f(x), because f(x) is a complicated distribution.
 cases in which h(x) corresponds to a rare event over f (e.g. less than 3 in a standard normal distribution).
In the second case, using the basic method without importance sampling will result in high variability in the simulated results (which goes against the purpose of variance reduction)
So from g(x)
One can think of as weights. We sample from g(x), and then reweight our samples based on their importance.
Note that is an unbiased estimator for I as
'Problem:'The variance of could be very large with bad choice of g.
Advice 1:
Choose g such that g has thicker tails compare to f.
In general, if over a set A, g is small but f is large, then f(x)/g(x) could be large. ie: the variance could be large. (the values for which h(x) is exceedingly small)
Advice 2：
Choose g to have similar shape with f.
In general, it is better to choose g such that it is similar to f in terms of shape, but has thicker tails.
Procedure
1. Sample
2. where for
Example 2
where
Now we have to compute the expectation of h which is:
where
which gives
Matlab Code:
n = 200; x = randn(1,n); I= sum(x>3)./n; >> mean(I) >> var(I) % to calculate the variance of the estimates
Comments on Example 2:
 Since observations less than 3 are a relatively rare event, this method will give us a relatively high variance.
 To illustrate this, suppose we sample 100 points each time for many times, we will be getting mostly 0's and some 1's and occasionally 2's. This data has large variances.
Note ： h(x) is counting the number of observations that are less than 3.
Remarks：
 We can actually compute the form of to have optimal variance.
Mathematically, it is to find subject to
It can be shown that the optimal is . Using the optimal will minimize the variance of estimation in Importance Sampling. This is of theoretical interest but not useful in practice. As we can see, if we can actually show the expression of g(x), we must first have the value of the integrationwhich is what we want in the first place.
In practice, we shall choose which has similar shape as but with a thicker tail than in order to avoid the problem mentioned above.
The case when g(x) is important it should have the same support. If g(x) does not have the same support then it may not be able to sample from f like before. Also, if g(x) is not a good choice then it increases the variance very badly.
Note:
Normalized imporatance sampling is biased, but it is asymptotically unbiased.
and the second I,
Source: STAT 340 Spring 2010 Course Notes
Example:
Suppose
Since the range is from 0 to here, we can use g(x) = e^{ − x} ; x>0
So where
Algorithm:
1) Generate n number of U_{i}~U(0,1)
2) Set X_{i} = − log(1 − U_{i}) for i=1,...,n
3) Set
4)
Actual value of the integral is 1
Matlab Code:
>> clear all >> close all >> n=1000; >> u=rand(1,n); >> x=log(u); % Generates number from exponential distribution using inverse transformation method >> w=(1./(1+x).^2).*exp(x); >> sum(w)/n ans = 0.8884 Similarly for n=1000000, we get 0.9376 which is even closer to 1.
Another Method
By changing the variable so that the bounds is (0,1), we can apply the Unif(0,1) method:
Let
We can express the integral as
which we recognise that it is just a Unif(0,1) and the result follows.
The following are general forms for the change of variable method for different cases
Source: Wikipedia Numerical Integration
Insertformulahere===Problem of Importance Sampling===
The variance of could be very large (infinitely large) with a bad choice of g
when g(x) is very small, then E(w^{2}) can be (infinitely) large. This leads to Var(x) being (infinitely) large too.
Consider the term .
• If g(x) has thinner tails compared to f(x), then could be infinitely large.
i.e. E(w^{2}) is infinitely large and so is variance.
A bad choice for g(x) can cause a problem and a good choice can reduce the variance. Therefore we need to have criteria for choosing good g:
Advice 1: Choose g such that g has thicker tails compared to f
 Also, if over a set A, g is small but f is large, then could be large. (i.e. the variance could be large.)
Advice 2: Choose g to have similar shape with f
In general, it is better to choose g such that it is similar to f in terms of shape but with thicker tails.
Example List
Estimate
Note: due to the symmetric property of normal distribution. The occurrence of Z>3 is a rare event since is roughly 0.13% (this is obtained from a normal probability table). stat 231 note.
Method 1: Basic Sampling
We let be the pdf of the standard normal. We want to compute
where
This gives where
which is equivalent to
Note :we could also formulate h(x) to be the following because the density at a single point (3 in this case) is 0 anyways.
MATLAB Code
x=randn(1,100); sum(x>3)/100; clc clear all close all n = 100; for ii = 1:200; x = randn(1,n); I(ii) = sum(x>3)/n %%sums values in x vector greater than 3 and divides by n end
Note: (x>3) is an indicator function in Matlab.
It will provide answers in the form of boolean.
In this example,
We see that if we repeat I(ii) several times, we get 0, 0, 0.01, 0, 0, 0.
This is considered a very good result as 5 out of 6 times you get the actual mean of the distribution.
Method 2: Importance Sampling
where Choose g(x) from N(4,1)
Note :
 N(4,1) was chosen according to our advice mentioned earlier. N(4,1) has the same shape (actually the exact same shape) as N(0,1). Hence it will not increase the variance of our simulation.
 The reason why we do not choose uniform distribution for this case is because the uniform distribution only distributed over a finite interval from a to b, where the required N(4,1) distributed over all x.
 To be more precise, we can see that choosing a distribution centered at 3 or nearby points (i.e. 2 or 4) will help us generate more points which are greater than 3. Thus the size of variance between different samples will be reduced. The reason behind this can be explained as follows:
Eg: If we take a sample of 1000 points and very few points are above three and we take the sample again, we will have a huge variance as the probability of samples greater than 3 is low. We may even get 0 as our simulated answer as shown in class which is not the case. Thus using this method helps us overcome the problem of sampling from rare events.
where
This gives
MATLAB
clear all close all clc %% clc clears all input and output from the Command Window display, giving you a "clean screen." n=100; for ii=1:200 x=randn(1,n); lb(ii)=sum(x>3)/n; %sums values in x vector greater than 3 and divides by n x=randn(1,n)+4; ls(ii)=sum((x>3).*exp(84*x))/n; %w(x)/n end var(lb) var(ls) var(ls)/var(lb) hist(ls,50)
Note:
The helper g(x) needs to be a valid pdf.
Example3
If g(x) = x for x belongs to [0,1], the integral of this function is not 1.
So, we need to add a constant number to make it a valid pdf.
Therefore, we change it to g(x) = 2x for 0<x<1
This code is for calculating the variance.
The first method produced a variance with a power of 10^{5}, while the second method produced a variance with a power of 10^{8}. Hence, a clear variance reduction is evident.
Side Note:
 The most effective variance reduction technique is to increase the sample size. For instance, in the above example, by using Importance Sampling, we are able to reduce the variance by 3 degrees of power.
 However if we used Method 1 while increasing the sample size from 200 to 1,000,000 or more, we are able to decrease the variance by 4 or more degrees of power.
 Also, note that since there is a large variance, it is problematic. So by choosing a different distribution that is not centered around 0, a distribution that is centered at 4 for example would result in less variation. For example, choose
Important Notes on selection of g(x):
 g(x) must have the same support as f(x) in order for accurate sampling
 g(x) must be such that it encourages the occurrence of rare points (rare h(x))
 Selection of g(x) greatly affects E[w^{2}] therefore affects the variance. A poor choice of g(x) can cause a significant increase in the variance, thus defeating the purpose of Importance Sampling.
 Specifically, it is recommended that g(x) have the following properties^{[14]}
1) It is greater than 0 whenever the function in question is not zero.
2) It should be close to being proportional to the absolute value of the function in question.
3) It should be easy to simulate.
4) It should be easy to compute for any realizable x.
 Although there are many methods of variance reduction, the best way is to increase n. The larger n is, the closer your value is to the exact value.
 Using various computer software is the most effective method of reducing a variance.
Class 24, Thursday, July 25, 2013
Importance Sampling
Importance Sampling is the most fundamental variance reduction technique and usually leads to a dramatic variance reduction.
Importance sampling involves choosing a sampling distribution that favour important samples*.(Simulation and the Monte Carlo Method, Reuven Y. Rubinstein)
 Here "favour important samples" implies encouraging the occurrence of the desired event or part of the desired event. For instance, if the event of interest is rare (probability of occurrence is close to zero), we "favour important samples" by choosing a sampling distribution such that the event has higher probability of occurrence.
Definition of importance sampling from Wikipedia:
Importance sampling is a general technique for estimating properties of a particular distribution, while samples are generated from a different distribution other than the distribution of interest. It is related to umbrella sampling in computational physics. Depending on the application, the term may refer to the process of sampling from this alternative distribution, the process of inference, or both.
Recall that using importance sampling,we have the following:
If g(x) is another probability density function,
note: in summary, a good importance sampling function g(x) should satisfies:
1. g(x) > 0 whenever f(x)not equal to 0
2. g(x) should be equal or close to the absolute value of f(x)
3. easy to simulate values from g(x)
4. easy to compute the density of g(x)
original source is here
http://ib.berkeley.edu/labs/slatkin/eriq/classes/guest_lect/mc_lecture_notes.pdf
then we have:
, where
In order to estimate I we have:
and , where h(x) > = 0 for all x
Higher values of n correspond to values of closer to I, which approaches as n approaches infinity.
Note: g(x) should be chosen carefully. It should be easy to sample from. Also, since this method is for minimizing the variance, g(x) should be chosen in a manner such that the variance is minimized. g*(x) is the distribution that minimizes the variance.
 In assignment 6, we need to prove that "the choice of g that minimizes the variance of I is g*(x)". Furthermore, we were asked to minimize the variance of I which requires us to minimize the variance of w (as seen below). For simplicity, we assume that h(x) is greater than or equal to 0 for all x. In reality, h(x) can be positive, negative or 0.
Note: This expression has equivalent to the summation of all variances of W, because W’s are independent, hence covariance terms are zero.
 The Second Term
 Note ： No matter what g is, the second term is always constant with respect to g at I^{2}.
since I^{2} is constant with respect to g, if we want to minimize the variance, we only need to consider the first term.
So, we need to minimize the first term.
 The First Term
If , then where
= I^{2}
(because we choose g(x)=g*(x))
since ,
Therefore, at
Note that although this proof uses the assumption of h(x) ≥ 0, the result still holds for functions h(x) that are not always nonnegative (however, the variance will not be 0)
More specifically, since where h(x) can be negative, so , and as a result Var(w) will always be nonnegative.
Remark: Since I^{2} is constant of g, we only consider minimizing the first term to minimize the variance.
Normalized Importance Sampling
since f(x) is a pdf, and the integral is just equal to 1
where and
Where corresponds to a weight.
xi~g(x)
Note: Above is not included in exam.
 Note:
 One advantage of using Normalized Importance Sampling is that we don't need to know the normalization factor of distribution f(x). The normalization will be applied to the individual β_{i}, and so the sum of the β's will be of the same proportion.
 The normalization factor will be cancelled out when we calculate the weights. Note that this is the same advantage as that of Metropolis Hastings. It is a powerful advantage because in practice, determining the normalizing constant can be very difficult. This advantage does not hold when using β only β^{ * }
 Normalized Importance Sampling however, performs worse than regular importance sampling as we are approximating the normalizing constant
 One advantage of using Normalized Importance Sampling is that we don't need to know the normalization factor of distribution f(x). The normalization will be applied to the individual β_{i}, and so the sum of the β's will be of the same proportion.
Here is a video explaining normalized importance sampling sightly differently.
Final Exam Review
Summary of Final Exam Topics: PreMidterm: • Multiplicative Congruential Algorithm • Inverse Transform Method • Acceptance Rejection Method • Multivariate Random Variable Generation • Vector Acceptance Rejection Method PostMidterm: • Poisson Process • Markov Chains (MC) • Page Rank (MC Application) • Markov Chain Monte Carlo (MCMC) • MetropolisHasting Algorithm (MCMC Application) • Simulated Annealing (MCMC Application) • Gibbs Sampling (MetropolisHasting adaptation) • Monte Carlo Integration • Importance Sampling
Only review of material not covered on the midterm, the final will be cumulative
For review of material covered on the midterm refer to class 12  June 13th.
Stochastic Processes (we learned Poisson Process and Markov Chain).
 {X_{t}  t in T}
where x_{t} is an element of state space X and T is the index set.
 A collection of random variables.
 The two most important stochastic processes we looked at in this term are Poission Process and Markov Chain.
===Poisson Process=== (useful for counting number of arrivals):
 two assumptions:
 the number of arrivals in nonoverlapping intervals are independent
 the number of arrivals in an interval I is Poisson distributed.
 the mean of the Poisson Process is
 Can be generated using the exponential distribution
Algorithm
 1. Set n=1, a=1
 2. U_{n} ~ U[0,1] and set a = aU_{n}
 3. If then: n=n+1 and go to Step 2. Else set X=n1.
Acknowledgments: from Spring 2012 stat 340 coursenotes
Matlab code review:
T(1)=0; ii=1; l=2; TT=5; while T(ii)<=TT u=rand; ii=ii+1; T(ii)=T(ii1)  (1/l)*log(u); end plot(T, '.')
Markov Chain:
Recall that:
 A Markov Chain is a discrete random process which transits from one state to another. The number of states in a Markov Chain can be finite or countable.
 A Markov Chain has the Memoriless Property:
Pr(X_{t} = x_{t}  X_{t − 1} = x_{t − 1},...,X_{1} = x_{1}) = Pr(X_{t} = x_{t}  X_{t − 1} = x_{t − 1}).
In other words, the current state only depends on the previous state and no other prior states. This property is also called the "Markov property".
 The possible values of X_{i} are called the "state space" of the chain.
 Transition probability P_{ij} = Pr {x_{t+1}=j  x_{t} = i} = P(i,j)
 Transition matrix P = [P_{11} ... P_{1n} ; ... ; P_{n1} ... P_{nn}]. where P_{ ij} >= 0, row sum = 1
 Nstep transition matrix P_{n(i,j)} = Pr {x_{t+n}=j  x_{t} = i}, P_{n} = P^{n}
 Marginal distribution:
In general,
where μ_{0} is initial dust.
 Stationary distribution: π = π P
There are three conditions to calculate Stationary Distribution
1.
2. sum of π= 1
3. π is greater than 0
 Limiting distribution:
 Detailed Balance:
Detailed Balance
if π_{i} P_{ij} = π_{j} P_{ji},
_{i} P_{ij} _{j}P_{ji} = π_{j}_{ji} = π_{j }
Proof: We will look at a single row from
, denoted by
note:
∑  P_{ji} = 1. 
i 
 Application of Markov Chain  PageRank:
, where 0 < d < 1 is constant
where L_{ij} is 1 if j has link to i, and 0 otherwise;
C_{j} =  ∑  L_{ij} 
i 
Note: we solved this using systems of equations or eigenvalues and eigenvectors
Matrix form:
(ee^T is a matrix of all 1s)
The matrix has column summation equals to one and has eigenvalues equal to one.
Markov Chain Monte Carlo (MCMC):
Recall that MCMC is a special form of stochastic process where X_{t} depends only on X_{t1}
The two applications of MCMC are Metropolis–Hasting algorithm and Simulated Annealing.
 'Metropolis–Hasting Algorithm':
If we have target distribution f, which we want to sample from, then
decide to accept the sample or reject.
1) X_{0}= state of chain at time 0. Set i = 0
2) Y~q(y  x)
3)
4) U~U(0,1)
5) If U < r, X_{t + 1} = Y; else X_{t + 1} = X_{t}
6) i = i + 1. Return to Step 2.
Note :for just the Metropolis Algorithm everything is the same as in MetropolisHasting Algorithm except that step 3 is:
This is because q is symmetric in the Metropolis Algorithm.
 Application of M.H. Algorithm  Simulated Annealing:
min h(x) = max exp(h(x)/T)
Simulated Annealing Algorithm:
1) Set T to be a large number, Set i = 0, X_{t} = 0
2) Y~Q(Y  X)
3)
Since q(.) is symetric
4) U~U(0,1)
5) If U < r, X_{t + 1} = Y; else X_{t + 1} = X_{t}
6) Decrease T. Return to Step 2.
 note: popular candidates for Q(YX) are uniform distribution and normal distribution.(symmetric)
 Proof of MH Algorithm (convergence):
Detailed Balance: f(x)P(y  x) = f(y)P(x  y)
1)
=> r(x,y) =
2)
=> r(x,y) = 1
LHS: f(x)P(y  x) = f(x)q(y  x)r(x,y)
=f(x)q(yx)
=f(y)q(xy)
 Therefore, detailed balance is satisfied, so f(x) is a stationary distribution!
 We can also prove similarly for Metropolis Hasting and Simulated Annealing (even easier since they don't have q(xy)/q(yx) when calculating r)
 Proof of Simulated Annealing Algorithm (convergence):
Detailed Balance:
Since q(yx) is symmetric > q(yx)=q(xy)
1)
=>
2)
=>
Gibbs Sampling:
The most widely used version of the MetropolisHastings algorithm is the Gibbs sampler.
This sampling method is useful when dealing with multivariable distributions.
f(x_{1},x_{2},...,x_{d})
x = (x_{1},...,x_{d})
 Suppose are the initial values.
Start by sampling from x_{1}:
, where i = 2,...,d
Example:
Consider a biased die π= [0.1, 0.1, 0.3, 0.3, 0.1, 0.1]
We use 6x6 matrix as the proposal distribution
And we use U(0,1) distribution.
Algorithm
1. x_{t} = 5
2. Y~unif[1,2,...,6]
3.
4. U~Unif(0,1)
if , X_{t+1}=Y
else X_{t+1}=X_{t}
go back to 2
Monte Carlo Integration
 It is a technique used for numerical integration using random numbers.
 This method is one of the Monte Carlo methods that numerically computes definite integrals.
 The above integral can be rewritten as following:
where U(a,b) = 1 / (b − a)
So we have and
For the case where we do not have finite bounds on the integration, we have
Importance Sampling
Importance Sampling is a useful technique for variance reduction.
Using importance sampling, we have:
If g(x) is another probability density function,
, where
To approximate I,
and , where h(x) > = 0 for all x
Note: g(x) should be chosen carefully so that its distribution would minimize the variance.