profiling_analysis.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Profiling Analysis – Lab 5\n",
    "Baseline: `lab-5/Mosaic_Generator` (Lab 1 reference).\\n\n",
    "This notebook captures the required profiling evidence (cProfile + line_profiler) and timing tables for the legacy code.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Environment Setup\n",
    "Install `line_profiler`, configure module paths, and import the legacy pipeline.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "83b86137",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m25.2\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m25.3\u001b[0m\n",
      "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49m/Applications/Xcode.app/Contents/Developer/usr/bin/python3 -m pip install --upgrade pip\u001b[0m\n",
      "Note: you may need to restart the kernel to use updated packages.\n"
     ]
    }
   ],
   "source": [
    "%pip install -q line_profiler\n",
    "from pathlib import Path\n",
    "import sys\n",
    "import time\n",
    "import cProfile, pstats\n",
    "from PIL import Image\n",
    "ROOT = Path.cwd()\n",
    "MODULE_ROOT = ROOT / 'Mosaic_Generator'\n",
    "sys.path.insert(0, str(MODULE_ROOT))\n",
    "from src.config import Config as LegacyConfig\n",
    "from src.pipeline import MosaicPipeline as LegacyPipeline\n",
    "ASSETS = ROOT / 'data' / 'test_images'\n",
    "ASSETS.mkdir(parents=True, exist_ok=True)\n",
    "assert any(ASSETS.glob('*')), 'Drop square JPG/PNG samples into lab-5/data/test_images'\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f7635951",
   "metadata": {},
   "source": [
    "## 2. Benchmark Harness\n",
    "Helper that measures total runtime for a given (image size, grid) using the legacy pipeline.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "2c4b3d7d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_benchmark(image_path: Path, size: int, grid: int):\n",
    "    img = Image.open(image_path).convert('RGB').resize((size, size))\n",
    "    cfg = LegacyConfig(grid=grid, out_w=size, out_h=size, tiles_cache_dir=str(ROOT / 'tile_cache'))\n",
    "    pipeline = LegacyPipeline(cfg)\n",
    "    t0 = time.perf_counter()\n",
    "    pipeline.run_full_pipeline(img)\n",
    "    return time.perf_counter() - t0\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8709e4d",
   "metadata": {},
   "source": [
    "## 3. Timing Sweep\n",
    "Measure legacy runtimes for several image/grid sizes.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "b36e7088",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loaded tiles from disk cache: /Users/Teoman/Desktop/Classes/Northeastern/Fall2025/CS5130/assignments/CS5130/lab-5/tile_cache/tiles_dd86876e3ed91f2029f9c0eb270ddc1086de27f131375b25b066e0e1f0f2abc0.pkl\n",
      "Using cached tiles (200 tiles)\n",
      "Using cached tiles (200 tiles)\n",
      "Image\tGrid\tLegacy Time (s)\n",
      "256\t16\t0.067\n",
      "512\t32\t0.135\n",
      "1024\t64\t0.554\n"
     ]
    }
   ],
   "source": [
    "tests = [(256, 16), (512, 32), (1024, 64)]\n",
    "sample_image = next(ASSETS.glob('*'))\n",
    "results = []\n",
    "for size, grid in tests:\n",
    "    elapsed = run_benchmark(sample_image, size, grid)\n",
    "    results.append((size, grid, elapsed))\n",
    "print('Image\tGrid\tLegacy Time (s)')\n",
    "for image, grid, elapsed in results:\n",
    "    print(f'{image}\t{grid}\t{elapsed:.3f}')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cff680e4",
   "metadata": {},
   "source": [
    "## 4. cProfile – Function-Level Hotspots\n",
    "Run `cProfile` on the legacy implementation and store `legacy.prof` for inspection.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "daf13f92",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using cached tiles (200 tiles)\n",
      "         10781 function calls in 0.152 seconds\n",
      "\n",
      "   Ordered by: cumulative time\n",
      "   List reduced from 224 to 15 due to restriction <15>\n",
      "\n",
      "   ncalls  tottime  percall  cumtime  percall filename:lineno(function)\n",
      "        1    0.000    0.000    0.152    0.152 pipeline.py:20(run_full_pipeline)\n",
      "        1    0.001    0.001    0.103    0.103 metrics.py:136(calculate_comprehensive_metrics)\n",
      "        7    0.000    0.000    0.049    0.007 Image.py:2222(resize)\n",
      "        5    0.049    0.010    0.049    0.010 {method 'resize' of 'ImagingCore' objects}\n",
      "        1    0.000    0.000    0.049    0.049 mosaic.py:73(generate_mosaic)\n",
      "        1    0.003    0.003    0.038    0.038 mosaic.py:51(map_tiles_to_grid)\n",
      "        2    0.001    0.001    0.033    0.016 metrics.py:9(calculate_mse)\n",
      "        1    0.001    0.001    0.031    0.031 mosaic.py:142(_find_all_tile_matches_vectorized)\n",
      "        1    0.000    0.000    0.029    0.029 metrics.py:53(calculate_ssim)\n",
      "       16    0.012    0.001    0.027    0.002 utils.py:5(pil_to_np)\n",
      "        1    0.001    0.001    0.025    0.025 metrics.py:86(calculate_color_similarity)\n",
      "        1    0.001    0.001    0.016    0.016 metrics.py:165(calculate_mae)\n",
      "        1    0.000    0.000    0.015    0.015 metrics.py:34(calculate_psnr)\n",
      "        1    0.000    0.000    0.014    0.014 mosaic.py:154(<listcomp>)\n",
      "        1    0.012    0.012    0.014    0.014 tiles.py:315(_calculate_perceptual_distance)\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "def profile_pipeline(pipeline_cls, config, image, outfile):\n",
    "    profiler = cProfile.Profile()\n",
    "    profiler.enable()\n",
    "    pipeline = pipeline_cls(config)\n",
    "    pipeline.run_full_pipeline(image)\n",
    "    profiler.disable()\n",
    "    profiler.dump_stats(outfile)\n",
    "    stats = pstats.Stats(profiler).strip_dirs().sort_stats('cumulative')\n",
    "    stats.print_stats(15)\n",
    "sample_img = Image.open(sample_image).convert('RGB').resize((512, 512))\n",
    "legacy_cfg = LegacyConfig(grid=32, out_w=512, out_h=512, tiles_cache_dir=str(ROOT / 'tile_cache'))\n",
    "profile_pipeline(LegacyPipeline, legacy_cfg, sample_img, str(ROOT / 'legacy.prof'))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b7f06bf",
   "metadata": {},
   "source": [
    "## 5. line_profiler – Line-Level Detail\n",
    "Instrument the slowest legacy functions to pinpoint nested loops and redundant work.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "93059214",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using cached tiles (200 tiles)\n",
      "Timer unit: 1e-09 s\n",
      "\n",
      "Total time: 0.004604 s\n",
      "File: /Users/Teoman/Desktop/Classes/Northeastern/Fall2025/CS5130/assignments/CS5130/lab-5/src/mosaic.py\n",
      "Function: analyze_grid_cells at line 39\n",
      "\n",
      "Line #      Hits         Time  Per Hit   % Time  Line Contents\n",
      "==============================================================\n",
      "    39                                               def analyze_grid_cells(self, image: Image.Image) -> np.ndarray:\n",
      "    40                                                   \"\"\"\n",
      "    41                                                   Step 2: Divide image into grid and analyze each cell using vectorized operations.\n",
      "    42                                                   \"\"\"\n",
      "    43         1     877000.0 877000.0     19.0          img_array = pil_to_np(image)\n",
      "    44                                                   \n",
      "    45                                                   # Always use vectorized operations for better performance\n",
      "    46         1    3727000.0 3.73e+06     81.0          cell_colors = cell_means(img_array, self.config.grid)\n",
      "    47                                                   \n",
      "    48         1          0.0      0.0      0.0          return cell_colors\n",
      "\n",
      "Total time: 0.024555 s\n",
      "File: /Users/Teoman/Desktop/Classes/Northeastern/Fall2025/CS5130/assignments/CS5130/lab-5/src/mosaic.py\n",
      "Function: map_tiles_to_grid at line 51\n",
      "\n",
      "Line #      Hits         Time  Per Hit   % Time  Line Contents\n",
      "==============================================================\n",
      "    51                                               def map_tiles_to_grid(self, cell_colors: np.ndarray) -> np.ndarray:\n",
      "    52                                                   \"\"\"\n",
      "    53                                                   Step 3: Replace each grid cell with corresponding tile.\n",
      "    54                                                   Optimized vectorized version.\n",
      "    55                                                   \"\"\"\n",
      "    56         1       1000.0   1000.0      0.0          grid = self.config.grid\n",
      "    57         1          0.0      0.0      0.0          tile_size = self.config.tile_size\n",
      "    58         1          0.0      0.0      0.0          output_h, output_w = grid * tile_size, grid * tile_size\n",
      "    59                                                   \n",
      "    60                                                   # Vectorized approach - find all matches at once\n",
      "    61         1   20529000.0 2.05e+07     83.6          tile_indices = self._find_all_tile_matches_vectorized(cell_colors)\n",
      "    62                                           \n",
      "    63                                                   # Stack tile bank once and gather the selected tiles in bulk\n",
      "    64         1     448000.0 448000.0      1.8          tile_bank = np.stack(self.tile_manager.tiles, axis=0).astype(np.float32, copy=False)\n",
      "    65         1    1435000.0 1.44e+06      5.8          selected_tiles = tile_bank[tile_indices]  # (grid, grid, tile_size, tile_size, 3)\n",
      "    66         1       1000.0   1000.0      0.0          mosaic_array = (\n",
      "    67         2    2140000.0 1.07e+06      8.7              selected_tiles.transpose(0, 2, 1, 3, 4)\n",
      "    68         1          0.0      0.0      0.0              .reshape(output_h, output_w, 3)\n",
      "    69                                                       .copy()\n",
      "    70                                                   )\n",
      "    71         1       1000.0   1000.0      0.0          return mosaic_array\n",
      "\n",
      "Total time: 0.133746 s\n",
      "File: /Users/Teoman/Desktop/Classes/Northeastern/Fall2025/CS5130/assignments/CS5130/lab-5/src/pipeline.py\n",
      "Function: run_full_pipeline at line 20\n",
      "\n",
      "Line #      Hits         Time  Per Hit   % Time  Line Contents\n",
      "==============================================================\n",
      "    20                                               def run_full_pipeline(self, image: Image.Image) -> Dict:\n",
      "    21                                                   \"\"\"\n",
      "    22                                                   Run the complete mosaic generation pipeline.\n",
      "    23                                                   \n",
      "    24                                                   Args:\n",
      "    25                                                       image: Input PIL Image\n",
      "    26                                                       \n",
      "    27                                                   Returns:\n",
      "    28                                                       Dictionary with all results and metrics\n",
      "    29                                                   \"\"\"\n",
      "    30         1       1000.0   1000.0      0.0          results = {\n",
      "    31         1       1000.0   1000.0      0.0              'input_image': image,\n",
      "    32         1       1000.0   1000.0      0.0              'config': self.config.__dict__.copy(),\n",
      "    33         1       1000.0   1000.0      0.0              'timing': {},\n",
      "    34         1          0.0      0.0      0.0              'metrics': {},\n",
      "    35         1          0.0      0.0      0.0              'outputs': {}\n",
      "    36                                                   }\n",
      "    37                                                   \n",
      "    38                                                   # Generate mosaic\n",
      "    39         1       1000.0   1000.0      0.0          start_time = time.time()\n",
      "    40         1   34502000.0 3.45e+07     25.8          mosaic_img, stats = self.mosaic_generator.generate_mosaic(image)\n",
      "    41         1       1000.0   1000.0      0.0          results['timing'] = stats['processing_time']\n",
      "    42         1       1000.0   1000.0      0.0          results['outputs']['mosaic'] = mosaic_img\n",
      "    43                                                   \n",
      "    44                                                   # Calculate similarity metrics\n",
      "    45         1       1000.0   1000.0      0.0          metrics_start = time.time()\n",
      "    46         1   99111000.0 9.91e+07     74.1          metrics = calculate_comprehensive_metrics(image, mosaic_img)\n",
      "    47         1       1000.0   1000.0      0.0          results['metrics'] = metrics\n",
      "    48         1       6000.0   6000.0      0.0          results['metrics_interpretation'] = interpret_metrics(metrics)\n",
      "    49         1       2000.0   2000.0      0.0          results['timing']['metrics_calculation'] = time.time() - metrics_start\n",
      "    50                                                   \n",
      "    51                                                   # Store additional information\n",
      "    52         1     114000.0 114000.0      0.1          results['outputs']['processed_image'] = self.mosaic_generator.preprocess_image(image)\n",
      "    53         1          0.0      0.0      0.0          results['grid_info'] = {\n",
      "    54         1          0.0      0.0      0.0              'grid_size': self.config.grid,\n",
      "    55         1       1000.0   1000.0      0.0              'tile_size': self.config.tile_size,\n",
      "    56         1       1000.0   1000.0      0.0              'total_tiles': self.config.grid ** 2\n",
      "    57                                                   }\n",
      "    58                                                   \n",
      "    59         1          0.0      0.0      0.0          self.results = results\n",
      "    60         1          0.0      0.0      0.0          return results\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from line_profiler import LineProfiler\n",
    "legacy_pipeline = LegacyPipeline(legacy_cfg)\n",
    "legacy_generator = legacy_pipeline.mosaic_generator\n",
    "lp = LineProfiler()\n",
    "lp.add_function(legacy_generator.analyze_grid_cells)\n",
    "lp.add_function(legacy_generator.map_tiles_to_grid)\n",
    "lp_wrapper = lp(legacy_pipeline.run_full_pipeline)\n",
    "lp_wrapper(sample_img)\n",
    "lp.print_stats()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0c5ba66",
   "metadata": {},
   "source": [
    "### 6. Bottleneck Analysis\n",
    "\n",
    "The profiler runs show that map_tiles_to_grid dominates the legacy runtime. More than 80% of that function’s cost comes from _find_all_tile_matches_vectorized, which loops over every grid cell and compares it to every tile. The second biggest hotspot is analyze_grid_cells, where the old version walks each pixel with nested Python loops. Smaller spikes appear in repeated Image.resize calls and in the metric helpers, but they contribute less than 10% each.\n",
    "\n",
    "From these numbers I focused on two priorities:\n",
    "\n",
    "1. Replace the nested loops in analyze_grid_cells with a NumPy stride view that computes all cell means at once.\n",
    "2. Restructure tile matching so we stack the entire tile bank once, compute distances with pure NumPy, and gather results in bulk instead of looping per cell.\n",
    "\n",
    "These are the areas where optimization would have the largest impact on total runtime.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27c13039",
   "metadata": {},
   "source": [
    "## 7. Before/After Timing Comparison\n",
    "Re-run the same benchmarks twice:\n",
    "1. “Legacy” — monkey-patches `analyze_grid_cells` and `map_tiles_to_grid` back to their original loop-heavy forms.\n",
    "2. “Optimized” — uses the vectorized helpers currently in `lab-5/src`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "c5e762b9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Image\tGrid\tLegacy(s)\tOptimized(s)\tSpeedup\n",
      "Using cached tiles (200 tiles)\n",
      "Using cached tiles (200 tiles)\n",
      "256\t16\t0.063\t0.038\t1.6x\n",
      "Using cached tiles (200 tiles)\n",
      "Using cached tiles (200 tiles)\n",
      "512\t32\t0.149\t0.140\t1.1x\n",
      "Using cached tiles (200 tiles)\n",
      "Using cached tiles (200 tiles)\n",
      "1024\t64\t0.576\t0.542\t1.1x\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from types import MethodType\n",
    "from src.utils import pil_to_np\n",
    "\n",
    "def legacy_cell_means(arr: np.ndarray, grid: int) -> np.ndarray:\n",
    "    H, W, _ = arr.shape\n",
    "    bh, bw = H // grid, W // grid\n",
    "    center_h, center_w = bh // 2, bw // 2\n",
    "    max_dist = (center_h**2 + center_w**2) ** 0.5 or 1.0\n",
    "    weights = np.zeros((bh, bw), dtype=np.float32)\n",
    "    for i in range(bh):\n",
    "        for j in range(bw):\n",
    "            dist = ((i - center_h)**2 + (j - center_w)**2) ** 0.5\n",
    "            weights[i, j] = 1.0 - (dist / max_dist) * 0.5\n",
    "    weights /= weights.sum()\n",
    "    weighted = np.zeros((grid, grid, 3), dtype=np.float32)\n",
    "    for gi in range(grid):\n",
    "        for gj in range(grid):\n",
    "            block = arr[gi*bh:(gi+1)*bh, gj*bw:(gj+1)*bw]\n",
    "            for c in range(3):\n",
    "                weighted[gi, gj, c] = np.sum(block[:, :, c] * weights)\n",
    "    return weighted\n",
    "\n",
    "def legacy_analyze(self, image):\n",
    "    return legacy_cell_means(pil_to_np(image), self.config.grid)\n",
    "\n",
    "def legacy_map(self, cell_colors):\n",
    "    grid, tile_size = self.config.grid, self.config.tile_size\n",
    "    mosaic_array = np.zeros((grid * tile_size, grid * tile_size, 3), dtype=np.float32)\n",
    "    tile_indices = self._find_all_tile_matches_vectorized(cell_colors)\n",
    "    for i in range(grid):\n",
    "        for j in range(grid):\n",
    "            tile_idx = tile_indices[i, j]\n",
    "            tile = self.tile_manager.tiles[tile_idx]\n",
    "            sh, eh = i * tile_size, (i + 1) * tile_size\n",
    "            sw, ew = j * tile_size, (j + 1) * tile_size\n",
    "            mosaic_array[sh:eh, sw:ew] = tile\n",
    "    return mosaic_array\n",
    "\n",
    "def run_variant(image_path: Path, size: int, grid: int, mode: str) -> float:\n",
    "    cfg = LegacyConfig(grid=grid, out_w=size, out_h=size, tiles_cache_dir=str(ROOT / \"tile_cache\"))\n",
    "    pipeline = LegacyPipeline(cfg)\n",
    "    img = Image.open(image_path).convert(\"RGB\").resize((size, size))\n",
    "    if mode == \"legacy\":\n",
    "        generator = pipeline.mosaic_generator\n",
    "        generator.analyze_grid_cells = MethodType(legacy_analyze, generator)\n",
    "        generator.map_tiles_to_grid = MethodType(legacy_map, generator)\n",
    "    start = time.perf_counter()\n",
    "    pipeline.run_full_pipeline(img)\n",
    "    return time.perf_counter() - start\n",
    "\n",
    "print(\"Image\\tGrid\\tLegacy(s)\\tOptimized(s)\\tSpeedup\")\n",
    "for size, grid in tests:\n",
    "    base = run_variant(sample_image, size, grid, \"legacy\")\n",
    "    opt = run_variant(sample_image, size, grid, \"optimized\")\n",
    "    print(f\"{size}\\t{grid}\\t{base:.3f}\\t{opt:.3f}\\t{base/opt:.1f}x\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4bf9bb7b",
   "metadata": {},
   "source": [
    "## 8. Visualization of Timing Data\\n\n",
    "Bar charts and scaling plots for the configurations measured above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "640ddd3d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "times_legacy = np.array([0.063, 0.149, 0.576])\n",
    "times_opt = np.array([0.038, 0.140, 0.542])\n",
    "image_sizes = np.array([256, 512, 1024])\n",
    "grid_sizes = np.array([16, 32, 64])\n",
    "speedup = times_legacy / times_opt\n",
    "fig, ax = plt.subplots(figsize=(6,4))\n",
    "x = np.arange(len(image_sizes))\n",
    "width = 0.35\n",
    "ax.bar(x - width/2, times_legacy, width, label='Lab 1')\n",
    "ax.bar(x + width/2, times_opt, width, label='Lab 5')\n",
    "ax.set_xticks(x)\n",
    "ax.set_xticklabels([f'{s}px / {g}×{g}' for s, g in zip(image_sizes, grid_sizes)])\n",
    "ax.set_ylabel('Time (s)')\n",
    "ax.set_title('Execution Time Comparison')\n",
    "ax.legend()\n",
    "plt.show()\n",
    "fig, ax = plt.subplots(figsize=(6,4))\n",
    "ax.bar(np.arange(len(grid_sizes)), speedup, color='#4daf4a')\n",
    "ax.set_xticks(np.arange(len(grid_sizes)))\n",
    "ax.set_xticklabels([f'{g}×{g}' for g in grid_sizes])\n",
    "ax.set_ylabel('Speedup (×)')\n",
    "ax.set_title('Speedup vs Grid Size')\n",
    "plt.show()\n",
    "fig, ax = plt.subplots(figsize=(6,4))\n",
    "tiles = grid_sizes ** 2\n",
    "ax.plot(tiles, times_legacy, marker='o', label='Lab 1')\n",
    "ax.plot(tiles, times_opt, marker='o', label='Lab 5')\n",
    "ax.set_xlabel('Total Tiles (grid²)')\n",
    "ax.set_ylabel('Time (s)')\n",
    "ax.set_title('Scaling with Tile Count')\n",
    "ax.legend()\n",
    "ax.grid(alpha=0.3)\n",
    "plt.show()\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.9.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}