A community-maintained Python framework for creating mathematical animations.
First couple scenes of bayes
Grant Sandersoncfc5ecc59c90
diff --git a/3b1b_projects/active/bayes.py b/3b1b_projects/active/bayes.pynew file mode 100644index 000000000..2221fe694--- /dev/null+++ b/3b1b_projects/active/bayes.py@@ -0,0 +1,788 @@+from manimlib.imports import *++OUTPUT_DIRECTORY = "bayes"++HYPOTHESIS_COLOR = YELLOW+NOT_HYPOTHESIS_COLOR = GREY+EVIDENCE_COLOR1 = BLUE_C+EVIDENCE_COLOR2 = BLUE_D+NOT_EVIDENCE_COLOR1 = RED+NOT_EVIDENCE_COLOR2 = RED_E++#+++def get_bayes_formula(expand_denominator=False):+ t2c = {+ "{H}": HYPOTHESIS_COLOR,+ "{\\neg H}": NOT_HYPOTHESIS_COLOR,+ "{E}": EVIDENCE_COLOR1,+ }+ substrings_to_isolate = ["P", "\\over", "=", "\\cdot", "+"]++ tex = "P({H} | {E}) = {P({H}) \\cdot P({E} | {H}) \\over "+ if expand_denominator:+ tex += "P({H}) \\cdot P({E} | {H}) + P({\\neg H}) \\cdot P({E} | {\\neg H})}"+ else:+ tex += "P({E})}"++ formula = TexMobject(+ tex,+ tex_to_color_map=t2c,+ substrings_to_isolate=substrings_to_isolate,+ )++ formula.posterior = formula[:6]+ formula.prior = formula[8:12]+ formula.likelihood = formula[13:19]++ if expand_denominator:+ pass+ formula.denom_prior = formula[20:24]+ formula.denom_likelihood = formula[25:31]+ formula.denom_anti_prior = formula[32:36]+ formula.denom_anti_likelihood = formula[37:42]+ else:+ formula.p_evidence = formula[20:]++ return formula+++class BayesDiagram(VGroup):+ CONFIG = {+ "height": 2,+ "square_style": {+ "fill_color": DARK_GREY,+ "fill_opacity": 1,+ "stroke_color": WHITE,+ "stroke_width": 2,+ },+ "rect_style": {+ "stroke_color": WHITE,+ "stroke_width": 1,+ "fill_opacity": 1,+ },+ "hypothesis_color": HYPOTHESIS_COLOR,+ "not_hypothesis_color": NOT_HYPOTHESIS_COLOR,+ "evidence_color1": EVIDENCE_COLOR1,+ "evidence_color2": EVIDENCE_COLOR2,+ "not_evidence_color1": NOT_EVIDENCE_COLOR1,+ "not_evidence_color2": NOT_EVIDENCE_COLOR2,+ }++ def __init__(self, prior, likelihood, antilikelihood, **kwargs):+ super().__init__(**kwargs)+ square = Square(side_length=self.height)+ square.set_style(**self.square_style)++ # Create all rectangles+ h_rect, nh_rect, he_rect, nhe_rect, hne_rect, nhne_rect = [+ square.copy().set_style(**self.rect_style)+ for x in range(6)+ ]++ # Add as attributes+ self.square = square+ self.h_rect = h_rect # Hypothesis+ self.nh_rect = nh_rect # Not hypothesis+ self.he_rect = he_rect # Hypothesis and evidence+ self.hne_rect = hne_rect # Hypothesis and not evidence+ self.nhe_rect = nhe_rect # Not hypothesis and evidence+ self.nhne_rect = nhne_rect # Not hypothesis and not evidence++ # Stretch the rectangles+ for rect in h_rect, he_rect, hne_rect:+ rect.stretch(prior, 0, about_edge=LEFT)+ for rect in nh_rect, nhe_rect, nhne_rect:+ rect.stretch(1 - prior, 0, about_edge=RIGHT)++ he_rect.stretch(likelihood, 1, about_edge=DOWN)+ hne_rect.stretch(1 - likelihood, 1, about_edge=UP)+ nhe_rect.stretch(antilikelihood, 1, about_edge=DOWN)+ nhne_rect.stretch(1 - antilikelihood, 1, about_edge=UP)++ # Color the rectangles+ h_rect.set_fill(self.hypothesis_color)+ nh_rect.set_fill(self.not_hypothesis_color)+ he_rect.set_fill(self.evidence_color1)+ hne_rect.set_fill(self.not_evidence_color1)+ nhe_rect.set_fill(self.evidence_color2)+ nhne_rect.set_fill(self.not_evidence_color2)++ # Add them+ self.hypothesis_split = VGroup(h_rect, nh_rect)+ self.evidence_split = VGroup(he_rect, hne_rect, nhe_rect, nhne_rect)++ # Don't add hypothesis split by default+ self.add(self.square, self.evidence_split)++ def generate_braces(self):+ pass # TODO+++class ProbabilityBar(VGroup):+ CONFIG = {+ "color1": BLUE_D,+ "color2": GREY_BROWN,+ "height": 0.5,+ "width": 6,+ "rect_style": {+ "stroke_width": 1,+ "stroke_color": WHITE,+ "fill_opacity": 1,+ },+ "include_braces": True,+ "brace_direction": UP,+ "include_percentages": True,+ }++ def __init__(self, p=0.5, **kwargs):+ super().__init__(**kwargs)+ self.add_backbone()+ self.add_p_tracker(p)+ self.add_bars()+ if self.include_braces:+ self.braces = always_redraw(lambda: self.get_braces())+ self.add(self.braces)+ if self.include_percentages:+ self.percentages = always_redraw(lambda: self.get_percentages())+ self.add(self.percentages)++ def add_backbone(self):+ backbone = Line()+ backbone.set_opacity(0)+ backbone.set_width(self.width)+ self.backbone = backbone+ self.add(backbone)++ def add_p_tracker(self, p):+ self.p_tracker = ValueTracker(p)++ def add_bars(self):+ bars = VGroup(Rectangle(), Rectangle())+ bars.set_height(self.height)+ colors = [self.color1, self.color2]+ for bar, color in zip(bars, colors):+ bar.set_style(**self.rect_style)+ bar.set_fill(color=color)++ bars.add_updater(self.update_bars)+ self.bars = bars+ self.add(bars)++ def update_bars(self, bars):+ vects = [LEFT, RIGHT]+ p = self.p_tracker.get_value()+ values = [p, 1 - p]+ total_width = self.backbone.get_width()+ for bar, vect, value in zip(bars, vects, values):+ bar.set_width(value * total_width, stretch=True)+ bar.move_to(self.backbone, vect)+ return bars++ def get_braces(self):+ return VGroup(*[+ Brace(+ bar,+ self.brace_direction,+ min_num_quads=1,+ buff=SMALL_BUFF,+ )+ for bar in self.bars+ ])++ def get_percentages(self):+ p = self.p_tracker.get_value()+ labels = VGroup(*[+ Integer(value, unit="\\%")+ for value in [+ np.floor(p * 100),+ 100 - np.floor(p * 100),+ ]+ ])+ for label, bar in zip(labels, self.bars):+ label.set_height(0.75 * bar.get_height())+ min_width = 0.75 * bar.get_width()+ if label.get_width() > min_width:+ label.set_width(min_width)+ label.move_to(bar)+ label.set_stroke(BLACK, 5, background=True)+ return labels++ def add_icons(self, *icons, buff=SMALL_BUFF):+ if hasattr(self, "braces"):+ refs = self.braces+ else:+ refs = self.bars++ for icon, ref in zip(icons, refs):+ icon.ref = ref+ icon.add_updater(lambda i: i.next_to(+ i.ref,+ self.brace_direction,+ buff=buff+ ))+ self.icons = VGroup(*icons)+ self.add(self.icons)+++class Steve(SVGMobject):+ CONFIG = {+ "file_name": "steve",+ "fill_color": GREY,+ "sheen_factor": 0.5,+ "sheen_direction": UL,+ "stroke_width": 0,+ "height": 3,+ "include_name": True,+ }++ def __init__(self, **kwargs):+ super().__init__(**kwargs)+ if self.include_name:+ self.add_name()++ def add_name(self):+ self.name = TextMobject("Steve")+ self.name.match_width(self)+ self.name.next_to(self, DOWN, SMALL_BUFF)+ self.add(self.name)+++class LibrarianIcon(SVGMobject):+ CONFIG = {+ "file_name": "book",+ "stroke_width": 0,+ "fill_color": LIGHT_GREY,+ "sheen_factor": 0.5,+ "sheen_direction": UL,+ "height": 0.75,+ }++ def __init__(self, **kwargs):+ super().__init__(**kwargs)+++class FarmerIcon(SVGMobject):+ CONFIG = {+ # "file_name": "pitch_fork_and_roll",+ "file_name": "farming",+ "stroke_width": 0,+ "fill_color": GREEN_E,+ "sheen_factor": 0.5,+ "sheen_direction": UL,+ "height": 1.5,+ }++ def __init__(self, **kwargs):+ super().__init__(**kwargs)+++# Scenes+++# class Test(Scene):+# def construct(self):+# icon = FarmerIcon()+# icon.scale(2)+# self.add(icon)+# # self.add(get_submobject_index_labels(icon))+++# class FullFormulaIndices(Scene):+# def construct(self):+# formula = get_bayes_formula(expand_denominator=True)+# formula.set_width(FRAME_WIDTH - 1)+# self.add(formula)+# self.add(get_submobject_index_labels(formula))+++class IntroduceFormula(Scene):+ def construct(self):+ formula = get_bayes_formula()+ formula.set_width(FRAME_WIDTH - 1)++ def get_formula_slice(*indices):+ return VGroup(*[formula[i] for i in indices])++ H_label = formula.get_part_by_tex("{H}")+ E_label = formula.get_part_by_tex("{E}")++ hyp_label = TextMobject("Hypothesis")+ hyp_label.set_color(HYPOTHESIS_COLOR)+ hyp_label.next_to(H_label, UP, LARGE_BUFF)++ evid_label = TextMobject("Evidence")+ evid_label.set_color(EVIDENCE_COLOR1)+ evid_label.next_to(E_label, DOWN, LARGE_BUFF)++ hyp_arrow = Arrow(hyp_label.get_bottom(), H_label.get_top(), buff=SMALL_BUFF)+ evid_arrow = Arrow(evid_label.get_top(), E_label.get_bottom(), buff=SMALL_BUFF)++ self.add(formula[:6])+ # self.add(get_submobject_index_labels(formula))+ # return+ self.play(+ FadeInFrom(hyp_label, DOWN),+ GrowArrow(hyp_arrow),+ FadeInFrom(evid_label, UP),+ GrowArrow(evid_arrow),+ )+ self.wait()++ # Prior+ self.play(+ ShowCreation(formula.get_part_by_tex("=")),+ TransformFromCopy(+ get_formula_slice(0, 1, 2, 5),+ get_formula_slice(8, 9, 10, 11),+ ),+ )+ self.wait()++ # Likelihood+ lhs_copy = formula[:6].copy()+ likelihood = formula[13:19]+ run_time = 1+ self.play(+ lhs_copy.next_to, likelihood, UP,+ DrawBorderThenFill(formula.get_part_by_tex("\\cdot")),+ run_time=run_time,+ )+ self.play(+ Swap(lhs_copy[2], lhs_copy[4]),+ run_time=run_time,+ )+ self.play(+ lhs_copy.move_to, likelihood,+ run_time=run_time,+ )+ self.wait()++ # Evidence+ self.play(+ ShowCreation(formula.get_part_by_tex("\\over")),+ TransformFromCopy(+ get_formula_slice(0, 1, 4, 5),+ get_formula_slice(20, 21, 22, 23),+ ),+ )+ self.wait()+++class StateGoal(PiCreatureScene):+ CONFIG = {+ "default_pi_creature_kwargs": {+ "color": BLUE_B,+ "height": 2,+ },++ }++ def construct(self):+ you = self.pi_creature+ line = NumberLine(+ x_min=-2,+ x_max=12,+ include_tip=True+ )+ line.to_edge(DOWN, buff=1.5)+ line.to_edge(LEFT, buff=-0.5)++ you.next_to(line.n2p(0), UP)++ you_label = TextMobject("you")+ you_label.next_to(you, RIGHT, MED_LARGE_BUFF)+ you_arrow = Arrow(you_label.get_left(), you.get_right() + 0.5 * LEFT, buff=0.1)++ now_label = TextMobject("Now")+ later_label = TextMobject("Later")+ now_label.next_to(line.n2p(0), DOWN)+ later_label.next_to(line.n2p(10), DOWN)++ self.add(line, now_label)+ self.add(you)+ self.play(+ FadeInFrom(you_label, LEFT),+ GrowArrow(you_arrow),+ you.change, "pondering",+ )+ self.wait()+ you_label.add(you_arrow)+ self.play(+ you.change, "horrified",+ you.look, DOWN,+ you.next_to, line.n2p(10), UP,+ MaintainPositionRelativeTo(you_label, you),+ FadeInFromPoint(later_label, now_label.get_center()),+ )+ self.wait()++ bubble = you.get_bubble(+ height=4,+ width=6,+ )+ bubble.set_fill(opacity=0)+ formula = get_bayes_formula()+ bubble.position_mobject_inside(formula)++ self.play(+ you.change, "confused", bubble,+ ShowCreation(bubble),+ )+ self.play(FadeIn(formula))+ self.play(you.change, "hooray", formula)+ self.wait(2)++ # Levels of understanding+ # Turn bubble into level points+ level_points = VGroup(*[bubble.copy() for x in range(3)])+ for n, point in enumerate(level_points):+ point.set_width(0.5)+ point.set_height(0.5, stretch=True)+ point.add(*[+ point[-1].copy().scale(1.2**k)+ for k in range(1, n + 1)+ ])+ point[:3].scale(1.2**n, about_point=point[3].get_center())+ point.set_stroke(width=2)+ point.set_fill(opacity=0)+ level_points.arrange(DOWN, buff=LARGE_BUFF)++ title = TextMobject("Levels of understanding")+ title.scale(1.5)+ title.to_corner(UL)+ underline = Line()+ underline.match_width(title)+ underline.move_to(title, DOWN)+ title.add(underline)++ level_points.next_to(title, DOWN, buff=1.5)+ level_points.to_edge(LEFT)+ level_points.set_submobject_colors_by_gradient(GREEN, YELLOW, RED)++ self.remove(bubble)+ self.play(+ formula.to_corner, UR,+ Uncreate(line),+ FadeOutAndShift(now_label, DOWN),+ FadeOutAndShift(later_label, DOWN),+ FadeOut(you_label),+ FadeOut(you_arrow),+ FadeOut(you),+ *[+ ReplacementTransform(bubble.copy(), point)+ for point in level_points+ ],+ )+ self.play(Write(title, run_time=1))+ self.wait()++ # Write level 1+ level_labels = VGroup(+ TextMobject("What is it saying?"),+ TextMobject("Why is it true?"),+ TextMobject("When is it useful?"),+ )+ for lp, ll in zip(level_points, level_labels):+ ll.scale(1.25)+ ll.match_color(lp)+ ll.next_to(lp, RIGHT)++ formula_parts = VGroup(+ formula.prior,+ formula.likelihood,+ formula.p_evidence,+ formula.posterior,+ ).copy()+ formula_parts.generate_target()+ formula_parts.target.scale(1.5)+ formula_parts.target.arrange(DOWN, buff=LARGE_BUFF, aligned_edge=LEFT)+ formula_parts.target.next_to(formula, DOWN, buff=LARGE_BUFF)+ formula_parts.target.shift(3 * LEFT)++ equal_signs = VGroup(*[+ TextMobject("=").next_to(fp, RIGHT)+ for fp in formula_parts.target+ ])++ kw = {+ "tex_to_color_map": {+ "hypothesis": HYPOTHESIS_COLOR,+ "evidence": EVIDENCE_COLOR1,+ },+ "alignment": "",+ }+ meanings = VGroup(+ TextMobject("Probability a hypothesis is true\\\\(before any evidence)", **kw),+ TextMobject("Probability of seeing the evidence \\quad \\\\if the hypothesis is true", **kw),+ TextMobject("Probability of seeing the evidence", **kw),+ TextMobject("Probability a hypothesis is true\\\\given some evidence", **kw),+ )+ for meaning, equals in zip(meanings, equal_signs):+ meaning.scale(0.5)+ meaning.next_to(equals, RIGHT)++ self.play(+ FadeIn(level_labels[0], lag_ratio=0.1),+ MoveToTarget(formula_parts),+ LaggedStartMap(FadeInFrom, equal_signs, lambda m: (m, RIGHT)),+ LaggedStartMap(FadeIn, meanings),+ )+ self.wait()++ # Write level 2+ diagram = BayesDiagram(0.35, 0.5, 0.2, height=2.5)+ diagram.next_to(formula, DOWN, aligned_edge=LEFT)++ braces = VGroup(*[+ Brace(diagram.he_rect, vect, buff=SMALL_BUFF)+ for vect in [DOWN, LEFT]+ ])++ formula_parts.generate_target()+ formula_parts.target[:2].scale(0.5)+ formula_parts.target[0].next_to(braces[0], DOWN, SMALL_BUFF)+ formula_parts.target[1].next_to(braces[1], LEFT, SMALL_BUFF)++ pe_picture = VGroup(+ diagram.he_rect.copy(),+ TexMobject("+"),+ diagram.nhe_rect.copy()+ )+ pe_picture.arrange(RIGHT, buff=SMALL_BUFF)+ pe_picture.next_to(equal_signs[2], RIGHT)++ phe_picture = VGroup(+ diagram.he_rect.copy(),+ Line().match_width(pe_picture),+ pe_picture.copy(),+ )+ phe_picture.arrange(DOWN, buff=MED_SMALL_BUFF)+ phe_picture.next_to(equal_signs[3], RIGHT)++ pe_picture.scale(0.5, about_edge=LEFT)+ phe_picture.scale(0.3, about_edge=LEFT)++ self.play(+ FadeOut(meanings),+ FadeOut(equal_signs[:2]),+ MoveToTarget(formula_parts),+ FadeIn(diagram),+ LaggedStartMap(GrowFromCenter, braces),+ FadeIn(level_labels[1], lag_ratio=0.1),+ level_labels[0].set_opacity, 0.5,+ )+ self.play(+ TransformFromCopy(diagram.he_rect, pe_picture[0]),+ TransformFromCopy(diagram.nhe_rect, pe_picture[2]),+ FadeIn(pe_picture[1]),+ )+ self.play(+ TransformFromCopy(pe_picture, phe_picture[2]),+ TransformFromCopy(pe_picture[0], phe_picture[0]),+ ShowCreation(phe_picture[1])+ )+ self.wait()++ # Write level 3+ steve = Steve(height=3)+ steve.to_edge(RIGHT, buff=2)++ arrow = Arrow(level_points.get_bottom(), level_points.get_top(), buff=0)+ arrow.shift(0.25 * LEFT)++ self.play(+ LaggedStartMap(+ FadeOutAndShift,+ VGroup(+ VGroup(diagram, braces, formula_parts[:2]),+ VGroup(formula_parts[2], equal_signs[2], pe_picture),+ VGroup(formula_parts[3], equal_signs[3], phe_picture),+ ),+ lambda m: (m, 3 * RIGHT),+ ),+ FadeIn(level_labels[2], lag_ratio=0.1),+ level_labels[1].set_opacity, 0.5,+ )+ self.wait()+ self.play(+ GrowArrow(arrow),+ level_points.shift, 0.5 * RIGHT,+ level_labels.shift, 0.5 * RIGHT,+ level_labels.set_opacity, 1,+ )+ self.wait()+ self.play(Write(steve, run_time=3))+ self.wait()++ # Transition to next scene+ self.play(+ steve.to_corner, UR,+ Uncreate(arrow),+ LaggedStartMap(+ FadeOutAndShift,+ VGroup(+ title,+ formula,+ *level_points,+ *level_labels,+ ),+ lambda m: (m, DOWN),+ ),+ )+ self.wait()+++class DescriptionOfSteve(Scene):+ def construct(self):+ self.write_description()+ self.compare_probabilities()++ def write_description(self):+ steve = Steve(height=3)+ steve.to_corner(UR)++ description = TextMobject(+ """+ Steve is very shy and withdrawn,\\\\+ invariably helpful but with very\\\\+ little interest in people or in the\\\\+ world of reality. A meek and tidy\\\\+ soul, he has a need for order and\\\\+ structure, and a passion for detail.\\\\+ """,+ tex_to_color_map={+ "shy and withdrawn": BLUE,+ "meek and tidy": WHITE,+ "soul": WHITE,+ },+ alignment="",+ )+ description.to_edge(LEFT)+ description.match_y(steve)++ self.add(steve)+ self.play(+ FadeIn(description),+ run_time=3,+ lag_ratio=0.01,+ rate_func=linear,+ )+ self.wait(3)++ mt_parts = VGroup(+ description.get_part_by_tex("meek"),+ description.get_part_by_tex("soul"),+ )+ lines = VGroup(*[+ Line(mob.get_corner(DL), mob.get_corner(DR), color=YELLOW)+ for mob in mt_parts+ ])+ self.play(+ ShowCreation(lines),+ mt_parts.set_color, YELLOW,+ )+ self.play(FadeOut(lines))+ self.wait()++ def compare_probabilities(self):+ bar = ProbabilityBar(0.5, width=10)+ icons = VGroup(+ LibrarianIcon(),+ FarmerIcon(),+ )+ for icon, text, half in zip(icons, ["Librarian", "Farmer"], bar.bars):+ icon.set_height(0.7)+ label = TextMobject(text)+ label.next_to(icon, DOWN, buff=SMALL_BUFF)+ label.set_color(+ interpolate_color(half.get_color(), WHITE, 0.5)+ )+ icon.add(label)++ bar.add_icons(*icons)+ bar.move_to(1.75 * DOWN)++ bar.icons.set_opacity(0)++ q_marks = TexMobject(*"???")+ q_marks.scale(1.5)+ q_marks.space_out_submobjects(1.5)+ q_marks.next_to(bar, DOWN)++ self.play(FadeIn(bar))+ self.wait()+ self.play(+ bar.p_tracker.set_value, 0.9,+ bar.icons[0].set_opacity, 1,+ )+ self.wait()+ self.play(+ bar.p_tracker.set_value, 0.1,+ bar.icons[1].set_opacity, 1,+ )+ self.play(+ LaggedStartMap(+ FadeInFrom, q_marks,+ lambda m: (m, UP),+ run_time=2,+ ),+ ApplyMethod(+ bar.p_tracker.set_value, 0.7,+ run_time=8,+ )+ )+ for value in 0.3, 0.7:+ self.play(+ bar.p_tracker.set_value, 0.3,+ run_time=7,+ )+++class IntroduceKahnemanAndTversky(Scene):+ def construct(self):+ images = Group(+ ImageMobject("kahneman"),+ ImageMobject("tversky"),+ )+ danny, amos = images+ images.set_height(3.5)+ images.arrange(DOWN, buff=0.5)+ images.to_edge(LEFT, buff=MED_LARGE_BUFF)++ names = VGroup(+ TextMobject("Daniel\\\\Kahneman", alignment=""),+ TextMobject("Amos\\\\Tversky", alignment=""),+ )+ for name, image in zip(names, images):+ name.scale(1.25)+ name.next_to(image, RIGHT)+ image.name = name++ prize = ImageMobject("nobel_prize", height=1)+ prize.move_to(danny, UR)+ prize.shift(MED_SMALL_BUFF * UR)++ books = Group(+ ImageMobject("thinking_fast_and_slow"),+ ImageMobject("undoing_project"),+ )+ books.set_height(5)+ books.arrange(RIGHT, buff=0.5)+ books.to_edge(RIGHT, buff=MED_LARGE_BUFF)++ self.play(+ FadeInFrom(danny, DOWN),+ FadeInFrom(danny.name, LEFT),+ )+ self.play(+ FadeInFrom(amos, UP),+ FadeInFrom(amos.name, LEFT),+ )+ self.wait()+ self.play(FadeInFromLarge(prize))+ self.wait()+ for book in books:+ self.play(FadeInFrom(book, LEFT))+ self.wait()