stat340s13

Introduction, Class 1 - Tuesday, May 7

Course Instructor: Ali Ghodsi

Lecture:
001: T/Th 8:30-9:50am MC1085
002: T/Th 1:00-2:20pm DC1351
Tutorial:
2:30-3:20pm Mon M3 1006
Office Hours:
Friday at 10am, M3 4208

Midterm

Monday June 17,2013 from 2:30pm-3:20pm

Final

Saturday August 10,2013 from 7:30pm-10:00pm

TA(s):

TA Day Time Location
Lu Cheng Monday 3:30-5:30 pm M3 3108, space 2
Han ShengSun Tuesday 4:00-6:00 pm M3 3108, space 2
Yizhou Fang Wednesday 1:00-3:00 pm M3 3108, space 1
Huan Cheng Thursday 3:00-5:00 pm M3 3111, space 1
Wu Lin Friday 11:00-1:00 pm M3 3108, space 1

Four Fundamental Problems

1. Classification: Given an input object X, we have a function which will take in 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. (Example of stock prices)
(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)
4. Dimensionality Reduction (aka 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 (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.

- 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
- Discrete-Event Systems
- Variance reduction
- Markov Chain Monte Carlo

Tentative Marking Scheme

Item Value
Assignments (~6) 30%
WikiCourseNote 10%
Midterm 20%
Final 40%

The final exam is going to be closed book and only non-programmable calculators are allowed.
A passing mark must be achieved in the final to pass the course

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 must first: <br\> 1. Use a computer to generate (pseudo) random numbers.
2. Use these numbers to generate values of random variable from distributions.
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.)

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 deterministic. Although the pseudo random numbers are deterministic, these numbers have a sequence of value and all of them have the appearance of being independent uniform random variables. Being deterministic, pseudo random numbers are valuable and beneficial due to the ease of generation and manipulation.

When people do the test many times, the results will be the closed express values, which make the trial look deterministic, however for each trial, the result is random. So, it looks like pseudo random numbers.

Mod

Let $n \in \N$ and $m \in \N^+$, then by Division Algorithm, $\exists q, \, r \in \N \;\text{with}\; 0\leq r \lt m, \; \text{s.t.}\; n = mq+r$, where $q$ is called the quotient and $r$ the remainder. Hence we can define a binary function $\mod : \N \times \N^+ \rightarrow \N$ given by $r:=n \mod m$ 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.
if y = ax + b, then $b:=y \mod a$.

For example:
30 = 4 * 7 + 2
2 = 30 mod 7

25 = 8 * 3 + 1
1 = 25 mod 3

Note: $\mod$ here is different from the modulo congruence relation in $\Z_m$, 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 non-zero remainder. But both integers should satisfy n = mq + r, where m, r, q, and n are all integers, and r is smaller than m.

Mixed Congruential Algorithm

We define the Linear Congruential Method to be $x_{k+1}=(ax_k + b) \mod m$, where $x_k, a, b, m \in \N, \;\text{with}\; a, m \neq 0$. Given a seed (i.e. an initial value $x_0 \in \N$), we can obtain values for $x_1, \, x_2, \, \cdots, x_n$ 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 $b \neq 0$

An interesting fact about Linear Congruential Method is that it is one of the oldest and best-known 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.)

First consider the following algorithm
$x_{k+1}=x_{k} \mod m$

Example
$\text{Let }x_{0}=10,\,m=3$

\begin{align} x_{1} &{}= 10 &{}\mod{3} = 1 \\ x_{2} &{}= 1 &{}\mod{3} = 1 \\ x_{3} &{}= 1 &{}\mod{3} =1 \\ \end{align}

$\ldots$

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.

$x_{k+1}=(a \cdot x_{k} + b) \mod m$(a little tip: $(a \cdot b)\mod c = (a\mod c)\cdot(b\mod c))$

Example
$\text{Let }a=2,\, b=1, \, m=3, \, x_{0} = 10$
\begin{align} \text{Step 1: } 0&{}=(2\cdot 10 + 1) &{}\mod 3 \\ \text{Step 2: } 1&{}=(2\cdot 0 + 1) &{}\mod 3 \\ \text{Step 3: } 0&{}=(2\cdot 1 + 1) &{}\mod 3 \\ \end{align}
$\ldots$

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: $\frac {x_{n+1}}{m-1}$ 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.

>>a=13
>>b=0
>>m=31
>>x(1)=1
>>for ii=2:1000
x(ii)=mod(a*x(ii-1)+b,m);
end
>>size(x)
ans=1    1000
>>hist(x)


(Note: The semicolon after the x(ii)=mod(a*x(ii-1)+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 $x_{k+1} = ax_k+ b \mod m$.

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 0-30 had the same frequency in the histogram, so we can conclude that they are uniformly distributed.

If $x_0=1$, then

$x_{k+1} = 13x_{k}\mod{31}$

So,

\begin{align} x_{0} &{}= 1 \\ x_{1} &{}= 13 \times 1 + 0 &{}\mod{31} = 13 \\ x_{2} &{}= 13 \times 13 + 0 &{}\mod{31} = 14 \\ x_{3} &{}= 13 \times 14 + 0 &{}\mod{31} =27 \\ \end{align}

etc.

For example, with $a = 3, b = 2, m = 4, x_0 = 1$, we have:

$x_{k+1} = (3x_{k} + 2)\mod{4}$

So,

\begin{align} x_{0} &{}= 1 \\ x_{1} &{}= 3 \times 1 + 2 \mod{4} = 1 \\ x_{2} &{}= 3 \times 1 + 2 \mod{4} = 1 \\ \end{align}

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 $\Z_{31}$.
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 $\mod m$, 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]
If $x_0=3$ and $x_n=(5x_{n-1}+7)\mod 200$, find $x_1,\cdots,x_{10}$.
Solution:
\begin{align} x_1 &{}= (5 \times 3+7) &{}\mod{200} &{}= 22 \\ x_2 &{}= 117 &{}\mod{200} &{}= 117 \\ x_3 &{}= 592 &{}\mod{200} &{}= 192 \\ x_4 &{}= 2967 &{}\mod{200} &{}= 167 \\ x_5 &{}= 14842 &{}\mod{200} &{}= 42 \\ x_6 &{}= 74217 &{}\mod{200} &{}= 17 \\ x_7 &{}= 371092 &{}\mod{200} &{}= 92 \\ x_8 &{}= 1855467 &{}\mod{200} &{}= 67 \\ x_9 &{}= 9277342 &{}\mod{200} &{}= 142 \\ x_{10} &{}= 46386717 &{}\mod{200} &{}= 117 \\ \end{align}

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 $\left[0,1\right]$ (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 non-zero constant. Then for any seed x0, and LCG will have largest max. period if and only if
(i) m and c are coprime;
(ii) (a-1) is divisible by all prime factor of m;
(iii) if and only if m is divisible by 4, then a-1 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=(15Xn-1 + 4) mod 7


(i) m=7 c=4 -> coprime;
(ii) a-1=14 and a-1 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:

1. find integer: a b m(large prime) x0(the seed) .
2. $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)


$\lt math\gt Insert formula here$$\lt math\gt Insert formula here$[/itex][/itex]=== 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 $F:\R \rightarrow \left[0,1\right]$ be a cdf. If $U \sim U\left[0,1\right]$, then the random variable given by $X:=F^{-1}\left(U\right)$ follows the distribution function $F\left(\cdot\right)$, where $F^{-1}\left(u\right):=\inf F^{-1}\big(\left[u,+\infty\right)\big) = \inf\{x\in\R | F\left(x\right) \geq u\}$ 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:
\begin{align} \forall u \in \left[0,1\right], \, x \in \R, \\ &{} F^{-1}\left(u\right) \leq x &{} \\ \Rightarrow &{} F\Big(F^{-1}\left(u\right)\Big) \leq F\left(x\right) &&{} F \text{ is non-decreasing} \\ \Rightarrow &{} F\Big(\inf \{y \in \R | F(y)\geq u \}\Big) \leq F\left(x\right) &&{} \text{by definition of } F^{-1} \\ \Rightarrow &{} \inf \{F(y) \in [0,1] | F(y)\geq u \} \leq F\left(x\right) &&{} F \text{ is right continuous and non-decreasing} \\ \Rightarrow &{} u \leq F\left(x\right) &&{} \text{by definition of } \inf \\ \Rightarrow &{} x \in \{y \in \R | F(y) \geq u\} &&{} \\ \Rightarrow &{} x \geq \inf \{y \in \R | F(y)\geq u \}\Big) &&{} \text{by definition of } \inf \\ \Rightarrow &{} x \geq F^{-1}(u) &&{} \text{by definition of } F^{-1} \\ \end{align}

That is $F^{-1}\left(u\right) \leq x \Leftrightarrow u \leq F\left(x\right)$

Finally, $P(X \leq x) = P(F^{-1}(U) \leq x) = P(U \leq F(x)) = F(x)$, 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 $U from U(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) = \lambda e^{-\lambda x}$
Calculate the CDF:
$F(x)= \int_0^x f(t) dt = \int_0^x \lambda e ^{-\lambda t}\ dt$ $= \frac{\lambda}{-\lambda}\, e^{-\lambda t}\, | \underset{0}{x}$ $= -e^{-\lambda x} + e^0 =1 - e^{- \lambda x}$
Solve the inverse:
$y=1-e^{- \lambda x} \Rightarrow 1-y=e^{- \lambda x} \Rightarrow x=-\frac {ln(1-y)}{\lambda}$
$y=-\frac {ln(1-x)}{\lambda} \Rightarrow F^{-1}(x)=-\frac {ln(1-x)}{\lambda}$
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: $x=\frac{-ln(U)}{\lambda}$

MatLab Code:

>>u=rand(1,1000);
>>hist(u)       #will generate a fairly uniform diagram


#let λ=2 in this example; however, you can make another value for λ
>>x=(-log(1-u))/2;
>>size(x)       #1000 in size
>>figure
>>hist(x)       #exponential


Example 2 - Continuous Distribution:

$f(x) = \dfrac {\lambda } {2}e^{-\lambda \left| x-\theta \right| } for -\infty \lt X \lt \infty , \lambda \gt 0$

Calculate the CDF:

$F(x)= \frac{1}{2} e^{-\lambda (\theta - x)} , for \ x \le \theta$
$F(x) = 1 - \frac{1}{2} e^{-\lambda (x - \theta)}, for \ x \gt \theta$

Solve for the inverse:

$F^{-1}(x)= \theta + ln(2y)/\lambda, for \ 0 \le y \le 0.5$
$F^{-1}(x)= \theta - ln(2(1-y))/\lambda, for \ 0.5 \lt y \le 1$

Algorithm:
Steps:
Step 1: Draw U ~ U[0, 1];
Step 2: Compute $X = F^-1(U)$ i.e. $X = \theta + \frac {1}{\lambda} ln(2U)$ for U < 0.5 else $X = \theta -\frac {1}{\lambda} ln(2(1-U))$

MatLab Code:

>> u = rand;
>> theta  = 1;
>> lambda = 1;
>> if u < 0.5
X = theta + (1/lambda) * log(2u);
else
X = theta - (1/lambda) * log(2(1-u));
end


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: $x=y^\frac {1}{5}$. Therefore, $F^{-1} (x) = x^\frac {1}{5}$
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 $x= u^\frac{1}{5}$

Algorithm:
Steps:
Step 1: Draw U ~ rand[0, 1];
Step 2: X=U^(1/5);

MatLab Code:

>>x=rand^(1/5)


Example 4 - BETA(1,β):
Given u~U[0,1], generate x from BETA(1,β)
Solution: $F(x)= 1-(1-x)^\beta$, $u= 1-(1-x)^\beta$
Solve for x: $(1-x)^\beta = 1-u$, $1-x = (1-u)^\frac {1}{\beta}$, $x = 1-(1-u)^\frac {1}{\beta}$
let β=3, use Matlab to construct N=1000 observations from Beta(1,3)
Matlab Code:
>> u = rand(1,1000);

  x = 1-(1-u)^(1/3);


>> hist(x,50)
>> mean(x)

Example 5 - Estimating $\pi$:
Let's use rand() and Monte Carlo Method to estimate $\pi$
N= total number of points
Nc = total number of points inside the circle
Prob[(x,y) lies in the circle=$\frac {Area(circle)}{Area(square)}$
If we take square of size 2, circle will have area =$\pi (\frac {2}{2})^2 =\pi$.
Thus $\pi= 4(\frac {N_c}{N})$

  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 the effect of changes of 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

To sample X with CDF F(x),

1. Draw u~U(0,1)
2. X = F-1(u)

Proof
First note that $P(U\leq a)=a, \forall a\in[0,1]$

$P(X\leq x)$

$= P(F^{-1}(U)\leq x)$ (since $X= F^{-1}(U)$ by the inverse method)
$= P((F(F^{-1}(U))\leq F(x))$ (since $F$ is monotonically increasing)
$= P(U\leq F(x))$ (since $P(U\leq a)= a$ for $U \sim U(0,1), a \in [0,1]$, this is explained further below)
$= F(x) , \text{ where } 0 \leq F(x) \leq 1$

This is the c.d.f. of X.

Note: that the CDF of a U(a,b) random variable is:

$F(x)= \begin{cases} 0 & \text{for }x \lt a \\[8pt] \frac{x-a}{b-a} & \text{for }a \le x \lt b \\[8pt] 1 & \text{for }x \ge b \end{cases}$

Further, the pdf $f(x) = \frac{1}{b-a}$ and 0 otherwise.

Thus, for $U$ ~ $U(0,1)$, we have $P(U\leq 1) = 1$ and $P(U\leq 1/2) = 1/2$.
More generally, we see that $P(U\leq a) = a$.
For this reason, we had $P(U\leq F(x)) = F(x)$.

Reminder:
This is only for uniform distribution $U~ \sim~ Unif [0,1]$
$P (U \le 1) = 1$
$P (U \le 0.5) = 0.5$
$P (U \le a) = a$

$P(U\leq a)=a$

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 $P(X = x) = F(x)- \lim_{s \to x^-}F(x)$ which equals zero for any continuous random variable

Advantages of the Inverse Transform Method

• It is very easy to use and apply if we are able to find the inverse cdf $F^{-1}(\cdot)$.
• It preserves monotonicity and correlation, which consequently helps in order statistics, variance reduction methods, and also generating truncated distributions.

Limitations of the Inverse Transform Method

Though this method is very easy to use and apply, it does have some major disadvantages/limitations:

• Since a number of comparisons are required, the speed of this method is often very slow.
• We need to find the inverse cdf $F^{-1}(\cdot)$. In some cases the inverse function does not exist, or is difficult to find.

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.

[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:

\begin{align}P(X = x_i) &{}= p_i \end{align}
$x_0 \leq x_1 \leq x_2 \dots \leq x_n$
$\sum p_i = 1$

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, $U~ \sim~ Unif [0,1]$
3. If $U\leq p_{o}$, deliver $X = x_{o}$
4. Else, if $U\leq p_{o} + p_{1}$, deliver $X = x_{1}$
5. Repeat the process again till we reached to $U\leq p_{o} + p_{1} + ......+ p_{k}$, 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.

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

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

• Matlab Code
>> u = rand;
>> if u < 0.5
x = -1;
elseif u< 0.8
x = 2;
elseif u < 0.9
x = -2;
elseif u < 0.97
x = 0;
else
x = 1;
end


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 U <= 0.5, then X = 0

and if 0.5 < U <= 1, then X =1.

This allows the probability of Heads occurring to be 0.5 and is a good generator of a random coin flip.

$U~ \sim~ Unif [0,1]$

\begin{align} P(X = 0) &{}= 0.5\\ P(X = 1) &{}= 0.5\\ \end{align}

$x = \begin{cases} 0, & \text{if } U\leq 0.5 \\ 1, & \text{if } 0.5 \lt U \leq 1 \end{cases}$

• 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 semi-colon in Matlab: Matlab will not print out the results if the line ends in a semi-colon and vice versa.

Example 3.2 (From class):

Suppose we have the following discrete distribution:

\begin{align} P(X = 0) &{}= 0.3 \\ P(X = 1) &{}= 0.2 \\ P(X = 2) &{}= 0.5 \end{align}

The cumulative distribution function (cdf) for this distribution is then:

$F(x) = \begin{cases} 0, & \text{if } x \lt 0 \\ 0.3, & \text{if } x \lt 1 \\ 0.5, & \text{if } x \lt 2 \\ 1, & \text{if } x \ge 2 \end{cases}$

Then we can generate numbers from this distribution like this, given $U \sim~ Unif[0, 1]$:

$x = \begin{cases} 0, & \text{if } U\leq 0.3 \\ 1, & \text{if } 0.3 \lt U \leq 0.5 \\ 2, & \text{if } 0.5 \lt U\leq 1 \end{cases}$

"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

• 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)


Can you find a faster way to run this algorithm? Consider:

$x = \begin{cases} 2, & \text{if } U\leq 0.5 \\ 1, & \text{if } 0.5 \lt U \leq 0.7 \\ 0, & \text{if } 0.7 \lt U\leq 1 \end{cases}$

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?

close all
clear all
for ii=1:1000
u=rand;
if u<=0.5
x(ii)=2;
elseif u<=0.7
x(ii)=1;
else
x(ii)=0;
end
end
size(x)
hist(x)


Example 3.3: Generating a random variable from pdf

$f_{x}(x) = \begin{cases} 2x, & \text{if } 0\leq x \leq 1 \\ 0, & \text{if } otherwise \end{cases}$
$F_{x}(x) = \begin{cases} 0, & \text{if } x \lt 0 \\ \int_{0}^{x}2sds = x^{2}, & \text{if } 0\leq x \leq 1 \\ 1, & \text{if } x \gt 1 \end{cases}$
\begin{align} U = x^{2}, X = F^{-1}x(U)= U^{\frac{1}{2}}\end{align}

• Code
>> u = rand;
>> x = u ^ (1/2);


Example 3.4: Generating a Bernoulli random variable

\begin{align} P(X = 1) = p, P(X = 0) = 1 - p\end{align}
$F(x) = \begin{cases} 1-p, & \text{if } x \lt 1 \\ 1, & \text{if } x \ge 1 \end{cases}$

1. Draw $U~ \sim~ Unif [0,1]$
2. $X = \begin{cases} 0, & \text{if } 0 \lt U \lt 1-p \\ 1, & \text{if } 1-p \le U \lt 1 \end{cases}$

• Code
>> u = rand;
>> P = .3   % p from (0,1)
>> if u < (1-p)
x = 0;
else
x = 1;
end


Example 3.5: Generating Binomial(n,p) Random Variable
$use p\left( x=i+1\right) =\dfrac {n-i} {i+1}\dfrac {p} {1-p}p\left( x=i\right)$

Step 1: Generate a random number $U$.
Step 2: $c = \frac {p}{(1-p)}$, $i = 0$, $pr = (1-p)^n$, $F = pr$
Step 3: If U<F, set X = i and stop,
Step 4: $pr = \, {\frac {c(n-i)}{(i+1)}} {pr}, F = F +pr, i = i+1$
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.

Step 1: Generate n uniform numbers U1 ... Un.
Step 2: X = $\sum U_i \lt = p$ 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:

\begin{align} f(x) = \frac {\, e^{-u} u^x}{x!} \end{align}

We know that

\begin{align} P_{x+1} = \frac {\, e^{-u} u^{x+1}}{(x+1)!} \end{align}

The ratio is \begin{align} \frac {P_{x+1}}{P_x} = ... = \frac {u}{{x+1}} \end{align} Therefore, \begin{align} P_{x+1} = \, {\frac {u}{x+1}} P_x\end{align}

Algorithm:
1) Generate U ~ U(0,1)
2) \begin{align} X = 0 \end{align}

  \begin{align} F = P(X = 0) = e^{-u}*u^0/{0!} = e^{-u} = p \end{align}


3) If U<F, output x

  Else, \begin{align} p = (u/(x+1))^p \end{align}
\begin{align} F = F + p \end{align}
\begin{align} x = x + 1 \end{align}


4) Go to 1

Acknowledgements: This is 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: $P(X=x_i) = \, p (1-p)^{x_{i}-1}$ We have CDF: $F(x)=P(X \leq x)=1-P(X\gt x) = 1-(1-p)^x$, P(X>x) means we get at least x failures before observe the first success. Now consider the inverse transform:

$x = \begin{cases} 1, & \text{if } U\leq p \\ 2, & \text{if } p \lt U \leq 1-(1-p)^2 \\ 3, & \text{if } 1-(1-p)^2 \lt U\leq 1-(1-p)^3 \\ .... k, & \text{if } 1-(1-p)^{k-1} \lt U\leq 1-(1-p)^k .... \end{cases}$

Note: Unlike the continuous case, the discrete inverse-transform 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 $U \leq P_{0}$ deliver $x = x_{0}$
3. Else if $U \leq P_{0} + P_{1}$ deliver $x = x_{1}$
4. Else if $U \leq P_{0} + P_{1} + P_{2}$ deliver $x = x_{2}$
...

  Else if $U \leq P_{0} + ... + P_{k}$ 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/(1-p),i=0, pr=(1-p)n, F=pr.
step 3: If U<F, set X=i and stop.
step 4: pr =[c(n-i)/(i+1)]pr, F=F+pr, i=i+1.
step 5: Go to step 3.

Problems
1. We have to find $F^{-1}$

2. For many distributions, such as Gaussian, it is too difficult to find the inverse of $F(x)$.
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 closed 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:

1. find CDF F
2. find the inverse F-1
3. Generate a list of uniformly distributed number {x}
4. {F-1(x)} is what we want

Matlab Instruction

>>u=rand(1,1000);
>>hist(u)
>>x=(-log(1-u))/2;
>>size(x)
>>figure
>>hist(x)


Discrete case:

1. generate a list of uniformly distributed number {u}
2. di=xi if$X=x_i,$ if $F(x_{i-1})\lt U\leq F(x_i)$
3. {di=xi} 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)


Continuous Case

Example 3.8: Generating a Weibull(a,b) distribution

Let X ~ Weibull(a,b). Write an algorithm to generate X.
The PDF of X is:

     $f(x) = ab^{-a}x^{a-1}exp((-x/b)^a)$ ; x > 0


The CDF of X is:

     $F(x) = 1-exp((-x/b)^a)$ ; x > 0


Solve for U = F(X) for X:

     $U = 1-exp((-x/b)^a)$


<=> $-(X/b)^a=ln(1-U)$
<=> $(X/b)=(-ln(1-U))^{1/a}$
<=> $X=b(-ln(1-U))^{1/a}$

Algorithm:
1. Generate U~U(0,1) <- Note: Generating U and 1-U is the same since they are still U(0,1)
2. Return $X=b(-ln (U) )^{1/a}$

Acceptance-Rejection Method

Although the inverse transformation method does allow us to change our uniform distribution, it has two limits;

1. Not all functions have inverse functions (ie, the range of x and y have limit and do not fix the inverse functions)
2. 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 Acceptance-Rejection 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∈Sx, where Sx 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 Sx so that f(x)≤cg(x), ∀x∈Sx, then we can apply the procedure for Acceptance-Rejection Method. Typically we choose a density function that we already know how to sample from for g(x).

The main logic behind the Acceptance-Rejection Method is that:
1. We want to generate sample points from an unknown distribution, say f(x).
2. We use $\,cg(x)$ 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 $\,c g(x)$ (i.e. c=1), then $g(x) \geq f(x)$ 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, $g(x) \ngeqq f(x)$ ∀x.

Also remember that $\,c g(x)$ always generates higher probability than what we need. Thus we need an approach of getting the proper probabilities.

c must be chosen so that $f(x)\leqslant c g(x)$ 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 $f(x)\leqslant c g(x)$ 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 $f(x)\leqslant c g(x)$ at all the local maximums as well as the absolute maximums.
4. Verify that $f(x)\leqslant c g(x)$ at the tail ends by calculating $\lim_{x \to +\infty} \frac{f(x)}{\, c g(x)}$ and $\lim_{x \to -\infty} \frac{f(x)}{\, c g(x)}$ 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 p=P(U<= f(Y)/(cg(Y))) , P(N=n)=(1-p^(n-1))p ,n>=1.Thus on average the number of iterations required is given by E(N)=1/p

c should be close to the maximum of f(x)/g(x), not just some arbitrarily picked large number. Otherwise, the Acceptance-Rejection method will have more rejections (since our probability $f(x)\leqslant c g(x)$ 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 x1 will be sampled more often under cg(x) than under f(x).There will be more samples than we actually need, if $\frac{f(y)}{\, c g(y)}$ is small, the acceptance-rejection technique will need to be done to these points to get the accurate amount.In the region above x1, we should accept less and reject more.
2. Value around x2: number of sample that are drawn and the number we need are much closer. So in the region above x2, 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 $\frac{f(y)}{\, c g(y)}$, is by thinking of areas. From the graph above, we see that the target function in under the proposed function c g(y). Therefore, $\frac{f(y)}{\, c g(y)}$ 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 $\frac{f(y)}{\, c g(y)}$ 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, $c g(x) \geq f(x)$
-Similar or the same amount of points, $c g(x) \geq f(x)$
There is 1 case that is not possible:
-Less than enough points, such that $g(x)$ is greater than $f$, $g(x) \geq f(x)$

Procedure

1. Draw Y~g(.)
2. Draw U~u(0,1) (Note: U and Y are independent)
3. If $u\leq \frac{f(y)}{cg(y)}$ (which is $P(accepted|y)$) then x=y, else return to Step 1

Note: Recall $P(U\leq a)=a$. Thus by comparing u and $\frac{f(y)}{\, c g(y)}$, 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 X1, low probability to accept the point since f(x) is much smaller than cg(x).
At X2, high probability to accept the point. $P(U\leq a)=a$ 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 $c\leq \frac{f(y)}{g(y)}$

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 $c g(y)\geq f(y)$, that is,$c g(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 $c g(y)$ and $f(y)$ are the same.

2. $\frac {1}{C}$ is the area of $F(y)$ over the area of $c G(y)$ and is the acceptance rate of the points generated. For example, if $\frac {1}{C} = 0.7$ 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 $f: \R \rightarrow [0,+\infty]$ be a well-defined pdf, and $\displaystyle Y$ be a random variable with pdf $g: \R \rightarrow [0,+\infty]$ such that $\exists c \in \R^+$ with $f \leq c \cdot g$. If $\displaystyle U \sim~ U(0,1)$ is independent of $\displaystyle Y$, then the random variable defined as $X := Y \vert U \leq \frac{f(Y)}{c \cdot g(Y)}$ has pdf $\displaystyle f$, and the condition $U \leq \frac{f(Y)}{c \cdot g(Y)}$ is denoted by "Accepted".

Proof

Recall the conditional probability formulas:
\begin{align} P(A|B)=\frac{P(A \cap B)}{P(B)}, \text{ or }P(A|B)=\frac{P(B|A)P(A)}{P(B)} \text{ for pmf} \end{align}

$P(y|accepted)=f(y)=\frac{P(accepted|y)P(y)}{P(accepted)}$

based on the concept from procedure-step1:
$P(y)=g(y)$

$P(accepted|y)=\frac{f(y)}{cg(y)}$
(the larger the value is, the larger the chance it will be selected)

\begin{align} P(accepted)&=\int_y\ P(accepted|y)P(y)\\ &=\int_y\ \frac{f(s)}{cg(s)}g(s)ds\\ &=\frac{1}{c} \int_y\ f(s) ds\\ &=\frac{1}{c} \end{align}

Therefore:
\begin{align} P(x)&=P(y|accepted)\\ &=\frac{\frac{f(y)}{cg(y)}g(y)}{1/c}\\ &=\frac{\frac{f(y)}{c}}{1/c}\\ &=f(y)\end{align}

Here is an alternative introduction of Acceptance-Rejection Method

-Acceptance-Rejection Method is not good for all cases. The limitation with this method is that sometimes many points will be rejected. One obvious cons 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 $cg(x) \leq f(x)$ else the the algorithm will not be efficient. This is because $f(x)/cg(x)$ will become smaller and probability $u \leq f(x)/cg(x)$ 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.

Acceptance-Rejection 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.
$f(x)=Pr(X=x)=2Cx*(0.5)^2$

 $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 $c \geq f(x)/g(x)$
We need $c=3/2$

Therefore, the algorithm is:
1. Generate $u,v~U(0,1)$
2. Set $y= \lfloor 3*u \rfloor$ (This is using uniform distribution to generate DU[0,2]
3. If $(y=0)$ and $(v\lt 1/2), output=0$
If $(y=2)$ and $(v\lt 1/2), output=2$
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 $u \lt f(x)/(cg(x))$ 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)\gt =f(x)$
Since we need to generate y from $g(x)$,
$Pr(select y)=g(y)$
$Pr(output y|selected y)=Pr(u\lt f(y)/(cg(y)))= f(y)/(cg(y))$ (Since u~Unif(0,1))
$Pr(output y)=Pr(output y1|selected y1)Pr(select y1)+ Pr(output y2|selected y2)Pr(select y2)+…+ Pr(output yn|selected yn)Pr(select yn)=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 Acceptance-Rejection Method

Generating a random variable having p.d.f.

                               $f(x) = 20x(1 - x)^3, 0\lt x \lt 1$


Since this random variable (which is beta with parameters 2, 4) is concentrated in the interval (0, 1), let us consider the acceptance-rejection method with

                                    g(x) = 1,           0 < x < 1


To determine the constant c such that f(x)/g(x) <= c, we use calculus to determine the maximum value of

                                  $f(x)/g(x) = 20x(1 - x)^3$


Differentiation of this quantity yields

                                  $d/dx[f(x)/g(x)]=20*[(1-x)^3-3x(1-x)^2]$


Setting this equal to 0 shows that the maximal value is attained when x = 1/4, and thus,

                                 $f(x)/g(x)\lt = 20*(1/4)*(3/4)^3=135/64=c$


Hence,

                                 $f(x)/cg(x)=(256/27)*(x*(1-x)^3)$


and thus the simulation procedure is as follows:

1) Generate two random numbers U1 and U2 .

2) If U2<(256/27)*U1*(1-U1)3, set X=U1, 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 accepetance-rejection method, find the local maximum of f(x)/g(x). and we can calculate the best constant c.

Another Example of Acceptance-Rejection Method

Generate a random variable from:

  $f(x)=3*x^2$, 0< x <1


Assume g(x) to be uniform over interval (0,1), where 0< x <1
Therefore:

  $c = max(f(x)/(g(x)))= 3$


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

  $f(x)/(cg(x))= x^2$


Acknowledgement: this is example 1 from http://www.cs.bgu.ac.il/~mps042/acceptance.htm

Class 4 - Thursday, May 16

• When we want to find a target distribution, denoted as $f(x)$, we need to first find a proposal distribution $g(x)$ that is easy to sample from.
• The relationship between the proposal distribution and target distribution is: $c \cdot g(x) \geq f(x)$, where c is a constant. This means that the area of f(x) is under the area of $c \cdot g(x)$.
• Chance of acceptance is less if the distance between $f(x)$ and $c \cdot g(x)$ is big, and vice-versa, we use $c$ to keep $\frac {f(x)}{c \cdot g(x)}$ below 1 (so $f(x) \leq c \cdot g(x)$). Therefore, we must find the constant $C$ to achieve this.
• In other words, a $C$ is chosen to make sure $c \cdot g(x) \geq f(x)$. However, it will not make sense if $C$ is simply chosen to be arbitrarily large. We need to choose $C$ such that $c \cdot g(x)$ fits $f(x)$ as tightly as possible.
• The constant c cannot be a negative number.

How to find C:
\begin{align} &c \cdot g(x) \geq f(x)\\ &c\geq \frac{f(x)}{g(x)} \\ &c= \max \left(\frac{f(x)}{g(x)}\right) \end{align}
If $f$ and $g$ are continuous, we can find the extremum by taking the derivative and solve for $x_0$ such that:
$0=\frac{d}{dx}\frac{f(x)}{g(x)}|_{x=x_0}$
Thus $c = \frac{f(x_0)}{g(x_0)}$

• The logic behind this:

The Acceptance-Rejection method involves finding a distribution that we know how to sample from (g(x)) and multiplying g(x) by a constant c so that $c \cdot g(x)$ is always greater than or equal to f(x). Mathematically, we want $c \cdot g(x) \geq f(x)$. And it means c has to be greater or equal to $\frac{f(x)}{g(x)}$. So the smallest possible c that satisfies the condition is the maximum value of $\frac{f(x)}{g(x)}$
. If c is 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 $c g(x) \geq f(x)$.

• 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 $\left ( \frac{1}{c} \right )$)
• It is easy to show that the expected number of trials for an acceptance is $\frac{Total Number of Trials} {C}$.
• recall the acceptance rate is 1/c. (Not rejection rate)
Let $X$ be the number of trials for an acceptance, $X \sim~ Geo(\frac{1}{c})$
$\mathbb{E}[X] = \frac{1}{\frac{1}{c}} = c$
• 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 UNIF(0,1). However, in other cases we need to generate UNIF(a,b). We may need to perform a linear transformation on the UNIF(0,1) variable.
2. Find a constant c such that :$c \cdot g(x) \geq f(x)$, otherwise return to step 1.

Recall the general procedure of Acceptance-Rejection Method

1. Let $Y \sim~ g(y)$
2. Let $U \sim~ Unif [0,1]$
3. If $U \leq \frac{f(Y)}{c \cdot g(Y)}$ 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

$f(x) = \begin{cases} 2x, & \mbox{if }0 \leqslant x \leqslant 1 \\ 0, & \mbox{otherwise} \end{cases}$

We can note that this is a special case of Beta(2,1), where, $beta(a,b)=\frac{\Gamma(a+b)}{\Gamma(a)\Gamma(b)}x^{(a-1)}(1-x)^{(b-1)}$

Where Γ (n)=(n-1)! if n is positive integer

$Gamma(z)=\int _{0}^{\infty }t^{z-1}e^{-t}dt$

Aside: Beta function

In mathematics, the beta function, also called the Euler integral of the first kind, is a special function defined by $B(x,y)=\int_0^1 \! {t^{(x-1)}}{(1-t)^{(y-1)}}\,dt$

$beta(2,1)= \frac{\Gamma(3)}{(\Gamma(2)\Gamma(1))}x^1 (1-x)^0 = 2x$

$g=u(0,1)$
$y=g$
$f(x)\leq c\cdot g(x)$
$c\geq \frac{f(x)}{g(x)}$
$c = \max \frac{f(x)}{g(x)}$

$c = \max \frac{2x}{1}, 0 \leq x \leq 1$
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 y-axis. Thus we need to multiply by c to ensure that $c\cdot g$ can cover entire f(x) area. In this case, c=2, so that makes g runs from 0 to 2 on y-axis 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 $n\cdot c$ points from the proposal distribution (g(x)) in total.
Step

1. Draw y~U(0,1)
2. Draw u~U(0,1)
3. if $u \leq \frac{(2\cdot y)}{(2\cdot 1)}, u \leq y,$ then $x=y$
4. 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)
>>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

$F(x)=\int_0^x \! 2s\,ds={x^2}-0={x^2}$
$y=x^2$
$x=\sqrt y$
$F^{-1}\left (\, x \, \right) =\sqrt x$
• Procedure
1: Draw $U~ \sim~ Unif [0,1]$
2: $x=F^{-1}\left (\, u\, \right) =\sqrt u$

Matlab Code

>>u=rand(1,1000);
>>x=u.^0.5;
>>hist(x)


Matlab Tip: Periods, ".",meaning "element-wise", 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 matrix dimensions must agree.

Example for A-R method:

Given $f(x)= \frac{3}{4} (1-x^2), -1 \leq x \leq 1$, use A-R method to generate random number

Let g=U(-1,1) and g(x)=1/2

let y ~ f, $cg(x)\geq f(x), c\frac{1}{2} \geq \frac{3}{4} (1-x^2) /1, c=max 2*\frac{3}{4} (1-x^2) = 3/2$

The process:

1: Draw U1 ~ U(0,1)
2: Draw U2 ~ U(0,1)
3: let $y = U1*2 - 1$
4: if $U2 \leq \frac { \frac{3}{4} * (1-y^2)} { \frac{3}{4}} = {1-y^2}$, then x=y, note that (3/4(1-y^2)/(3/4) is getting from f(y) / (cg(y)) )

Matlab Code

>> ii = 1
>> while  ii < 1000   % example of generating 1000 points
u1 = rand;
u2 = rand;
y = 2 * u1 - 1;  % make y uniform over (-1,1)
if u2 <= (1 - y^2)
x(ii) = y;
ii = ii + 1;
end
end


Example of Acceptance-Rejection Method

$f(x) = 3x^2, 0\lt x\lt 1$ $g(x)=1, 0\lt x\lt 1$

$c = \max \frac{f(x)}{g(x)} = \max \frac{3x^2}{1} = 3$
$\frac{f(x)}{c \cdot g(x)} = x^2$

1. Generate two uniform numbers in the unit interval $U_1, U_2 \sim~ U(0,1)$
2. If $U_2 \leqslant {U_1}^2$, accept $U_1$ as the random variable with pdf $f$, if not return to Step 1

We can also use $g(x)=2x$ for a more efficient algorithm

$c = \max \frac{f(x)}{g(x)} = \max \frac {3x^2}{2x} = \frac {3x}{2}$. Use the inverse method to sample from $g(x)$ $G(x)=x^2$. Generate $U$ from $U(0,1)$ and set $x=sqrt(u)$

1. Generate two uniform numbers in the unit interval $U_1, U_2 \sim~ U(0,1)$
2. If $U_2 \leq \frac{3\sqrt{U_1}}{2}$, accept $U_1$ as the random variable with pdf $f$, if not return to Step 1

• Note :the function q(x) = c * g(x) is called an envelop or majoring function.

To obtain a better proposing function g(x), we can first assume a new q(x) and then solve for the normalizing constant by integrating.
In the previous example, we first assume q(x) = 3x. To find the normalizing constant, we need to solve k * $\sum 3x = 1$ which gives us k = 2/3. So, g(x) = k*q(x) = 2x.

Another example of Acceptance-Rejection Method

Let $f(x) = x^3$ for $0\lt x\lt \sqrt{2}$. Use acceptance-rejection method with the proposal distribution, $g(x)=x$ for $0\lt x\lt \sqrt{2}$

$c=max(\frac{f(x)}{g(x)}) = max(\frac{x^3}{x}) = max(x^2) = (\sqrt{2})^2 = 2 =\gt \frac{f(x)}{c \cdot g(x)} = \frac{x^2}{2}$
Hence, the algorithm is:
1. Generate $y \sim~ U(0,1)$
2. Generate $U \sim~ U(0,1)$
3. If $U \leqslant \frac{y^2}{2}$. Then X=y, else go to step 1.

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

$X \sim∼ N(\mu,\sigma^2), \text{ or } X = \sigma Z + \mu, Z \sim~ N(0,1)$
$\vert Z \vert$ has probability density function of

f(x) = (2/$\sqrt{2\pi}$) 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 = $\sqrt{2e/\pi}$

Thus f(y)/cg(y) = e-(y-1)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 $f(x)= \frac{2}{\pi R^2} \sqrt{R^2-x^2}, -R\leq x\leq R$.

-> Proposal distribution: UNIF(-R, R)

-> We know how to generate using $U \sim 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
$f(x)= \frac{2}{\pi R^2} \sqrt{R^2-x^2}$, $g(x)=\frac{1}{2R}$, $-R\leq x\leq R$
Thus, we have to maximize R^2-x^2. => When x=0, it will be maximized. Therefore, c=4/pi. * Note: This also means that the probability of accepting a point is $\pi/4$.

We will accept the points with limit f(x)/[cg(x)]. Since $\frac{f(y)}{cg(y)}=\frac{\frac{2}{\pi R^{2}} \sqrt{R^{2}-y^{2}}}{\frac{4}{\pi} \frac{1}{2R}}=\frac{\frac{2}{\pi R^{2}} \sqrt{R^{2}-R^{2}(2U-1)^{2}}}{\frac{2}{\pi R}}$

• Note: Y= R(2U-1)

We can also get Y= R(2U-1) by using the formula y = a+(b-a)*u, to transform U~(0,1) to U~(a,b). Letting a=-R and b=R, and substituting it in the formula y = a+(b-a)*u, we get Y= R(2U-1).

Thus, $\frac{f(y)}{cg(y)}=\sqrt{1-(2U-1)^{2}}$ * this also means the probability we can accept points

The algorithm to generate random variable x is then:

1. Draw $\ U$ from $\ U(0,1)$

2. Draw $\ U_{1}$ from $\ U(0,1)$

3. If $U_{1} \leq \sqrt{1-(2U-1)^2}, set x = U_{1}$

  else return to step 1.


The condition is
$U_{1} \leq \sqrt{(1-(2U-1)^2)}$
$\ U_{1}^2 \leq 1 - (2U -1)^2$
$\ U_{1}^2 - 1 \leq -(2U - 1)^2$
$\ 1 - U_{1}^2 \geq (2U - 1)^2$

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)=x*e^{-x}, x\gt 0$
Use $g(x)=a*e^{-a*x}$to generate random variable

Solution: First of all, we need to find c
$cg(x)\gt =f(x)$
$c\gt =\frac{f(x)}{g(x)}$
$\frac{f(x)}{g(x)}=\frac{x}{a} * e^{-(1-a)x}$
take derivative with respect to x, and set it to 0 to get the maximum,
$\frac{1}{a} * e^{-(1-a)x} - \frac{x}{a} * e^{-(1-a)x} * (1-a) = 0$
$x=\frac {1}{1-a}$

$\frac {f(x)}{g(x)} = \frac {e^{-1}}{a*(1-a)}$
$\frac {f(0)}{g(0)} = 0$
$\frac {f(\infty)}{g(\infty)} = 0$

therefore, $c= \frac {e^{-1}}{a*(1-a)}$

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 $a= \frac {1}{2}$
$c=\frac{4}{e}$
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 $v\lt \frac{f(y)}{c\cdot g(y)}$, 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 $h(x) = \frac {f(x)}{g(x)}$, and then we have the following:
1. First, take derivative of h(x) with respect to x, get x1;
2. Plug x1 into h(x) and get the value(or a function) of c, denote as c1;
3. Check the endpoints of x and sub the endpoints into h(x);
4. (if c1 is a value, then we can ignore this step) Since we want the smallest value of c such that $f(x) \leq c\cdot g(x)$ for all x, we want the unknown parameter that minimizes c.
So we take derivative of c1 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 c1. (Double check that $c_1 \geq 1$
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 $c=max\frac {f(y)}{g(y)}$. If $v\lt \frac {f(y)}{c\cdot g(y)}$, 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 $f(x)\leq c\cdot g(x)$
4) A uniform draw

Interpretation of 'C'

We can use the value of c to calculate the acceptance rate by '1/c'.

For instance, assume c=1.5, then we can tell that 66.7% of the points will be accepted (1/1.5=0.667). We can also call the efficiency of the method is 66.7%.

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*u2-1);
if (1-u1^2)>=(2*u2-1)^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


MATLAB tips: hist(x,y) where y is the number of bars in the graph.

a histogram to show variable x, and the bars number is y.

Discrete Examples

• Example 1

Generate random variable $X$ according to p.m.f
\begin{align} P(x &=1) &&=0.15 \\ P(x &=2) &&=0.25 \\ P(x &=3) &&=0.3 \\ P(x &=4) &&=0.1 \\ P(x &=5) &&=0.2 \\ \end{align}

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, $Y \sim~ g$.
Step 2. Draw $U \sim~ U(0,1)$.
Step 3. If $U \leq \frac{f(Y)}{c \cdot g(Y)}$, then X = Y ;

       else return to Step 1.


C can be found by maximizing the ratio :$\frac{f(x)}{g(x)}$. To do this, we want to maximize $f(x)$ and minimize $g(x)$.

$c = max \frac{f(x)}{g(x)} = \frac {0.3}{0.2} = 1.5$

Note: In this case $f(x)=P(X=x)=0.3$ (highest probability from the discrete probabilities in the question)

$\frac{p(x)}{cg(x)} = \frac{p(x)}{1.5*0.2} = \frac{p(x)}{0.3}$

Note: The U is independent from y in Step 2 and 3 above. The constant c is an indicator of rejection rate or efficiency of the algorithm.

Since g follows a discrete uniform distribution, the probability is the same for all variables. And since there are 5 parameters (1,2,3,4,5), g(x)=1/5=0.2.

Remember that we always want to choose $c/timesg$ to be equal to or greater than $f$, but as close as possible.
limitations: If the form of the proposal distribution g is very different from the target distribution f, then c is very large and the algorithm is not computationally effective.

• 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 $\frac {1}{c}$, 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 $\frac {1}{1.5}=\frac {2}{3}$. 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
$c=max(p_{x}/g(x))=0.6/(1/3)=1.8$
Hence p(x)/cg(x) = p(x)/(1.8*1/3)= p(x)/0.6

1,y~g
2,u~U(0,1)
3, If $U \leq \frac{f(y)}{cg(y)}$, set x = y. Else go to 1.

• Code for example 2
>>close all
>>clear all
>>p=[.1 .3 .6];
>>ii=1;
>>while ii < 1000
y=unidrnd(3);
u=rand;
if u<= p(y)/0.6
x(ii)=y;
ii=ii+1;
end
end
>>hist(x)


• Example 3

$p_{x}=e^{-3}3^{x}/x! , x\gt =0$
(poisson distribution) Try the first few p_{x}'s: .0498 .149 .224 .224 .168 .101 .0504 .0216 .0081 .0027

Use the geometric distribution for $g(x)$;
$g(x)=p(1-p)^{x}$, choose p=0.25
Look at $p_{x}/g(x)$ for the first few numbers: .199 .797 1.59 2.12 2.12 1.70 1.13 .647 .324 .144
We want $c=max(p_{x}/g(x))$ which is approximately 2.12

1. Generate $U_{1} \sim~ U(0,1); U_{2} \sim~ U(0,1)$
2. $j = \lfloor \frac{ln(U_{1})}{ln(.75)} \rfloor+1;$
3. if $U_{2} \lt \frac{p_{j}}{cg(j)}$, set X = xj, else go to step 1.

• Code for example 3
>> ii = 1
>> while ii < 1000
u1 = rand;
u2 = rand;
j = floor((log(u1)/log(.75)) + 1;
pj = (e^3) * (3^j)/fact(j);
gj = .25 * (1 - .25)^j
if u2 < pj / (2.12 * gj)
x(ii) = j;
ii = ii + 1;
end
end
>> hist(x)



Note: In this case, f(x)/g(x) is extremely difficult to differentiate so we were required to test points. If the function is easily differentiable, 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: $P(X=0) =\binom{10}{3}/\binom{15}{3} =0.2637, P(x=1)=\binom{10}{2} * \binom{5}{1} /\binom{15}{3}=0.4945, P(X=2)=\binom{10}{1} * \binom{5}{2} /\binom{15}{3}=0.2198,$

$P(X=3)=\binom{5}{3}/\binom{15}{3}= 0.02198$

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.

the example below provides a better understanding about the pros and cons of the AR method. The AR method is useless when dealing with sampling distribution with a higher peak since c will be large, hence making our algorithm inefficient
which brings the acceptance rate low which leads to very time consuming sampling

Acceptance-Rejection Method

Problem: The CDF is not invertible or it is difficult to find the inverse.

Plan:

1. Draw y~g(.)
2. Draw u~Unif(0,1)
3. If $u\leq \frac{f(y)}{cg(y)}$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*u2-1);
if (1-u1^2)>=(2*u2-1)^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 acceptance-rejection 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 acceptance-rejection sampling. Later, we will generalize the distributions for multidimensional purposes.

• Gamma

The CDF of the Gamma distribution $Gamma(t,\lambda)$ is(t denotes the shape, $\lambda$ denotes the scale:
$F(x) = \int_0^{x} \frac{e^{-y}y^{t-1}}{(t-1)!} \mathrm{d}y, \; \forall x \in (0,+\infty)$, where $t \in \N^+ \text{ and } \lambda \in (0,+\infty)$.

Neither Inverse Transformation nor Acceptance/Rejection Method can be easily applied to Gamma distribution. However, we can use additive property of Gamma distribution to generate random variables.

If $X_1, \dots, X_t$ are independent exponential distributions with hazard rate $\lambda$ (in other words, $X_i\sim~ Exp (\lambda)$$, Exp (\lambda)= Gamma (1, \lambda)), then \Sigma_{i=1}^t X_i \sim~ Gamma (t, \lambda)$

Side notes: if $X_i\sim~ Gamma(a,\lambda)$ and $Y_i\sim~ Gamma(B,\lambda)$ are independent gamma distributions, then $\frac{X}{X+Y}$ 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 $X_i \sim~ Exp(10)$. To achieve this, we generate a 20-by-1000 matrix whose entries follow $Exp(10)$ and add the rows together. $x_1$~Exp($\lambda$) $x_2$~Exp($\lambda$) ... $x_t$~Exp($\lambda$) $x_1+x_2+...+x_t$

>>l=1
>>u-rand(1,1000);
>>x=-(1/l)*log(u);
>>hist(x)
>>rand


• Procedure
1. Sample independently from a uniform distribution $t$ times, giving $U_1,\dots,U_t \sim~ U(0,1)$
2. Use the Inverse Transform Method, $X_i = -\frac {1}{\lambda}\log(1-U_i)$, giving $X_1,\dots,X_t \sim~Exp(\lambda)$
3. Use the additive property,$X = \Sigma_{i=1}^t X_i \sim~ Gamma (t, \lambda)$

• Note for Procedure
1. If $U\sim~U(0,1)$, then $U$ and $1-U$ will have the same distribution (both follows $U(0,1)$)
2. This is because the range for $1-U$ is still $(0,1)$, and their densities are identical over this range.
3. Let $Y=1-U$, $Pr(Y\lt =y)=Pr(1-U\lt =y)=Pr(U\gt =1-y)=1-Pr(U\lt =1-y)=1-(1-y)=y$, thus $1-U\sim~U(0,1)$

• 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(1-u);      Note: log(1-u) 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(sum(x))                   Note: see the size of x if we forget it
>>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 1-u 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(1-u) 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

$R=\sqrt{x_{1}^2+x_{2}^2}= x_{2}/sin(\theta)= x_{1}/cos(\theta)$
$tan(\theta)=x_{2}/x_{1} \rightarrow \theta=tan^{-1}(x_{2}/x_{1})$

• Box-Muller Transformation:

It is a transformation that consumes two continuous uniform random variables $X \sim U(0,1), Y \sim U(0,1)$ and outputs a bivariate normal random variable with $Z_1\sim N(0,1), Z_2\sim N(0,1).$
In other words, the Box-Muller method is a method of producing two independent standard normals from two independent uniforms.

• Basic Form:

Let U1 and U2 ~ U(0,1). Assuming U1 & U2 are independent, and let:

1) $Z_0 = R \cos(\Theta) =\sqrt{-2 \ln U_1} \cos(2 \pi U_2)\,$

2) $Z_1 = R \sin(\Theta) = \sqrt{-2 \ln U_1} \sin(2 \pi U_2)\,$

where both Z0 and Z1~N(0,1) are independent, with corresponding polar coordinates:

  $R^2 = -2\cdot\ln U_1\,$


and

  $\Theta = 2\pi U_2\,$


Note:

R2 here has Chi-Squared distribution with df = 2 since it is just the square of the norm of the standard bivariate normal variable (X,Y). For the special case where df = 2, chi-squared distribution is the same as the exponential distribution. Hence, R2 is simply obtainable by generating the required exponential variate.

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

$f(x) = \frac{1}{\sqrt{2\pi}}\, e^{- \frac{\scriptscriptstyle 1}{\scriptscriptstyle 2} x^2}$
• Warning : the General Normal distribution is
 $f(x) = \frac{1}{\sigma\sqrt{2\pi}} e^{ -\frac{(x-\mu)^2}{2\sigma^2} }$ which is almost useless in this course

where $\mu$ is the mean or expectation of the distribution and $\sigma$ is standard deviation

• N(0,1) is standard normal. $\mu$ =0 and $\sigma$=1

Let X and Y be independent standard normal.

Let $\theta$ and R denote the Polar coordinate of the vector (X, Y)

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 Chi-squared and Exponential distribution)

The form of the joint distribution of R and $\theta$ will show that the best choice for distribution of R2 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

R2= X2+Y2 and $\tan(\theta) = \frac{y}{x}$ where X and Y are two independent standard normal
$f(x) = \frac{1}{\sqrt{2\pi}}\, e^{- \frac{\scriptscriptstyle 1}{\scriptscriptstyle 2} x^2}$
$f(y) = \frac{1}{\sqrt{2\pi}}\, e^{- \frac{\scriptscriptstyle 1}{\scriptscriptstyle 2} y^2}$
$f(x,y) = \frac{1}{\sqrt{2\pi}}\, e^{- \frac{\scriptscriptstyle 1}{\scriptscriptstyle 2} x^2} * \frac{1}{\sqrt{2\pi}}\, e^{- \frac{\scriptscriptstyle 1}{\scriptscriptstyle 2} y^2}=\frac{1}{2\pi}\, e^{- \frac{\scriptscriptstyle 1}{\scriptscriptstyle 2} (x^2+y^2)}$
- Since for independent distributions, their joint probability function is the multiplication of two independent probability functions

It can also be shown using 1-1 transformation that the joint distribution of R and θ is given by, 1-1 transformation:
Let $d=R^2$

$x= \sqrt {d}\cos \theta$
$y= \sqrt {d}\sin \theta$


then $\left| J\right| = \left| \dfrac {1} {2}d^{-\frac {1} {2}}\cos \theta d^{\frac{1}{2}}\cos \theta +\sqrt {d}\sin \theta \dfrac {1} {2}d^{-\frac{1}{2}}\sin \theta \right| = \dfrac {1} {2}$ It can be shown that the pdf of $d$ and $\theta$ is:

$\begin{matrix} f(d,\theta) = \frac{1}{2}e^{-\frac{d}{2}}*\frac{1}{2\pi},\quad d = R^2 \end{matrix},\quad for\quad 0\leq d\lt \infty\ and\quad 0\leq \theta\leq 2\pi$

Note that $\begin{matrix}f(r,\theta)\end{matrix}$ consists of two density functions, Exponential and Uniform, so assuming that r and $\theta$ are independent $\begin{matrix} \Rightarrow d \sim~ Exp(1/2), \theta \sim~ Unif[0,2\pi] \end{matrix}$

• \begin{align} R^2 = x^2 + y^2 \end{align}
• $\tan(\theta) = \frac{y}{x}$

\begin{align} f(d) = Exp(1/2)=\frac{1}{2}e^{-\frac{d}{2}}\ \end{align}
\begin{align} f(\theta) =\frac{1}{2\pi}\ \end{align}
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 $Y2 \geq(Y-1)^2/2$,set $V=Y1$,otherwise,go to step 1 Step 4: If $u1 \leq 1/2$,then $X=-V$

Expectation of a Standard Normal distribution

The expectation of a standard normal distribution is 0

Below is the proof:
$\operatorname{E}[X]= \;\int_{-\infty}^{\infty} x \frac{1}{\sqrt{2\pi}} e^{-x^2/2} \, dx.$
$\phi(x) = \frac{1}{\sqrt{2\pi}}\, e^{- \frac{\scriptscriptstyle 1}{\scriptscriptstyle 2} x^2}.$
$=\;\int_{-\infty}^{\infty} x \phi(x), dx.$
Since the first derivative ϕ′(x) is −(x)
$=\;\ - \int_{-\infty}^{\infty} \phi'(x), dx.$
$= - \left[\phi(x)\right]_{-\infty}^{\infty}$
$= 0$

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)). If support is from negative infinity to infinity, then the integral will return 0.

• Procedure (Box-Muller 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 acceptance-rejection 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 Box-Muller 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.$R^2=Z_{1}^2+Z_{2}^2$ is exponentially distributed with mean 2, i.e.
$P(R^2 \leq x) = 1-e^{-x/2}$.
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 \begin{align} U_1,U_2 \sim~ \mathrm{Unif}(0, 1) \end{align}
2) Generate polar coordinates using the exponential distribution of d and uniform distribution of θ,

\begin{align} R^2 = d = -2\log(U_1), & \quad r = \sqrt{d} \\ & \quad \theta = 2\pi U_2 \end{align}

$\begin{matrix} \ R^2 \sim~ Exp(1/2), \theta \sim~ Unif[0,2\pi] \end{matrix}$

Note: If U~unif(0,1), then ln(1-U)=ln(U)

3) Transform polar coordinates (i.e. R and θ) back to Cartesian coordinates (i.e. X and Y),
\begin{align} x = R\cos(\theta) \\ y = R\sin(\theta) \end{align}
.

Alternatively,
$x =\cos(2\pi U_2)\sqrt{-2\ln U_1}\,$ and
$y =\sin(2\pi U_2)\sqrt{-2\ln U_1}\,$

Note: In steps 2 and 3, we are using a similar technique as that used in the inverse transform method.
The Box-Muller 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 Box-Muller method several times.
For example:
If you want 8 independent standard normal distributed numbers, then run the Box-Muller methods 4 times (8/2 times).
If you want 9 independent standard normal distributed numbers, then run the Box-Muller methods 5 times (10/2 times), and then delete one.

• 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)


Note: randn is random sample from a standard normal distribution.
Note: hist(x+2) will be centered at 2 instead of at 0.

     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: Box-Muller transformations are not computationally efficient. The reason for this is the need to compute sine and cosine functions. A way to get around this time-consuming 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 Box-Muller 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(\mu, \sigma^2)$

If Z1, Z2... Zd are independent identically distributed N(0,1), then Z=(Z1,Z2...Zd)T ~N(0, Id), where 0 is the zero vector and Id 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 two-dimensional continuous uniform distribution to a two-dimensional bivariate normal distribution (or complex normal distribution).

Let U1 and U2 be independent uniform (0,1) random variables. Then $X_{1} = (-2lnU)^0.5_{1}*cos(2\pi U_{2})$

$X_{2} = (-2lnU)^0.5_{1}*sin(2\pi U_{2})$ are independent N(0,1) random variables.

This is a standard transformation problem. The joint distribution is given by

                  f(x1 ,x2) = fu1, u2(g1^− 1(x1,x2),g2^− 1(x1,x2)) * | J |


where J is the Jacobian of the transformation,

                  J = |∂u1/∂x1,∂u1/∂x2|
|∂u2/∂x1,∂u2/∂x2|


where

     u1 = g1 ^-1(x1,x2)
u2 = g2 ^-1(x1,x2)


Inverting the above transformations, we have

    u1 = exp^{-(x1 ^2+ x2 ^2)/2}
u2 = (1/2pi)*tan^-1 (x2/x1)


Finally we get

 f(x1,x2) = {exp^(-(x1^2+x2^2)/2)}/2pi


which factors into two standard normal pdfs.

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
 $f(x) = \frac{1}{\sigma\sqrt{2\pi}} e^{ -\frac{(x-\mu)^2}{2\sigma^2} }$ which is almost useless in this course

where $\mu$ is the mean or expectation of the distribution and $\sigma$ is standard deviation

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 Z = (X − μ)/σ will have a standard normal distribution.

If Z ~ N(0,1), and we want $X$~$N(\mu, \sigma^2)$, then $X = \mu + \sigma * Z$ Since $E(x) = \mu +\sigma*0 = \mu$ and $Var(x) = 0 +\sigma^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= $\underline{\mu} + \Sigma^{\frac{1}{2}} \,Z$ then $\underline{X}$ ~$N(\underline{\mu},\Sigma)$

Non-Standard Normal Distributions

Example 1: Single-variate Normal

If X ~ Norm(0, 1) then (a + bX) has a normal distribution with a mean of $\displaystyle a$ and a standard deviation of $\displaystyle b$ (which is equivalent to a variance of $\displaystyle b^2$). Using this information with the Box-Muller transform, we can generate values sampled from some random variable $\displaystyle Y\sim N(a,b^2)$ for arbitrary values of $\displaystyle a,b$.

1. Generate a sample u from Norm(0, 1) using the Box-Muller transform.
2. Set v = a + bu.

The values for v generated in this way will be equivalent to sample from a $\displaystyle N(a, b^2)$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: Multi-variate Normal

The Box-Muller 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.

$\mathbf{z} = N(\mathbf{u}, \Sigma)$ defines the n by 1 vector $\mathbf{z}$ such that:

• $\displaystyle u_i$ is the average of $\displaystyle z_i$
• $\!\Sigma_{ii}$ is the variance of $\displaystyle z_i$
• $\!\Sigma_{ij}$ is the co-variance of $\displaystyle z_i$ and $\displaystyle z_j$

If $\displaystyle z_1, z_2, ..., z_d$ are normal variables with mean 0 and variance 1, then the vector $\displaystyle (z_1, z_2,..., z_d)$ has mean 0 and variance $\!I$, where 0 is the zero vector and $\!I$ 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 $\mathbf{z} \sim N(0,I)$, then $\Sigma^{1/2}\mathbf{z}+\mu \sim N(\mu,\Sigma)$. Note here that the covariance matrix is symmetric and nonnegative, so its square root should always exist.

We can compute $\mathbf{z}$ in the following way:

1. Generate an n by 1 vector $\mathbf{x} = \begin{bmatrix}x_{1} & x_{2} & ... & x_{n}\end{bmatrix}$ where $x_{i}$ ~ Norm(0, 1) using the Box-Muller transform.
2. Calculate $\!\Sigma^{1/2}$ using singular value decomposition.
3. Set $\mathbf{z} = \Sigma^{1/2} \mathbf{x} + \mathbf{u}$.

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 co-variance 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.

Let x1,x2 denote the lifetime of 2 independent particles, x1~exp($\lambda$), x2~exp($\lambda$) 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

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 \begin{align} X_i \sim Bernoulli(p) \end{align} where each \begin{align} X_i \end{align} is independent,
$U = \sum_{i=1}^{n} X_i \sim Binomial(n,p)$
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;
while (i <= n)
u=rand();
if (u <= p)
y(i) = 1;
else
y(i) = 0;
end
i = i + 1;
end

x(k) = sum(y==1);
end

hist(x)



</pre>

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. However, this is not always the case as some functions do not have an inverse while others may be difficult to find. As such, there exist different procedures such as Acceptance-Rejection which is outlined in a further lecture.

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 as Generate a random number U If U<p0 set X=x0 and stop If U<p0+p1 set X=x1 and stop ... 2. If the xi, i>=0, are ordered so that x0<x1<x2<... and if we let F denote the distribution function of X, then $F(\lt sub\gt xk\lt /sub\gt =\lt sub\gt /sum/pi\lt /sub\gt )$ and so X will equal xj if F(x(j-1))<=U<F(xj)

Example 1

Let $X$1,$X$2 denote the lifetime of two independent particles:
$X$1~exp($\lambda$1)
$X$2~exp($\lambda$2)

We are interested in $y=min(X$1$,X$2$)$
Design an algorithm based on the Inverse-Transform Method to generate samples according to $f$y$(y)$

Solution:

x1~exp($\lambda_1$)
x2~exp($\lambda_2$)
$f_{x(x)}=\lambda e^{-\lambda x},x\geq0$
$F_X(x)=1-e^{-\lambda x}, x\geq 0$

$1-F_Y(y) = P(Y\gt y)$ = P(min(X1,X2) > y) = $\, P((X_1)\gt y) P((X_2)\gt y) = e^{\, -(\lambda_1 + \lambda_2) y}$

$F_Y(y)=1-e^{\, -(\lambda_1 + \lambda_2) y}, y\geq 0$

$U=1-e^{\, -(\lambda_1 + \lambda_2) y}$ => $y=\, {-\frac {1}{{\lambda_1 +\lambda_2}}} ln(1-u)$

Procedure:

Step1: Generate U~ U(0, 1)
Step2: set $y=\, {-\frac {1}{{\lambda_1 +\lambda_2}}} ln(u)$

If we generalize this example from two independent particles to n independent particles we will have:

$X$1~exp($\lambda$1)
$X$2~exp($\lambda$2)
...
$X$n~exp($\lambda$n)
.

And the algorithm using the inverse-transform method as follows:

step1: Generate U~U(0,1)

Step2: $y=\, {-\frac {1}{{ \sum\lambda_i}}} ln(1-u)$

Example 2
Consider U~Unif[0,1)
$X=\, a (1-\sqrt{1-u})$,
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.

$X=\, a (1-\sqrt{1-u})$
=>$1-\frac {x}{a}=\sqrt{1-u}$
=>$u=1-(1-\frac {x}{a})^2$
=>$u=\, {\frac {x}{a}} (2-\frac {x}{a})$
$f(x)=\frac {dF(x)}{dx}=\frac {2}{a}-\frac {2x}{a^2}=\, \frac {2}{a} (1-\frac {x}{a})$

Example 3

Suppose FX(x) = xn, 0 ≤ x ≤ 1, n ∈ N > 0. Generate values from X.

Solution:

1. generate u ~ Unif[0, 1)
2. Set x = U1/n

For example, when n = 20,
u = 0.6 => x = u1/20 = 0.974
u = 0.5 => x = u1/20 = 0.966
u = 0.2 => x = u1/20 = 0.923

Observe from above that the values of X for n = 20 are close to 1, this is because we can view Xn as the maximum of n independent random variables X, X~Unif(0,1) 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 (X1, X2, ... , Xn), where X1, X2, ... , Xn are independent,
FY(y) = P(Y ≤ y) = P(max (X1, X2, ... , Xn) ≤ y) = P(X1 ≤ y, X2 ≤ y, ... , Xn ≤ y) = Fx1(y) Fx2(y) ... Fxn(y)
Similarly if $Y = min(X_1,\ldots,X_n)$ then the cdf of $Y$ is $F_Y = 1-$$\prod$$(1- F_{X_i})$

Method 1: Following the above result we can see that in this example, FX = xn is the cumulative distribution function of the max of n uniform random variables between 0 and 1 (since for U~Unif(0, 1), FU(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 inverse-transform 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 X1,X2 denote the lifetime of two independent particles:
$\, X_1, X_2 \sim exp(\lambda)$

We are interested in Z=max(X1,X2)
Design an algorithm based on the Inverse-Transform Method to generate samples according to fZ(z)

$\, F_Z(z)=P[Z\lt =z] = F_{X_1}(z) \cdot F_{X_2}(z) = (1-e^{-\lambda z})^2$
$\text{thus } F^{-1}(z) = -\frac{1}{\lambda}\log(1-\sqrt z)$

To sample Z:
$\, \text{Step 1: Generate } U \sim U[0,1)$
$\, \text{Step 2: Let } Z = -\frac{1}{\lambda}\log(1-\sqrt U)$, therefore we can generate random variable of Z.

Discrete Case:

  u~unif(0,1)
x <- 0, S <- P0
while u < S
x <- x + 1
S <- S + P0
Return x


Decomposition Method

The CDF, F, is a composition if $F_{X}(x)$ can be written as:

$F_{X}(x) = \sum_{i=1}^{n}p_{i}F_{X_{i}}(x)$ where

1) pi > 0

2) $\sum_{i=1}^{n}$pi = 1.

3) $F_{X_{i}}(x)$ is a CDF

The general algorithm to generate random variables from a composition CDF is:

1) Generate U, V ~ $U(0,1)$

2) If u < p1, v=$F_{X_{1}}(x)$-1

3) Else if u < p1+p2, v=$F_{X_{2}}(x)$-1

4) ....

Explanation
Each random variable that is a part of X contributes $p_{i} F_{X_{i}}(x)$ to $F_{X}(x)$ every time. From a sampling point of view, that is equivalent to contributing $F_{X_{i}}(x)$ $p_{i}$ of the time. The logic of this is similar to that of the Accept-Reject 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 \sim Unif(0,1)$
2) Set $X=0, s=P_0$
3) While $u \gt s,$
set $X = X+1$ and $s=s+P_x$
4) Return $X$

Examples of Decomposition Method

Example 1
$f(x) = \frac{5}{12}(1+(x-1)^4) 0\leq x\leq 2$
$f(x) = \frac{5}{12}+\frac{5}{12}(x-1)^4 = \frac{5}{6} (\frac{1}{2})+\frac {1}{6}(\frac{5}{2})(x-1))^4$
Let$f_{x_1}= \frac{1}{2}$ and $f_{x_2} = \frac {5}{2}(x-1)^4$

Algorithm: Generate U~Unif(0,1)
If $0\lt u\lt \frac {5}{6}$, then we sample from fx1
Else if $\frac{5}{6}\lt u\lt 1$, we sample from fx2
We can find the inverse CDF of fx2 and utilize the Inverse Transform Method in order to sample from fx2
Sampling from fx1 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
$f(x)=\frac{1}{4}e^{-x}+2x+\frac{1}{12}, \quad 0\leq x \leq 3$
We can rewrite f(x) as $f(x)=(\frac{1}{4}) e^{-x}+(\frac{2}{4}) 4x+(\frac{1}{4}) \frac{1}{3}$
Let fx1 = $e^{-x}$, fx2 = 4x, and fx3 = $\frac{1}{3}$
Generate U~Unif(0,1)
If $0\lt u\lt \frac{1}{4}$, we sample from fx1

If $\frac{1}{4}\leq u \lt \frac{3}{4}$, we sample from fx2

Else if $\frac{3}{4} \leq u \lt 1$, we sample from fx3
We can find the inverse CDFs of fx1 and fx2 and utilize the Inverse Transform Method in order to sample from fx1 and fx2

We find Fx1 = $1-e^{-x}$ and Fx2 = $2x^{2}$
We find the inverses are $X = -ln(1-u)$ for Fx1 and $X = \sqrt{\frac{U}{2}}$ for Fx2
Sampling from fx3 is more straightforward since it is uniform over the interval (0,3)

In general, to write an efficient algorithm for:
$F_{X}(x) = p_{1}F_{X_{1}}(x) + p_{2}F_{X_{2}}(x) + ... + p_{n}F_{X_{n}}(x)$
We would first calculate ${q_i} = \sum_{j=1}^i p_j, \forall i = 1,\dots, n$ Then Generate $U \sim~ Unif(0,1)$
If $U \lt q_1$ sample from $f_1$
else if $u\lt q_i$ sample from $f_i$ for $1 \lt i \lt 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

Fx(x) = 1/3*x+1/3*x2+1/3*x3, 0<= x<=1

let U =Fx(x) = 1/3*x+1/3*x2+1/3*x3, solve for x.

P1=1/3, Fx1(x)= x, P2=1/3,Fx2(x)= x2, P3=1/3,Fx3(x)= x3

Algorithm:

Generate U ~ Unif [0,1)

Generate V~ Unif [0,1)

if 0<u<1/3, x = v

else if $u\lt \frac{2}{3}, x = v\lt sup\gt \frac{1}{2}\lt /sup\gt$

else $x = v\lt sup\gt \frac{1}{3}\lt /sup\gt$

Matlab Code:

u=rand
v=rand
if $u<\frac{1}{3}$
x=v
elseif $u<\frac{2}{3}$
x=sqrt(v)
else
x=v^(1/3)
end


=== Example of Decomposition Method(new) ===

Fx(x) = 1/2*x+1/2*x2, 0<= x<=1

let U =Fx(x) = 1/2*x+1/2*x2, solve for x.

P1=1/2, Fx1(x)= x, P2=1/2,Fx2(x)= x2,

Algorithm:

Generate U ~ Unif [0,1)

Generate V~ Unif [0,1)

if 0<u<1/2, x = v

else x = v1/2

Matlab Code:

u=rand
v=rand
if u<1/2
x=v
else
x=sqrt(v)
end


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 sub-shape (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 Accept-Reject 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.

Question 2

Use Acceptance and Rejection Method to sample from $f_X(x)=b*x^n*(1-x)^n$ , $n\gt 0$, $0\lt x\lt 1$

Solution: This is a beta distribution, Beta ~$\int _{0}^{1}b*x^{n}*(1-x)^{n}dx = 1$

U1~Unif[0,1)

U2~Unif[0,1)

fx=$bx^{1/2}(1-x)^{1/2} \lt = bx^{-1/2}\sqrt2 ,0\lt =x\lt =1/2$

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)\lt math\gt 2.If \lt math\gt U_2\lt =b*(U_1)^n*(1-(U_1))^n/b*(1/4)^n=(4*(U_1)*(1-(U_1)))^n$

 then X=U_1


Discrete Case: Most discrete random variables do not have a closed form inverse CDF. Also, its CDF $F:X \rightarrow [0,1]$ 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 $a \leq X \leq b$ and $a,b \in \mathbb{Z}$ .
To sample from $X$, we use the partition method below:

$\, \text{Step 1: Generate u from } U \sim Unif[0,1]$
$\, \text{Step 2: Set } x=a, s=P(X=a)$
$\, \text{Step 3: While } u\gt s, x=x+1, s=s+P(X=x)$
$\, \text{Step 4: Return } x$

Class 8 - Thursday, May 30, 2013

In this lecture, we will discuss algorithms to generate 3 well-known 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 utilizing 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 if the event success, otherwise the probability is 1-p (we usually define a variate q, q= 1-p). The mean of Bernoulli is p, variance is p(1-p). 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)=1-p, P(x=0)+P(x=1)=p+q=1

Algorithm:

1. Generate u~Unif(0,1)
2. If u ≤ p, then x = 1
else x = 0
when U≤p, x=1
when U>p, x=0
3.Repeat as necessary

Code

i = 1;

while (i <=1000)
u =rand();
p = 0.1;
if (u <= p)
x(i) = 1;
else
x(i) = 0;
end
i = i + 1;
end

hist(x)


The Binomial Distribution

If X~Bin(n,p), then its pmf is of form:

f(x)=(nCx) px(1-p)(n-x), x=0,1,...n
Or f(x) = $(n!/x!(n-x)!)$ px(1-p)(n-x), 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 summation of n Bernoulli trials, each with probability of success p. Thus, we can say equivalently that sampling from a Bin (n, p) distribution is the same as sampling from n Bernoulli trials. In the example below, 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 the pdf f(x), we can use code binornd(N,P). N represents the 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].

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 of geometric distributions. 1. Generate the probability distribution of X Bernoulli fail trials (probability 1-p), until the first success (probability p). X belongs in the set {1, 2, 3, ...}. 2. Generate probability distribution of Y = X - 1 failures (probability 1-p) before the first success (probability p). Y belongs in 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(1-p).
If the success event showed at the third time and failed at the first and second time, which x=3, then f(x)= p(1-p)(k-1). etc.
If the success event showed at the x time and all failed before time x, which x=x, then f(x)= p(1-p)(k-1)
which is,
x Pr
1 P
2 P(1-P)
3 P(1-P)2
. .
. .
. .
n P(1-P)(n-1)
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)=(1-p)(x-1)*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(1-p)(k-1)

Tail probability : P(X>n) = $(1-p)^n$

The CDF : P(X<n) = 1 - $(1-p)^n$

Memorylessness properties : P(X>m+n|X>=m)=P(X>n)

Mean of x = 1/p Var(x) = (1-p)/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)=>(1-p)(x-1)*(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)=> ((1-p)^x)*p , x = 0, 1, 2, ....

If Y~Exp($\lambda$) then X=floor(Y)+1 is geometric.
Choose e^(-$\lambda$)=1-p. Then X ~ geo (p)

P (X > x) = (1-p)x(because first x trials are not successful)

Proof

P(X>x) = P( floor(Y) + 1 > X) = P(floor (Y) > x- 1) = P(Y>= x) = e(-$\lambda$ * x)

SInce p = 1- e-$\lambda$ or $\lambda$= $-log(1-p)$(compare the pdf of exponential distribution and Geometric distribution,we can look at e-$\lambda$ the probability of the fail trial), then

P(X>x) = e(-$\lambda$ * x) = elog(1-p)*x = (1-p)x

Note that floor(Y)>X -> Y >= X+1 (X is an integer)

proof how to use EXP distribution to find P(X>x)=(1-p)^x

Suppose X has the exponential distribution with rate parameter $\lambda \gt 0$
the $\left \lfloor X \right \rfloor$ and $\left \lceil X \right \rceil$ have geometric distribution on $\mathcal{N}$ and $\mathcal{N}_{+}$ respectively each with success probability $1-e^ {- \lambda}$

Proof:
$\text{For } n \in \mathcal{N}$

\begin{align} P(\left \lfloor X \right \rfloor = n)&{}= P( n \leq X \lt n+1) \\ &{}= F( n+1) - F(n) \\ \text{By algebra and simplification:} \\ P(\left \lfloor X \right \rfloor = n)&{}= (e^ {-\lambda})^n \cdot (1 - e^ {-\lambda}) \\ &{}= Geo (1 - e^ {-\lambda}) \\ \text{Proof of ceiling part follows immediately.} \\ \end{align}

Algorithm:
1) Let $\lambda = -\log (1-p)$
2) Generate a $Y \sim Exp(\lambda )$
3) We can then let $X = \left \lfloor Y \right \rfloor + 1, where X\sim Geo(p)$
note: $\left \lfloor Y \right \rfloor \gt 2 -\gt Y\gt =3$

        $\left \lfloor Y \right \rfloor \gt 5 -\gt Y\gt =6$


$\left \lfloor Y \right \rfloor\gt x$ -> Y>= X+1

$P(Y\gt =X)$
Y ~ Exp ($\lambda$)
pdf of Y : $\lambda e^{-\lambda}$
cdf of Y : $1- e^{-\lambda}$
cdf $P(Y\lt x)=1-e^{-\lambda x}$
$P(Y\gt =x)=1-(1- e^{-\lambda x})=e^{-\lambda x}$
$e^{-\lambda}=1-p -\gt -log(1-p)=\lambda$
$P(Y\gt =x)=e^{-\lambda 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)>x-1)
=P(y>=x)

use $e^{-\lambda}=1-p$ to figure out the mean and variance. Code

>>p=0.4;
>>l=-log(1-p);
>>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]=> (1-p)/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 $Y=e^{\lambda}$ => x=floor(Y) +1

Let $e^{-\lambda}=5/6$

$P(X\gt x) = P(Y\gt =x)$ (from the class notes)

We have $e^{-\lambda *x} = (5/6)^x$

Algorithm: let $\lambda = -\log(5/6)$

1) Let Y be $e^{\lambda}$, exponentially distributed

2) Set X= floor(Y)+1, 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)=1-p=5/6, and then generate x.

Poisson Distribution

If $\displaystyle X \sim \text{Poi}(\lambda)$, its pdf is of the form $\displaystyle \, f(x) = \frac{e^{-\lambda}\lambda^x}{x!}$ , where $\displaystyle \lambda$ is the rate parameter.

Definition: In probability theory and statistics, the Poisson distribution 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. (from Wikipedia) In short, the Poisson distribution measures the number of occurrences at a particular time interval, given the rate of occurrences per unit time.

Understanding of Poisson distribution:

If customers independently come to bank over time, all of the following exponential distributions with rate $\lambda$ per unit of time, then X(t) = # of customer in [0,t] ~ Poi$(\lambda t)$

Its mean and variance are
$\displaystyle E[X]=\lambda$
$\displaystyle Var[X]=\lambda$
An useful property: If $X_i \sim \mathrm{Pois}(\lambda_i)\, i=1,\dots,n$ are independent and $\lambda=\sum_{i=1}^n \lambda_i$, then $Y = \left( \sum_{i=1}^n X_i \right) \sim \mathrm{Pois}(\lambda)$

A Poisson random variable X can be interpreted as the maximal number of i.i.d. (Independent and Identically Distributed) exponential variables(with parameter $\lambda$) 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.

$\displaystyle\text{Let } Y_j \sim \text{Exp}(\lambda), U_j \sim \text{Unif}(0,1)$
$Y_j = -\frac{1}{\lambda}\log(U_j) \text{ from Inverse Transform Method}$

\begin{align} X &= \max \{ n: \sum_{j=1}^{n} Y_j \leq 1 \} \\ &= \max \{ n: \sum_{j=1}^{n} - \frac{1}{\lambda}\log(U_j) \leq 1 \} \\ &= \max \{ n: \sum_{j=1}^{n} \log(U_j) \gt = -\lambda \} \\ &= \max \{ n: \log(\prod_{j=1}^{n} U_j) \gt = -\lambda \} \\ &= \max \{ n: \prod_{j=1}^{n} U_j \gt = e^{-\lambda} \} \\ &= \min \{ n: \prod_{j=1}^{n} U_j \gt = e^{-\lambda} \} - 1 \\ \end{align}

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 \sim U(0,1), a=aU_n$
3) If $a \gt = e^{-\lambda}$ , then n=n+1, and go to Step 2. Else, x=n-1

using inverse-method 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)=n-1;
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: $P(X=x)=\frac {e^{-\lambda}\lambda^x}{x!}, \forall x \in \N$
Let $\displaystyle p(x) = P(X=x)$ denote the pmf of $\displaystyle X$.
Then ratio is $\frac{p(x+1)}{p(x)}=\frac{\lambda}{x+1}, \forall x \in \N$
Therefore, $p(x+1)=\frac{\lambda}{x+1}p(x)$
Algorithm:
1. Set $\displaystyle x=0$
2. Set $\displaystyle F=p=e^{-\lambda}$
3. Generate $\displaystyle U \sim~ \text{Unif}(0,1)$
4. If $\displaystyle U\lt F$, output $\displaystyle x$
Else
$\displaystyle p=\frac{\lambda}{x+1} p$
$\displaystyle F=F+p$
$\displaystyle x = x+1$
Go to 4.

This is indeed the inverse-transform 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. There are two positive shape parameters (i.e. greater than zero) in this distribution, defined as α and β. X falls within the interval [0,1]. The parameter α is used as exponents of the random variable. The parameter β 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($\alpha, \beta$) then its p.d.f. is of the form

$\displaystyle \text{ } f(x) = \frac{\Gamma(\alpha+\beta)}{\Gamma(\alpha)\Gamma(\beta)}x^{\alpha-1}(1-x)^{\beta-1}$ where $0 \leq x \leq 1$ and $\alpha$>0, $\beta$>0

and $f(x;\alpha,\beta)= 0$ otherwise Note: $\Gamma(\alpha)=(\alpha-1)!$ if $\alpha$ is a positive integer.

The mean of the beta distribution is $\frac{\alpha}{\alpha + \beta}$. The variance is $\frac{\alpha\beta}{(\alpha+\beta)^2 (\alpha + \beta + 1)}$ The variance of the beta distribution decreases monotonically if $\alpha = \beta$ and as $\alpha = \beta$ 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 $\alpha$ and $\beta$:

Case 1: If $\alpha=1$ and $\beta=1$

$\displaystyle \text{Beta}(1,1) = \frac{\Gamma(1+1)}{\Gamma(1)\Gamma(1)}x^{1-1}(1-x)^{1-1}$
$= \frac{1!}{0!0!}x^{0}(1-x)^{0}$
$= 1$

Note: 0! = 1.
Hence, the distribution is:

$\displaystyle \text{Beta}(1,1) = U (0, 1)$

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 $\alpha=1$ or $\beta=1$

e.g. $\alpha=1$ We don't make any assumption about $\beta$ except that it is a positive integer. <br\>

$\displaystyle \text{f}(x) = \frac{\Gamma(1+\beta)}{\Gamma(1)\Gamma(\beta)}x^{1-1}(1-x)^{\beta-1}=\beta(1-x)^{\beta-1}$
$\beta=1$
$\displaystyle \text{f}(x) = \frac{\Gamma(\alpha+1)}{\Gamma(\alpha)\Gamma(1)}x^{\alpha-1}(1-x)^{1-1}=\alpha x^{\alpha-1}$

The CDF is $F(x) = x^{\alpha}$ (using integration of $f(x)$) WIth CDF F(x) = x^α, if U have CDF, it is very easy to sample: y=x^α --> x=y^α --> inverseF(x)= x^(1/α) U~U(0,1) --> x=u^(1/α) Applying the inverse transform method with $y = x^\alpha \Rightarrow x = y^\frac {1}{\alpha}$

$F(x)^{-1} = y^\frac {1}{\alpha}$

between case 1 and case 2, when alpha and beta be different value, the beta distribution can simplify to other distribution.

Algorithm

1. Generate U~Unif(0,1)<br\>
2. Assign $x = u^\frac {1}{\alpha}$

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:<br\> To sample from beta in general. we use the property that <br\>

if $Y_1$ follows gamma $(\alpha,1)$<br\>
$Y_2$ follows gamma $(\beta,1)$<br\>

Note: 1. $\alpha$ and $\beta$ are shape parameters here and 1 is the scale parameter.<br\>

then $Y=\frac {Y_1}{Y_1+Y_2}$ follows Beta $(\alpha,\beta)$<br\>

2.Exponential: $-\frac{1}{\lambda} \log(u)$ <br\> 3.Gamma: $-\frac{1}{\lambda} \log(u_1 * \cdots * u_t)$<br\>

Algorithm<br\>

• 1. Sample from Y1 ~ Gamma ($\alpha$,1) #$\alpha$ is the shape, and 1 is the scale. <br\>
• 2. Sample from Y2 ~ Gamma ($\beta$,1) <br\>
• 3. Set
$Y = \frac{Y_1}{Y_1+Y_2}$

Please see the following example for Matlab code.

Case 4:<br\> Use The Acceptance-Rejection Method <br\> The beta density is
$\displaystyle \text{Beta}(\alpha,\beta) = \frac{\Gamma(\alpha+\beta)}{\Gamma(\alpha)\Gamma(\beta)}x^{\alpha-1}(1-x)^{\beta-1}$ where $0 \leq x \leq 1$
Assume $\alpha,\beta \geq 1$. Then $\displaystyle f(x)$ has the maximum at $\frac{\alpha-1}{\alpha+\beta-2}$.
(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
$c=f(\frac{\alpha-1}{\alpha+\beta-2}$) and choose $\displaystyle g(x)=1$.
The A-R method becomes
1.Generate independent $\displaystyle U_1$ and $\displaystyle U_2$ from $\displaystyle UNIF[0,1]$ until $\displaystyle cU_2 \leq f(U_1)$;
2.Return $\displaystyle U_1$.
MATLAB Code for generating Beta Distribution

>>Y1 = sum(-log(rand(10,1000)))             #Gamma(10,1), sum 10 exponential for each of the 1000 samples

>>Y2 = sum(-log(rand(5,1000)))              #Gamma(5,1), sum 5 exponential 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^(alpha-1)*(1-t)^(beta-1)
>> u1 = rand
>> u2 = rand
>> x = (andb/(a*b))*u1^(alpha-1)*(1-u1)^(beta-1)
>> while c*u2>x
>> u1 = rand
>> u2 = rand
>> x = (andb/(a*b))*u1^(alpha-1)*(1-u1)^(beta-1)
>> end
>> u1


Random Vector Generation

We want to sample from $X = (X_1, X_2,$…,$X_d)$, a d-dimensional vector from a known pdf $f(x)$ and cdf $F(x)$. We need to take into account the following two cases:

Case 1

If $x_1, x_2 \cdots, x_d$'s are independent, then
$f(x) = f(x_1,\cdots, x_d) = f(x_1)\cdots f(x_d)$
We can sample from each component $x_1, x_2,\cdots, x_d$ individually, and then form a vector.

Based on the property of independence, we can derive the pdf or pmf of $x=x_1,x_2,x_3,x_4,x_5,\cdots$

Case 2

If $X_1, X_2, \cdots , X_d$ are not independent
$f(x) = f(x_1, \cdots , x_d) = f(x_1) f(x_2|x_1) \cdots f(x_d|x_{d-1},\cdots ,x_1)$
we need to know the conditional distributions of $f(x_2|x_1), f(x_3|x_2, x_1),\cdots, f(x_d|x_{d-1}, \cdots, x_1)$
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 one-dimensional, 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 d-tuple $X := (X_1 ,\ldots , X_d)$ (i.e random variable generated by $X_1,\ldots , X_d$ 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 d-dimensional vector, when they are not independent of each x. we use conditional function to define the probability function of x with d-dimensional.

Example

Generate uniform random vectors

1) x = (x1, …, xd) from the d-dimensional rectangle
2) D = { (x1, …, xd) : ai <= xi <= bi , i = 1, …, d}

Algorithm:
1) for i = 1 to d
2) Ui ~ U(0,1)
3) xi = ai + U(bi-ai)
4) end

• Note: xi = ai + U(bi-ai) denotes Xi ~U(ai,bi)

An example of the 2-D 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),'.')



Code:

function x = urectangle (d,n,a,b)
for ii = 1:d;
u(ii,:) = rand(1,n);
x(ii,:) = a+ u(ii,:)*(b-a);
%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 3-dimensional
>>scatter3(x(1,:), x(2,:), x(3,:))
>>axis square


Vector Acceptance-Rejection Method

The acceptance-rejection method can be extended to n-dimensional 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 acceptance-rejection 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: d-dimensional unit ball, $G = \big\{{x: \sum_{i}{x_i}^2 \leq 1}\big\}$

w: d-dimensional hypercube, $W = \big\{{-1 \leq x_i \leq 1}\big\}_{i=1}^d$

Procedure:
Step 1: $U_1 \sim~ U(0,1),\cdots, U_d \sim~ U(0,1)$
Step 2: $X_1 = 1 - 2U_1, \cdots, X_d = 1 - 2U_d, R = \sum_i X_i^2$
Step 3: If $R \leq 1, Z=(X_1, ..... , X_d)$
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) <br\>

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

This is the picture of 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 d-dimensional unit ball.

1.  U1~UNIF(0, 1)
U2~UNIF(0, 1)
...
Ud~UNIF(0, 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) determines whether the generated random coordinates fall within the unit ball. In 2-D we have a random x and y, thus if x^2+y^2 <=1 then it falls within the unit ball and we increase our count by 1.

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.

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 x-y 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 $\displaystyle \pi$

• We know the radius is 1
• Then the area of the square is $(1-(-1))^2=4$<br\>
• Then the area of the circle is $\pi$<br\>
• $\pi$ is approximated to be $4\times c=4 \times 0.7839=3.1356$ in the above example <br\>
>> 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 rejections of more points. 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

$\frac{1}{C}=\frac{\text{volume of hyperball}}{\text{volume of hybercube}}= \max \frac{g(x)}{f(x)}$

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 $\pi$, when $d \text{(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.

Thus, when we want to generate high dimension vectors, Acceptance-Rejection Method is not efficient to be used.

The end of midterm coverage

Stochastic Process

The basic idea of Stochastic Process (also called random process) is a collection of some random variables, $\big\{X_t:t\in T\big\}$, 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 non-deterministic. This means that there is some indeterminacy in the final state, even if the initial condition is known.

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 Process-This 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 birth-death process.
2. Markov Process- This is a stochastic process that satisfies the Markov property which can be understood as the memory-less 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 memory-less mouse in a maze, etc.

Stochastic Process means even we get some conditions at the beginning, we just can guess some variables followed the first, but at the end the variable would be unpredictable.

Example

stochastic process always has state space and the index set to limit the range.

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 non-negative numbers is the state space, and $x_t$ are stock prices.

The state space is the set of cars , while $x_t$ are sport cars.

Poisson Process

The Poisson process, which is discrete, arises when we count the number of occurrences of events over time.

e.g traffic accidents , arrival of emails. Emails arrive at random time $T_1, T_2$ ...

-Let $N_t$ denote the number of arrivals in the time interval $(0,t]$<br\> -Let $N(a,b]$ denote the number of arrivals in the time interval (a,b]<br\> -By definition, $N(a,b]=N_b-N_a$<br\> -The two random variables $N(a,b]$ and $N(c,d]$ are independent if $(a,b]$ and $(c,d]$ do not intersect.<br\>

Definition: An arrival counting process $N=(N_t)$ is called (Homogeneous) Poisson Process (PP) with rate $\lambda \gt 0$ if

A. The numbers of points in non-overlapping intervals are independent.
B. The number of points in interval $I(a,b]$ has a poisson distribution with mean $\lambda (b-a)$ ,where (b-a) represents the length of I.

In particular, observe that if $N=(N_t)$ is a Poisson process of rate $\lambda\gt 0$, then the moments are E[Nt] = $\lambda t$ and Var[Nt] = $\lambda t$

How to generate a multivariate normal with build in 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;


and if we want to use box-muller 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

We can use simulation to test results in probability and statistics. For example, with the central limit theorem, if we sample from a sufficiently large number of independently distributed random variables, the mean will be approximately normally distributed. We illustrate with an example using 1000 observations each of 20 independent exponential random variables.

Definition:

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.

>> X = exprnd (20,20,1000); % 1000 instances of 20 exponential random numbers with mean 20
>> hist(X(1,:))
>> hist(sum(X(1:2,:)))
...
>>hist(sum(X(1:20,:))) -> approaches to normal


Theorem: Central Limit Theorem Let $X_1, ..., X_n$ be iid random variables such that $E(X_i)=\mu$ and $Var(X_i)=\sigma^2$, and $\bar{X} = n^{-1} \left ( \sum_{i=1}^n x_i \right )$.
Then $\ \frac{\sqrt{n}(\bar{X} - \mu)}{\sigma} \xrightarrow{d}\ N(0,1)$

Class 11 - Tuesday，June 11, 2013

Poisson Process

A discrete stochastic variable X is said to have a Poisson distribution with parameter λ > 0 if

$\!f(n)= \frac{\lambda^n e^{-\lambda}}{n!} \qquad n= 0,1,\ldots,$.

Definition
The number of arrivals N(t) in a time interval of length t follows Poisson distribution with mean $lambda*t$,i.e.
$P(N(t)=n) = \frac{e^{-\lambda t} (\lambda t)^n}{n!}$

Properties of Homogeneous Poisson Process
(a) Independence: The numbers of arrivals in non-overlapping intervals are independent
(b) Homogeneity or Uniformity: The number of arrival in each interval I(a,b] is Poisson distribution with rate $\lambda (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

Notation
Nt denotes the number of arrivals up to t, i.e.(0,t]
N(a,b] = Nb - Na denotes the number of arrivals in I(a, b].
where I denotes the an interval.

For a small interval (t,t+h], where h is small
1. The number of arrivals in this interval is independent of the number of arrivals up to t(Nt)
2. $P (N(t,t+h)=1|N_{t} ) = P (N(t,t+h)=1) =\frac{e^{-\lambda h} (\lambda h)^1}{1!} =e^{-\lambda h} {\lambda h} \approx \lambda h$ since $e^{-\lambda h} \approx 1$ when h is small.

$\lambda 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-$\lambda$ h.

• Note : Recall that exponential random variable is the waiting time until one event of interested occurs.

In other words, the inter-arrival times are independent and follows Exponential distribution with mean λ.

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(X=4)=\frac {e^{-1.8}(1.8)^4}{4!}$

$P(X\geq1) = 1 - P(x=0) = 1- e^{-1.8}$

P(N3>3|N2)=P(N1>2)

when we use the inverse-transfer method, we can assume the poisson process to be exp distribution, and get the h function from the inverse method, and sometimes we assume h is very small.

Generating a Homogeneous Poisson Process

Suppose we want to generate the first n events of a Poisson process with rate ${\lambda}$. We showed that the times between successive events are independent exponential random variables, each with rate ${\lambda}$. Therefore, we can first generate n random numbers U1, U2,...,Un and use the inverse transform method to find the corresponding exponential variable X1, X2,...,Xn. Then Xi can be interpreted as the time between the (i-1)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 $\sum_{i=1}^{j} X_i$, j = 1...n.

Homogeneous poisson process refers to the rate of occurrences remaining constant for all periods of time.

Un~U(0,1)
$T_n-T_{n-1}=-\frac {1}{\lambda} log(U_n)$

The waiting time between each occurrence follows the exponential distribution with parameter $\lambda$. $T_n$ represents the time elapsed at the nth occurence.

1) Set T0 = 0 ,and n = 1
3) Tn - Tn-1 =$-\frac {1}{\lambda}$ log (Un) (Declare an arrival)
4) if Tn >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 $-\frac {1}{\lambda}$ log (Un)represents that chance that one arrival arrives.

Higher Dimensions:

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 Template:nowrap is count of the number of events in D, then

$P(N(D)=k)=\frac{(\lambda|D|)^k e^{-\lambda|D|}}{k!} .$

To sample from higher dimensional Poisson process:
1. Generate a random number N that is Poisson distributed with parameter ${\lambda}$*Ad, where Ad is the area under the bounded region. (ie A2 is area of the region, A3 is the volume of the 3-d space.
2. Given N=n, generate n random (uniform) points in the region.

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(ii-1) - (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 $\lambda$ * 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.

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.

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 nthrandom variable would only depend on the n-1thterm 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 (memory-less random walk)
• Finance: The volatility of prices of financial securities or commodities
• Actuarial Science: The pricing and valuation of multiple-state and multiple-lives insurance and annuity contracts

Product Rule (Stochastic Process):
$f(x_1,x_2,...,x_n)=f(x_1)f(x_2\mid x_1)f(x_3\mid x_2,x_1)...f(x_n\mid x_{n-1},x_{n-2},....)$

In Markov Chain
$f(x_1,x_2,...,x_n)=f(x_1)f(x_2\mid x_1)f(x_3\mid x_2)...f(x_n\mid x_{n-1})$

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}$.

$x_1 \rightarrow x_2\rightarrow...\rightarrow x_n$

Formal Definition: The process $\{x_n: n \in T\}$ is a markov chain if:
$Pr(x_n|x_{n-1},...,x_1) = Pr(x_n|x_{n-1}) \ \ \forall n\in T$ and $\forall x\in X$

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

Definition: A Markov transition matrix is a square matrix describing the probabilities of moving from one state to another in a dynamic system. In each row are the probabilities of moving from the state represented by that row, to the other states. Thus the rows of a Markov transition matrix each add to one.
A Transition Matrix is used to describe the transitions of a Markov chain. Each of its entries is a non-negative real number representing a probability.

Transition Probability: $P_{ij} = P(X_{t+1} =j | X_t =i)$ is the one-step 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 k-step transition probability from state i to state j.

The matrix P whose elements are transition Probabilities $P_{ij}$ is a one-step transition matrix.

Example:

\begin{align} P_{ab} &=P(X_{t+1} &=b &\mid X_{t} &=a) &= 0.3 \\ P_{aa} &=P(X_{t+1} &=a &\mid X_{t} &=a) &= 0.7 \\ P_{ba} &=P(X_{t+1} &=a &\mid X_{t} &=b) &= 0.2 \\ P_{bb} &=P(X_{t+1} &=b &\mid X_{t} &=b) &= 0.8 \\ \end{align}

$P= \left [ \begin{matrix} 0.7 & 0.3 \\ 0.2 & 0.8 \end{matrix} \right]$

The above matrix can be drawn into a state transition diagram

Properties of Transition Matrix:

1. $1 \geq P_{ij} \geq 0$

2. $\sum_{j}^{}{P_{ij}=1}$ which means the rows of P should sum to 1.

In general, one would consider a (finite) set of elements $\Omega$ such that:

$\forall x \in \Omega$, the probability of the next state is given according to the distribution $P(x,\cdot)$

This means our model can be simulated as a sequence of random variables $(X_0, X_1, X_2, \ldots )$ with state space $\Omega$ and transition matrix $P = [P_{ij}]$ where $\forall t \in \N, 0 \leq s \leq t+1, x_s \in \Omega,$

we have to following property (Markov property):
$P(X_{t+1}= x_{t+1} \vert \cap^{t}_{s=0} X_s = x_s) = P(X_{t+1} =x_{t+1} \vert X_t =x_t) = P(x_t,x_{t+1})$

And $\forall x \in \Omega, \sum_{y\in\Omega} P(x,y) =1; \; \forall x,y\in\Omega, P_{xy} = P(x,y) \geq 0$

Moreover if $\forall x,y \in \Omega, \exists k, P^k (x,y) \gt 0$
$|\Omega| \lt \infty$ (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.

Example of Double-Stochastic Matrix:

Consider the following probability transition matrix.
$P= \left [ \begin{matrix} 0 & p & q \\ q & 0 & p \\ p & q & 0 \end{matrix} \right]$ Where q=1-p
Each row is sum to 1 and each column is also sum to 1. Thus, this kind of probability transition matrix called Double-Stochastic Matrix.

Examples of Transition Matrix

Example 1

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 $P= \left [ \begin{matrix} 1/3 & 2/3 \\ 3/4 & 1/4 \end{matrix} \right]$. 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?

\begin{align} P(X_{2} &=1 &\mid X_{0} &=0) & =P(X_{1} &=0,X_{2} &=1 &\mid X_{0} &=0)+P(X_{1} &=1,X_{2} &=1 &\mid X_{0} &=0)\end{align} \begin{align} P(X_{1} &=0 &\mid X_{0} &=0) * P(X_{2} &=1 &\mid X_{1} &=0)+P(X_{1} &=1 &\mid X_{0} &=0) * P(X_{2} &=1 &\mid X_{1}&=1) &=1/3*2/3+ 2/3*1/4 &=7/18 \\ \end{align}

Example 2
The transition matrix in this case would be:
$P=\left [ \begin{matrix} 0.7 & 0.1 & 0 \\ 0 & 1 & 0 \\ 0.3 & 0.7 & 0 \\ \end{matrix}\right]$. Notice the "1" entry at $P_{2,2}$, even though the image doesn't show that. This is because there is no way of getting out of state 2, hence the probability of staying in state 2 is 1 (cant get out).

Multiplicative Congruential Algorithm

xk+1= (axk+c) mod m

Where a, c, m and x1 (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.

Examples:

      X0 = 10 ,a = 2 , c = 1 , m = 13

X1 = 2 * 10 + 1  mod 13 = 8
X2 = 2 * 8  + 1  mod 13 = 4
... and so on

      X0 = 44 ,a = 13 , c = 17 , m = 211

X1 = 13 * 44 + 17  mod 211 = 167
X2 = 13 * 167  + 17  mod 211 = 78
X3 = 13 * 78  + 17  mod 211 = 187
... 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\lt =a)=a$
proof:$P(X\lt =x) = P(F^{-1}(u)\lt =x)=P(u\lt =F(x)) = F(x)$

For discrete cases:
1. U~U(0,1)
2. x=xi if F(xi-1)$\lt$u$\leq$F(xi)

Acceptance-Rejection Method

cg(x)>=f(x) $c=max\left[\frac{f(x)}{g(x)}\right]$
$\frac{1}{c}$ is the efficiency of the method/probability of acceptance

1. Y~g(x)
2. U~U(0,1)
3. If $U\lt =\frac{f(y)}{c*g(y)}$ then X=Y else go to step 1

Proof that this method generates the desired distribution: $P(Y|accepted)=\frac{P(accepted|Y)P(Y)}{P(accepted)}=\frac{\frac{f(y)}{cg(y)} g(y)}{\int_{y}^{ } \frac{f(y)}{cg(y)} g(y) dy}=\frac{\frac{f(y)}{c}}{\frac{1}{c}\cdot 1}=f(y)$

Multivariate

f(x1,....,xn)=f(x1)f(x2|x1)...f(xn|xn-1,...x1) in general we need knowledge of conditional distribution if x1....xn are independent i.e. f(x1...xn)=f(x1)f(x2)...f(xn)

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
Sample uniformly from W
g(x)=$\frac{1}{A_W}$, where AW is the area of W.
f(x)=$\frac{1}{A_G}$, where AG is the area of G.

-$\frac{A_G}{A_W}$ = $\frac{1}{c}$ 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 $\frac{A_G}{A_W}$ decreases exponentially as the dimensional goes up, thus its not efficient for for high dimensional.

Exponential

Models the waiting until the first success.

X~Exp$(\lambda)$
$f (x) = \lambda e^{-\lambda x}$ , $x\gt 0$

1. U~Unif(0,1)

2. The inverse of exponential function is x = $\frac{-1}{\lambda} log(U)$

Normal

Box-Muller method

1.$U_{1},U_{2}\sim~ U(0,1)$
2.$R^{2}=-2log(U_{1}), R^{2}\sim~ Exp(1/2)$

$\theta = 2\pi U_{2},\theta\sim~ U(0,2\pi)$
3.$X=Rcos(\theta), Y=Rsin(\theta), X,Y\sim~ N(0,1)$

To obtain any normal distribution X once a set of standard normal samples Z is generated, apply the following transformations:
$Z\sim N(0,1)\rightarrow X \sim N(\mu,\sigma ^{2})$
$X=\mu+\sigma~Z$

In the multivariate case,
$\underline{Z}\sim N(\underline{0},I)\rightarrow \underline{X} \sim N(\underline{\mu},\Sigma)$
$\underline{X} = \underline{\mu} +\Sigma ^{1/2} \underline{Z}$

Gamma

Gamma(t,λ)
t: The number of exponentials and the shape parameter
1/λ: The mean of the exponentials and the scale parameter

Also, Gamma(t,λ) can be expressed into a summation of t exp(λ).
$x=\frac {-1}{\lambda}\log(u_1)-\frac {1}{\lambda}\log(u_2)-.......-\frac {1}{\lambda}\log(u_t)$

$=\frac {-1}{\lambda}[\log(u_1)+\log(u_2)+.....+\log(u_t)]$

$=\frac {-1}{\lambda}\log(\prod_{j=1}^{t} U_j)$

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

$f(x)= p^x (1-p)^{1-x}, x=0,1$

To generate a Bernoulli random variable we use the following procedure:

sample u~U(0,1)
if u <= p, then x=1
else x=0
where 1 stands for success and 0 stands for failure.

Binomial

The sum of n independent Bernoulli trials <br\> X~ Bin(n,p)
1. U1, U2, ... Un ~ U(0,1)
2. $X= \sum^{n}_{1} I(U_i \leq p)$ ,where $I(U_i \leq p)$ is an indicator for a successful trial.

I is an indicator variable if for U <= P, then I(U<=P)=1; else I(U>P)=0.

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, 1-p=5/6, rolling for 10 times, n=10

simulate this binomial distribution.

1) Generate $U_1....U_{10}$ ~ $U(0,1)$
2) $X= \sum^{10}_{1} I(U_i \leq \frac{1}{6})$

Beta Distribution

$\displaystyle \text{Beta}(\alpha,\beta) = \frac{\Gamma(\alpha+\beta)}{\Gamma(\alpha)\Gamma(\beta)}x^{\alpha-1}(1-x)^{\beta-1}$ where $0 \leq x \leq 1$ and $\alpha$>0, $\beta$>0
and $f(x;\alpha,\beta)= 0$ otherwise

$\displaystyle \text{Beta}(1,1) = U (0, 1)$
generate uniform directly


$\displaystyle \text{Beta}(\alpha,1)={f}(x) = \frac{\Gamma(\alpha+1)}{\Gamma(\alpha)\Gamma(1)}x^{\alpha-1}(1-x)^{1-1}=\alpha x^{\alpha-1}$
use inverse method to generate


Algorithm<br\>

• 1. Sample from Y1 ~ Gamma ($\alpha$,1) where $\alpha$ is the shape, and 1 is the scale.<br\>
• 2. Sample from Y2 ~ Gamma ($\beta$,1) where $\alpha$ is the shape, and 1 is the scale.<br\>
• 3. Set $Y = \frac{Y_1}{Y_1+Y_2},$ Then Y ~ $\beta ( \alpha , \beta )$, where we suppose $\alpha , \beta$ are integers.

Geometric

This distribution models the number of failures before the first success.

this requires attention

X~Geo(p)

$f(x)=p*(1-p)^{x-1}, x=1, 2, ........$
If Y~Exp$(\lambda)$ where $\lambda=-log(1-p)$
then $X=floor[Y]+1$ is Geo(p)

Proof:

   $F(x)=P(X\lt =x)$
$=1-P(X\gt x)$
$=1-P(floor [Y]+1\gt x)$ as $floor [Y]+1\gt x$ implies $Y\leq x$ for all real-valued Y
$=1-P(Y\gt =x)$
$=1-(1-P(Y\lt x))$
$=1-e^{-\lambda*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)=P(X \leq x)$
$F(x)=1- P(X\gt x)$
$P(X \leq x)=1-(1-p)^x$ since $P(X\gt x)=(1-p)^x$
$y=1-(1-p)^x$
$y-1=-(1-p)^x$
$1-y=(1-p)^x$
$1-y=(e^(-\lambda))^x=e^(-\lambda*x)$ since $1-p=e^-\lambda$
$log(1-y)=-\lambda*x$
$x=-1/(\lambda)*log(1-y)$
$F^(-1)(x)=-1/(\lambda)*log(1-x)$

Algorithm:
1. Generate U ~ U(0,1)
2. Generate $Y=-1/(\lambda)*log(1-u)$ where $Y ~ \sim Exp(\lambda)$
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]

Poisson

This distribution models the number of times and event occurs in a given time period

X~Poi$(\lambda)$
X is the maximum number of iid Exp($\lambda$) whose sum is less than or equal to 1.
$X = \max\{n: \sum\limits_{i=1}^n Y_i \leq 1, Y_i \sim Exp(\lambda)\}$
$= \max\{n: \sum\limits_{i=1}^n \frac{-1}{\lambda} log(U_i)\lt =1 , U_i \sim U[0,1]\}$
$= \max\{n: \prod\limits_{i=1}^n U_i \gt = e^{-\lambda}, U_i \sim U[0,1]\}$

Algorithm<br\>

• 1. Set n=1, a=1<br\>
• 2. $U_n$ ~ $U[0,1]$ and set $a=aU_n$<br\>
• 3. If $a \geq e^{-\lambda}$ then: n=n+1 and go to Step 2. Else set X=n-1.

An alternate way to write an algorithm for Poisson is as followings:

1) x = 0, F = $P(X=0) = e^{-\lambda} = p$

2) Generate U ~ U(0,1)

3) If U < F, then output x

4) Else $p = \frac{p*\lambda}{x+1}$

   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

N-step Transition Matrix

Definition: The n-step transition matrix is the matrix $P_n$ whose elements are the probability of moving from state $i$ to state $j$ in $n$ steps.
$\quad P_n(i,j) = Pr(X_{m+n)}=j | X_m = i)$
$P_n(i,j)$
is called n-steps transition probability

One-step transition probability:
The probability of Xn+1 being in state j given that Xn is in state, i is called the one-step transition probability and is denoted by Pi,jn,n+1. That is
Pi,jn,n+1 = Pr(Xn+1=j|Xn=i)

Two-step transition probability:
The 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$

N-step Transition Matrixi:
A matrix $P_n$ whose elements are the probability of moving to state j from state i in n steps.
$P_n (i,j)=Pr⁡(X_{m+n}=j|X_m=i)$ is the n-step transition probability.

In general $P_n = P^n$ with $P_n(i,j) \geq 0$ and $\sum_{j} P_n(i,j) = 1$

Example from previous class:

$P= \left [ \begin{matrix} 0.7 & 0.3 \\ 0.2 & 0.8 \end{matrix} \right]$

The two step transition probability matrix is:

$P P= \left [ \begin{matrix} 0.7 & 0.3 \\ 0.2 & 0.8 \end{matrix} \right] \left [ \begin{matrix} 0.7 & 0.3 \\ 0.2 & 0.8 \end{matrix} \right]$=$\left [ \begin{matrix} 0.7(0.7)+0.3(0.2) & 0.7(0.3)+0.3(0.8) \\ 0.2(0.7)+0.8(0.2) & 0.2(0.3)+0.8(0.8) \end{matrix} \right]$=$\left [ \begin{matrix} 0.55 & 0.45 \\ 0.3 & 0.7 \end{matrix} \right]$<br\>

$P_2 = P_1 P_1$<br\>

$P_n = P_1^n$<br\>

The equation above is a special case of the Chapman-Kolmogorov 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 1-step transition
matrix n-times to get a n-step transition matrix.

Example:
We can see how $P_n = P^n$ from the following:
$\mu_1=\mu_0\cdot P$
$\mu_2=\mu_1\cdot P$
$\mu_3=\mu_2\cdot P$

Therefore,
$\mu_3=\mu_0\cdot P^3$

$P_n(i,j)$ is called N-steps Transition Probability.
$\mu_0$ is called the Initial Distribution.
$\mu_n = \mu_0* P^n$

Example 1:
Consider a two-state Markov chain {$X_t; t = 0, 1, 2,...$} with states {1,2} and transition probability matrix

$P= \left [ \begin{matrix} 1/2 & 1/2 \\ 1/3 & 2/3 \end{matrix} \right]$

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$ (Start from state 1 and then get back to it in 3 steps) (1 ->1->1 = (1/2)*(1/2) or 1->2->1 = (1/2)*(1/3))

d)$P^2=P*P= \left [ \begin{matrix} 5/12 & 7/12 \\ 7/18 & 11/18 \end{matrix} \right]$

Example 2:
Consider a 3-state Markov chain {$X_t; t = 0, 1, 2,...$ with states {1,2,3} and transition probability matrix

$P= \left [\begin{matrix} 1/4 & 1/2 & 1/4 \\ 1/3 & 1/3 & 1/3 \\ 1/7 & 2/7 & 4/7 \end{matrix} \right]$

Given $X_0=1$. Compute the following:

a)$P(X_2=1, X_1=3 | X_0 = 2) = P(X_2=1|X_1=3)*P(X_1=3|X_0=2)= 2/7 * 1/4 = 1/14$

b)$P(X_2=3|X_0=1) = P(X_2=3|X_1=1)*P(X_1=1|X_0=1)+P(X_2=3|X_1=2)*P(X_1=2|X_0=1)+P(X_2=3|X_1=3)*P(X_1=3|X_0=1)=(1/4)* (1/7)+(1/3)*(2/7)+(1/7)*(4/7)=125/588$

Marginal Distribution of Markov Chain

We represent the probability of all states at time t with a vector $\underline{\mu_t}$
$\underline{\mu_t}~=(\mu_t(1), \mu_t(2),...\mu_t(n))$ where $\mu_t(1)$ is the probability of being on state 1 at time t.
and in general, $\mu_t(i)$ shows the probability of being on state i at time t.
For example, if there are two states a and b, then $\underline{\mu_5}$=(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 $\underline{\mu_0}$ is called the initial distribution.

$P_2~=P_1 P_1$ (as verified above)

In general, $P_n~=(P_1)^n$ **Note that $P_1$ is equal to the matrix P
$\mu_n~=\mu_0 P_n$
where $\mu_0$ is the initial distribution, and $\mu_{m+n}~=\mu_m P_n$
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
$\mu_4~=(3/4, 1/4)$

if we simulate a chain many times, frequency of states at time t show the marginal distribution at time t

Marginal Distribution

$\mu_1~ = \mu_0P$
$\mu_2~ = \mu_1P = \mu_0PP = \mu_0P^2$
Given the marginal distribustion at time n-1, we can compute the distribution at time n:
$\mu_n~ = \mu_{n-1}~P$
After repeating the algorithm starting at time 0, we can have the following relationship:
In general, $\mu_n~ = \mu_0P^n$
Property: If $\mu_n~\neq\mu_t~$(for any t less than n), then we say P does not converge.

Stationary Distribution

$\pi$ is stationary distribution of the transition matrix P if $\pi \cdot$ P = $\pi$

where $\pi$ is a probability vector $\pi$=($\pi$i | $i \in X$) such that, all the entries are nonnegative and sum to 1.

In other words, if X0 is drawn from $\pi$. Generally, Xn is drawn from the same distribution as $\pi$ for every n≥0.

Example: consider the following transition matrix

$P= \left [ \begin{matrix} 0 & 1 \\ 1 & 0 \end{matrix} \right]$

Intuitively, the chain spends half of the time in each of the states, so $\pi$ = (1/2,1/2)

1. As n gets bigger and bigger, $\mu_n$ will possibly stop changing, so the quantity $\pi$ i can also be interpreted as the limiting probability that the chain is in the state $j$
2. $\pi$ may not exist and even if it exists, it may not always be unique.
3. If $\pi$ exists and is unique, then $\pi$i is called the long-run proportion of the process in state i and the stationary distribution is also the limiting distribution of the process.

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



An alternate Method of Computing the Stationary Distribution

Recall that if $\lambda v = A v$, then $\lambda$ is the eigenvalue of $A$ corresponding to the eigenvector $v$

By definition of stationary distribution, $\pi = \pi P$
Taking the transpose, $\pi^T = (\pi P)^T$
then $I \pi^T = P^T \pi^T \Rightarrow (P^T-I) \pi^T = 0$
So $\pi^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 non-negative 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
$\mu~=rand(1,n)$
$\mu~=\mu/\Sigma(\mu)$

Doubly Stochastic Matrices
We say that the transition matrix $\, P=(p_{ij})$ is doubly stochastic if both rows and columns sum to 1, i.e.,
$\, \sum_{i} p_{ij} = \sum_{j} p_{ij} = 1$
It is easy to show that the stationary distribution of an nxn doubly stochastic matrix P is:
$(\frac{1}{n}, \ldots , \frac{1}{n})$

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 real-world processes.

Formal Definition:
A Markov Chain consists of a countable (possibly finite) set S (called the state space) together with a countable family of random variables X0,X1,X2,X3,... with values in S such that:

  $P(X_{t+1}=s \vert X_t=s_t,X_{t-1}=s_{t-1},...,X_0=s_0)=P(X_{t+1}=s \vert X_t=s_t)$


and we refer to this fundamental equation as the Markov property. Here are some properties of Markov Chain:

1. Reducibility
State $j$ is said to be accessible from State $i$ (written $i \rightarrow j$) if a system started in State $i$ has a non-zero probability of transitioning into State $j$ at some point. Formally, State $j$ is accessible from State $i$ if there exists an integer $n_{ij} \geq 0$ such that
$P(X_{n_{ij}} =j \vert X_0 =i) \gt 0$

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
$k= \gcd\{n:P(X_n =j \vert X_0 =i)\gt 0\}$

3. Recurrence
State $i$ is said to be transient if, given that we start in State $i$, there is a non-zero 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"):
$T_i = \min\{n \geq 1:X_n=i \vert X_0=i\}$

Properties of Markov Chain (continued)

4. Ergodicity
If state i is aperiodic and positive recurrent, state i is said to be ergodic. In other words, state i is ergodic if it has a period of 1 and has finite mean recurrence time. Consequently, an irreducible Markov Chain is said to be ergodic if all states in the chain are ergodic.

An extra note here is that if a finite state irreducible Markov chain has an aperiodic state, then it is ergodic. If there is a finite number N such that any state can be reached from any other state in exactly N steps, a model is said to have the ergodic property. For example, if we have a fully connected transition matrix where all transitions have a non-zero probability, this condition is fulfilled with N=1. A model with more than one state and just one out-going transition per state cannot be ergodic. We will have more examples to follow later on.

5. Steady-state analysis and limiting distributions
Definition: If a Markov Chain is time-homogeneous, then the vector $\boldsymbol{\pi}$is called a stationary distribution if $\forall j \in S$ it satisfies:

   1)$0\leq\pi_j\leq1$

   2)$\sum_{j \in S}\pi_j = 1$

   3)$\pi_j = \sum_{i \in S} \pi_i p_{ij}$


If all states of an irreducible chain are positive recurrent, it has a stationary distribution. In this case, $\boldsymbol{\pi}$ is unique. It is also related to the expected return time:

   $\pi_j = \frac{C}{M_j}\,,$


where C is the normalizing constant.

If the chain is both irreducible and aperiodic, then for any i and j,

   $\lim_{n \rarr \infty} p_{ij}^{(n)} = \frac{C}{M_j}$


Final result:
$\boldsymbol{\pi}$ is called the equilibrium distribution of the chain if the chain converges to the stationary distribution regardless of where it begins.

Examples of finding stationary distribution

We will have examples for this later.
Example: Find the stationary distribution of $P= \left[ {\begin{array}{ccc} \frac{1}{3} & \frac{1}{3} & \frac{1}{3} \\[6pt] \frac{1}{4} & \frac{3}{4} & 0 \\[6pt] \frac{1}{2} & 0 & \frac{1}{2} \end{array} } \right]$

Solve the system of linear equations to find the Stationary Distribution

$\pi_0=\frac{1}{3}\pi_0+\frac{1}{4}\pi_1+\frac{1}{2}\pi_2$
$\pi_1=\frac{1}{3}\pi_0+\frac{3}{4}\pi_1+0\pi_2$
$\pi_2=\frac{1}{3}\pi_0+0\pi_1+\frac{1}{2}\pi_2$
$\pi_{0}~ + \pi_{1} + \pi_{2} = 1$

Solving the 4 equations,
$\pi_{0}=\frac {1}{3}$, $\pi_{1}~=\frac {4}{9}$, and $\pi_{2}~=\frac {2}{9}$

Therefore $\pi=(\frac{1}{3},\frac{4}{9}, \frac{2}{9})$

Similarly, this can be achieved by calculating
$P^{30}=\left[ {\begin{array}{ccc} \frac{1}{3} & \frac{4}{9} & \frac{2}{9} \\[6pt] \frac{1}{3} & \frac{4}{9} & \frac{2}{9} \\[6pt] \frac{1}{3} & \frac{4}{9} & \frac{2}{9} \end{array} } \right]$
Which produces the same result as solving the systems of equations.

Alternatively, the system of equations can also be solved using matrix simplification. Namely, when the system of equations is more complicated and doesn't simplify easily. Continuing from the above example, we would have [-2/3 1/4 1/2 | 0] [1/3 -1/4 0 | 0] [1/3 0 -1/2 | 0] [1 1 1 | 1]

Simplifying this matrix (from math 136), we can easily obtain the results for $\pi_0$, $\pi_1$, and $\pi_2$.

$\lambda u=A u$

$\pi$ can be considered as an eigenvector of P with eigenvalue = 1.

But the vector u here needs to be a column vector. So we need to transform $\pi$ into a column vector.

$\pi$T= PT$\pi$T

Then $\pi$T is an eigenvector of PT 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

Limiting Distribution

A Markov chain has Limiting Distribution $\pi$ if

$\lim_{n\to \infty} P^n= \left[ {\begin{array}{ccc} \pi \\ \vdots \\ \pi \\ \end{array} } \right]$

That is $\pi_j=\lim[P^n]_{ij}$ exists and is independent of i.

A Markov Chain is convergent if and only if its limiting distribution exists.

If the Limiting Distribution $\pi$ exists, it must be equal to the Stationary Distribution.

In general, there are chains with Stationary distributions that don't converge, which means that they have Stationary Distributions but are not limiting. Converge means the the limit extend to a certain number when n -> infinite.

Example:

$P= \left [ \begin{matrix} \frac{4}{5} & \frac{1}{5} & 0 & 0 \\[6pt] \frac{1}{5} & \frac{4}{5} & 0 & 0 \\[6pt] 0 & 0 & \frac{4}{5} & \frac{1}{5} \\[6pt] 0 & 0 & \frac{1}{10} & \frac{9}{10} \\[6pt] \end{matrix} \right]$

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.

The following contents are problematic. Please correct it if possible.
Suppose we're given that the Limiting Distribution $\pi$ exists for stochastic matrix P, that is, $\pi = \pi * P$

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 * \Sigma * U^{-1}$ be the eigenvalue decomposition of $P$, where $\Sigma = diag(\lambda_1,\ldots,\lambda_n) ; |\lambda_i| \gt |\lambda_j|, \forall i \lt j$

Suppose $\pi^T = \sum a_i u_i$ where $a_i \in \mathcal{R}$ and $u_i$ are eigenvectors of $P$ for $i = 1\ldots n$

By definition: $\pi^k = \pi*P = \pi*P^k \implies \pi = \pi*(U * \Sigma * U^{-1}) *(U * \Sigma * U^{-1} )*\ldots*(U * \Sigma * U^{-1})$

Therefore $\pi^k = \sum a_i * \lambda_i^k u_i$ since $\lt u_i , u_j\gt = 0, \forall i\neq j$.

Therefore $\lim_{k \rightarrow \infty} \pi^k = \lim_{k \rightarrow \infty} \lambda_i^k * a_1 * u_1 = u_1$

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 Sistribution, then 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 $\pi_j = lim[p^n]_(ij)$ exist and is independent of i

Example: Find the Stationary Distribution of P= $\left[ {\begin{array}{ccc} 0 & 1 & 0 \\ 0 & 0 & 1 \\ 1 & 0 & 0 \end{array} } \right]$

$\pi=\pi~P$

$\pi=$ [$\pi$0, $\pi$1, $\pi$2]

The system of equations is:

0*$\pi$0+0*$\pi$1+1*$\pi$2 = $\pi$0 => $\pi$2 = $\pi$0
1*$\pi$0+0*$\pi$1+0*$\pi$2 = $\pi$1 => $\pi$1 = $\pi$0
0*$\pi$0+1*$\pi$1+0*$\pi$2 = $\pi$2
$\pi$0+$\pi$1+$\pi$2 = 1

$\pi$0+$\pi$0+$\pi$0 = 3$\pi$0 = 1, which gives $\pi$0 = 1/3
Also, $\pi$1 = $\pi$2 = 1/3
So, $\pi$ = $[\frac{1}{3}, \frac{1}{3}, \frac{1}{3}]$

when the p matrix is a standard matrix, then all the probabilities of pi are the same in the matrix.

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 $\pi$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 having a Limiting Distribution(convergence).Note: $\pi=(1/3,1/3,1/3)$ is the stationary distribution as $\pi=\pi*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.

Another example:

Find the stationary distribution of P= $\left[ {\begin{array}{ccc} 0.5 & 0 & 0 \\ 1 & 0 & 0.5 \\ 0 & 1 & 0.5 \end{array} } \right]$

$\pi=\pi~P$

$\pi=$ [$\pi$0, $\pi$1, $\pi$2]

The system of equations is:

$0.5\pi_0+1\pi_1+0\pi_2= \pi_0=\gt 2\pi_1 = \pi_0$
$0\pi_0+0\pi_1+1\pi_2= \pi_1 =\gt \pi_1=\pi_2$
$0\pi_0+0.5\pi_1+0.5\pi_2 = \pi_2 =\gt \pi_1 = \pi_2$
$\pi_0+\pi_1+\pi_2 = 1$

$2\pi_1+\pi_1+\pi_1 = 4\pi_1 = 1$, which gives $\pi_1=\frac {1}{4}$
Also, $\pi_1 = \pi_2 = \frac {1}{4}$
So, $\pi = [\frac{1}{2}, \frac{1}{4}, \frac{1}{4}]$

The definition of stationary distribution is that $\pi$ is the stationary distribution of the chain if $\pi=\pi~P$, where $\pi$ is a probability vector. For every n$\gt =$0.

However, just because Xn ~ $\pi$ for every n$\gt =$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= $\left[ {\begin{array}{ccc} 1/3 & 1/3 & 1/3 \\ 1/4 & 3/4 & 0 \\ 1/2 & 0 & 1/2 \end{array} } \right]$

Solution: $\pi=\left[ {\begin{array}{ccc} \pi_0 & \pi_1 & \pi_2 \end{array} } \right]$

Using the stationary distribution property $\pi=\pi~P$ we get,
$\pi_0=\frac{1}{3}\pi_0+\frac{1}{4}\pi_1+\frac{1}{2}\pi_2$
$\pi_1=\frac{1}{3}\pi_0+\frac{3}{4}\pi_1+0\pi_2$
$\pi_2=\frac{1}{3}\pi_0+0\pi_1+\frac{1}{2}\pi_2$

And since $\pi$ is a probability vector,
$\pi_{0}~ + \pi_{1} + \pi_{2} = 1$

Solving the 4 equations for the 3 unknowns gets,
$\pi_{0}~=1/3$, $\pi_{1}~=4/9$, and $\pi_{2}~=2/9$
Therefore $\pi=\left[ {\begin{array}{ccc} 1/3 & 4/9 & 2/9 \end{array} } \right]$

Example 2: Find the Stationary Distribution of P= $\left[ {\begin{array}{ccc} 1/3 & 1/3 & 1/3 \\ 1/4 & 1/2 & 1/4 \\ 1/6 & 1/3 & 1/2 \end{array} } \right]$

Solution: $\pi=\left[ {\begin{array}{ccc} \pi_0 & \pi_1 & \pi_2 \end{array} } \right]$

Using the Stationary Distribution property $\pi=\pi~P$ we get,
$\pi_0=\frac{1}{3}\pi_0+\frac{1}{4}\pi_1+\frac{1}{6}\pi_2$
$\pi_1=\frac{1}{3}\pi_0+\frac{1}{2}\pi_1+\frac{1}{3}\pi_2$
$\pi_2=\frac{1}{3}\pi_0+\frac{1}{4}\pi_1+\frac{1}{2}\pi_2$

And since $\pi$ is a probability vector,
$\pi_{0}~ + \pi_{1} + \pi_{2} = 1$

Solving the 4 equations for the 3 unknowns gets,
$\pi_{0}=\frac {6}{25}$, $\pi_{1}~=\frac {2}{5}$, and $\pi_{2}~=\frac {9}{25}$

Therefore $\pi=\left[ {\begin{array}{ccc} \frac {6}{25} & \frac {2}{5} & \frac {9}{25} \end{array} } \right]$

The above two examples are designed to solve for the stationary distribution of the matrix P. Meanwhile, 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.

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, 1 to 2, then from 2 to 3, and finally from 3 to 4 .Therefore, 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.

Example

$P= \left[ \begin{matrix} \frac{1}{3} \; & \frac{1}{3} \; & \frac{1}{3} \\ \\ \frac{1}{4} \; & \frac{3}{4} \; & 0 \\ \\ \frac{1}{2} \; & 0 \; & \frac{1}{2} \end{matrix} \right]$

$\pi=\left[ \begin{matrix} \frac{1}{3} & \frac{4}{9} & \frac{2}{9} \end{matrix} \right]$

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. Henceit 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 K-by-K Matrix indicates that the chain has k states.

- Ergodic Markov chains are irreducible.
Recall that a Markov chain is irreducible if all the states communicate with each other.

- 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

$P = \left[ \begin{matrix} & R & N & S \\ R & 1/2 & 1/4 & 1/4 \\ N & 1/2 & 0 & 1/2 \\ S & 1/4 & 1/4 & 1/2 \\ \end{matrix} \right]$

Example

The following chain is not an ergodic chain.
Note that this is true because it is not possible to get to every state from any state. So you cannot get to states C or D from states A or B, and vice versa.

The matrix looks like this:

$L= \left[ {\begin{matrix} 1 & 1 & 0 & 0 \\ 1 & 1 & 0 & 0 \\ 0 & 0 & 1 & 1 \\ 0 & 0 & 1 & 1 \end{matrix} } \right]$

Obviously, you cannot get from A or B to C or D.

Theorem

An ergodic Markov chain has a unique Stationary Distribution $\pi$. The Limiting Distribution exists and is equal to $\pi$

• Note1: Ergodic Markov Chain is irreducible, aperiodic and positive recurrent, meaning all states have to be positive recurrent.
• Note2: positive recurrent if the expected amount of time between recurrences is finite.Or, E(Ti) < $infinite$.
• Note3: If the limiting distribution exists for a markov chain does not always imply that the chain is ergodic.

Example

Consider the markov chain of $\left[\begin{matrix}0 & 1 \\ 1 & 0\end{matrix}\right]$, the Stationary Sistribution is obtained by solving $\pi P = \pi$, getting $\pi=[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 $P^2=\left[\begin{matrix}1 & 0 \\ 0 & 1\end{matrix}\right]$ and $P^3=\left[\begin{matrix}0 & 1 \\ 1 & 0\end{matrix}\right]$

Another Example

$P=\left[ {\begin{array}{ccc} \frac{1}{4} & \frac{3}{4} \\[6pt] \frac{1}{5} & \frac{4}{5} \end{array} } \right]$

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 $\pi = \pi P$
$\pi_0 = .25 \pi_0 + .2 \pi_1$
$\pi_1 = .75 \pi_0 + .8 \pi_1$
$\pi_0 + \pi_1 = 1$
Solving this system of equations we get:
$\pi_0 = \frac{4}{15} \pi_1$
$\pi_1 = \frac{15}{19}$
$\pi_0 = \frac{4}{19}$
$\pi = [\frac{4}{19}, \frac{15}{19}]$
$\pi$ is the long run 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 : $E[T_{i,i}]=\frac{1}{\pi_i}$
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.

remark：satisfied balance of $\pi_i P_{ij} = P_{ji} \pi_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, this 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



$\Pi$ satisfies detailed balance if $\Pi_i P_{ij}=P_{ij} \Pi_j$. Detailed balance guarantees that $\Pi$ 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. If we compute $A^2$, we can know which states are connected with paths of length 2.

Markov chain -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 $\pi$. The limiting distribution exists and it is equal to $\pi$.

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 $\pi$ is stationary distributed.

$\pi$ satisfies detailed balance if $\pi_i P_{ij} = P_{ji} \pi_j$
which is the same as the Markov process equation.

Example in the class: $P= \left[ {\begin{array}{ccc} \frac{1}{3} & \frac{1}{3} & \frac{1}{3} \\[6pt] \frac{1}{4} & \frac{3}{4} & 0 \\[6pt] \frac{1}{2} & 0 & \frac{1}{2} \end{array} } \right]$

and $\pi=(\frac{1}{3},\frac{4}{9}, \frac{2}{9})$

$\pi_1 P_{1,2} = 1/3 \times 1/3 = 1/9,\, P_{2,1} \pi_2 = 1/4 \times 4/9 = 1/9 \Rightarrow \pi_1 P_{1,2} = P_{2,1} \pi_2$

$\pi_2 P_{2,3} = 4/9 \times 0 = 0,\, P_{3,2} \pi_3 = 0 \times 2/9 = 0 \Rightarrow \pi_2 P_{2,3} = P_{3,2} \pi_3$

Remark：Detailed balance of $\pi_i * Pij = Pji * \pi_j$ ， so there is other way to calculate the step probability
$\pi$ is stationary but is not limiting.

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

Let $\displaystyle P$ be the transition probability matrix of a Markov chain. If there exists a distribution vector $\displaystyle \underline{\pi} = [\pi_1 \pi_2 ... \pi_n]$ such that $\pi_i \cdot P_{ij}=P_{ji} \cdot \pi_j, \; \forall i,j$, then the Markov chain is said to have detailed balance. The principle of detailed balance, formulated for kinetic systems, are decomposed into elementary processes (collisions, or steps, or elementary reactions): Each elementary process should be equilibrated by its reverse process at equilibrium.

A detailed balanced Markov chain must have $\displaystyle \underline{\pi}$ given above as a stationary distribution, that is $\displaystyle \underline{\pi} = \underline{\pi} P$, where $\displaystyle \underline{\pi}$ is a 1 by n matrix and $\displaystyle P$ is a n by n matrix.

Proof:

   $\; [\pi P]_j = \sum_i \pi_i P_{ij} =\sum_i P_{ji}\pi_j =\pi_j\sum_i P_{ji} =\pi_j ,\forall j$

Note: Since $\pi_j$ is a sum of column j and we can do this proof for every element in matrix P; in general, we can prove $\pi=\pi P$ . Hence $\pi$ 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 $\pi_j$ is the equilibrium probability of being in state j and $\pi_i$ is the equilibrium probability of being in state i. $P(X_{n-1} = i) = \pi_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 $\pi=\pi P$, in the proof the sum of the p is equal 1 so the $\pi P=\pi$.

PageRank (http://en.wikipedia.org/wiki/PageRank)

• PageRank is a link-analysis algorithm developed by Larry Page from Google in 1996; 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. (Eg. 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 allows Google to remain more popular than Yahoo, Bink, AskJeeves, etc.)

The order of importance
1. A web page is important if it has many other pages linked 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 (eg: if a page links to everyone, like 411, it is not as important as pages that have incoming links)

File:diagram.jpg $L= \left[ {\begin{matrix} 0 & 0 & 0 & 0 & 0 \\ 1 & 0 & 0 & 0 & 0 \\ 1 & 1 & 0 & 1 & 0 \\ 0 & 1 & 0 & 0 & 1 \\ 0 & 0 & 0 & 0 & 0 \end{matrix} } \right]$

ie: According to the above example
Page 3 is the most important since it has the most links pointing to it (3 links), therefore more weight should be placed on its outgoing links.
Page 4 comes after page 3 since it has the second most links (2) pointing to it
Page 2 comes after page 4 since it has the third most links (1) pointing to it
Page 1 and page 5 are the least important since no links point to them
As page 1 and page 2 has the most outgoing links, then their links have less value compared to the other pages.

$L_{ij} = 1$ if j has a link to i;
$L_{ij} = 0$ otherwise.

Cj = The number of outgoing links of page $j$: $C_j=\sum_i L_{ij}$ (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 $N \times 1$ vector.

- $P_i$ counts the number of incoming links of page $i$
(i.e. sum of entries in row i)
$P_i=\sum_j L_{ij}$ For a row i, if there is a 1 in the third column, it means page three points to page i.

Alternate Example

File:pagerank.jpg
In this case, Page 5 does not have any pointers to or from the cluster of pages on its left. When we build the algorithm to conduct page rank in the next lecture, we will ensure that Page 5 is not ignored in the ranking system.

Obviously the rank is Page 3, Page 4, Page 2, Page 1, Page 5. Without an additional term ($d$), poor old Page 5 would not come up on the search. However, we will make sure that it does. Yay!

Explanation

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 the 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 co-founders Brin and Page: http://infolab.stanford.edu/pub/papers/google.pdf

Notice: Page and Brin confused a formula in above paper.

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) ] + ((1-d)/N) * (NxN Matrix U of all 1's)

Class 16 - Thursday June 27th 2013

Page Rank

$L_{ij}$ = 1 (if j has a link to i) & 0 (otherwise)
$C_j$ :The number of outgoing links for page j, where $c_j=\sum_i L_{ij}$

P is a Nx1 vector that contains the rank of all N pages.
For page i, the rank is $P_i$

$P_i= (1-d) + d\cdot \sum_j \frac {L_{ij}P_j}{c_j}$
where 0 < d < 1 is constant (in original page rank algorithm d = 0.8).

Note: the rank of page i is
1) Proportional to the importance of each page that linked to it and
2) Inversely proportional to the total number of links coming from each of those pages.

If given all other Pj, we can easily calculate Pi. However, we don't know any of them, thus we need to solve N unknowns with the N equations that we have.

Note: We do not want a page with rank 0 to occur (to give new websites an opportunity to be clicked), so we use d (damping factor)

The reason why we are multiplying by the d term in front of the $\sum_j \frac {L_{ij}P_j}{c_j}$ is to get rid of the problem with extreme cases where term one or two is dominant over the others.

Interpretation of the formula:
1) Sum of Lij 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 (Pj) i.e. if a high-rank page points to page i, then this link carries more weight than links from lower-rank pages.
3) The sum is then weighted by the inverse of the number of outgoing links from the pages that contain links to i (cj). 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.

Note that this is a system of N equations with N unknowns.

$c_j$ is the number of outgoing links, the less outgoing links a page has, the more important the page is.

Let D be a diagonal N by N matrix such that $D_{ii}$ = $c_i$

$D= \left[ {\begin{matrix} c_1 & 0 & ... & 0 \\ 0 & c_2 & ... & 0 \\ 0 & 0 & ... & 0 \\ 0 & 0 & ... & c_N \end{matrix} } \right]$

Then P = (1-d) e + dLD-1P
where e =[1 1 ....]T , i.e. a N by 1 vector.

The relative value of page rank is valuable, but the absolute value is meaningless.
P is a vector of rank which could contain any arbitrary numbers. We only care about whether one web is more important than others(Pi$\gt =$ Pj for any j)

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 proportions.

i.e. eT P = N, then $~\frac{e^{T}P}{N} = 1$

D-1 will be:

D-1$= \left[ {\begin{matrix} \frac {1}{c_1} & 0 & ... & 0 \\ 0 & \frac {1}{c_2} & ... & 0 \\ 0 & 0 & ... & 0 \\ 0 & 0 & ... & \frac {1}{c_N} \end{matrix} } \right]$

$P=~(1-d)e+dLD^{-1}P$ where $e=\begin{bmatrix} 1\\ 1\\ ...\\ 1 \end{bmatrix}$

$P=(1-d)~\frac{ee^{T}P}{N}+dLD^{-1}P$

$P=[(1-d)~\frac{ee^T}{N}+dLD^{-1}]P$

$P=AP, where A=[(1-d)~\frac{ee^T}{N}+dLD^{-1}]$

P is the stationary distribution of A and it is a row vector
A is a transitional probability matrix (N$*$N)

The following variables are necessary to calculate the page rank. $N$ - the rank
$L$ - an NxN matrix (Binary Matrix)
$D^{-1}=$ - an N*N matrix (Diagonal Matrix)
$P$ - an N*1 matrix (Row Vector)
$d$ - a constant between 0 and 1 (In the origional algorithm, d =0.8 )

Example:Given that
$L= \left[ {\begin{matrix} L11 & L12 \\ L21 & L22 \end{matrix} } \right]$

$D^{-1}= \left[ {\begin{matrix} 1/C1 & 0 \\ 0 & 1/C2 \end{matrix} } \right]$

$P= \left[ {\begin{matrix} P1 \\ P2 \end{matrix} } \right]$

Then
L D-1 P = $\left[ {\begin{matrix} L11/C1 & L12/C2\\ L21/C1 & L22/C2 \end{matrix} } \right] \left [ \begin{matrix} P1 \\ P2 \end{matrix} \right]$=$\left [ \begin{matrix} L11*P1/C1+L12*P2/C2 \\ L21*P1/C1+L22*P2/C2 \end{matrix} \right]$<br\>

P=AP
P is an eigenvector of A with corresponding eigenvalue equal to 1.

PT=PTAT

Notice that all entries in AT are non-negative and each row sums to 1.
Hence AT satisfies the definition of a transition probability matrix.
PT is the stationary distribution of a Markov Chain with transition probability matrix AT.

We can consider AT to be the matrix describing all possible movements following links on the internet, and PT as the probability of being on any given webpage if we have been on the internet long enough.

Damping Factor "d" (http://en.wikipedia.org/wiki/PageRank)

The PageRank assumes that an imaginary user who is randomly clicking on links will eventually stop clicking. The probability, at any step, that the person will continue is a damping factor, "d". It is generally assumed that "d" is set around a value of 0.85.
(1-d) is the likelihood of a web surfer jumping to a page chosen at random throughout the entire web.
A web page with no outbound links is known as a "sink" page. If a web surfer lands on a sink page, they are randomly transferred to another page and continue surfing. Thus, it is assumed that a page with no outbound links is linked to all other pages in the web.

Additionally, the higher the damping factor, the larger is the effect of an additional inbound link for the PageRank of the page that receives the link, and the more evenly distributes PageRank over the other pages of a site.

Examples

Example 1

File:eg1.jpg
$L= \left[ {\begin{matrix} 0 & 0 & 1 \\ 1 & 0 & 0 \\ 0 & 1 & 0 \end{matrix} } \right]$

$c= \left[ {\begin{matrix} 1 & 1 & 1 \end{matrix} } \right]$

$D= \left[ {\begin{matrix} 1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1 \end{matrix} } \right]$


MATLAB Code

d=0.8
N=3
A=(1-d)*ones(N)/N+d*L*pinv(D) #pinv: Moore-Penrose inverse (pseudoinverse) of symbolic matrix
We use the pinv(D) function [pseudo-inverse] instead of the inv(D) function because in
the case of a non-invertible matrix, it would not crash the program.
[vec val]=eigs(A) (eigen-decomposition)
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

$L= \left[ {\begin{matrix} 0 & 0 & 1 \\ 1 & 0 & 1 \\ 0 & 1 & 0 \end{matrix} } \right]$

$c= \left[ {\begin{matrix} 1 & 1 & 2 \end{matrix} } \right]$

$D= \left[ {\begin{matrix} 1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 2 \end{matrix} } \right]$


Matlab code

>> L=[0 0 1;1 0 1;0 1 0];
>> C=sum(L);
>> D=diag(C);
>> d=0.8;
>> N=3;
>> A=(1-d)*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)  ;;standardize a

a =

0.2201
0.3962
0.3836


NOTE:
Page 2 is the most important page, because it has 2 incomings.
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.
Hence, 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.

Example 3

$L= \left[ {\begin{matrix} 0 & 1 & 0 \\ 1 & 0 & 1 \\ 0 & 1 & 0 \end{matrix} } \right]$

$c= \left[ {\begin{matrix} 1 & 2 & 1 \end{matrix} } \right]$

$D= \left[ {\begin{matrix} 1 & 0 & 0 \\ 0 & 2 & 0 \\ 0 & 0 & 1 \end{matrix} } \right]$

$d=0.8$
$N=3$

In this example the second page has 2 incomings (from the first and third page). So, page 2 is the most important. Since the number of incoming for page 1 and 3 both come from page 2, they are equally important.

Another Example:

Consider: 1 <-> 2 -> 3

$L= \left[ {\begin{matrix} 0 & 1 & 0 \\ 1 & 0 & 0 \\ 0 & 1 & 0 \end{matrix} } \right]$ $c= \left[ {\begin{matrix} 1 & 1 & 1 \end{matrix} } \right]$ $D= \left[ {\begin{matrix} 1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1 \end{matrix} } \right]$

Example 4

1 <-> 2 -> 3 <-> 4

$L= \left[ {\begin{matrix} 0 & 1 & 0 & 0 \\ 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 1 \\ 0 & 0 & 1 & 0 \end{matrix} } \right]$

$c= \left[ {\begin{matrix} 1 & 2 & 1 & 1 \end{matrix} } \right]$

$D= \left[ {\begin{matrix} 1 & 0 & 0 & 0 \\ 0 & 2 & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & 1 \end{matrix} } \right]$

Matlab code


>> 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=(1-d)*ones(N)/N+d*L*pinv(D)

A =

0.0500    0.4500    0.0500    0.0500
0.8500    0.0500    0.0500    0.0500
0.0500    0.4500    0.0500    0.8500
0.0500    0.0500    0.8500    0.0500

>> [vec val]=eigs(A)

vec =

0.1817   -0.0000   -0.4082    0.4082
0.2336    0.0000    0.5774    0.5774
0.7009   -0.7071    0.4082   -0.4082
0.6490    0.7071   -0.5774   -0.5774

val =

1.0000         0         0         0
0   -0.8000         0         0
0         0   -0.5657         0
0         0         0    0.5657

>> a=vec(:,1)

>> a=vec(:,1)

a =

0.1817
0.2336
0.7009
0.6490

>> a=a/sum(a)

a =

0.1029
0.1324
0.3971
0.3676


NOTE:
The ranking of each page is as follows: Page 3, Page 4, Page 2 and Page 1.
Page 3 has the highest ranking,since it has the most incoming links.
All of the other pages only have one incoming link, but Page 4 becomes the second highest ranked since Page 3 (highest ranked page) links to Page 4.
Page 2 is ranked next, because it links to Page 3. It has 2 outgoing links; page with the same number of incoming links can be ranked closest to the highest ranked page.
If the page with the highest ranking P1 has an incoming link to page P2, then P2 is ranked second, and so on.

Example 5

$L= \left[ {\begin{matrix} 0 & 1 & 0 & 1 \\ 1 & 0 & 1 & 1 \\ 1 & 0 & 0 & 1 \\ 1 & 0 & 0 & 0 \end{matrix} } \right]$

$c= \left[ {\begin{matrix} 3 & 1 & 1 & 3 \end{matrix} } \right]$

$D= \left[ {\begin{matrix} 3 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & 3 \end{matrix} } \right]$


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=(1-d)*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

$L= \left[ {\begin{matrix} 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 \end{matrix} } \right]$

Matlab Code

>> d=0.8

d =

0.8000

>> 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]

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)

c =

1     3     1     1     2

>> D=diag(c)

D =

1     0     0     0     0
0     3     0     0     0
0     0     1     0     0
0     0     0     1     0
0     0     0     0     2

>> N=5

N =

5

>> A=(1-d)*ones(N)/N+d*L*pinv(D)

A =

0.0400    0.3067    0.0400    0.0400    0.4400
0.8400    0.0400    0.0400    0.0400    0.0400
0.0400    0.3067    0.0400    0.0400    0.0400
0.0400    0.3067    0.8400    0.0400    0.4400
0.0400    0.0400    0.0400    0.8400    0.0400

>> [vec val]=eigs(A)

vec =

Columns 1 through 4

-0.4129             0.4845 + 0.1032i   0.4845 - 0.1032i  -0.0089 + 0.2973i
-0.4158            -0.6586            -0.6586            -0.5005 + 0.2232i
-0.1963             0.2854 - 0.0608i   0.2854 + 0.0608i  -0.2570 - 0.2173i
-0.5700             0.1302 + 0.2612i   0.1302 - 0.2612i   0.1462 - 0.3032i
-0.5415            -0.2416 - 0.3036i  -0.2416 + 0.3036i   0.6202

Column 5

-0.0089 - 0.2973i
-0.5005 - 0.2232i
-0.2570 + 0.2173i
0.1462 + 0.3032i
0.6202

val =

Columns 1 through 4

1.0000                  0                  0                  0
0            -0.5886 - 0.1253i        0                  0
0                  0            -0.5886 + 0.1253i        0
0                  0                  0             0.1886 - 0.3911i
0                  0                  0                  0

Column 5

0
0
0
0
0.1886 + 0.3911i

>> a=-vec(:,1)

a =

0.4129
0.4158
0.1963
0.5700
0.5415

>> a=a/sum(a)

a =

0.1933
0.1946
0.0919
0.2668 % (the most important)
0.2534


For the matrix above:
page 4 has 3 incomings;
page 5 has 1 incomings from page 4;
page 2 has 1 incoming;
page 1 has 2 incoming;.
page 3 has 1 incoming;

The rank is then: page 4 , page 5, page 2 and page 1 and page 3.

where c=[2 1 1 3 1].

Class 17 - Tuesday July 2nd 2013

Markov Chain Monte Carlo (MCMC)

Definition: 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)

One of the main purposes of MCMC : to simulate dependent samples. Other methods learned in class allow us to simulate iid random variables overtime. In this case, we could sample slightly dependent random variables using a Markov Chain. Its Markov properties help to simplify the simulation process.

Basic idea: Given a probability distribution $\pi$ on a set $\Omega$, we want to generate random elements of $\Omega$ with distribution $\pi$. MCMC does that by constructing a Markov Chain with stationary distribution $\pi$ and simulating the chain. After a large number of iterations, the Markov Chain will reach its stationary distribution. Simply by choosing the value of the Markov chain at that large step, we are effectively sampling from the desired distribution.

Note
1)Regardless of the chosen starting point, the Markov Chain will converge to its stationary distribution. However, the time taken for the chain to converge depends on its chosen starting point.)

2)Monte Carlo is used for sampling from a distribution, estimating the distribution, and computing the max and mean. Markov Chain Monte Carlo is used to sample using

3)“local” information. It is used as a generic “problem solving technique” to solve decision/optimization/value problems, but is not necessarily very efficient.

4)The goal when simulating with a Markov Chain is to create a chain with the same stationary distribution as the target distribution.

5)The MCMC method is usually used in continuous cases but a discrete example is given below.

== Detailed explanation of $\pi$ ==

$\pi$ indicates the proportion of time the process spends in each of the states 1,2,...,n. Therefore $\pi$ satisfies the following two inequalities:

1. $\pi_j$ = sum($\pi_i*P{ij}$).
This is because $\pi$ 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, $\pi_i*p{ij}$ is the proportion of time it takes for the process to enter state j. Therefore, $\pi_j$ is the sum of this probability over overall states i.

2)$\pi_j$ = Sum($\pi_i$) = 1

Motivation example

- Suppose we want to generate a random variable X according to distribution $\pi=(\pi_1, \pi_2, ... , \pi_m)$
X can take m possible different values from ${1,2,3,\cdots,m}$
- We want to generate $\{X_t: t=0, 1, \cdots, m\}$ according to $\pi$

Suppose our example is of a bias die.
Now we have m=6, $\pi=[0.1,0.1,0.1,0.2,0.3,0.2]$, $X \in [1,2,3,4,5,6]$

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.)

$\mathbf{Q} = \begin{bmatrix} q_{11} & q_{12} & \cdots & q_{1m} \\ q_{21} & q_{22} & \cdots & q_{2m} \\ \vdots & \vdots & \ddots & \vdots \\ q_{m1} & q_{m2} & \cdots & q_{mm} \end{bmatrix}$

We generate Y = j according to the i-th row of Q. Note that the i-th 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 $\pi$ is the stationary distribution, then it must satisfy the detailed balance condition:

$\pi_i P_{ij}$ = $\pi_j P_{ji}$


Since $P_{ij}$ = $q_{ij} r_{ij}$, we have $\pi_i q_{ij} r_{ij}$ = $\pi_j q_{ji} r_{ji}$.
We want to find a general solution: $r_{ij} = a(i,j) \pi_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)$ $\pi_j q_{ji}$≤1, then we get: $a(i,j)$$1/(\pi_j q_{ji})$

2. $r_{ji} = a(i,j)$ $\pi_i q_{ij}$ ≤ 1, then we get: $a(j,i)$$1/(\pi_j q_{ji})$

So we choose a(i,j) as large as possible, but it needs to satisfy the two conditions above.

$a(i,j) = \min \{\frac{1}{\pi_j q_{ji}},\frac{1}{\pi_i q_{ij}}\}$

Thus, $r_{ij} = \min \{\frac{\pi_j q_{ji}}{\pi_i q_{ij}}, 1\}$

Note: 1 is the upper bound to make rij a probability

Algorithm:

• $P(Y=j) = q_{ij}$. $\frac{\pi_j q_{ji}}{\pi_i q_{ij}}$ is a positive ratio.
• $r_{ij} = \min \{\frac{\pi_j q_{ji}}{\pi_i q_{ij}}, 1\}$
• $x_{t+1} = \begin{cases} Y, & \text{with probability } r_{ij} \\ x_t, & \text{otherwise} \end{cases}$
• go back to the first step

We can compare this with the Acceptance-Rejection model we learned before.

• $U$ ~ $Uniform(0,1)$
• If $U \lt r_{ij}$, then accept.

The algorithm generates a stochastic sequence that only depends on the most current ones which is a Markov Chain.

Note

If Pij is zero, the chain is not ergodic (i.e. we cannot go from one state to another).


Metropolis Algorithm

Proposition: Metropolis works:

The $P_{ij}$'s from Metropolis Algorithm satisfy detailed balance property w.r.t $\pi$ . i.e. $\pi_i P_{ij} = \pi_j P_{ji}$. The new Markov Chain has a stationary distribution $\pi$.

Remarks:
1) We only need to know ratios of values of $\pi_i$'s.
2) The MC might converge to $\pi$ exponentially slowly

This algorithm generates $\{x_t: t=0,...,m\}$.
In the long run, the marginal distribution of $x_t$ is $\underline{\Pi}$
$\{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
$P_{ij}= \begin{cases} q_{ij} r_{ij}, & \text{if }i \neq j \\[6pt] 1 - \displaystyle\sum_{k \neq i} q_{ik} r_{ik}, & \text{if }i = j \end{cases}$

$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 $\underline{\Pi}$, i.e. $\displaystyle \underline{\Pi} = \underline{\Pi}P$

Recall

If a Markov chain satisfies the detailed balance property, i.e. $\displaystyle \pi_i P_{ij} = \pi_j P_{ji} \, \forall i,j$, then $\underline{\Pi}$ is the stationary distribution of the chain.


Proof:

WLOG, we can assume that $\frac{\pi_j q_{ji}}{\pi_i q_{ij}}\lt 1$

LHS:
$\pi_i P_{ij} = \pi_i q_{ij} r_{ij} = \pi_i q_{ij} \cdot \min(\frac{\pi_j q_{ji}}{\pi_i q_{ij}},1) = \cancel{\pi_i q_{ij}} \cdot \frac{\pi_j q_{ji}}{\cancel{\pi_i q_{ij}}} = \pi_j q_{ji}$

RHS:
Note that by our assumption, since $\frac{\pi_j q_{ji}}{\pi_i q_{ij}}\lt 1$, its reciprocal $\frac{\pi_i q_{ij}}{\pi_j q_{ji}} \geq 1$
So $\displaystyle \pi_j P_{ji} = \pi_ j q_{ji} r_{ji} = \pi_ j q_{ji} \cdot \min(\frac{\pi_i q_{ij}}{\pi_j q_{ji}},1) = \pi_j q_{ji} \cdot 1 = \pi_ j q_{ji}$

Hence LHS=RHS

If we assume that $\frac{\pi_j q_{ji}}{\pi_i q_{ij}}=1$
(essentially $\frac{\pi_j q_{ji}}{\pi_i q_{ij}}\gt =1$)

LHS:
$\pi_i P_{ij} = \pi_i q_{ij} r_{ij} = \pi_i q_{ij} \cdot \min(\frac{\pi_j q_{ji}}{\pi_i q_{ij}},1) =\pi_i q_{ij} \cdot 1 = \pi_i q_{ij}$

RHS:
Note
by our assumption, since $\frac{\pi_j q_{ji}}{\pi_i q_{ij}}\geq 1$, its reciprocal $\frac{\pi_i q_{ij}}{\pi_j q_{ji}} \leq 1$

So $\displaystyle \pi_j P_{ji} = \pi_ j q_{ji} r_{ji} = \pi_ j q_{ji} \cdot \min(\frac{\pi_i q_{ij}}{\pi_j q_{ji}},1) = \cancel{\pi_j q_{ji}} \cdot \frac{\pi_i q_{ij}}{\cancel{\pi_j q_{ji}}} = \pi_i q_{ij}$

Hence LHS=RHS $\square$

Note
1) If we instead assume $\displaystyle \frac{\pi_i q_{ij}}{\pi_j q_{ji}} \geq 1$, the proof is similar with LHS= RHS = $\pi_i q_{ij}$

2) If $\displaystyle i = j$, then detailed balance is satisfied trivially.

since ${\pi_i q_{ij}}$, and ${\pi_j q_{ji}}$ are smaller than one. so the above steps show the proof of $\frac{\pi_i q_{ij}}{\pi_j q_{ji}}\lt 1$.

Class 18 - Thursday July 4th 2013

1. REDIRECT === Last class ===

$r_{ij}=min(\frac {{\pi_j}q_{ji}}{{\pi_i}q_{ij}},1)$
when $\frac {{\pi_j}q_{ji}}{{\pi_i}q_{ij}} \lt 1$, we have $r_{ij}=\frac {{\pi_j}q_{ji}}{{\pi_i}q_{ij}}$, and rji=1
when $\frac {{\pi_j}q_{ji}}{{\pi_i}q_{ij}} \geq 1$, we have $r_{ji}=\frac {{\pi_i}q_{ij}}{{\pi_j}q_{ji}}$, and rij=1

Example: Discrete Case

Consider a biased die $\pi$= [0.1, 0.1, 0.2, 0.4, 0.1, 0.1]

$\mathbf{Q} = \begin{bmatrix} 1/6 & 1/6 & \cdots & 1/6 \\ 1/6 & 1/6 & \cdots & 1/6 \\ \vdots & \vdots & \ddots & \vdots \\ 1/6 & 1/6 & \cdots & 1/6 \end{bmatrix}$

Algorithm
1. $x_t=5$ (sample from the 5th row)
2. Y~Unif[1,2,...,6]
$r_{ij} = \min \{\frac{\pi_j q_{ji}}{\pi_i q_{ij}}, 1\} = \min \{\frac{\pi_j 1/6}{\pi_i 1/6}, 1\} = \pi_j/\pi_i$
Note: current state i is Xt, the candidate state j is Y.
Note: since qij = qji for all i and j, then we have $r_{ij} = \min \{\frac{\pi_j}{\pi_i }, 1\}$

U~Unif(0,1) (**)
if $u \leq r_{ij}$,
Xt+1=Y
else
Xt+1=Xt
end if
go to (2)

Steps to generate a probability transition matrix with a uniform distribution.

Matlab

 pii=[.1,.1,.2,.4,.1,.1];
x(1)=5;
for ii=2:1000
Y=unidrnd(6);                 %%% Unidrnd(x) is a built-in function which generates a number between (0) and (x)
r = min (pii(Y)/pii(x(ii-1)), 1);
u=rand;
if u<r
x(ii)=Y;
else
x(ii)=x(ii-1);
end
end
hist(x,6)
xx = x(501,end);     %After 500, the chain will mix well and converge.
hist(xx,6)                 % The result should be better.


In place of qi,j put q(y|x) In place of ri,j put r(x,y) Assume that q(y|x) is a friendly distribution that is easy to sample.

NOTE: Generally, we will generate a large number of points (say, 1500) and throw away the first points (say, 500). Those first points are called the burn-in period. Since the chain is said to converge in the long run, the burn-in period is where the chain is moving toward the limiting distribution, but has not reached it yet; by discarding those 500 points, our data set will be more representative of the desired limiting distribution.

Remark
1. The chain may not get to a stationary distribution if the # of steps generated are small.
2. If we are given $\pi^'=\pi\alpha=[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}$,
$\frac{\pi^'_j/s}{\pi^'_i/s}\times\frac{q_{ji}}{q_{ij}}=\frac{\pi^'_j}{\pi^'_i}\times\frac{q_{ji}}{q_{ij}}$
$s$ cancels out in this case. Therefore it is not necessary to calculate the sum and normalize the vector.

The code generate 1000 points from the probability transition matrix.

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 purpose of the Metropolis-Hastings 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, $\pi(x)$. (http://en.wikipedia.org/wiki/Metropolis%E2%80%93Hastings_algorithm)

Metropolis-Hastings is an algorithm for constructing a Markov chain with a given limiting probability distribution. In particular, we consider what happens if we apply the Metropolis-Hastings 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.

There are several 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 $r{ij}$ in discrete
3. $f$ is used instead of $\pi$

Before we consider the algorithm there are a couple general steps to follow to build acceptance ratio:
a) Find the distribution you wish to use to generate samples
b) Find a candidate distribution that fits the desired distribution, q(y|x). (the proposed moves are independent of the current state)
c) Build the acceptance ratio $\displaystyle \frac{f(y)q(x|y)}{f(x)q(y|x)}$

Assume that f(y) is the target distribution; Choose q(y|x) such that it is a friendly distribution that is easy to sample from.

Algorithm:

1. Set $\displaystyle i = 0$ and initialize the chain, i.e. $\displaystyle x_0 = s$ where $\displaystyle s$ is some state of the Markov Chain.
2. Sample $\displaystyle Y \sim q(y|x)$
3. Set $\displaystyle r(x,y) = min(\frac{f(y)q(x|y)}{f(x)q(y|x)},1)$
4. Sample $\displaystyle u \sim \text{UNIF}(0,1)$
5. If $\displaystyle u \leq r(x,y), x_{i+1} = Y$
Else $\displaystyle x_{i+1} = x_i$
6. Increment i by 1 and go to Step 2, i.e. $\displaystyle i=i+1$

Note: q(x|y) is moving from y to x and q(y|x) is moving from x to y.
We choose q(y|x) so that it is simple to sample from. Usually, we choose a normal distribution.

Comparing with previous sampling methods we have learned, samples generated from M-H 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 Metropolis-Hastings. 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.

Remark 1

A common choice for q(y|x) is a normal distribution centered at x with standard deviation b. q(y|x)=N(x,b2)

i.e. $q(y|x)=q(x|y)$ $q(y|x)=\frac{1}{\sqrt{2\pi}b}\,e^{- \frac{\scriptscriptstyle 1}{\scriptscriptstyle 2b^2} (y-x)^2}$ $q(x|y)=\frac{1}{\sqrt{2\pi}b}\,e^{- \frac{\scriptscriptstyle 1}{\scriptscriptstyle 2b^2} (x-y)^2}$ $\Rightarrow (y-x)^2=(x-y)^2$ so $~q(y \mid x)=q(x \mid y)$
In this case $\frac{q(x \mid y)}{q(y \mid x)}=1$ and therefore $r(x,y)=\min \{\frac{f(y)}{f(x)}, 1\}$

This is true for any symmetric q. In general if q(y|x) 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. Beta ---> 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~$min\{\frac{f(y)}{f(x)},1\}$, so it is accepted with the probability $min\{\frac{f(y)}{f(x)},1\}$. Thus, if $f(y)\gt 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$. As a result it makes sense that 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 Metropolis-Hastings 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:

\begin{align} f(x;\alpha,\beta)& = \frac{1}{\mathrm{B}(\alpha,\beta)}\, x^{\alpha-1}(1-x)^{\beta-1}\end{align}

The beta function, B, appears as a normalizing constant but it can be simplified by construction of the method.

Example

$\,f(x)=\frac{1}{\pi^{2}}\frac{1}{1+x^{2}}$

Then, we have $\,f(x)\propto\frac{1}{1+x^{2}}$.

And let us take $\,q(x|y)=\frac{1}{\sqrt{2\pi}b}e^{-\frac{1}{2b^{2}}(y-x)^{2}}$.

Then $\,q(x|y)$ is symmetric.

Therefore Y can be simplified.

We get :

\,\begin{align} \displaystyle r(x,y) & =min\left\{\frac{f(y)}{f(x)}\frac{q(x|y)}{q(y|x)},1\right\} \\ & =min\left\{\frac{f(y)}{f(x)},1\right\} \\ & =min\left\{ \frac{ \frac{1}{1+y^{2}} }{ \frac{1}{1+x^{2}} },1\right\}\\ & =min\left\{ \frac{1+x^{2}}{1+y^{2}},1\right\}\\ \end{align}.

$\pi=[0.1\,0.1\,...]$
$\pi \propto [3\,2\, 10\, 100\, 1.5]$
$\Rightarrow \pi=1/c \times [3\, 2\, 10\, 100\, 1.5]$
$\Rightarrow c=3+2+10+100+1.5$

In practice, if elements of $\pi$ are functions or random variables, we need c to be the normalization factor, the summation/integration over all members of $\pi$. This is usually very difficult. Since we are taking ratios, with the Metropolis-Hasting 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(i-1);
r=min((1+x(i-1)^2)/(1+y^2),1);
u=rand;
if u<r
x(i)=y;
else
x(i)=x(i-1);
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(ii-1);
r=min((1+x(ii-1)^2)/(1+y^2),1);
u=rand;
if u<=r
x(ii)=y;
else
x(ii)=x(ii-1);
end
end
xx=x(501:end)
hist(xx,100)


If a function f(x) can only take values from (0,inf), but we need to use normal distribution as the candidate distribution, then we can use $q=2/sqrt(2*Pi)*exp(-1/2*(y-x)^2)$, where y is from 0 to inf. (This is essentially the pdf of the absolute value of a normal distribution centered around x)

Example We want to sample from exp(2), q(y|x)~N(x,b^2)
r=$min(exp(2*(x-y)),1)$

MATLAB

x(1)=0;
for ii=2:100
y=2*(randn*b+abs(x(ii-1)))
r=min(exp(2*(x-y)),1);
u=rand;
if u<=r
x(ii)=y;
else
x(ii)=x(ii-1);
end
end


Definition of Burn in:

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 burn-in. 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)

Several extensions have been proposed in the literature to speed up the convergence and reduce the so called “burn-in” period.

Aside: The algorithm works best if the candidate density q(y|x) matches the shape of the target distribution f(x). If a normal distribution is used as a candidate distribution, the variance parameter b2 has to be tuned during the burn-in 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 M-H method to generate sample from f(x)=2x 0<x<1, 0 otherwise.

1) Initialize the chain with xi and set i=0

2)Y~q(y|xi) where our proposal function would be uniform [0,1] since it matches our original ones support. =>Y~Unif[0,1]

3)consider $\frac{f(y)}{f(x)}=\frac{y}{x}$, $r(x,y)=min (\frac{y}{x},1)$ since q(y|xi) and q(xi|y) can be cancelled together.

4)Xi+1=Y with prob r(x,y), Xi+1=Xi, otherwise

5)i=i+1, go to 2

Class 19 - Tuesday July 9th 2013

Recall: Metropolis–Hasting Algorithm

Xt= state of chain at step t
$Y$~$q(y|x)$
$\,r=min[\frac{f(y)}{f(x)}\,\frac{q(x|y)}{q(y|x)}\,,1]$
$U$~$Uniform(0,1)$
If $U\lt r$, then
xt+1 = y
else
xt+1 = xt

Why can we use this algorithm to generate a Markov Chain?
By the memoryless property of Markov Chain, the current state will only be affected by the previous state. Thus, time t will not affect the choice of state.

Choosing b: 3 cases

In this example, q(y|x)=N(x, b^2)
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(i-1);
r=min((1+x(i-1)^2)/(1+y^2),1);
u=rand;
if u<r
x(i)=y;
else
x(i)=x(i-1);
end

end
hist(x(5000:end,100)
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 too small

Then we are setting up our proposal distribution $q(y\mid{x})$ to be much narrower than the target $\displaystyle f(x)$ so the chain will not have a chance to explore the sample state space and visit a lot of the states of the target $\displaystyle f(x)$. For example, if we are generating samples from the combination of two normal distributions, it is highly likely the histogram of $\displaystyle X$ will only be able to show the distribution of one of the normal distributions.
with b =0.02, the chain takes small steps so the chain doesn't explore enough of the sample space. Thus, we want b large enough so that it explores both distributions, but small enough so that it is still efficient

As CLT said, when b is very large the graph looks like a normal distribution(b=20). However, when b is very small it looks like a fluctuate graph. (b= 0.2)

b too large

Then the fraction $\frac{f(y)}{f(x)}$ would be very small $\Rightarrow$ $r=min{\{\frac{f(y)}{f(x)},1}\}$ is very small as well. It is highly unlikely that $\displaystyle u\lt r$, the probability of rejecting $\displaystyle Y$ is high so the chain is likely to get stuck in the same state for a long time $\rightarrow$ chain may not coverge to the right distribution.It is easy to observe by looking at the histogram of $\displaystyle X$, the shape will not resemble the shape of the target $\displaystyle f(x)$ Most likely we reject y and the chain will get stuck.
with b = 20, jumps are very unlikely to be accepted

if b is too large then the normal distribution can not cover the fluctuate graph, so it is hard to accept.

b just right

Well chosen b will help avoid the issues mentioned above and we can say that the chain is "mixing well".

with b = 2, the chain is mixing well.

$\frac{f(y)}{f(x)}$ and consequently r is very small and very unlikely that u < r, so the current value will be repeated.
ie. y is rejected as $\frac{f(y)}{f(x)}$ and xt+1 = xt; as a result, we get a lot of the same points from the output.

Recall detailed balance for discrete case if $\pi_i*P_ij=\pi_j*Pji$ then $\pi=\pi*P$

   $\; [\pi P]_j = \sum_i \pi_i P_{ij} =\sum_i P_{ji}\pi_j =\pi_j\sum_i P_{ji} =\pi_j ,\forall j$


Recall: sum of each column of P is 1.

Continuous case: If $\displaystyle f(x)P(y|x)=f(y)P(x|y)$, then $\displaystyle f(x)$ is a stationary distribution.
Because $\int^{}_y f(y)P(x|y)dy=\int^{}_y f(x)P(y|x)dy=f(x) \cancel{\int^{}_y P(y|x)dy}=f(x)*1 = f(x)$

Convergence of MH
We generate y from q(y|x) and accept with probability
$\,r=min[\frac{f(y)}{f(x)}\,\frac{q(x|y)}{q(y|x)}\,,1]$
without loss of generality, assume $\,\frac{f(y)}{f(x)}\,\frac{q(x|y)}{q(y|x)}\,\lt 1$
then r(x,y) i.e. probability of accepting y given that the current state is x will be
$\,r(x,y)=min[\frac{f(y)}{f(x)}\,\frac{q(x|y)}{q(y|x)}\,,1]=\frac{f(y)}{f(x)}\,\frac{q(x|y)}{q(y|x)}\,$

Now suppose that the current state is y and we are generating x. The probability of accepting x, given that the current state is y is $\,r(y,x)=min[\frac{f(x)}{f(y)}\,\frac{q(y|x)}{q(x|y)}\,,1]=1$
Based on our original assumption $\frac{f(y)}{f(x)}$$\frac{q(x|y)}{q(y|x)}\gt 1$ , then r(y,x)=1

In Metropolis-Hastings, the probability of jumping to y, given that the current state is x (denoted by P[y|x]) depends on (1) the probability of generating y, and (2) the probability of accepting y.
$\,P(y|x)=q(y|x)×r(x,y)=\frac{q(y|x)f(y)}{f(x)}\,\frac{q(x|y)}{q(y|x)}\,=\frac{f(y)q(x|y)}{f(x)}\,$

The probability of jumping to x, given that the current state is y.
$\,P(x|y)=q(x|y)×r(y,x)=q(x|y)$
Detailed balance for the chain requires $\,f(x)P(y|x)=f(y)P(x|y)$.

L.H.S
$f(x)\frac{f(y)q(x|y)}{f(x)}\,=f(y)q(x|y)$
R.H.S
$\,f(y)P(x|y)=f(y)q(x|y)$
L.H.S = R.H.S
Thus, detailed balance holds. Therefore f(x) is the stationary distribution of the chain generated by Metropolis-Hastings.

If $\,\frac{f(y)}{f(x)}\,\frac{q(x|y)}{q(y|x)}\,\gt 1$
then r(x,y) i.e. probability of accepting y given that the current state is x will be
$\,r(x,y)=min[\frac{f(y)}{f(x)}\,\frac{q(x|y)}{q(y|x)}\,,1]=1$
$\,r(y,x)=min[\frac{f(x)}{f(y)}\,\frac{q(y|x)}{q(x|y)}\,,1]=\frac{f(x)}{f(y)}\,\frac{q(y|x)}{q(x|y)}\,$
$\,P(y|x)=q(y|x)×r(x,y)=q(y|x)$
$\,P(x|y)=q(x|y)×r(y,x)=\frac{f(x)q(y|x)}{f(y)}\,$
LHS=RHSusing the same rationale as the previous case

Suppose we have two normal distribution N(2, σ^2) and N(10, σ^2), and we want

$f(x) = \begin{cases} N(2, \sigma^2), & \text{if } j = 0 \\ N(10, \sigma^2), & \text{if } j = 1 \end{cases}$

where P(j = 0) = 0.5 and P(j = 1) = 0.5

Mixture of Gaussians
We want to sample f(x)=0.5*exp-(x-mu1)^2/sigma1^2+=0.5*exp-(x-mu2)^2/sigma2^2

We can use MH where, $\,r(x,y)=min[\frac{e^{-(y-2)^2}+e^{-(y-10)^2}}{e^{-(x-2)^2}+e^{-(x-10)^2}}\,,1]$

MATLAB

clear all
close all
b=2;%b=20, b=200
x(1)=randn;
for i=2:100000
y=b*randn+x(i-1);
%r=min((1+x(i-1)^2)/(1+y^2), 1);
r=min((exp(-(y-2)^2)+exp(-(y-10)^2))/(exp(-(x(i-1)-2)^2)+exp(-(x(i-1)-10)^2),1);
u=rand;
if u<r
x(i)=y;
else
x(i)=x(i-1);
end
end
hist(x(5000:end), 100)


As it it clear from this plot that the matlab code above generated (simulated) mixture of Gaussian, one around mean of 2 and other around mean of 10.

However, keep in mind that inappropriate b (either too small or too large) may not simulate it properly

For b = 0.02 (too small)

For b = 200 (too large)

These both doesnot seem like the gaussian distribution centered around mean 2 and 10

In general, the mixture of Normal distributions can have any mixture of weights as long as they are between 0 and 1, and the sum of the weights equals 1. For the mixture of Normal distributions, it is important to be careful with the selection of b.
1) If b is too small, it will easily get stuck in one of the two parts of the Normal distribution, as it can't choose a number in the other half as a candidate
2) If b is too large, it will get stuck on a single number for larger periods of time, as we saw before.

To simulate a multivariate distribution, we can use the above algorithm and modify the code so that the scalars x and y are vectors.

ezplot
ex.
>>syms x
>>ezplot(x^2)
>>ezsurf('exp(-(x1^2*x2^2+x1^2+x2^2-8*x1-8*x2)/2)')


Matlab Tips:

1. Function "ezplot" is used to "easily" plot a curve $\displaystyle y=f(x)$. By default the domain is set to $-2 \pi\leq x \leq 2\pi$
2. Function "ezsurf" is used to "easily" plot a surface $\displaystyle z=f(x,y)$. By default the domain is set to $-2\pi\leq x\leq 2\pi, -2\pi\leq y\leq 2\pi$
3. Function "syms" is a shortcut used to create symbolic variables.

we are interested in the probability of moving to y from x in the Markov Chain generated by MH algorithm denoted by p(y|x) p(y|x) depends on two probabilities. 1) probabilities of generating y 2)probabilities of accepting y

Mixture distribution of two random variables:
In general if X is a mixture distribution of random variables Y and Z, then
1) f(x) = p*fy(x) + (1-p)*fz(x)
2) F(x) = p*Fy(x) + (1-p)*Fz(x)
3) S(x) = 1-F(x) = p*Sy(x) + (1-p)*Sz(x)
4) E(Xk) = p*E(Yk) + (1-p)*E(Zk)

Class 20 - Thursday July 11th 2013

Simulated Annealing

following are definition from wikipedia

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). For certain problems, simulated annealing may be more efficient than exhaustive enumeration — provided that the goal is merely to find an acceptably good solution in a fixed amount of time, rather than the best possible solution. http://en.wikipedia.org/wiki/Simulated_annealing

Simulated Annealing is a popular algorithm in simulation for minimizing functions.

The method was independently described by Scott Kirkpatrick, C. Daniel Gelatt and Mario P. Vecchi in 1983 and by Vlado Černý in 1985

Simulated Annealing is an application of the Metropolis algorithm that is used in optimization. Note that under the Metropolis algorithm $q(y|x)$ is symmetric. This algorithm aims to find a global minimum or a global maximum.
File:http://en.wikipedia.org/wiki/File:Hill Climbing with Simulated Annealing.gif

Correction: No matter how big or small T is, the curves will overlap at the center
Since when h(x)=0, f(x)=1

Suppose that we want to minimize h(x) to max
e-h(x)/T

Note that exponential function is monotonic - meaning that it is only ever increasing/decreasing.

min h(x) x

for a given (arbitrary) constant T>0 min h(x) is equivalent to max e-h(x)/T

We want to find min h(x)

h(x)=(x-2)2

min h(x)

x

This is equivalent to finding max e-h(x)/T

T is an arbitrary positive number. Small T makes the function narrow, large T makes the function wide.

This equivalency follows because the exponential function is monotonic

Why? $e^{-x}$ is a decreasing function of x. Therefore the minimum value of this function occurs at the largest value of x.

Consider the function

f$\alpha$e-h(x)/T

We do not need to know the normalization factor (alpha).

Note that exponential function is monotonic. If T is small, then sampling from f is in fact a sample of points close to the mode of $e^{\frac{-h(x)}{T}}$ which are the min of h(x). Based on this intuition, simulated annealing has the process:

1. Set T to a large number
2. Initialize the chain. Set $X_t$
3. $y~q(y|x)$ (q should be symmetric)
4. $r = min{\frac{f(y)}{f(x)}}$
5. $U$~$U(0,1)$
6. If U < r: $x_{t+1}=y$
else: $x_{t+1}=x_t$
7. Decrease T. Go back to 3.

$r = \min ( \frac{f(y)}{f(x)} ,1 )$
$= \min (\frac{e^{\frac{-h(y)}{T}}}{e^\frac{-h(x)}{T}} ,1)$
$= \min (e^{\frac{-h(y)}{T}-\frac{-h(x)}{T}} ,1)$
$= \min (e^{\frac{h(x)-h(y)}{T}},1)$

$r=min\left[\frac{f(y)}{f(x)},1\right]=min\left[\frac{e^{\frac{-h(y)}{T}}}{e^{\frac{-h(x)}{T}}},1\right]=min\left[e^{\frac{h(x)-h(y)}{T}},1\right]$

Suppose T is large,

1. If $h(y)\lt h(x)$, then e(h(y)-h(x))/T=1. Therefore r=1 and we will always accept y (a good move)

2. If $h(y)\lt h(x)$, then e(h(y)-h(x))/T<1. Therefore r<1 and we will accept with probability r (this will help to escape from local minima).

Suppose T is small (T->0)
1. If $h(y)\lt h(x)$, then e(h(y)-h(x))/T->infinity. Therefore r=1, we always accept y. Since h(y) takes on a lower value, moving towards h(y) is considered a good move and we always accept such a good move.

2. If $h(y)\lt h(x)$, then e(h(y)-h(x))/T->0. Therefore r->0, we almost never accept y.

Essentially, the smaller the value of T, the sharper the distribution, and the higher the probability of rejection. We start by picking T large so that there is a lower probability of rejection which is more efficient. The algorithm will then be able to explore the target distribution instead of rejecting all proposed points and just repeating the previous state. Note though that the convergence of this algorithm to an accurate estimate of the global minimum is not guaranteed. We can never be sure if we have escaped the local minimums, if it is a complex example and there are a lot of them. However, with a large enough T, and reasonable choice of 'b' in the proposal density the algorithm should work for most functions.

also the main reason choose T to be large enought at first is mainly because we had no idea what are the possibilities of what the xt can be.having that in mind,if we initialize a value of x which is away from mean too muchwe may never have the chance to ever get any closer to meanbecause the probability to move towards the wrong direction will be way too high due to the mechanism of the algorithm

The acceptance probability is also equal to the minimum of ((e^(-h(y)/T)/e^(-h(x)/T)),1)=min((e^((h(x)-h(y))/T),1)

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 - in our case, starting the algorithm with a high T, and then lowering it.

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 q(y|x)=1, uniform [0,1]

4) r=min (e^(3x^2-3y^2)/100,1)

5) U~U[0,1]

6) U<r =>Xt+1=y, else, Xt+1=xt

7) decrease T, go back to 3

MATLAB

Syms x
Ezplot((x-3)^2)
Ezplot((x-3)^2,[-6,12])
Ezplot(exp(-((x-3)^2)), [-6, 12])


ezplot((x-3)^2)

ezplot((x-3)^2,[-6, 12])
300px
ezplot(exp(-((x-3)^2)),[-6, 12])
300px

MATLAB

clear all
close all
T=100;
x(1)=rand;
ii=1;
b=1;
while T>0.001
y=b*rand+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)


example for H(x)=(x-3)^2

function c=H(x)
c=(x-3)^2;
end


Another Example: $h(x)=((x-2)^2-4)((x-4)^2-8)$

>>syms x
>>ezplot(((x-2)^2-4)*((x-4)^2-8),[-1,8])

function c=H(x)
c=((x-2)^2-4)*((x-4)^2-8);
end


Run earlier code with the new H(x) function

Samulated Annealing algorithm can be used to solve 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 origin city? The idea of using Samulated Annealing algorithm is: 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 Samulated Annealing algorithm to find the minimum value of f(x).