{"id":352,"date":"2015-04-17T13:50:07","date_gmt":"2015-04-17T13:50:07","guid":{"rendered":"http:\/\/drsfenner.org\/blog\/?p=352"},"modified":"2016-02-05T16:19:11","modified_gmt":"2016-02-05T16:19:11","slug":"visualizing-probabilities-in-a-venn-diagram-2","status":"publish","type":"post","link":"https:\/\/drsfenner.org\/blog\/2015\/04\/visualizing-probabilities-in-a-venn-diagram-2\/","title":{"rendered":"Visualizing Probabilities in a Venn Diagram"},"content":{"rendered":"
\n
\n<\/div>\n
\n
\n

I came across a little problem that lends itself nicely to visualization. And, it’s the kind of visualization that many of us have seen before: Venn diagrams. <\/p>\n<\/div>\n<\/div>\n<\/div>\n

\n
\n
In [103]:<\/div>\n
\n
\n
\n
import<\/span> matplotlib.pyplot<\/span> as<\/span> plt<\/span>\r\n%<\/span>matplotlib<\/span> inline<\/span>\r\n\r\n# create some circles<\/span>\r\ncircle1<\/span> =<\/span> plt<\/span>.<\/span>Circle<\/span>((<\/span>-.<\/span>5<\/span>,<\/span>0<\/span>),<\/span> 1<\/span>,<\/span> color<\/span>=<\/span>'r'<\/span>,<\/span> alpha<\/span>=.<\/span>2<\/span>)<\/span>\r\ncircle2<\/span> =<\/span> plt<\/span>.<\/span>Circle<\/span>((<\/span> .<\/span>5<\/span>,<\/span>0<\/span>),<\/span> 1<\/span>,<\/span> color<\/span>=<\/span>'b'<\/span>,<\/span> alpha<\/span>=.<\/span>2<\/span>)<\/span>\r\n\r\n# create a figure<\/span>\r\nfig<\/span> =<\/span> plt<\/span>.<\/span>figure<\/span>(<\/span>figsize<\/span>=<\/span>(<\/span>8<\/span>,<\/span>8<\/span>))<\/span>\r\nax<\/span> =<\/span> fig<\/span>.<\/span>gca<\/span>()<\/span>\r\n\r\n\r\n# add them to the figure<\/span>\r\nax<\/span> =<\/span> fig<\/span>.<\/span>gca<\/span>()<\/span>\r\nax<\/span>.<\/span>add_artist<\/span>(<\/span>circle1<\/span>)<\/span>\r\nax<\/span>.<\/span>add_artist<\/span>(<\/span>circle2<\/span>)<\/span>\r\nax<\/span>.<\/span>set_xlim<\/span>(<\/span>-<\/span>2<\/span>,<\/span> 2<\/span>)<\/span>\r\nax<\/span>.<\/span>set_ylim<\/span>(<\/span>-<\/span>2<\/span>,<\/span> 2<\/span>)<\/span>\r\nax<\/span>.<\/span>set_aspect<\/span>(<\/span>'equal'<\/span>)<\/span>\r\n\r\n# display it<\/span>\r\nplt<\/span>.<\/span>plot<\/span>();<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n
\n
<\/div>\n
\n\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n<\/div>\n
\n
\n
Almost certainly you’ve seen a Venn diagram used to visualize the partitioning of a universe that has two possible events which may (or may not) occur. With two events, there are four atomic or primitive events \\(AB\\)<\/span>, \\(A{\\lnot}B\\)<\/span>, \\(\\lnot{A}{B}\\)<\/span>, \\(\\lnot{A}\\lnot{B}\\)<\/span>. These possibilities, like components of a Boolean logic expression, can be displayed in a pseudo-truth table:<\/p>\n\n\n\n\n\n\n\n\n
Event A<\/th>\nEvent B<\/th>\nPrimitive Event<\/th>\nPrimitive \\(P()\\)<\/span><\/th>\nExample \\(P()\\)<\/span><\/th>\n<\/tr>\n<\/thead>\n
\\(T\\)<\/span><\/td>\n\\(T\\)<\/span><\/td>\n\\(AB\\)<\/span><\/td>\n\\(P(AB)\\)<\/span><\/td>\n.25<\/td>\n<\/tr>\n
\\(T\\)<\/span><\/td>\n\\(F\\)<\/span><\/td>\n\\(A{\\lnot}B\\)<\/span><\/td>\n\\(P(A{\\lnot}B)\\)<\/span><\/td>\n.25<\/td>\n<\/tr>\n
\\(F\\)<\/span><\/td>\n\\(T\\)<\/span><\/td>\n\\(\\lnot{A}{B}\\)<\/span><\/td>\n\\(P(\\lnot{A}{B})\\)<\/span><\/td>\n.25<\/td>\n<\/tr>\n
\\(F\\)<\/span><\/td>\n\\(F\\)<\/span><\/td>\n\\(\\lnot{A}\\lnot{B}\\)<\/span><\/td>\n\\(P(\\lnot{A}\\lnot{B})\\)<\/span><\/td>\n.25<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
I’m not really harping on this to be daft. I’m also using this notebook to test out my ipython \\(\\rightarrow\\)<\/span> html conversion system. So far, these cells are testing markdown tables and \\(\\LaTeX\\)<\/span> symbols. If you chuckle at the meta-structure of that sentence, I’ll forgive you.<\/p>\n
Fairly often, Venn Diagrams are introduced in a discussion when the events, \\(A\\)<\/span> and \\(B\\)<\/span> are independent. Two events are independent, mathematically, if and only if \\(P(AB)=P(A)P(B)\\)<\/span>. When events are independent, knowning \\(P(A)\\)<\/span> and \\(P(B)\\)<\/span> is sufficent to determine the probabilities of each primitive event. We just saw how to compute \\(P(AB)\\)<\/span>. To compute \\(P(\\lnot{A}\\lnot{B})\\)<\/span> we notice that the sum of all the events must<\/em> be 1.0. Then we give a name to the event where either \\(A\\)<\/span>, \\(B\\)<\/span>, or both happens: \\(A\\cup{B}\\)<\/span>. So, we can subtract from one to get \\(P(\\lnot{A}\\lnot{B})=1-P(A\\cup{B})\\)<\/span> . For reference, \\(P(A\\cup{B})=P(A)+P(B)-P(AB)\\)<\/span>. Back to the main point: if the events are independent, we can compute all the other primative event probabilities.<\/p>\n
Often though, events in the real world are not independent. In that case, we need to fill in the complete table of probabilities. We can do that reasonably in a table for two or three events. But for more than two or three events, it becomes difficult very quickly. That’s where Venn diagrams can come back into the picture. You may have also seen Venn diagrams for three events. I won’t draw one here, but it looks a lot like the one above with a third circle.<\/p>\n
Now, I had never actually come to the realization that you can simple keep adding circles for more events and keep getting a complete<\/em> representation of all the possible primitive events (occurance\/non-occurance of the events). Once I knew that was possible, I had a great idea to visually represent the probabilities for all the possible states of the world using these (extended) Venn diagrams.<\/p>\n
What we’re going to do is use grayscale values to color the primitive events within the probability space.<\/p>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n<\/div>\n
\n
\n
Creating Lots of Circles¶<\/a><\/h3>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n<\/div>\n
\n
\n
To start out (and to add a bit of color), here’s how you can draw the circles that make up the Venn diagram in pure matplotlib. Turns out we need some more tools to do the coloring, so we won’t follow this up. But, I made it and it looks pretty. It reminds me of Spirograph<\/a>.<\/p>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n
In [104]:<\/div>\n
\n
\n
\n
from<\/span> matplotlib.collections<\/span> import<\/span> PatchCollection<\/span>\r\n\r\n\r\n# walk around a clock from 3:00 (the positive x-axis) backwards, stop one step shy of full circle<\/span>\r\n# take n number of steps<\/span>\r\n# recall that x = r cos(theta) and y = r sin(theta) from trig (polar<->rectangular coordinates)<\/span>\r\nn<\/span> =<\/span> 20<\/span>\r\nthetas<\/span> =<\/span> np<\/span>.<\/span>linspace<\/span>(<\/span>0<\/span>,<\/span> 2<\/span>*<\/span>np<\/span>.<\/span>pi<\/span> -<\/span> (<\/span>2<\/span>*<\/span>np<\/span>.<\/span>pi<\/span>\/<\/span>n<\/span>)<\/span> ,<\/span> n<\/span>)<\/span>\r\nr<\/span> =<\/span> 1.0<\/span>\r\n\r\n# create the circles<\/span>\r\npatches<\/span> =<\/span> [<\/span>plt<\/span>.<\/span>Circle<\/span>((<\/span>r<\/span>*<\/span>np<\/span>.<\/span>cos<\/span>(<\/span>th<\/span>),<\/span> r<\/span>*<\/span>np<\/span>.<\/span>sin<\/span>(<\/span>th<\/span>)),<\/span> 2.0<\/span>)<\/span> for<\/span> th<\/span> in<\/span> thetas<\/span>]<\/span>\r\ncollection<\/span> =<\/span> PatchCollection<\/span>(<\/span>patches<\/span>,<\/span> alpha<\/span>=.<\/span>2<\/span>)<\/span>\r\ncollection<\/span>.<\/span>set_array<\/span>(<\/span>np<\/span>.<\/span>arange<\/span>(<\/span>n<\/span>))<\/span>\r\n\r\n# create the figure and add the circles<\/span>\r\nfig<\/span> =<\/span> plt<\/span>.<\/span>figure<\/span>(<\/span>figsize<\/span>=<\/span>(<\/span>8<\/span>,<\/span>8<\/span>))<\/span>\r\nax<\/span> =<\/span> fig<\/span>.<\/span>gca<\/span>()<\/span>\r\nplt<\/span>.<\/span>gca<\/span>()<\/span>.<\/span>add_collection<\/span>(<\/span>collection<\/span>)<\/span>\r\n\r\n# scale it appropriately<\/span>\r\nplt<\/span>.<\/span>xlim<\/span>(<\/span>-<\/span>5<\/span>,<\/span> 5<\/span>)<\/span>\r\nplt<\/span>.<\/span>ylim<\/span>(<\/span>-<\/span>5<\/span>,<\/span> 5<\/span>)<\/span>\r\nplt<\/span>.<\/span>gca<\/span>()<\/span>.<\/span>set_aspect<\/span>(<\/span>'equal'<\/span>)<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n
\n
<\/div>\n
\n\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n<\/div>\n
\n
\n
Required Tools¶<\/a><\/h3>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n<\/div>\n
\n
\n
To get started, we need to import a few modules. I had originally wanted to use a pure matplotlib solution. However, it turned out that the fundamental task of slicing up pre-drawn circles and figuring out the constituent patches (the different colored areas in the Venn diagram above) was not immediately possible. So, I asked on stackoverflow and got a pointer<\/a> to shapely and descartes. Turns out that shapely has an API<\/a> for exactly this sort of task. In fact, you can explictly take the unions and intersections of graphical objects and compute the patches where those set operations occur.<\/p>\n
Huzzah: the right tool for the job!<\/p>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n
In [105]:<\/div>\n
\n
\n
\n
import<\/span> itertools<\/span> as<\/span> it<\/span>\r\n\r\nimport<\/span> numpy<\/span> as<\/span> np<\/span>\r\nnp<\/span>.<\/span>set_printoptions<\/span>(<\/span>precision<\/span>=<\/span>4<\/span>,<\/span> suppress<\/span>=<\/span>True<\/span>)<\/span>\r\n\r\nimport<\/span> matplotlib.pyplot<\/span> as<\/span> plt<\/span>\r\nimport<\/span> matplotlib<\/span> as<\/span> mpl<\/span>\r\nimport<\/span> descartes<\/span>\r\nimport<\/span> shapely.geometry<\/span> as<\/span> sg<\/span>\r\nimport<\/span> shapely.ops<\/span> as<\/span> so<\/span>\r\n\r\n%<\/span>matplotlib<\/span> inline<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n<\/div>\n
\n
\n
I define a few functions to give me a basic vocabulary for the subtasks in this problem: creating a bunch of (overlapping) circles, coloring patches of the output graph from patches and colors, computing a running intersection from a GeometryCollection<\/code> (a Shapely critter) of circles, and creating patch colors from probabilities.<\/p>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n
In [106]:<\/div>\n
\n
\n
\n
def<\/span> makeShapelyCircles<\/span>(<\/span>numEvents<\/span>,<\/span> size<\/span>=<\/span>2.0<\/span>):<\/span>\r\n    thetas<\/span> =<\/span> np<\/span>.<\/span>linspace<\/span>(<\/span>0<\/span>,<\/span> 2<\/span>*<\/span>np<\/span>.<\/span>pi<\/span> -<\/span> (<\/span>2<\/span>*<\/span>np<\/span>.<\/span>pi<\/span>\/<\/span>numEvents<\/span>),<\/span> numEvents<\/span>)<\/span>\r\n    r<\/span> =<\/span> np<\/span>.<\/span>ones<\/span>(<\/span>thetas<\/span>.<\/span>shape<\/span>)<\/span>\r\n    centers<\/span> =<\/span> np<\/span>.<\/span>column_stack<\/span>([<\/span>r<\/span>*<\/span>np<\/span>.<\/span>cos<\/span>(<\/span>thetas<\/span>),<\/span> r<\/span>*<\/span>np<\/span>.<\/span>sin<\/span>(<\/span>thetas<\/span>)])<\/span>\r\n    print<\/span> len<\/span>(<\/span>centers<\/span>)<\/span>\r\n    return<\/span> [<\/span>sg<\/span>.<\/span>Point<\/span>(<\/span>*<\/span>c<\/span>)<\/span>.<\/span>buffer<\/span>(<\/span>float<\/span>(<\/span>size<\/span>))<\/span> for<\/span> c<\/span> in<\/span> centers<\/span>]<\/span>\r\n\r\n# patch = [p1, p2, p3, ...]<\/span>\r\n# color = [c1, c2, c3, ...]<\/span>\r\ndef<\/span> addPatchesAndColors<\/span>(<\/span>ax<\/span>,<\/span> patch<\/span>,<\/span> color<\/span>):<\/span>\r\n    addPatchColorPairs<\/span>(<\/span>ax<\/span>,<\/span> it<\/span>.<\/span>izip<\/span>(<\/span>patch<\/span>,<\/span> color<\/span>))<\/span>    \r\n\r\n# pAndC = [(patch, color), (patch, color)]<\/span>\r\ndef<\/span> addPatchColorPairs<\/span>(<\/span>ax<\/span>,<\/span> pAndC<\/span>):<\/span>\r\n    for<\/span> patch<\/span>,<\/span> color<\/span> in<\/span> pAndC<\/span>:<\/span>\r\n        ax<\/span>.<\/span>add_patch<\/span>(<\/span>descartes<\/span>.<\/span>PolygonPatch<\/span>(<\/span>patch<\/span>,<\/span> \r\n                                            fc<\/span>=<\/span>color<\/span>,<\/span> \r\n                                            ec<\/span>=<\/span>'w'<\/span>))<\/span>\r\n\r\n# for bonus points, you could try to replace this with<\/span>\r\n# a clever reduce\/functools.reduce call<\/span>\r\ndef<\/span> chainIntersection<\/span>(<\/span>comps<\/span>):<\/span>\r\n    comps<\/span> =<\/span> iter<\/span>(<\/span>comps<\/span>)<\/span>\r\n    intersection<\/span> =<\/span> comps<\/span>.<\/span>next<\/span>()<\/span>\r\n    for<\/span> comp<\/span> in<\/span> comps<\/span>:<\/span>\r\n        intersection<\/span> =<\/span> comp<\/span>.<\/span>intersection<\/span>(<\/span>intersection<\/span>)<\/span>\r\n    return<\/span> intersection<\/span>    \r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n<\/div>\n
\n
\n
A quick note here, if we have \\(N\\)<\/span> events there are \\(2^N\\)<\/span> primitive events (this is the size of the powerset created from our \\(N\\)<\/span> events). We express each possible primitive event as a (reverse) binary representation of a number from \\(0\\)<\/span> to \\(2^N-1\\)<\/span>. This may seem a bit odd (not even? ha!). But, it allows us to quickly add up primitive events as they would occur in the pseudo-truth table above using a numpy array. [Here the array creation is "hard", but the use of it is "easy". The creation process is really just making a series of indicators for which events occur and don’t occur on a given line. The real key is numpy’s indices<\/code> routine. I recommend playing around with it at the interactive prompt. The [2]<\/code> is used since our events either occur or don’t occur. Play around with the other values and see what happens! That’s part of the beauty of python.<\/p>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n
In [107]:<\/div>\n
\n
\n
\n
eventCt<\/span>  =<\/span> 2<\/span>\r\npwrSetCt<\/span> =<\/span> 2<\/span>**<\/span>eventCt<\/span>\r\n\r\natomicEvents<\/span> =<\/span> (<\/span>np<\/span>.<\/span>indices<\/span>([<\/span>2<\/span>]<\/span> *<\/span> eventCt<\/span>,<\/span> dtype<\/span>=<\/span>np<\/span>.<\/span>uint8<\/span>)<\/span>.<\/span>reshape<\/span>(<\/span>eventCt<\/span>,<\/span> pwrSetCt<\/span>)[::<\/span>-<\/span>1<\/span>]<\/span>.<\/span>T<\/span>)<\/span>\r\natomicProbs<\/span> =<\/span> np<\/span>.<\/span>array<\/span>([<\/span>.<\/span>25<\/span>,<\/span> .<\/span>25<\/span>,<\/span> .<\/span>25<\/span>,<\/span> .<\/span>25<\/span>])<\/span>\r\n\r\n# this is actually the first time (i can recall) doing a nested<\/span>\r\n# multiple target assignment in python!<\/span>\r\nfor<\/span> idx<\/span>,<\/span> (<\/span>event<\/span>,<\/span> probs<\/span>)<\/span> in<\/span> enumerate<\/span>(<\/span>zip<\/span>(<\/span>atomicEvents<\/span>,<\/span> atomicProbs<\/span>)):<\/span>\r\n        print<\/span> idx<\/span>,<\/span> event<\/span>,<\/span> prob<\/span>\r\n\r\n# since these are disjoin events, to get P(A) we just add up everywhere A happens<\/span>\r\nprimitiveEvents<\/span>[:,<\/span>0<\/span>]<\/span> # 0-th column is "A"<\/span>\r\nprimitiveEvents<\/span>[:,<\/span>0<\/span>]<\/span> *<\/span> primitiveProbs<\/span> # contribution to total P(A) <\/span>\r\n(<\/span>primitiveEvents<\/span>[:,<\/span>0<\/span>]<\/span> *<\/span> primitiveProbs<\/span>)<\/span>.<\/span>sum<\/span>()<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n
\n
<\/div>\n
\n
\r\n0 [0 0] 0.25\r\n1 [1 0] 0.25\r\n2 [0 1] 0.25\r\n3 [1 1] 0.25\r\n\r\n<\/pre>\n<\/div>\n<\/div>\n
\n
Out[107]:<\/div>\n
\n
\r\n0.5\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n
In [108]:<\/div>\n
\n
\n
\n
# more examples of the indexing scheme:<\/span>\r\n# index ---> event indicator ---> which events occurred<\/span>\r\n# 0 --> 0,0,0,0  []<\/span>\r\n\r\n# 1 --> 1,0,0,0  [0]<\/span>\r\n# 2 --> 0,1,0,0  [1]<\/span>\r\n# 3 --> 1,1,0,0  [0,1]<\/span>\r\n# 4 --> 0,0,1,0  [2]<\/span>\r\n\r\n# 5 --> 1,0,1,0  [0,2]<\/span>\r\n\r\n# 15  --> 1,1,1,1  [0,1,2,3]<\/span>\r\ndef<\/span> makePatchColors<\/span>(<\/span>events<\/span>,<\/span> probs<\/span>):<\/span>\r\n    eventCt<\/span>  =<\/span> len<\/span>(<\/span>events<\/span>)<\/span>\r\n    pwrSetCt<\/span> =<\/span> 2<\/span>**<\/span>eventCt<\/span>\r\n    primEvents<\/span> =<\/span> (<\/span>np<\/span>.<\/span>indices<\/span>([<\/span>2<\/span>]<\/span> *<\/span> eventCt<\/span>,<\/span> dtype<\/span>=<\/span>np<\/span>.<\/span>uint8<\/span>)<\/span>\r\n                    .<\/span>reshape<\/span>(<\/span>eventCt<\/span>,<\/span> pwrSetCt<\/span>)[::<\/span>-<\/span>1<\/span>]<\/span>.<\/span>T<\/span>)<\/span>\r\n \r\n    GC<\/span> =<\/span> sg<\/span>.<\/span>collection<\/span>.<\/span>GeometryCollection<\/span>\r\n    res<\/span> =<\/span> []<\/span>\r\n    for<\/span> anEvent<\/span>,<\/span> prob<\/span> in<\/span> zip<\/span>(<\/span>primEvents<\/span>,<\/span> probs<\/span>):<\/span>\r\n        print<\/span> anEvent<\/span>,<\/span> prob<\/span>\r\n        # UGLY!<\/span>\r\n        indices<\/span> =<\/span> [<\/span>idx<\/span> for<\/span> idx<\/span>,<\/span> val<\/span> in<\/span> enumerate<\/span>(<\/span>anEvent<\/span>)<\/span> if<\/span> val<\/span>]<\/span>\r\n        if<\/span> not<\/span> indices<\/span>:<\/span> continue<\/span>\r\n        components<\/span> =<\/span> GC<\/span>([<\/span>events<\/span>[<\/span>idx<\/span>]<\/span> for<\/span> idx<\/span> in<\/span> indices<\/span>])<\/span>\r\n        patch<\/span> =<\/span> chainIntersection<\/span>(<\/span>components<\/span>)<\/span>\r\n        res<\/span>.<\/span>append<\/span>((<\/span>patch<\/span>,<\/span> str<\/span>(<\/span>1.0<\/span>-<\/span>prob<\/span>)))<\/span> # color\/prob inverted<\/span>\r\n    return<\/span> res<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n<\/div>\n
\n
\n
Finally, a few utilities to (1) actually put the Venn diagram (and a color bar) on the matplotlib figure and (2) create random probabilities for some testing.<\/p>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n
In [109]:<\/div>\n
\n
\n
\n
def<\/span> makeRandomProbs<\/span>(<\/span>numEvents<\/span>,<\/span> bigNull<\/span> =<\/span> False<\/span>):<\/span>    \r\n    probs<\/span> =<\/span> np<\/span>.<\/span>random<\/span>.<\/span>uniform<\/span>(<\/span>0.0<\/span>,<\/span> 10.0<\/span>,<\/span> 2<\/span>**<\/span>numEvents<\/span>)<\/span>\r\n    if<\/span> bigNull<\/span>:<\/span> # hack null event to big prob.<\/span>\r\n        probs<\/span>[<\/span>0<\/span>]<\/span> =<\/span> .<\/span>5<\/span> *<\/span> probs<\/span>[<\/span>1<\/span>:]<\/span>.<\/span>sum<\/span>()<\/span> \r\n    probs<\/span> =<\/span> probs<\/span> \/<\/span> probs<\/span>.<\/span>sum<\/span>()<\/span>\r\n    print<\/span> "sorted probs: <\/span>%s<\/span> sum: <\/span>%d<\/span>"<\/span> %<\/span> (<\/span>np<\/span>.<\/span>array<\/span>(<\/span>sorted<\/span>(<\/span>probs<\/span>)),<\/span> probs<\/span>.<\/span>sum<\/span>())<\/span>\r\n    \r\n    return<\/span> probs<\/span>\r\n\r\ndef<\/span> addColorbar<\/span>(<\/span>ax<\/span>,<\/span> cmapName<\/span>):<\/span>\r\n    cbax<\/span>,<\/span> cbkw<\/span> =<\/span> mpl<\/span>.<\/span>colorbar<\/span>.<\/span>make_axes<\/span>(<\/span>ax<\/span>)<\/span>\r\n    mpl<\/span>.<\/span>colorbar<\/span>.<\/span>ColorbarBase<\/span>(<\/span>cbax<\/span>,<\/span>\r\n                              cmap<\/span>=<\/span>plt<\/span>.<\/span>cm<\/span>.<\/span>get_cmap<\/span>(<\/span>cmapName<\/span>),<\/span>\r\n                              norm<\/span>=<\/span>mpl<\/span>.<\/span>colors<\/span>.<\/span>Normalize<\/span>(<\/span>clip<\/span>=<\/span>True<\/span>,<\/span>\r\n                                                        vmin<\/span>=<\/span>0.0<\/span>,<\/span>\r\n                                                        vmax<\/span>=<\/span>1.0<\/span>),<\/span>\r\n                              **<\/span>cbkw<\/span>)<\/span>\r\n\r\ndef<\/span> addVennDiagram<\/span>(<\/span>ax<\/span>,<\/span> probs<\/span>):<\/span>\r\n    circs<\/span> =<\/span> makeShapelyCircles<\/span>(<\/span>np<\/span>.<\/span>log2<\/span>(<\/span>len<\/span>(<\/span>probs<\/span>)))<\/span>\r\n    pacs<\/span>   =<\/span> makePatchColors<\/span>(<\/span>circs<\/span>,<\/span> probs<\/span>)<\/span>\r\n    addPatchColorPairs<\/span>(<\/span>ax<\/span>,<\/span> pacs<\/span>)<\/span>\r\n    \r\n    ax<\/span>.<\/span>set_axis_bgcolor<\/span>(<\/span>str<\/span>(<\/span>1.0<\/span>-<\/span>probs<\/span>[<\/span>0<\/span>]))<\/span>\r\n    \r\n    # fig.colorbar(mplPatches)<\/span>\r\n    addColorbar<\/span>(<\/span>ax<\/span>,<\/span> "Greys"<\/span>)<\/span>\r\n  \r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n<\/div>\n
\n
\n
Some Simple Testing¶<\/a><\/h3>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n<\/div>\n
\n
\n
One last helper to make testing easier.<\/p>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n
In [110]:<\/div>\n
\n
\n
\n
def<\/span> createWith<\/span>(<\/span>probs<\/span>):<\/span>\r\n    #<\/span>\r\n    # control display<\/span>\r\n    #<\/span>\r\n    fig<\/span> =<\/span> plt<\/span>.<\/span>figure<\/span>(<\/span>figsize<\/span>=<\/span>(<\/span>8<\/span>,<\/span>8<\/span>))<\/span>\r\n    ax<\/span> =<\/span> plt<\/span>.<\/span>gca<\/span>()<\/span>\r\n    \r\n    ax<\/span>.<\/span>set_xlim<\/span>(<\/span>-<\/span>5<\/span>,<\/span> 5<\/span>)<\/span>\r\n    ax<\/span>.<\/span>set_ylim<\/span>(<\/span>-<\/span>5<\/span>,<\/span> 5<\/span>)<\/span>\r\n    ax<\/span>.<\/span>set_aspect<\/span>(<\/span>'equal'<\/span>)<\/span>\r\n    \r\n    addVennDiagram<\/span>(<\/span>ax<\/span>,<\/span> probs<\/span>)<\/span>\r\n    \r\n    ax<\/span>.<\/span>plot<\/span>()<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n<\/div>\n
\n
\n
For my first example, we’ll do the uniform probabilites as above (for two and three events).<\/p>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n
In [111]:<\/div>\n
\n
\n
\n
numEvents<\/span> =<\/span> 2<\/span>\r\ncreateWith<\/span>(<\/span>np<\/span>.<\/span>ones<\/span>(<\/span>2<\/span>**<\/span>numEvents<\/span>)<\/span>\/<\/span>2<\/span>**<\/span>numEvents<\/span>)<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n
\n
<\/div>\n
\n
\r\n2\r\n[0 0] 0.25\r\n[1 0] 0.25\r\n[0 1] 0.25\r\n[1 1] 0.25\r\n\r\n<\/pre>\n<\/div>\n<\/div>\n
\n
<\/div>\n
\n\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n
In [112]:<\/div>\n
\n
\n
\n
numEvents<\/span> =<\/span> 3<\/span>\r\ncreateWith<\/span>(<\/span>np<\/span>.<\/span>ones<\/span>(<\/span>2<\/span>**<\/span>numEvents<\/span>)<\/span>\/<\/span>2<\/span>**<\/span>numEvents<\/span>)<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n
\n
<\/div>\n
\n
\r\n3\r\n[0 0 0] 0.125\r\n[1 0 0] 0.125\r\n[0 1 0] 0.125\r\n[1 1 0] 0.125\r\n[0 0 1] 0.125\r\n[1 0 1] 0.125\r\n[0 1 1] 0.125\r\n[1 1 1] 0.125\r\n\r\n<\/pre>\n<\/div>\n<\/div>\n
\n
<\/div>\n
\n\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n<\/div>\n
\n
\n
Let’s test the colors to make sure the grayscale color bar matches with the graph.<\/p>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n
In [113]:<\/div>\n
\n
\n
\n
createWith<\/span>(<\/span>np<\/span>.<\/span>array<\/span>([<\/span>0.0<\/span>,<\/span> 0.25<\/span>,<\/span> .<\/span>5<\/span>,<\/span> .<\/span>75<\/span>]))<\/span> # doesn't have to actually be legit values<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n
\n
<\/div>\n
\n
\r\n2\r\n[0 0] 0.0\r\n[1 0] 0.25\r\n[0 1] 0.5\r\n[1 1] 0.75\r\n\r\n<\/pre>\n<\/div>\n<\/div>\n
\n
<\/div>\n
\n\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n<\/div>\n
\n
\n
The colors seem reasonable, but we might actually do better with an RGB colors to allow for better discrimination from (.75 to 1.0) and (.25, .40). In these ranges, it is a bit hard to see differences.<\/p>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n<\/div>\n
\n
\n
And a Less Simple Example¶<\/a><\/h3>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n
In [114]:<\/div>\n
\n
\n
\n
numEvents<\/span>=<\/span>2<\/span>\r\ncreateWith<\/span>(<\/span>makeRandomProbs<\/span>(<\/span>numEvents<\/span>,<\/span> bigNull<\/span>=<\/span>True<\/span>))<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n
\n
<\/div>\n
\n
\r\nsorted probs: [ 0.091   0.18    0.3333  0.3957] sum: 1\r\n2\r\n[0 0] 0.333333333333\r\n[1 0] 0.395735285593\r\n[0 1] 0.0909775362928\r\n[1 1] 0.179953844781\r\n\r\n<\/pre>\n<\/div>\n<\/div>\n
\n
<\/div>\n
\n\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n<\/div>\n
\n
\n
Wrap Up¶<\/a><\/h3>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n<\/div>\n
\n
\n
I never really mentioned why<\/em> I needed to deal with tables of probabilities. Suffice it to say, I’ll post on that sometime soon. But, here’s the flavor. Using a probabilistic model, I compute the probabilities of many primitive events and I wanted to compare them. Since there are typically a half-dozen events, evaluating \\(2^{6}\\)<\/span> table entries seemed up appealing. Instead, I can look at something like this:<\/p>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n
In [115]:<\/div>\n
\n
\n
\n
numEvents<\/span>=<\/span>5<\/span>\r\ncreateWith<\/span>(<\/span>makeRandomProbs<\/span>(<\/span>numEvents<\/span>))<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n
\n
<\/div>\n
\n
\r\nsorted probs: [ 0.001   0.0011  0.0018  0.0026  0.0053  0.0071  0.011   0.0122  0.013\r\n  0.0141  0.0161  0.0233  0.0238  0.032   0.0342  0.035   0.0367  0.0398\r\n  0.0401  0.0401  0.0427  0.0465  0.0465  0.0468  0.0484  0.0497  0.051\r\n  0.0534  0.0545  0.0555  0.0557  0.0592] sum: 1\r\n5\r\n[0 0 0 0 0] 0.00105401822624\r\n[1 0 0 0 0] 0.00709772596129\r\n[0 1 0 0 0] 0.00534088942059\r\n[1 1 0 0 0] 0.0400623973948\r\n[0 0 1 0 0] 0.040083860977\r\n[1 0 1 0 0] 0.0557490891542\r\n[0 1 1 0 0] 0.046763327347\r\n[1 1 1 0 0] 0.00255921482026\r\n[0 0 0 1 0] 0.0121836239739\r\n[1 0 0 1 0] 0.0237720580733\r\n[0 1 0 1 0] 0.0555410683744\r\n[1 1 0 1 0] 0.0342001630124\r\n[0 0 1 1 0] 0.0496952390391\r\n[1 0 1 1 0] 0.0465162493767\r\n[0 1 1 1 0] 0.000993345534805\r\n[1 1 1 1 0] 0.0465361310968\r\n[0 0 0 0 1] 0.0533523479925\r\n[1 0 0 0 1] 0.0109885205602\r\n[0 1 0 0 1] 0.0140987550261\r\n[1 1 0 0 1] 0.050973929174\r\n[0 0 1 0 1] 0.00177748579144\r\n[1 0 1 0 1] 0.0544584113676\r\n[0 1 1 0 1] 0.0398255051261\r\n[1 1 1 0 1] 0.0366771466407\r\n[0 0 0 1 1] 0.0427274160626\r\n[1 0 0 1 1] 0.0483520946623\r\n[0 1 0 1 1] 0.0592038498977\r\n[1 1 0 1 1] 0.0130488483142\r\n[0 0 1 1 1] 0.0160969424378\r\n[1 0 1 1 1] 0.0319563680393\r\n[0 1 1 1 1] 0.0350293936803\r\n[1 1 1 1 1] 0.0232845834446\r\n\r\n<\/pre>\n<\/div>\n<\/div>\n
\n
<\/div>\n
\n\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n<\/div>\n
\n
\n
\nAdditional Resources
\n<\/h3>\n
You can grab a copy of this notebook<\/a>.<\/p>\n
Even better, you can view it using nbviewer<\/a>.<\/p>\n
\nLicense
\n<\/h3>\n
Unless otherwise noted, the contents of this notebook are under the following license. The code in the notebook should be considered part of the text (i.e., licensed and treated as as follows).<\/p>\n
\"Creative<\/a>
DrsFenner.org Blog And Notebooks<\/span> by Mark and Barbara Fenner<\/a> is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License<\/a>.
Permissions beyond the scope of this license may be available at drsfenner.org\/blog\/about-and-contacts<\/a>.<\/p>\n<\/div>\n<\/div>\n<\/div>\n","protected":false},"excerpt":{"rendered":"
I came across a little problem that lends itself nicely to visualization. And, it’s the kind of visualization that many of us have seen before: Venn diagrams.<\/p>\n","protected":false},"author":3,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[6,7],"tags":[],"class_list":["post-352","post","type-post","status-publish","format-standard","hentry","category-mrdr","category-sci-math-stat-python"],"_links":{"self":[{"href":"https:\/\/drsfenner.org\/blog\/wp-json\/wp\/v2\/posts\/352","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/drsfenner.org\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/drsfenner.org\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/drsfenner.org\/blog\/wp-json\/wp\/v2\/users\/3"}],"replies":[{"embeddable":true,"href":"https:\/\/drsfenner.org\/blog\/wp-json\/wp\/v2\/comments?post=352"}],"version-history":[{"count":3,"href":"https:\/\/drsfenner.org\/blog\/wp-json\/wp\/v2\/posts\/352\/revisions"}],"predecessor-version":[{"id":418,"href":"https:\/\/drsfenner.org\/blog\/wp-json\/wp\/v2\/posts\/352\/revisions\/418"}],"wp:attachment":[{"href":"https:\/\/drsfenner.org\/blog\/wp-json\/wp\/v2\/media?parent=352"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/drsfenner.org\/blog\/wp-json\/wp\/v2\/categories?post=352"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/drsfenner.org\/blog\/wp-json\/wp\/v2\/tags?post=352"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}