Manim Notebooks/manim_examples.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Manim Examples\n",
    "\n",
    "Collection of examples using Manim. Check the blog post related to this notebook here:\n",
    "* https://andresberejnoi.com/using-manim-and-python-to-create-animations-like-3blue1brown"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">Manim Community <span style=\"color: #008000; text-decoration-color: #008000\">v0.17.3</span>\n",
       "\n",
       "</pre>\n"
      ],
      "text/plain": [
       "Manim Community \u001b[32mv0.\u001b[0m\u001b[32m17.3\u001b[0m\n",
       "\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from manim import *\n",
    "import numpy as np\n",
    "\n",
    "config.media_width = \"75%\"\n",
    "config.verbosity = \"WARNING\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                                                     \r"
     ]
    },
    {
     "data": {
      "text/html": [
       "<video src=\"media\\jupyter\\ShapeAndTextScene@2023-07-18@16-03-54.mp4\" controls autoplay loop style=\"max-width: 75%;\"  >\n",
       "      Your browser does not support the <code>video</code> element.\n",
       "    </video>"
      ],
      "text/plain": [
       "<IPython.core.display.Video object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%manim -qk ShapeAndTextScene\n",
    "\n",
    "class ShapeAndTextScene(Scene):\n",
    "    def construct(self):\n",
    "        text = Tex(\"Example Scene With Some Shapes\")\n",
    "\n",
    "        circle = Circle()\n",
    "        circle.set_fill(BLUE, opacity=0.8)\n",
    "\n",
    "        hexagon = RegularPolygon(n=6)\n",
    "        hexagon.set_fill(GREEN, opacity=0.5)\n",
    "\n",
    "        self.play(Write(text))\n",
    "        self.play(text.animate.shift(UP*3))\n",
    "        self.wait(0.3)\n",
    "        self.play(DrawBorderThenFill(circle))\n",
    "        self.wait()\n",
    "\n",
    "        self.play(Transform(circle, hexagon,run_time=1.5), )\n",
    "        self.wait(0.5)\n",
    "\n",
    "        self.play(hexagon.copy().animate.shift(LEFT * 3))\n",
    "        self.wait(0.35)\n",
    "        self.play(hexagon.copy().animate.shift(RIGHT * 3))\n",
    "        self.wait()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                             \r"
     ]
    },
    {
     "data": {
      "text/html": [
       "<video src=\"media\\jupyter\\CodeExamplePart2@2023-08-11@19-47-48.mp4\" controls autoplay loop style=\"max-width: 75%;\"  >\n",
       "      Your browser does not support the <code>video</code> element.\n",
       "    </video>"
      ],
      "text/plain": [
       "<IPython.core.display.Video object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%manim -qk CodeExamplePart2\n",
    "\n",
    "class CodeExamplePart1(Scene):\n",
    "    def construct(self):\n",
    "        code = '''\n",
    "%%manim -qh ShapeAndTextScene\n",
    "\n",
    "class ShapeAndTextScene(Scene):\n",
    "    def construct(self):\n",
    "        text = Tex(\"Example Scene With Some Shapes\")\n",
    "\n",
    "        circle = Circle()\n",
    "        circle.set_fill(BLUE, opacity=0.8)\n",
    "\n",
    "        hexagon = RegularPolygon(n=6)\n",
    "        hexagon.set_fill(GREEN, opacity=0.5)\n",
    "'''\n",
    "        rendered_code = Code(code=code, tab_width=4, background=\"window\",\n",
    "                            language=\"Python\", font=\"Monospace\",\n",
    "                            line_no_from=1,)\n",
    "        self.play(Create(rendered_code), run_time=5)\n",
    "        self.wait(2)\n",
    "\n",
    "class CodeExamplePart2(Scene):\n",
    "    def construct(self):\n",
    "        code = '''\n",
    "        ...\n",
    "        self.play(Write(text))\n",
    "        self.play(text.animate.shift(UP*3))\n",
    "        self.wait(0.3)\n",
    "        self.play(DrawBorderThenFill(circle))\n",
    "        self.wait()\n",
    "\n",
    "        self.play(Transform(circle, hexagon), run_time=1.5)\n",
    "        self.wait(0.5)\n",
    "\n",
    "        self.play(hexagon.copy().animate.shift(LEFT * 3))\n",
    "        self.wait(0.35)\n",
    "        self.play(hexagon.copy().animate.shift(RIGHT * 3))\n",
    "        self.wait()\n",
    "'''\n",
    "        rendered_code = Code(code=code, tab_width=4, background=\"window\",\n",
    "                            language=\"Python\", font=\"Monospace\",\n",
    "                            line_no_from=12,)\n",
    "        self.play(Create(rendered_code), run_time=5)\n",
    "        self.wait(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                                                           \r"
     ]
    },
    {
     "data": {
      "text/html": [
       "<video src=\"media\\jupyter\\CodeAndAnimation@2023-08-11@22-25-03.mp4\" controls autoplay loop style=\"max-width: 75%;\"  >\n",
       "      Your browser does not support the <code>video</code> element.\n",
       "    </video>"
      ],
      "text/plain": [
       "<IPython.core.display.Video object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%manim -qk CodeAndAnimation\n",
    "\n",
    "\n",
    "class CodeAndAnimation(Scene):\n",
    "    def construct(self):\n",
    "        code = '''\n",
    "        ...\n",
    "        self.play(Write(text))\n",
    "        self.play(text.animate.shift(UP*3))\n",
    "        self.wait(0.3)\n",
    "        self.play(DrawBorderThenFill(circle))\n",
    "        self.wait()\n",
    "\n",
    "        self.play(Transform(circle, hexagon), run_time=1.5)\n",
    "        self.wait(0.5)\n",
    "\n",
    "        self.play(hexagon.copy().animate.shift(LEFT * 3))\n",
    "        self.wait(0.35)\n",
    "        self.play(hexagon.copy().animate.shift(RIGHT * 3))\n",
    "        self.wait()'''\n",
    "\n",
    "        rendered_code = Code(\n",
    "            code=code, \n",
    "            tab_width=4, \n",
    "            background=\"window\",\n",
    "            language=\"Python\", \n",
    "            font=\"Monospace\",\n",
    "            line_no_from=12,\n",
    "            line_spacing=1\n",
    "        )\n",
    "\n",
    "        self.play(Create(rendered_code), run_time=2.5)\n",
    "        self.wait(0.5)\n",
    "\n",
    "        self.play(rendered_code.animate.scale(0.4).shift(LEFT*4 + UP*2))\n",
    "        self.wait()\n",
    "\n",
    "        #===========\n",
    "        text = Tex(\"Example Scene With Some Shapes\")\n",
    "\n",
    "        circle = Circle()\n",
    "        circle.set_fill(BLUE, opacity=0.8)\n",
    "\n",
    "        hexagon = RegularPolygon(n=6)\n",
    "        hexagon.set_fill(GREEN, opacity=0.5)\n",
    "\n",
    "        objects = VGroup(text, circle, hexagon)\n",
    "        objects.scale(0.7)\n",
    "        objects.move_to(RIGHT*2)\n",
    "\n",
    "        idx = 1\n",
    "        self.play(Write(text), Indicate(rendered_code.submobjects[2][idx]))\n",
    "        idx +=1\n",
    "        self.play(text.animate.shift(UP*3), Indicate(rendered_code.submobjects[2][idx]))\n",
    "        idx +=1\n",
    "        self.wait(0.3)\n",
    "        idx +=1\n",
    "        self.play(DrawBorderThenFill(circle), Indicate(rendered_code.submobjects[2][idx]))\n",
    "        idx +=1\n",
    "        self.wait()\n",
    "        idx +=2\n",
    "\n",
    "        self.play(Transform(circle, hexagon,run_time=1.5), Indicate(rendered_code.submobjects[2][idx]) )\n",
    "        idx +=1\n",
    "        self.wait(0.5)\n",
    "        idx +=2\n",
    "\n",
    "        self.play(hexagon.copy().animate.shift(LEFT * 3), Indicate(rendered_code.submobjects[2][idx]))\n",
    "        idx +=1\n",
    "        self.wait(0.35)\n",
    "        idx +=1\n",
    "        self.play(hexagon.copy().animate.shift(RIGHT * 3), Indicate(rendered_code.submobjects[2][idx]))\n",
    "        idx +=1\n",
    "        self.wait()\n",
    "        idx +=1\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                                                                                                       \r"
     ]
    },
    {
     "data": {
      "text/html": [
       "<video src=\"media\\jupyter\\MatrixExample@2023-08-12@19-07-51.mp4\" controls autoplay loop style=\"max-width: 75%;\"  >\n",
       "      Your browser does not support the <code>video</code> element.\n",
       "    </video>"
      ],
      "text/plain": [
       "<IPython.core.display.Video object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%manim -qk MatrixExample\n",
    "\n",
    "class MatrixExample(Scene):\n",
    "    def construct(self):\n",
    "\n",
    "        elements1 = [\n",
    "            [0.158, '\\\\pi', -4.325],\n",
    "            [11   ,    0  , 3.876],\n",
    "        ]\n",
    "\n",
    "        #create Matrix Mobject\n",
    "        mat1 = Matrix(\n",
    "            elements1,\n",
    "            left_bracket = '\\\\{',\n",
    "            right_bracket = '\\\\}',\n",
    "            v_buff=1.3,\n",
    "            h_buff=2.5,\n",
    "        )\n",
    "\n",
    "        #create column rectangles ahead of time (they will added to the scene later)\n",
    "        col0 = SurroundingRectangle(mat1.get_columns()[0])\n",
    "        col1 = SurroundingRectangle(mat1.get_columns()[1]) \n",
    "        col2 = SurroundingRectangle(mat1.get_columns()[2])\n",
    "\n",
    "        #animate creation of the matrix\n",
    "        self.play(Create(mat1), run_time=1.3)\n",
    "        self.wait(0.5)\n",
    "\n",
    "        # animate surrounding rectangles for each column\n",
    "        self.play(Create(col0), run_time=0.5)\n",
    "        self.wait(0.5)\n",
    "\n",
    "        self.play(Transform(col0, col1, replace_mobject_with_target_in_scene=True), run_time=1)\n",
    "        self.wait(0.5)      \n",
    "\n",
    "        self.play(Transform(col1, col2, replace_mobject_with_target_in_scene=True), run_time=1)\n",
    "        self.wait(0.5)\n",
    "        self.play(Uncreate(col2), run_time=0.5)\n",
    "        self.wait(0.5)\n",
    "\n",
    "        #--change brackets \n",
    "        #self.play(Indicate(mat1[1]))\n",
    "        self.play(\n",
    "            mat1[1].animate.become(MathTex('\\\\left(\\\\begin{array}{c}\\\\quad \\\\\\\\\\\\quad \\\\\\\\\\\\end{array}\\\\right.'), match_center=True, match_height=True),\n",
    "            mat1[2].animate.become(MathTex('\\\\left.\\\\begin{array}{c}\\\\quad \\\\\\\\\\\\quad \\\\\\\\\\\\end{array}\\\\right)'), match_center=True, match_height=True),\n",
    "        )\n",
    "\n",
    "        self.wait(0.5)\n",
    "\n",
    "        self.play(\n",
    "            mat1[1].animate.become(MathTex('\\\\left[\\\\begin{array}{c}\\\\quad \\\\\\\\\\\\quad \\\\\\\\\\\\end{array}\\\\right.'), match_center=True, match_height=True),\n",
    "            mat1[2].animate.become(MathTex('\\\\left.\\\\begin{array}{c}\\\\quad \\\\\\\\\\\\quad \\\\\\\\\\\\end{array}\\\\right]'), match_center=True, match_height=True),\n",
    "        )\n",
    "\n",
    "        self.wait()\n",
    "\n",
    "        # left_b_copy  = mat1[1].copy().become(MathTex('\\\\left[\\\\begin{array}{c}\\\\quad \\\\\\\\\\\\quad \\\\\\\\\\\\end{array}\\\\right.'), match_center=True, match_height=True)\n",
    "        # right_b_copy = mat1[2].copy().become(MathTex('\\\\left.\\\\begin{array}{c}\\\\quad \\\\\\\\\\\\quad \\\\\\\\\\\\end{array}\\\\right]'), match_center=True, match_height=True)\n",
    "        # self.play(TransformMatchingTex(mat1[1], left_b_copy))\n",
    "        # self.play(TransformMatchingTex(mat1[2], right_b_copy))\n",
    "\n",
    "        # self."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Automating Neural Network Layer Generation\n",
    "Since each layer usually looks very similar, this is a perfect task to automate. I created the following helper functions to encapsulate the repetitive parts of the neural network animation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_network_layer(\n",
    "    num_nodes, \n",
    "    include_bias    = True, \n",
    "    layer_type      = 'hidden', \n",
    "    orientation     = 'vertical',\n",
    "    node_buffer     = 0.75, \n",
    "    add_node_labels = True,\n",
    "    font_size       = 30,\n",
    "    add_layer_label = True,\n",
    "    layer_font_size = 35,\n",
    "    layer_idx       = None,\n",
    "    shape_params:dict = {},\n",
    "    ):\n",
    "\n",
    "\n",
    "    node_shape = None\n",
    "    if layer_type.lower() == 'input':\n",
    "        node_shape = Square\n",
    "        default_shape_params = {\n",
    "            'side_length'  : 1,\n",
    "            'fill_opacity' : 0.6,\n",
    "            'color'        : GREEN\n",
    "        }\n",
    "\n",
    "        shape_params = default_shape_params | shape_params\n",
    "\n",
    "    elif layer_type.lower() == 'hidden':\n",
    "        node_shape = Circle\n",
    "        default_shape_params = {\n",
    "            'radius'       : 0.6,\n",
    "            'fill_opacity' : 0.6,\n",
    "            'color'        : BLUE\n",
    "        }\n",
    "\n",
    "        shape_params = default_shape_params | shape_params\n",
    "\n",
    "    elif layer_type.lower() == 'output':\n",
    "        node_shape = Circle \n",
    "        default_shape_params = {\n",
    "            'radius'       : 0.6,\n",
    "            'fill_opacity' : 0.6,\n",
    "            'color'        : BLUE\n",
    "        }\n",
    "\n",
    "        shape_params = default_shape_params | shape_params\n",
    "\n",
    "    else:\n",
    "        node_shape = Circle\n",
    "        default_shape_params = {\n",
    "            'radius'       : 0.6,\n",
    "            'fill_opacity' : 0.6,\n",
    "            'color'        : BLUE\n",
    "        }\n",
    "        \n",
    "        shape_params = default_shape_params | shape_params\n",
    "\n",
    "\n",
    "    layer_group = VGroup()  #this group will contain everything here to return\n",
    "\n",
    "    #-- Create regular nodes and add them to a group\n",
    "    layer_nodes = VGroup(*[node_shape(**shape_params) for i in range(num_nodes)])\n",
    "    \n",
    "    layer_group.add(layer_nodes)\n",
    "\n",
    "    #-- Create bias node and add it to the group\n",
    "    if include_bias:\n",
    "        bias_node = input_bias  = Circle(color=RED, fill_opacity=0.6, radius=0.35)\n",
    "        bias_node.is_bias_node = True   #add custom attribute to check layer\n",
    "        layer_nodes.add(bias_node)  #add temporarily here to make arrangement easier\n",
    "\n",
    "\n",
    "    #-- Arrange the nodes either in a vertical column or in a horizontal row\n",
    "    if orientation.lower() == 'horizontal' or orientation.lower() == 'h':\n",
    "        layer_nodes.arrange(LEFT, buff=node_buffer)\n",
    "    elif orientation.lower() == 'vertical' or orientation.lower() == 'v':\n",
    "        layer_nodes.arrange(DOWN, buff=node_buffer)\n",
    "\n",
    "\n",
    "    #-- remove bias node to make labeling simpler\n",
    "    if include_bias:\n",
    "        layer_nodes -= bias_node\n",
    "        #layer_group.add(bias_node)\n",
    "\n",
    "    #-- add main label to layer\n",
    "    if add_layer_label:\n",
    "        if layer_idx is None:\n",
    "            if layer_type.lower()[0] == 'i':\n",
    "                layer_idx=0\n",
    "            else:\n",
    "                layer_idx='n'\n",
    "            \n",
    "        layer_label = Tex(fr\"{layer_type.capitalize()} Layer (\\(L_{layer_idx}\\))\", font_size=layer_font_size)\n",
    "        layer_label.next_to(layer_nodes, UP, buff=0.25)\n",
    "\n",
    "        layer_group.add(layer_label)\n",
    "\n",
    "    #-- add labels to main nodes\n",
    "    if add_node_labels:\n",
    "        label_letter = layer_type.lower()[0]    #use the first letter of the layer type\n",
    "        node_labels = VGroup(*\n",
    "            [\n",
    "                Tex(\n",
    "                    fr\"\\({label_letter}_{i}\\)\", \n",
    "                    font_size=font_size\n",
    "                )\n",
    "                for i in range(num_nodes)\n",
    "            ]           \n",
    "        )\n",
    "        \n",
    "        for label, node in zip(node_labels, layer_nodes):\n",
    "            label.move_to(node)\n",
    "\n",
    "        layer_group.add(node_labels)\n",
    "\n",
    "        if include_bias:\n",
    "            bias_label = Tex(r\"b\", font_size=font_size)\n",
    "            bias_label.move_to(bias_node)\n",
    "            layer_group.add(bias_label)\n",
    "\n",
    "    # add bias node back into the layer_nodes group\n",
    "    if include_bias:\n",
    "        layer_nodes.add(bias_node)\n",
    "\n",
    "\n",
    "    #-- Return the group containing all the nodes and labels\n",
    "    return layer_group"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_layer_connections(source_layer:VGroup, target_layer:VGroup, arrow_width=2.5):\n",
    "    '''source_layer and target_layer are both VGroups containing only nodes and bias'''\n",
    "    arrow_group = VGroup() \n",
    "\n",
    "    for j, target_node in enumerate(target_layer):\n",
    "        if hasattr(target_node,'is_bias_node'): #skip bias nodes for incoming arrows from previous layer\n",
    "            continue\n",
    "\n",
    "        for i, source_node in enumerate(source_layer):\n",
    "            arrow = Arrow(\n",
    "                source_layer[i].get_right(), \n",
    "                target_layer[j].get_left(), \n",
    "                stroke_width=arrow_width,\n",
    "            )\n",
    "            arrow_group.add(arrow)\n",
    "\n",
    "    return arrow_group\n",
    "\n",
    "def generate_random_labeled_layer_connections(\n",
    "        source_layer:VGroup, \n",
    "        target_layer:VGroup, \n",
    "        arrow_width=2.5, \n",
    "        label_position=0.15, \n",
    "        font_size=10, \n",
    "        add_frame=True, \n",
    "        weights:np.ndarray|list[list] = None):\n",
    "    \n",
    "    \"\"\"\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    weights: np.array | list[list]\n",
    "        A 2d array with shape = (len(source_layer) , len(target_layer))\n",
    "    \"\"\"\n",
    "    \n",
    "    arrow_group = VGroup()\n",
    "\n",
    "    if weights is None:\n",
    "        weights = np.random.uniform(-0.6, 0.6, size=(len(source_layer), len(target_layer)))\n",
    "    elif isinstance(weights, np.array):\n",
    "        assert(weights.shape == (len(source_layer), len(target_layer)))\n",
    "    elif isinstance(weights, list):\n",
    "        assert( (len(weights), len(weights[0])) == (len(source_layer), len(target_layer))    )\n",
    "        weights = np.array(weights)\n",
    "    else:\n",
    "        print(f\"Unsupported type `{weights.type}` for 'weights'.\")\n",
    "        raise TypeError\n",
    "\n",
    "    for j, target_node in enumerate(target_layer):\n",
    "        if hasattr(target_node, 'is_bias_node'):\n",
    "            continue \n",
    "\n",
    "        for i, source_node in enumerate(source_layer):\n",
    "            arrow = LabeledArrow(\n",
    "                #label = f\"{np.random.uniform(-0.6, 0.6):.2f}\",\n",
    "                label = f\"{weights[i,j]:.2f}\",\n",
    "                label_position = label_position,\n",
    "                font_size = font_size,\n",
    "                label_frame = add_frame,\n",
    "                start = source_layer[i].get_right(),\n",
    "                end   = target_layer[j].get_left(),\n",
    "                stroke_width = arrow_width\n",
    "            )\n",
    "            arrow_group.add(arrow)\n",
    "\n",
    "    return arrow_group"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## LabeledLine and LabeledArrow\n",
    "I wrote two new custom classes that inherit from Manim's `Line` and `Arrow` Mobjects. The new classes, `LabeledLine` and `LabeledArrow`, behave like their parents except that you supply a label to be put in a box somewhere along the lenght of the shape. I created a [pull request](https://github.com/ManimCommunity/manim/pull/3264) on Manim's GitHub repository, so we'll see how it goes. Meanwhile, I'm adding those classes here because they are useful when creating a neural network animation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "class LabeledLine(Line):\n",
    "    def __init__(\n",
    "        self, \n",
    "        label, \n",
    "        label_position:float=0.5, \n",
    "        font_size=15,\n",
    "        label_color=WHITE,\n",
    "        label_frame=True,\n",
    "        frame_fill_color=None,\n",
    "        frame_fill_opacity=1,\n",
    "        *args, \n",
    "        **kwargs,\n",
    "    ) -> None:\n",
    "        \n",
    "        if isinstance(label, str):\n",
    "            from manim import MathTex\n",
    "\n",
    "            rendered_label = MathTex(label, color=label_color, font_size=font_size)\n",
    "        else:\n",
    "            rendered_label = label\n",
    "\n",
    "        super().__init__(*args, **kwargs)\n",
    "\n",
    "        #calculating the vector for the label position\n",
    "        line_start, line_end = self.get_start_and_end()\n",
    "        new_vec = (line_end - line_start) * label_position\n",
    "        label_coords = line_start + new_vec\n",
    "\n",
    "        #rendered_label.move_to(self.get_vector() * label_position)\n",
    "        rendered_label.move_to(label_coords)\n",
    "\n",
    "        box = BackgroundRectangle(rendered_label, buff=0.05, color=frame_fill_color, fill_opacity=frame_fill_opacity, stroke_width=0.5)\n",
    "        self.add(box)\n",
    "        \n",
    "        if label_frame:\n",
    "            box_frame = SurroundingRectangle(rendered_label, buff=0.05, color=label_color, stroke_width=0.5)\n",
    "\n",
    "            self.add(box_frame)\n",
    "            \n",
    "        self.add(rendered_label)\n",
    "\n",
    "        #self.label_position = label_position\n",
    "\n",
    "\n",
    "class LabeledArrow(LabeledLine, Arrow):\n",
    "    def __init__(\n",
    "        self, \n",
    "        *args,\n",
    "        **kwargs,\n",
    "    ) -> None:\n",
    "        \n",
    "        super().__init__(*args, **kwargs)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Animating The Neural Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                                        \r"
     ]
    },
    {
     "data": {
      "text/html": [
       "<video src=\"media\\jupyter\\TestNetwork@2023-07-18@16-37-12.mp4\" controls autoplay loop style=\"max-width: 75%;\"  >\n",
       "      Your browser does not support the <code>video</code> element.\n",
       "    </video>"
      ],
      "text/plain": [
       "<IPython.core.display.Video object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "%%manim -qm TestNetwork\n",
    "\n",
    "class TestNetwork(Scene):\n",
    "    def construct(self,):\n",
    "\n",
    "        #--Constants and Stuff\n",
    "        _shift_val = 4\n",
    "        _run_time  = 1\n",
    "\n",
    "        #--Create the layers\n",
    "        input_layer = generate_network_layer(\n",
    "            num_nodes       = 2,\n",
    "            include_bias    = True, \n",
    "            layer_type      = 'input', \n",
    "            layer_idx       = 0,\n",
    "        )\n",
    "\n",
    "        hidden_layer = generate_network_layer(\n",
    "            num_nodes       = 3,\n",
    "            include_bias    = True, \n",
    "            layer_type      = 'hidden', \n",
    "            layer_idx       = 1,\n",
    "        )\n",
    "\n",
    "        output_layer = generate_network_layer(\n",
    "            num_nodes       = 1,\n",
    "            include_bias    = False, \n",
    "            layer_type      = 'output', \n",
    "            layer_idx       = 2,\n",
    "        )\n",
    "\n",
    "        #-- Draw the layers\n",
    "        self.play(*[Create(item, run_time=1) for item in input_layer]) \n",
    "        self.play(input_layer.animate.shift(LEFT * _shift_val))    \n",
    "        self.wait(0.5)\n",
    "\n",
    "        self.play(*[Create(item, run_time=_run_time) for item in hidden_layer]) \n",
    "        self.wait(0.5) \n",
    "\n",
    "\n",
    "        output_layer.shift(RIGHT * _shift_val).shift(UP * 0.75) \n",
    "        self.play(*[Create(item, run_time=_run_time) for item in output_layer])    \n",
    "        self.wait(0.5)\n",
    "\n",
    "        #----------------------------\n",
    "        #-- Create arrows \n",
    "        input_hidden_arrows  = generate_layer_connections(input_layer[0], hidden_layer[0])\n",
    "        hidden_output_arrows = generate_layer_connections(hidden_layer[0], output_layer[0])\n",
    "\n",
    "        self.play(*[GrowArrow(arrow) for arrow in input_hidden_arrows])\n",
    "        self.wait()\n",
    "\n",
    "        self.play(*[GrowArrow(arrow) for arrow in hidden_output_arrows])\n",
    "        self.wait(2)\n",
    "\n",
    "\n",
    "        #------------------------------\n",
    "        #-- add labels to connections\n",
    "        self.play(Uncreate(input_hidden_arrows), Uncreate(hidden_output_arrows))\n",
    "        self.wait()\n",
    "\n",
    "        labeled_input_hidden_arrows = generate_random_labeled_layer_connections(input_layer[0], hidden_layer[0], font_size=15, add_frame=True,)\n",
    "        self.play(*[GrowArrow(arrow) for arrow in labeled_input_hidden_arrows])\n",
    "        self.wait(0.4)\n",
    "\n",
    "        labeled_hidden_output_arrows = generate_random_labeled_layer_connections(hidden_layer[0], output_layer[0], font_size=15, add_frame=True,)\n",
    "        self.play(*[GrowArrow(arrow) for arrow in labeled_hidden_output_arrows])\n",
    "        self.wait()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "mat = Matrix([[1,2],[3,4]], left_bracket='(', right_bracket=')')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MathTex('\\\\left(\\\\begin{array}{c}\\\\quad \\\\\\\\\\\\quad \\\\\\\\\\\\end{array}\\\\right.')\n",
      "MathTex('\\\\left.\\\\begin{array}{c}\\\\quad \\\\\\\\\\\\quad \\\\\\\\\\\\end{array}\\\\right)')\n"
     ]
    }
   ],
   "source": [
    "bs = mat.get_brackets()\n",
    "for item in bs:\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "manim",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.4"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}