Probability Distributions in Python

The questions below are due on Sunday April 21, 2019; 11:00:00 PM.
 
Music for this Problem

Files

This exercise requires downloading a code distribution, which is available here.

1) DDist

In this exercise, we will implement classes and methods to represent and manipulate discrete probability distributions (which you have been using in the last few labs). Our starting point will be the class DDist, which represents a probability distribution over a discrete set.

A code skeleton for DDist can be found in dist.py in the code distribution from above. At initialization time, our class will take as input a dictionary, whose keys are members of the sample set of the distribution, and whose values are the associated probabilities. The __init__ method, which we have implemented for you, checks whether the distribution is valid, and stores the input dictionary as an attribute self.d. Note that we could have chosen other representations, and we will try to minimize the impact of this choice on the outward-facing pieces of DDist.

By the end of this exercise, you will have implemented several features in the class DDist, but the whole of DDist will only be checked once, near the bottom of the page. You will need to construct some test cases of your own to make sure these features are working correctly. Note that you can look back at the labs and exercises you have completed so far (or at the optional practice problems) if you are looking for inspiration for test cases.

2) Basic Functionality

In this part of the exercise, we will be adding two methods to DDist, prob and support:

• prob should take one input, representing an element, and should return a single number representing the probability assigned to it by the distribution. If an element e is not explicitly represented in the distribution d, then d.prob(e) should return 0.

  Implement the `prob` method in `dist.py`.
  Check Yourself 1:

  Look at the test case for `prob` is `dist.py`. What is this test case doing?

  Complete the second test case in `dist.py`, to test whether `d.prob(e)` returns `0` if `e` is not explicitly represented in the distribution.

  Run your code to make sure it passes this test case.

• support should take no inputs, and should return the support of this distribution, as a list; that is, it should return a list of all elements whose probability in the distribution is nonzero.

  Implement the `support` method in `dist.py`.
  Check Yourself 2:

  Look at the test cases (3 and 4) for `support` in `dist.py`. What are these test cases doing?

  Complete the test case (5) in `dist.py` to test whether `d.support()` excludes _all elements_ with 0 probability, even those that are explicitly included in the dictionary.

  Run your code to make sure it passes this test case.

3) Conditional and Joint Distributions

Some information on representation before we move on:

• We will represent the conditional probability distribution \Pr(A|B) as a function that takes a value b of random variable B as input and returns a distribution over A, \Pr(A|B=b), as an instance of DDist.
• We will represent the joint probability distribution \Pr(A,B) as an instance of DDist over pairs (a,b), where a is a value of A and b is a value of B. In Python, these pairs must be represented as tuples (a,b), rather than lists [a,b]¹.

Consult the appendix on distributions and their Pythonic representations, and ask for help if you do not understand.

In this section, we will implement a separate function make_joint_distribution, which takes as arguments a DDist representing \Pr(A) and a function representing \Pr(B \mid A) and returns an instance of DDist representing the joint distribution \Pr(A,B) , with A and B specifically in that order.

4) Projection and Conditioning

In this section, we will implement two more methods inside DDist: project and condition.

4.1) Projection

Assuming that self represents a distribution \Pr(A) , project should take as its lone argument a function f and return a new DDist representing a distribution \Pr(A') over all possible a' = f(a), such that:

The idea is that we are taking the elements a in the support of A and projecting them into a new domain, where the elements are f(a) for all a \in A.

For example, imagine we have a distribution over a random variable X with integer support:

>>> pr_X = DDist({-2: .1, 2: .3, -1: .4, 1: .1, 3: .1})

We could project this distribution into a new domain to get the distribution over X^2:

>>> def square(x): return x*x
>>> pr_Xsquared = pr_X.project(square)
>>> print(pr_Xsquared)
DDist({4:0.4, 1:0.5, 9:0.1})

4.2) Conditioning

Assuming that self represents a distribution \Pr(A) , condition should take as its lone argument a function f (which maps from elements to Boolean values), and return DDist representing a new, re-normalized distribution \Pr(A \mid f(A)) over only those elements a such that f(a) returns True:

$\Pr(A=a \mid f(A)) = \displaystyle{\begin{cases} \Pr(A=a)/Z, & \text{if}~f(a) = \text{True} \\ 0, & \text{otherwise} \end{cases}}$

where Z is the sum of \Pr(A=a_i) for every a_i in the support of \Pr(A) such that f(a_ i) =\text{True} .

You may assume that the provided function f will evaluate to True for at least one element in the distribution..

For example, consider the same distribution we considered earlier:

>>> pr_X = DDist({-2: .1, 2: .3, -1: .4, 1: .1, 3: .1})

We could condition this distribution with a function that returns True for positive values:

>>> def pos(x): return x > 0
>>> pr_Xpos = pr_X.condition(pos)
>>> print(pr_Xpos)
DDist({2:0.6, 1:0.2, 3:0.2})

5) Total Probability and Bayes' Rule

Now, we will implement the Law of the Total Probability and Bayes' Rule. You have already seen these in labs over the last week. Next week, we will make use of these methods to implement probabilistic state estimation, and, they are interesting and useful on their own.

5.1) Total Probability

We will implement the Law of Total Probability as a stand-alone method total_probability. total_probability should take two arguments: a DDist representing \Pr(A), and a function representing \Pr(B \mid A). It should return an instance of DDist representing \Pr(B) .

5.2) Bayes' Rule

We will implement Bayes' Rule as a stand-alone function bayes_rule. It should take three arguments: an instance of DDist representing P(A), a function representing the conditional distribution P(B|A), and a specific value of b. It should return an instance of DDist representing P(A|B=b).

6) Upload

Upload your dist.py file below:

 

7) Appendix: Notes on Distributions

7.1) Distribution

• Function from elements $a$ of domain $A$ into probabilities
• Math: whole distribution : $\Pr(A)$
• Math: probability of element : $\Pr(A = a)$
• Python: whole distribution : `pr_A = DDist({'a1' : 0.1, 'a2' : 0.9})`
• Python: probability of element : `pr_A.prob('a2')`

7.2) Conditional Distribution

• Function from elements $b$ of domain $B$ into distributions over $A$
• Math: whole conditional distribution : $\Pr(A \mid B)$
• Math: distribution conditioned on $B = b$ : $\Pr(A \mid B = b)$
• Math: probability of element conditioned on $B = b$ : $\Pr(A = a\mid B = b)$
• Python: whole distribution

      def pr_A_given_B(b):
          if b == 'foo':
              return DDist({'a1' : 0.2, 'a2' : 0.8})
          elif b == 'bar':
              return DDist({'a3' : 0.4, 'a2' : 0.6})
          else:
              print('Error:', b, 'not in domain of pr_A_given_B')
  

• Python: distribution conditioned on `b`: `pr_A_given_B(b)`
• Python: probability of element conditioned on `b`: `pr_A_given_B(b).prob(a)`

7.3) Joint Distribution

• Probability distribution over pairs of elements (which may themselves have more complex structure.)
• Math: $\Pr(A, B)$
• Math: $\Pr(A = a, B = b) = \Pr(B = b \mid A = a) \Pr(A = a)$
• Python: whole distribution : `pr_A_B = DDist({('a1', 'b2') : 0.1, ('a2', 'b1') : 0.5, ('a2', 'b3') : 0.4})`
• Python: whole distribution: `make_joint_distribution(pr_A, pr_A_given_B)`
• Python: probability of element: `pr_A_B.prob(('a1', 'b2'))`

7.4) Projection

• Given a probability distribution over elements in one space, find a related distribution over functions of those elements.
• Math: Old random var $A$; New random var $B = f(A)$
• Math: Element of distribution $\Pr(B = b) = \sum_{{a : f(a) = b}} \Pr(A = a)$
• Python: `pr_A.project(f)`

7.5) Conditioning

• Given a joint probability distribution, condition on one random variable having a particular value
• Math: Go from joint $\Pr(A, B)$ and evidence $b$ to whole distribution $\Pr(A \mid B = b)$; this is a distribution on $A$
• Math: Individual elements of the distribution $$\Pr(A = a \mid B = b) = \frac{\Pr(A = a, B = b)}{\Pr(B = b)}$$
• Python: whole distribution `pr_A_given_B = pr_A_B.condition(testb)` where `def testb(ab): return ab[1]==b` for some value b

7.6) Total Probability

• Given a conditional distribution and a marginal, compute the other marginal
• Math: Go from $\Pr(B \mid A)$ and $\Pr(A)$ to $\Pr(B)$
• Math: Individual elements $$\Pr(B = b) = \sum_a \Pr(A = a, B = b) = \sum_a \Pr(B = b \mid A =a) \Pr(A = a)$$
• Python: whole distribution : `pr_B = total_probability(pr_A, pr_B_given_A)`

7.7) Bayes' Rule

• Use conditional probability to switch the conditioning relationship
• Math: Go from $\Pr(H)$, $\Pr(E \mid H)$ and a given $e$ to $\Pr(H \mid E = e)$
• Math: Individual elements $$\Pr(H = h \mid E = e) = \frac{Pr(E=e | H=h)Pr(H=h)}{Pr(E=e)}$$
• Python: `pr_H_given_E = bayes_rule(pr_H, pr_E_given_H, e)`

 

---

Footnotes

¹This is because these pairs will be used as keys in the dictionary inside DDist, and dictionary keys must not be mutable. Tuples are not mutable (i.e., you cannot change an element inside a tuple) but lists are. (click to return to text)