Spaces:

arthrod
/

extraction_rankings

Sleeping

App Files Files Community

arthrod commited on Mar 24

Commit

5912687

verified ·

1 Parent(s): 55fbdf9

Update app.py

Browse files

Files changed (1) hide show

app.py +1716 -350

app.py CHANGED Viewed

@@ -1,469 +1,1835 @@
 import marimo
-__generated_with = "0.9.2"
-app = marimo.App()
 @app.cell
-def __():
-    import marimo as mo
-    mo.md("# Welcome to marimo! 🌊🍃")
-    return (mo,)
 @app.cell
-def __(mo):
-    slider = mo.ui.slider(1, 22)
-    return (slider,)
 @app.cell
-def __(mo, slider):
-    mo.md(
-        f"""
-        marimo is a **reactive** Python notebook.
-        This means that unlike traditional notebooks, marimo notebooks **run
-        automatically** when you modify them or
-        interact with UI elements, like this slider: {slider}.
-        {"##" + "🍃" * slider.value}
-        """
     )
     return
-@app.cell(hide_code=True)
-def __(mo):
-    mo.accordion(
-        {
-            "Tip: disabling automatic execution": mo.md(
-                rf"""
-            marimo lets you disable automatic execution: just go into the
-            notebook settings and set
-            "Runtime > On Cell Change" to "lazy".
-            When the runtime is lazy, after running a cell, marimo marks its
-            descendants as stale instead of automatically running them. The
-            lazy runtime puts you in control over when cells are run, while
-            still giving guarantees about the notebook state.
-            """
-            )
-        }
     )
     return
-@app.cell(hide_code=True)
-def __(mo):
-    mo.md(
-        """
-        Tip: This is a tutorial notebook. You can create your own notebooks
-        by entering `marimo edit` at the command line.
-        """
-    ).callout()
     return
-@app.cell(hide_code=True)
-def __(mo):
-    mo.md(
-        """
-        ## 1. Reactive execution
-        A marimo notebook is made up of small blocks of Python code called
-        cells.
-        marimo reads your cells and models the dependencies among them: whenever
-        a cell that defines a global variable  is run, marimo
-        **automatically runs** all cells that reference that variable.
-        Reactivity keeps your program state and outputs in sync with your code,
-        making for a dynamic programming environment that prevents bugs before they
-        happen.
-        """
-    )
     return
-@app.cell(hide_code=True)
-def __(changed, mo):
-    (
-        mo.md(
-            f"""
-            **✨ Nice!** The value of `changed` is now {changed}.
-            When you updated the value of the variable `changed`, marimo
-            **reacted** by running this cell automatically, because this cell
-            references the global variable `changed`.
-            Reactivity ensures that your notebook state is always
-            consistent, which is crucial for doing good science; it's also what
-            enables marimo notebooks to double as tools and  apps.
-            """
-        )
-        if changed
-        else mo.md(
-            """
-            **🌊 See it in action.** In the next cell, change the value of the
-            variable  `changed` to `True`, then click the run button.
-            """
-        )
-    )
     return
 @app.cell
-def __():
-    changed = False
-    return (changed,)
-@app.cell(hide_code=True)
-def __(mo):
-    mo.accordion(
-        {
-            "Tip: execution order": (
-                """
-                The order of cells on the page has no bearing on
-                the order in which cells are executed: marimo knows that a cell
-                reading a variable must run after the cell that  defines it. This
-                frees you to organize your code in the way that makes the most
-                sense for you.
-                """
             )
-        }
-    )
     return
-@app.cell(hide_code=True)
-def __(mo):
-    mo.md(
-        """
-        **Global names must be unique.** To enable reactivity, marimo imposes a
-        constraint on how names appear in cells: no two cells may define the same
-        variable.
-        """
-    )
     return
-@app.cell(hide_code=True)
-def __(mo):
-    mo.accordion(
-        {
-            "Tip: encapsulation": (
-                """
-                By encapsulating logic in functions, classes, or Python modules,
-                you can minimize the number of global variables in your notebook.
-                """
-            )
-        }
-    )
     return
-@app.cell(hide_code=True)
-def __(mo):
-    mo.accordion(
-        {
-            "Tip: private variables": (
-                """
-                Variables prefixed with an underscore are "private" to a cell, so
-                they can be defined by multiple cells.
-                """
-            )
         }
-    )
-    return
-@app.cell(hide_code=True)
-def __(mo):
-    mo.md(
         """
-        ## 2. UI elements
-        Cells can output interactive UI elements. Interacting with a UI
-        element **automatically triggers notebook execution**: when
-        you interact with a UI element, its value is sent back to Python, and
-        every cell that references that element is re-run.
-        marimo provides a library of UI elements to choose from under
-        `marimo.ui`.
         """
-    )
-    return
 @app.cell
-def __(mo):
-    mo.md("""**🌊 Some UI elements.** Try interacting with the below elements.""")
     return
 @app.cell
-def __(mo):
-    icon = mo.ui.dropdown(["🍃", "🌊", "✨"], value="🍃")
-    return (icon,)
 @app.cell
-def __(icon, mo):
-    repetitions = mo.ui.slider(1, 16, label=f"number of {icon.value}: ")
-    return (repetitions,)
 @app.cell
-def __(icon, repetitions):
-    icon, repetitions
     return
 @app.cell
-def __(icon, mo, repetitions):
-    mo.md("# " + icon.value * repetitions.value)
     return
-@app.cell(hide_code=True)
-def __(mo):
-    mo.md(
-        """
-        ## 3. marimo is just Python
-        marimo cells parse Python (and only Python), and marimo notebooks are
-        stored as pure Python files — outputs are _not_ included. There's no
-        magical syntax.
-        The Python files generated by marimo are:
-        - easily versioned with git, yielding minimal diffs
-        - legible for both humans and machines
-        - formattable using your tool of choice,
-        - usable as Python  scripts, with UI  elements taking their default
-        values, and
-        - importable by other modules (more on that in the future).
-        """
-    )
     return
-@app.cell(hide_code=True)
-def __(mo):
-    mo.md(
-        """
-        ## 4. Running notebooks as apps
-        marimo notebooks can double as apps. Click the app window icon in the
-        bottom-right to see this notebook in "app view."
-        Serve a notebook as an app with `marimo run` at the command-line.
-        Of course, you can use marimo just to level-up your
-        notebooking, without ever making apps.
-        """
     )
     return
-@app.cell(hide_code=True)
-def __(mo):
-    mo.md(
-        """
-        ## 5. The `marimo` command-line tool
-        **Creating and editing notebooks.** Use
-        ```
-        marimo edit
-        ```
-        in a terminal to start the marimo notebook server. From here
-        you can create a new notebook or edit existing ones.
-        **Running as apps.** Use
-        ```
-        marimo run notebook.py
-        ```
-        to start a webserver that serves your notebook as an app in read-only mode,
-        with code cells hidden.
-        **Convert a Jupyter notebook.** Convert a Jupyter notebook to a marimo
-        notebook using `marimo convert`:
-        ```
-        marimo convert your_notebook.ipynb > your_app.py
-        ```
-        **Tutorials.** marimo comes packaged with tutorials:
-        - `dataflow`: more on marimo's automatic execution
-        - `ui`: how to use UI elements
-        - `markdown`: how to write markdown, with interpolated values and
-           LaTeX
-        - `plots`: how plotting works in marimo
-        - `sql`: how to use SQL
-        - `layout`: layout elements in marimo
-        - `fileformat`: how marimo's file format works
-        - `markdown-format`: for using `.md` files in marimo
-        - `for-jupyter-users`: if you are coming from Jupyter
-        Start a tutorial with `marimo tutorial`; for example,
-        ```
-        marimo tutorial dataflow
-        ```
-        In addition to tutorials, we have examples in our
-        [our GitHub repo](https://www.github.com/marimo-team/marimo/tree/main/examples).
-        """
-    )
-    return
-@app.cell(hide_code=True)
-def __(mo):
-    mo.md(
-        """
-        ## 6. The marimo editor
-        Here are some tips to help you get started with the marimo editor.
-        """
-    )
     return
 @app.cell
-def __(mo, tips):
-    mo.accordion(tips)
-    return
-@app.cell(hide_code=True)
-def __(mo):
-    mo.md("""## Finally, a fun fact""")
     return
-@app.cell(hide_code=True)
-def __(mo):
-    mo.md(
-        """
-        The name "marimo" is a reference to a type of algae that, under
-        the right conditions, clumps together to form a small sphere
-        called a "marimo moss ball". Made of just strands of algae, these
-        beloved assemblages are greater than the sum of their parts.
-        """
-    )
     return
-@app.cell(hide_code=True)
-def __():
-    tips = {
-        "Saving": (
-            """
-            **Saving**
-            - _Name_ your app using the box at the top of the screen, or
-              with `Ctrl/Cmd+s`. You can also create a named app at the
-              command line, e.g., `marimo edit app_name.py`.
-            - _Save_ by clicking the save icon on the bottom right, or by
-              inputting `Ctrl/Cmd+s`. By default marimo is configured
-              to autosave.
-            """
-        ),
-        "Running": (
-            """
-            1. _Run a cell_ by clicking the play ( ▷ ) button on the top
-            right of a cell, or by inputting `Ctrl/Cmd+Enter`.
-            2. _Run a stale cell_  by clicking the yellow run button on the
-            right of the cell, or by inputting `Ctrl/Cmd+Enter`. A cell is
-            stale when its code has been modified but not run.
-            3. _Run all stale cells_ by clicking the play ( ▷ ) button on
-            the bottom right of the screen, or input `Ctrl/Cmd+Shift+r`.
-            """
-        ),
-        "Console Output": (
-            """
-            Console output (e.g., `print()` statements) is shown below a
-            cell.
-            """
-        ),
-        "Creating, Moving, and Deleting Cells": (
-            """
-            1. _Create_ a new cell above or below a given one by clicking
-                the plus button to the left of the cell, which appears on
-                mouse hover.
-            2. _Move_ a cell up or down by dragging on the handle to the
-                right of the cell, which appears on mouse hover.
-            3. _Delete_ a cell by clicking the trash bin icon. Bring it
-                back by clicking the undo button on the bottom right of the
-                screen, or with `Ctrl/Cmd+Shift+z`.
-            """
-        ),
-        "Disabling Automatic Execution": (
-            """
-            Via the notebook settings (gear icon) or footer panel, you
-            can disable automatic execution. This is helpful when
-            working with expensive notebooks or notebooks that have
-            side-effects like database transactions.
-            """
-        ),
-        "Disabling Cells": (
-            """
-            You can disable a cell via the cell context menu.
-            marimo will never run a disabled cell or any cells that depend on it.
-            This can help prevent accidental execution of expensive computations
-            when editing a notebook.
-            """
-        ),
-        "Code Folding": (
-            """
-            You can collapse or fold the code in a cell by clicking the arrow
-            icons in the line number column to the left, or by using keyboard
-            shortcuts.
-            Use the command palette (`Ctrl/Cmd+k`) or a keyboard shortcut to
-            quickly fold or unfold all cells.
-            """
-        ),
-        "Code Formatting": (
-            """
-            If you have [ruff](https://github.com/astral-sh/ruff) installed,
-            you can format a cell with the keyboard shortcut `Ctrl/Cmd+b`.
-            """
-        ),
-        "Command Palette": (
-            """
-            Use `Ctrl/Cmd+k` to open the command palette.
-            """
-        ),
-        "Keyboard Shortcuts": (
-            """
-            Open the notebook menu (top-right) or input `Ctrl/Cmd+Shift+h` to
-            view a list of all keyboard shortcuts.
-            """
-        ),
-        "Configuration": (
-            """
-           Configure the editor by clicking the gears icon near the top-right
-           of the screen.
-           """
-        ),
-    }
-    return (tips,)
 if __name__ == "__main__":

 import marimo
+__generated_with = "0.11.26"
+app = marimo.App(width="full")
 @app.cell
+def _():
+    import pandas as pd
+    import numpy as np
+    import matplotlib.pyplot as plt
+    import seaborn as sns
+    import altair as alt
+    return alt, np, pd, plt, sns
 @app.cell
+def _(platforms_data):
+    # Complete the platform data with GC AI, Notebook LM, and Vecflow
+    platforms_data.update(
+        {
+            'GC AI': {
+                'metrics': [
+                    {'metric': 'Pass Rate (Arthur)', 'value': 60},
+                    {'metric': 'Pass Rate (Anna)', 'value': 40},
+                    {'metric': 'Helpfulness (Arthur)', 'value': 1.4 * 50},
+                    {'metric': 'Helpfulness (Anna)', 'value': 0.5 * 50},
+                    {'metric': 'Adequate Length (Arthur)', 'value': 1.8 * 50},
+                    {'metric': 'Adequate Length (Anna)', 'value': 1.0 * 50},
+                ],
+                'performance': [
+                    {'task': 'Task #6', 'arthur': 6, 'anna': 0},
+                    {'task': 'Task #13', 'arthur': 0, 'anna': 0},
+                    {'task': 'Task #18', 'arthur': 6, 'anna': 6},
+                    {'task': 'Task #19', 'arthur': 0, 'anna': 0},
+                    {'task': 'Task #20', 'arthur': 6, 'anna': 0},
+                ],
+                'strengths': [
+                    'Good adequate length rating from Arthur',
+                    'Decent pass rate from Arthur (60%)',
+                    'Solid helpfulness score from Arthur',
+                ],
+                'weaknesses': [
+                    'Lowest helpfulness rating from Anna (0.5/2.0)',
+                    'Largest discrepancy between evaluators',
+                    'Lower pass rate from Anna (40%)',
+                ],
+            },
+            'Notebook LM': {
+                'metrics': [
+                    {'metric': 'Pass Rate (Arthur)', 'value': 60},
+                    {'metric': 'Pass Rate (Anna)', 'value': 60},
+                    {'metric': 'Helpfulness (Arthur)', 'value': 0.8 * 50},
+                    {'metric': 'Helpfulness (Anna)', 'value': 1.2 * 50},
+                    {'metric': 'Adequate Length (Arthur)', 'value': 1.6 * 50},
+                    {'metric': 'Adequate Length (Anna)', 'value': 2.0 * 50},
+                ],
+                'performance': [
+                    {'task': 'Task #3', 'arthur': 6, 'anna': 0},
+                    {'task': 'Task #6', 'arthur': 0, 'anna': 0},
+                    {'task': 'Task #11', 'arthur': 0, 'anna': 6},
+                    {'task': 'Task #13', 'arthur': 6, 'anna': 6},
+                    {'task': 'Task #15', 'arthur': 6, 'anna': 6},
+                    {'task': 'Task #19', 'arthur': 6, 'anna': 6},
+                ],
+                'strengths': [
+                    'Perfect agreement between Arthur and Anna on pass/fail',
+                    'Highest adequate length rating from Anna (2.0/2.0)',
+                    'Consistent pass rate between evaluators (60%)',
+                ],
+                'weaknesses': [
+                    'Lower helpfulness rating from Arthur (0.8/2.0)',
+                    'Mixed performance in specific tasks',
+                ],
+            },
+            'Vecflow': {
+                'metrics': [
+                    {'metric': 'Pass Rate (Arthur)', 'value': 60},
+                    {'metric': 'Pass Rate (Anna)', 'value': 40},
+                    {'metric': 'Helpfulness (Arthur)', 'value': 0.6 * 50},
+                    {'metric': 'Helpfulness (Anna)', 'value': 0.6 * 50},
+                    {'metric': 'Adequate Length (Arthur)', 'value': 1.8 * 50},
+                    {'metric': 'Adequate Length (Anna)', 'value': 1.4 * 50},
+                ],
+                'performance': [
+                    {'task': 'Task #11', 'arthur': 0, 'anna': 6},
+                    {'task': 'Task #13', 'arthur': 6, 'anna': 0},
+                    {'task': 'Task #15', 'arthur': 6, 'anna': 0},
+                    {'task': 'Task #18', 'arthur': 6, 'anna': 6},
+                    {'task': 'Task #19', 'arthur': 0, 'anna': 0},
+                ],
+                'strengths': [
+                    'Perfect agreement on helpfulness between evaluators',
+                    'Strong adequate length scores from both evaluators',
+                    'Good performance in specialized tasks',
+                ],
+                'weaknesses': [
+                    'Lowest helpfulness rating overall (0.6/2.0)',
+                    'Lower pass rate from Anna (40%)',
+                    'Inconsistent evaluation on complex tasks',
+                ],
+            },
+        }
+    )
+    return
 @app.cell
+def _():
+    # Platform data
+    platforms_data = {
+        'Chat GPT': {
+            'metrics': [
+                {'metric': 'Pass Rate (Arthur)', 'value': 100},
+                {'metric': 'Pass Rate (Anna)', 'value': 40},
+                {'metric': 'Helpfulness (Arthur)', 'value': 1.5 * 50},  # Scaling to 0-100
+                {'metric': 'Helpfulness (Anna)', 'value': 1.25 * 50},
+                {'metric': 'Adequate Length (Arthur)', 'value': 1.75 * 50},
+                {'metric': 'Adequate Length (Anna)', 'value': 1.25 * 50},
+            ],
+            'performance': [{'task': 'Task #1', 'arthur': 6, 'anna': 0}, {'task': 'Task #3', 'arthur': 6, 'anna': 0}],
+            'strengths': [
+                'High pass rate from Arthur (100%)',
+                'Strong helpfulness ratings from both evaluators',
+                'Good adequate length scores',
+            ],
+            'weaknesses': ['Lower pass rate from Anna (40%)', 'Inconsistent evaluation between Arthur and Anna'],
+        },
+        'CoPilot': {
+            'metrics': [
+                {'metric': 'Pass Rate (Arthur)', 'value': 40},
+                {'metric': 'Pass Rate (Anna)', 'value': 60},
+                {'metric': 'Helpfulness (Arthur)', 'value': 1.0 * 50},
+                {'metric': 'Helpfulness (Anna)', 'value': 1.33 * 50},
+                {'metric': 'Adequate Length (Arthur)', 'value': 1.2 * 50},
+                {'metric': 'Adequate Length (Anna)', 'value': 1.33 * 50},
+            ],
+            'performance': [
+                {'task': 'Task #1', 'arthur': 6, 'anna': 6},
+                {'task': 'Task #11', 'arthur': 0, 'anna': 6},
+                {'task': 'Task #15', 'arthur': 0, 'anna': 0},
+                {'task': 'Task #18', 'arthur': 6, 'anna': 0},
+                {'task': 'Task #20', 'arthur': 0, 'anna': 6},
+            ],
+            'strengths': [
+                'Balanced helpfulness scores from both evaluators',
+                'Consistent adequate length ratings',
+                'Higher pass rate from Anna than from Arthur',
+            ],
+            'weaknesses': ['Lower overall pass rates', 'Inconsistent evaluation between tasks', 'Below-average scores on complex tasks'],
+        },
+        'DeepSeek': {
+            'metrics': [
+                {'metric': 'Pass Rate (Arthur)', 'value': 75},
+                {'metric': 'Pass Rate (Anna)', 'value': 100},
+                {'metric': 'Helpfulness (Arthur)', 'value': 1.33 * 50},
+                {'metric': 'Helpfulness (Anna)', 'value': 2.0 * 50},
+                {'metric': 'Adequate Length (Arthur)', 'value': 2.0 * 50},
+                {'metric': 'Adequate Length (Anna)', 'value': 1.67 * 50},
+            ],
+            'performance': [
+                {'task': 'Task #11', 'arthur': 6, 'anna': 6},
+                {'task': 'Task #13', 'arthur': 6, 'anna': 0},
+                {'task': 'Task #18', 'arthur': 6, 'anna': 6},
+                {'task': 'Task #19', 'arthur': 0, 'anna': 6},
+            ],
+            'strengths': [
+                'Perfect pass rate from Anna (100%)',
+                'Highest helpfulness rating from Anna (2.0/2.0)',
+                'Highest adequate length rating from Arthur (2.0/2.0)',
+                'Strong overall performance across metrics',
+            ],
+            'weaknesses': ['Some inconsistency between evaluators', 'Lower pass rate from Arthur compared to Anna'],
+        },
+    }
+    return (platforms_data,)
+@app.cell
+def _(platforms_data):
+    # Complete the platform data with GC AI, Notebook LM, and Vecflow
+    platforms_data.update(
+        {
+            'GC AI': {
+                'metrics': [
+                    {'metric': 'Pass Rate (Arthur)', 'value': 60},
+                    {'metric': 'Pass Rate (Anna)', 'value': 40},
+                    {'metric': 'Helpfulness (Arthur)', 'value': 1.4 * 50},
+                    {'metric': 'Helpfulness (Anna)', 'value': 0.5 * 50},
+                    {'metric': 'Adequate Length (Arthur)', 'value': 1.8 * 50},
+                    {'metric': 'Adequate Length (Anna)', 'value': 1.0 * 50},
+                ],
+                'performance': [
+                    {'task': 'Task #6', 'arthur': 6, 'anna': 0},
+                    {'task': 'Task #13', 'arthur': 0, 'anna': 0},
+                    {'task': 'Task #18', 'arthur': 6, 'anna': 6},
+                    {'task': 'Task #19', 'arthur': 0, 'anna': 0},
+                    {'task': 'Task #20', 'arthur': 6, 'anna': 0},
+                ],
+                'strengths': [
+                    'Good adequate length rating from Arthur',
+                    'Decent pass rate from Arthur (60%)',
+                    'Solid helpfulness score from Arthur',
+                ],
+                'weaknesses': [
+                    'Lowest helpfulness rating from Anna (0.5/2.0)',
+                    'Largest discrepancy between evaluators',
+                    'Lower pass rate from Anna (40%)',
+                ],
+            },
+            'Notebook LM': {
+                'metrics': [
+                    {'metric': 'Pass Rate (Arthur)', 'value': 60},
+                    {'metric': 'Pass Rate (Anna)', 'value': 60},
+                    {'metric': 'Helpfulness (Arthur)', 'value': 0.8 * 50},
+                    {'metric': 'Helpfulness (Anna)', 'value': 1.2 * 50},
+                    {'metric': 'Adequate Length (Arthur)', 'value': 1.6 * 50},
+                    {'metric': 'Adequate Length (Anna)', 'value': 2.0 * 50},
+                ],
+                'performance': [
+                    {'task': 'Task #3', 'arthur': 6, 'anna': 0},
+                    {'task': 'Task #6', 'arthur': 0, 'anna': 0},
+                    {'task': 'Task #11', 'arthur': 0, 'anna': 6},
+                    {'task': 'Task #13', 'arthur': 6, 'anna': 6},
+                    {'task': 'Task #15', 'arthur': 6, 'anna': 6},
+                    {'task': 'Task #19', 'arthur': 6, 'anna': 6},
+                ],
+                'strengths': [
+                    'Perfect agreement between Arthur and Anna on pass/fail',
+                    'Highest adequate length rating from Anna (2.0/2.0)',
+                    'Consistent pass rate between evaluators (60%)',
+                ],
+                'weaknesses': [
+                    'Lower helpfulness rating from Arthur (0.8/2.0)',
+                    'Mixed performance in specific tasks',
+                ],
+            },
+            'Vecflow': {
+                'metrics': [
+                    {'metric': 'Pass Rate (Arthur)', 'value': 60},
+                    {'metric': 'Pass Rate (Anna)', 'value': 40},
+                    {'metric': 'Helpfulness (Arthur)', 'value': 0.6 * 50},
+                    {'metric': 'Helpfulness (Anna)', 'value': 0.6 * 50},
+                    {'metric': 'Adequate Length (Arthur)', 'value': 1.8 * 50},
+                    {'metric': 'Adequate Length (Anna)', 'value': 1.4 * 50},
+                ],
+                'performance': [
+                    {'task': 'Task #11', 'arthur': 0, 'anna': 6},
+                    {'task': 'Task #13', 'arthur': 6, 'anna': 0},
+                    {'task': 'Task #15', 'arthur': 6, 'anna': 0},
+                    {'task': 'Task #18', 'arthur': 6, 'anna': 6},
+                    {'task': 'Task #19', 'arthur': 0, 'anna': 0},
+                ],
+                'strengths': [
+                    'Perfect agreement on helpfulness between evaluators',
+                    'Strong adequate length scores from both evaluators',
+                    'Good performance in specialized tasks',
+                ],
+                'weaknesses': [
+                    'Lowest helpfulness rating overall (0.6/2.0)',
+                    'Lower pass rate from Anna (40%)',
+                    'Inconsistent evaluation on complex tasks',
+                ],
+            },
+        }
     )
     return
+@app.cell
+def _(pd):
+    # Task type data
+    task_type_data = pd.DataFrame(
+        [
+            {'name': 'Simple Extraction', 'arthur': 80, 'anna': 70},
+            {'name': 'Complex Analysis', 'arthur': 65, 'anna': 60},
+            {'name': 'Regulatory/Legal', 'arthur': 50, 'anna': 40},
+            {'name': 'Identification', 'arthur': 90, 'anna': 75},
+            {'name': 'Summarization', 'arthur': 70, 'anna': 65},
+        ]
     )
+    # Platform performance over time data
+    trend_data = {
+        'Chat GPT': [
+            {'task': 1, 'arthur': 6, 'anna': 0},
+            {'task': 3, 'arthur': 6, 'anna': 0},
+            {'task': 11, 'arthur': 6, 'anna': 0},
+            {'task': 13, 'arthur': 6, 'anna': 6},
+            {'task': 18, 'arthur': 6, 'anna': 6},
+        ],
+        'CoPilot': [
+            {'task': 1, 'arthur': 6, 'anna': 6},
+            {'task': 11, 'arthur': 0, 'anna': 6},
+            {'task': 15, 'arthur': 0, 'anna': 0},
+            {'task': 18, 'arthur': 6, 'anna': 0},
+            {'task': 20, 'arthur': 0, 'anna': 6},
+        ],
+        'DeepSeek': [
+            {'task': 11, 'arthur': 6, 'anna': 6},
+            {'task': 13, 'arthur': 6, 'anna': 0},
+            {'task': 18, 'arthur': 6, 'anna': 6},
+            {'task': 19, 'arthur': 0, 'anna': 6},
+        ],
+        'GC AI': [
+            {'task': 6, 'arthur': 6, 'anna': 0},
+            {'task': 13, 'arthur': 0, 'anna': 0},
+            {'task': 18, 'arthur': 6, 'anna': 6},
+            {'task': 19, 'arthur': 0, 'anna': 0},
+            {'task': 20, 'arthur': 6, 'anna': 0},
+        ],
+        'Notebook LM': [
+            {'task': 3, 'arthur': 6, 'anna': 0},
+            {'task': 6, 'arthur': 0, 'anna': 0},
+            {'task': 11, 'arthur': 0, 'anna': 6},
+            {'task': 13, 'arthur': 6, 'anna': 6},
+            {'task': 15, 'arthur': 6, 'anna': 6},
+            {'task': 19, 'arthur': 6, 'anna': 6},
+        ],
+        'Vecflow': [
+            {'task': 11, 'arthur': 0, 'anna': 6},
+            {'task': 13, 'arthur': 6, 'anna': 0},
+            {'task': 15, 'arthur': 6, 'anna': 0},
+            {'task': 18, 'arthur': 6, 'anna': 6},
+            {'task': 19, 'arthur': 0, 'anna': 0},
+        ],
+    }
+    # Map pass/fail values to binary for plotting
+    mapped_trend_data = {}
+    for platform, data in trend_data.items():
+        mapped_trend_data[platform] = [
+            {'task': item['task'], 'arthur': 1 if item['arthur'] == 6 else 0, 'anna': 1 if item['anna'] == 6 else 0} for item in data
+        ]
+    return data, mapped_trend_data, platform, task_type_data, trend_data
+@app.cell
+def _(alt, mapped_trend_data, pd):
+    def plot_task_performance_interactive(platform_name):
+        """Create an interactive line chart for task performance"""
+        # Convert to DataFrame
+        data = pd.DataFrame(mapped_trend_data[platform_name])
+        # Melt the dataframe for Altair
+        data_melted = data.melt(id_vars=['task'], var_name='evaluator', value_name='result')
+        # Create a color scale
+        color_scale = alt.Scale(domain=['arthur', 'anna'], range=['#4c78a8', '#ff7f0e'])
+        # Create the chart
+        chart = (
+            alt.Chart(data_melted)
+            .mark_line(point=True)
+            .encode(
+                x=alt.X('task:N', title='Task Number'),
+                y=alt.Y(
+                    'result:N', title='Result', scale=alt.Scale(domain=[0, 1]), axis=alt.Axis(labelExpr="datum.value === 0 ? 'Fail' : 'Pass'")
+                ),
+                color=alt.Color('evaluator:N', title='Evaluator', scale=color_scale, legend=alt.Legend(title='Evaluator')),
+                tooltip=['task', 'evaluator', alt.Tooltip('result', title='Result', format='.0f', formatType='number')],
+            )
+            .transform_calculate(result_label="datum.result === 0 ? 'Fail' : 'Pass'")
+            .properties(width=500, height=300, title=f'{platform_name} Task Performance')
+            .configure_title(fontSize=20, anchor='start')
+            .configure_axis(labelFontSize=12, titleFontSize=14)
+            .configure_point(size=100)
+            .interactive()
+        )
+        return chart
+    return (plot_task_performance_interactive,)
+@app.cell
+def _(alt, task_type_data):
+    def plot_task_type_performance_interactive():
+        """Create an interactive bar chart for task type performance"""
+        # Melt the dataframe for Altair
+        task_type_melted = task_type_data.melt(id_vars=['name'], var_name='evaluator', value_name='score')
+        # Create a color scale
+        color_scale = alt.Scale(domain=['arthur', 'anna'], range=['#4c78a8', '#ff7f0e'])
+        # Create the chart
+        chart = (
+            alt.Chart(task_type_melted)
+            .mark_bar()
+            .encode(
+                x=alt.X('name:N', title='Task Type', axis=alt.Axis(labelAngle=-45)),
+                y=alt.Y('score:Q', title='Average Score (%)'),
+                color=alt.Color('evaluator:N', title='Evaluator', scale=color_scale),
+                tooltip=['name', 'evaluator', alt.Tooltip('score', title='Score', format='.0f')],
+            )
+            .properties(width=600, height=400, title='Task Type Performance Analysis')
+            .configure_title(fontSize=20, anchor='start')
+            .configure_axis(labelFontSize=12, titleFontSize=14)
+            .interactive()
+        )
+        return chart
+    return (plot_task_type_performance_interactive,)
+@app.cell
+def _(
+    display_platform_evaluation,
+    platform_summary,
+    plot_platform_radar_interactive,
+    plot_task_performance_interactive,
+):
+    def analyze_platform_interactive(platform_name='DeepSeek'):
+        """Create a comprehensive interactive analysis for a single platform"""
+        from IPython.display import display, HTML, Markdown
+        # Display the platform name
+        display(Markdown(f'# AI Platform In-Depth Analysis: {platform_name}'))
+        # Create the radar chart for metrics
+        display(Markdown('## Performance Metrics'))
+        display(plot_platform_radar_interactive(platform_name))
+        # Show task performance
+        display(Markdown('## Task Performance'))
+        display(plot_task_performance_interactive(platform_name))
+        # Display strengths and weaknesses
+        display(Markdown('## Platform Evaluation'))
+        display_platform_evaluation(platform_name)
+        # Show platform summary
+        display(Markdown('## Platform Summary'))
+        platform_summary(platform_name)
+        return None
+    return (analyze_platform_interactive,)
+@app.cell
+def _(analyze_platform_interactive):
+    # Analyze Vecflow
+    analyze_platform_interactive('Vecflow')
     return
+@app.cell
+def _(analyze_platform_interactive):
+    # Analyze Vecflow
+    analyze_platform_interactive('Vecflow')
     return
+@app.cell
+def _(analyze_platform_interactive):
+    # Analyze Notebook LM
+    analyze_platform_interactive('Notebook LM')
+    return
+@app.cell
+def _(analyze_platform_interactive):
+    # Analyze GC AI
+    analyze_platform_interactive('GC AI')
+    return
+@app.cell
+def _(analyze_platform_interactive):
+    # Analyze CoPilot
+    analyze_platform_interactive('CoPilot')
     return
+@app.cell
+def _(analyze_platform_interactive):
+    # Analyze Chat GPT
+    analyze_platform_interactive('Chat GPT')
+    return
+@app.cell
+def _(analyze_platform_interactive):
+    # Analyze DeepSeek
+    analyze_platform_interactive('DeepSeek')
     return
 @app.cell
+def _(compare_all_platforms_interactive):
+    # Compare all platforms
+    compare_all_platforms_interactive()
+    return
+@app.cell
+def _(
+    compare_platforms_interactive,
+    pd,
+    platforms_data,
+    plot_task_type_performance_interactive,
+):
+    def compare_all_platforms_interactive():
+        """Display interactive comparison of all platforms"""
+        from IPython.display import display, Markdown
+        # Display the title
+        display(Markdown('# AI Platform Comparison'))
+        # Show interactive comparison chart
+        display(Markdown('## Metrics Comparison'))
+        display(compare_platforms_interactive())
+        # Show task type performance
+        display(Markdown('## Task Type Performance'))
+        display(plot_task_type_performance_interactive())
+        # Overall rankings
+        display(Markdown('## Overall Platform Rankings'))
+        # Calculate average metrics for each platform
+        rankings = []
+        for platform, data in platforms_data.items():
+            avg_metrics = sum(metric['value'] for metric in data['metrics']) / len(data['metrics'])
+            rankings.append({'Platform': platform, 'Average Score': avg_metrics})
+        rankings_df = pd.DataFrame(rankings)
+        rankings_df.sort_values('Average Score', ascending=False, inplace=True)
+        # Create a DataFrame to display rankings
+        for i, (idx, row) in enumerate(rankings_df.iterrows(), 1):
+            print(f'{i}. {row["Platform"]} - Average Score: {row["Average Score"]:.2f}')
+        return None
+    return (compare_all_platforms_interactive,)
+@app.cell
+def _(alt, pd, platforms_data):
+    def compare_platforms_interactive():
+        """Create an interactive chart for comparing all platforms"""
+        # Create a DataFrame with all platform metrics
+        metrics_comparison = []
+        for platform, data in platforms_data.items():
+            for metric in data['metrics']:
+                metrics_comparison.append({'Platform': platform, 'Metric': metric['metric'], 'Value': metric['value']})
+        comparison_df = pd.DataFrame(metrics_comparison)
+        # Create a grouped bar chart
+        chart = (
+            alt.Chart(comparison_df)
+            .mark_bar()
+            .encode(
+                x=alt.X('Platform:N', title='Platform'),
+                y=alt.Y('Value:Q', title='Score'),
+                color=alt.Color('Platform:N', legend=None),
+                column=alt.Column('Metric:N', title=None),
+                tooltip=['Platform', 'Metric', 'Value'],
             )
+            .properties(width=100, title='Platform Metric Comparison')
+            .configure_title(fontSize=20, anchor='start')
+            .configure_axis(labelFontSize=12, titleFontSize=14)
+            .interactive()
+        )
+        return chart
+    return (compare_platforms_interactive,)
+@app.cell
+def _(alt, pd, platforms_data):
+    def plot_platform_radar_interactive(platform_name):
+        """Create an interactive radar chart for platform metrics using Altair"""
+        # Get platform metrics data
+        metrics = platforms_data[platform_name]['metrics']
+        # Convert to long format for Altair
+        metrics_df = pd.DataFrame(metrics)
+        # Create the base chart
+        chart = (
+            alt.Chart(metrics_df)
+            .mark_line(point=True)
+            .encode(
+                x=alt.X('metric:N', title=None, sort=None),
+                y=alt.Y('value:Q', scale=alt.Scale(domain=[0, 100]), title='Score'),
+                color=alt.value('#4c78a8'),
+                tooltip=['metric', 'value'],
+            )
+            .properties(width=500, height=400, title=f'{platform_name} Performance Metrics')
+            .configure_title(fontSize=20, anchor='start')
+            .configure_axis(labelFontSize=12, titleFontSize=14)
+            .configure_point(size=100)
+            .interactive()
+        )
+        return chart
+    return (plot_platform_radar_interactive,)
+@app.cell
+def _(alt):
+    alt.renderers.enable('default')
     return
+@app.cell
+def _(compare_all_platforms):
+    # Compare all platforms
+    compare_all_platforms()
     return
+@app.cell
+def _(pd, platforms_data, plot_task_type_performance, plt):
+    def compare_all_platforms():
+        """Display comparison of all platforms"""
+        # Create a DataFrame with all platform metrics for comparison
+        metrics_comparison = []
+        for platform, data in platforms_data.items():
+            # Extract metrics
+            platform_metrics = {metric['metric']: metric['value'] for metric in data['metrics']}
+            platform_metrics['Platform'] = platform
+            metrics_comparison.append(platform_metrics)
+        comparison_df = pd.DataFrame(metrics_comparison)
+        comparison_df.set_index('Platform', inplace=True)
+        # Display the comparison table
+        print('# AI Platform Comparison\n')
+        print('## Metrics Comparison')
+        print(comparison_df)
+        # Create a bar chart to compare platforms
+        plt.figure(figsize=(14, 8))
+        comparison_df.plot(kind='bar', figsize=(14, 8))
+        plt.title('Platform Metrics Comparison')
+        plt.xlabel('Platform')
+        plt.ylabel('Score')
+        plt.legend(title='Metrics', bbox_to_anchor=(1.05, 1), loc='upper left')
+        plt.tight_layout()
+        print('\n## Task Type Performance')
+        plot_task_type_performance()
+        # Overall rankings
+        print('\n## Overall Platform Rankings')
+        # Calculate average metrics for each platform
+        rankings = []
+        for platform, data in platforms_data.items():
+            avg_metrics = sum(metric['value'] for metric in data['metrics']) / len(data['metrics'])
+            rankings.append({'Platform': platform, 'Average Score': avg_metrics})
+        rankings_df = pd.DataFrame(rankings)
+        rankings_df.sort_values('Average Score', ascending=False, inplace=True)
+        # Display rankings
+        for i, (idx, row) in enumerate(rankings_df.iterrows(), 1):
+            print(f'{i}. {row["Platform"]} - Average Score: {row["Average Score"]:.2f}')
+        return plt.gca()
+    return (compare_all_platforms,)
+@app.cell
+def _(compare_all_platforms):
+    # Compare all platforms
+    compare_all_platforms()
     return
+@app.cell
+def _(platforms_data):
+    def platform_summary(platform_name):
+        """Display a summary of the platform performance"""
+        summaries = {
+            'DeepSeek': 'DeepSeek shows the strongest overall performance across both evaluators, with a perfect pass rate from Anna and high marks on both helpfulness and adequate length metrics. It consistently delivers high-quality responses across various task types.',
+            'Chat GPT': "Chat GPT performs excellently according to Arthur with a perfect pass rate, but shows inconsistency with Anna's evaluations. Its strengths lie in helpfulness and adequate response length, particularly in extraction and summarization tasks.",
+            'Notebook LM': 'Notebook LM demonstrates the highest level of evaluator agreement with identical pass rates from Arthur and Anna. It excels in adequate length ratings but scores lower on helpfulness metrics from Arthur.',
+            'CoPilot': 'CoPilot shows moderate performance across metrics with slightly higher ratings from Anna than Arthur. It maintains consistency in adequate length but struggles with more complex analysis tasks.',
+            'GC AI': 'GC AI exhibits the largest discrepancy between evaluator ratings, with Arthur giving significantly higher scores than Anna across all metrics. It performs well in adequate length according to Arthur but scores poorly in helpfulness from Anna.',
+            'Vecflow': 'Vecflow demonstrates perfect agreement on helpfulness ratings between evaluators, though these scores are the lowest across all platforms. It excels in adequate length metrics but shows inconsistent pass rates between evaluators.',
         }
+        # Create tags for the platform
+        tags = []
+        metrics = platforms_data[platform_name]['metrics']
+        tags.append(f'📊 {platform_name}')
+        if metrics[0]['value'] >= 60:
+            tags.append('🟢 High Arthur Pass Rate')
+        if metrics[1]['value'] >= 60:
+            tags.append('🟢 High Anna Pass Rate')
+        if metrics[2]['value'] / 50 >= 1.3:
+            tags.append('🟣 Strong Helpfulness (Arthur)')
+        if metrics[3]['value'] / 50 >= 1.3:
+            tags.append('🟣 Strong Helpfulness (Anna)')
+        if metrics[4]['value'] / 50 >= 1.7:
+            tags.append('🔵 Excellent Length (Arthur)')
+        if metrics[5]['value'] / 50 >= 1.7:
+            tags.append('🔵 Excellent Length (Anna)')
+        if metrics[0]['value'] == metrics[1]['value']:
+            tags.append('🟡 Evaluator Agreement')
+        print(f'== {platform_name} Summary ==\n')
+        print(summaries[platform_name])
+        print('\nTags:')
+        print(' '.join(tags))
+        return None
+    return (platform_summary,)
+@app.cell
+def _(np, platforms_data, plt):
+    def plot_platform_radar(platform_name):
+        """Create a radar chart for platform metrics with enhanced styling"""
+        metrics = platforms_data[platform_name]['metrics']
+        # Extract data
+        categories = [m['metric'] for m in metrics]
+        values = [m['value'] for m in metrics]
+        # Number of categories
+        N = len(categories)
+        # Create angle for each category
+        angles = [n / float(N) * 2 * np.pi for n in range(N)]
+        angles += angles[:1]  # Close the loop
+        # Add the first value at the end to close the circle
+        values += values[:1]
+        # Create figure
+        fig, ax = plt.subplots(figsize=(10, 6), subplot_kw=dict(polar=True), facecolor='#f8f9fa')
+        # Draw the chart
+        ax.plot(angles, values, linewidth=2, linestyle='solid', label=platform_name, color='#8884d8')
+        ax.fill(angles, values, alpha=0.25, color='#8884d8')
+        # Set category labels
+        plt.xticks(angles[:-1], categories, size=10, fontweight='bold', color='#444444')
+        # Set y-axis limits
+        ax.set_ylim(0, 100)
+        # Add grid
+        ax.grid(color='#dddddd', linestyle='-', linewidth=0.5)
+        # Set background color for each level
+        ax.set_facecolor('#f8f9fa')
+        # Add title with platform-specific color
+        platform_colors = {
+            'DeepSeek': '#6b5b95',
+            'Chat GPT': '#3498db',
+            'CoPilot': '#f39c12',
+            'GC AI': '#1abc9c',
+            'Notebook LM': '#e74c3c',
+            'Vecflow': '#9b59b6',
+        }
+        color = platform_colors.get(platform_name, '#8884d8')
+        plt.title(f'{platform_name} Performance Metrics', size=16, fontweight='bold', color=color, pad=20)
+        # Add legend
+        plt.legend(loc='upper right', bbox_to_anchor=(0.1, 0.1), frameon=True, facecolor='white', edgecolor='#dddddd')
+        plt.tight_layout()
+        return plt.gca()
+    return (plot_platform_radar,)
+@app.cell
+def _(mapped_trend_data, pd, plt, sns):
+    def plot_task_performance(platform_name):
+        """Create an enhanced line chart for task performance"""
+        # Convert to DataFrame
+        data = pd.DataFrame(mapped_trend_data[platform_name])
+        # Set a theme
+        sns.set_style('whitegrid')
+        plt.figure(figsize=(10, 6), facecolor='#f8f9fa')
+        # Platform-specific colors
+        platform_colors = {
+            'DeepSeek': ('#6b5b95', '#d64161'),
+            'Chat GPT': ('#3498db', '#1abc9c'),
+            'CoPilot': ('#f39c12', '#e67e22'),
+            'GC AI': ('#1abc9c', '#16a085'),
+            'Notebook LM': ('#e74c3c', '#c0392b'),
+            'Vecflow': ('#9b59b6', '#8e44ad'),
+        }
+        arthur_color, anna_color = platform_colors.get(platform_name, ('#8884d8', '#82ca9d'))
+        # Plot lines with enhanced styling
+        plt.plot(
+            data['task'],
+            data['arthur'],
+            marker='o',
+            markersize=10,
+            linestyle='-',
+            linewidth=2.5,
+            label="Arthur's Evaluation",
+            color=arthur_color,
+            alpha=0.9,
+        )
+        plt.plot(
+            data['task'],
+            data['anna'],
+            marker='s',
+            markersize=10,
+            linestyle='-',
+            linewidth=2.5,
+            label="Anna's Evaluation",
+            color=anna_color,
+            alpha=0.9,
+        )
+        # Customize plot
+        plt.title(f'{platform_name} Task Performance', fontsize=16, fontweight='bold')
+        plt.xlabel('Task Number', fontsize=12, fontweight='bold')
+        plt.ylabel('Result', fontsize=12, fontweight='bold')
+        # Set y-axis to show Pass/Fail instead of 1/0
+        plt.yticks([0, 1], ['Fail', 'Pass'], fontsize=12)
+        # Ensure x-axis shows integer task numbers
+        plt.xticks(data['task'], fontsize=11)
+        plt.grid(True, linestyle='--', alpha=0.7)
+        # Enhanced legend
+        legend = plt.legend(
+            loc='upper center', bbox_to_anchor=(0.5, -0.15), facecolor='white', edgecolor='#dddddd', shadow=True, ncol=2, fontsize=12
+        )
+        # Add a border to the plot
+        ax = plt.gca()
+        for spine in ax.spines.values():
+            spine.set_edgecolor('#dddddd')
+            spine.set_linewidth(1.5)
+        plt.tight_layout()
+        return plt.gca()
+    return (plot_task_performance,)
+@app.cell
+def _(platforms_data):
+    def display_platform_evaluation(platform_name):
+        """Display platform strengths and weaknesses with HTML styling"""
+        strengths = platforms_data[platform_name]['strengths']
+        weaknesses = platforms_data[platform_name]['weaknesses']
+        # Platform-specific color
+        platform_colors = {
+            'DeepSeek': '#6b5b95',
+            'Chat GPT': '#3498db',
+            'CoPilot': '#f39c12',
+            'GC AI': '#1abc9c',
+            'Notebook LM': '#e74c3c',
+            'Vecflow': '#9b59b6',
+        }
+        color = platform_colors.get(platform_name, '#8884d8')
+        html_output = f"""
+        <div style="background-color: #f8f9fa; padding: 20px; border-radius: 10px; border: 1px solid #dddddd; margin: 15px 0;">
+            <h2 style="color: {color}; text-align: center; margin-bottom: 20px; border-bottom: 2px solid {color}; padding-bottom: 10px;">
+                {platform_name} Evaluation
+            </h2>
+            <div style="display: flex; flex-wrap: wrap; gap: 20px;">
+                <div style="flex: 1; min-width: 300px; background-color: white; border-radius: 8px; padding: 15px; border: 1px solid #eaeaea; box-shadow: 0 2px 4px rgba(0,0,0,0.1);">
+                    <h3 style="color: #28a745; margin-bottom: 15px; border-bottom: 1px solid #eaeaea; padding-bottom: 8px;">Key Strengths</h3>
+                    <ul style="list-style-type: none; padding-left: 5px; margin-bottom: 0;">
         """
+        for strength in strengths:
+            html_output += f'<li style="margin-bottom: 10px; display: flex; align-items: center;"><span style="color: #28a745; margin-right: 10px; font-size: 18px;">✅</span> {strength}</li>'
+        html_output += """
+                    </ul>
+                </div>
+                <div style="flex: 1; min-width: 300px; background-color: white; border-radius: 8px; padding: 15px; border: 1px solid #eaeaea; box-shadow: 0 2px 4px rgba(0,0,0,0.1);">
+                    <h3 style="color: #dc3545; margin-bottom: 15px; border-bottom: 1px solid #eaeaea; padding-bottom: 8px;">Areas for Improvement</h3>
+                    <ul style="list-style-type: none; padding-left: 5px; margin-bottom: 0;">
         """
+        for weakness in weaknesses:
+            html_output += f'<li style="margin-bottom: 10px; display: flex; align-items: center;"><span style="color: #dc3545; margin-right: 10px; font-size: 18px;">⚠️</span> {weakness}</li>'
+        html_output += """
+                    </ul>
+                </div>
+            </div>
+        </div>
+        """
+        from IPython.display import HTML, display
+        display(HTML(html_output))
+        return None
+    return (display_platform_evaluation,)
+@app.cell
+def _(np, plt, sns, task_type_data):
+    def plot_task_type_performance():
+        """Create an enhanced bar chart for task type performance"""
+        # Set a theme
+        sns.set_style('whitegrid')
+        plt.figure(figsize=(12, 6), facecolor='#f8f9fa')
+        # Customize colors
+        colors = {'arthur': '#6b5b95', 'anna': '#d64161'}
+        # Set width of bars
+        bar_width = 0.35
+        # Set positions of bars on x-axis
+        x = np.arange(len(task_type_data))
+        # Create bars with enhanced styling
+        plt.bar(
+            x - bar_width / 2,
+            task_type_data['arthur'],
+            bar_width,
+            label="Arthur's Rating",
+            color=colors['arthur'],
+            edgecolor='white',
+            linewidth=1.5,
+            alpha=0.9,
+        )
+        plt.bar(
+            x + bar_width / 2,
+            task_type_data['anna'],
+            bar_width,
+            label="Anna's Rating",
+            color=colors['anna'],
+            edgecolor='white',
+            linewidth=1.5,
+            alpha=0.9,
+        )
+        # Add labels and title with enhanced styling
+        plt.xlabel('Task Type', fontsize=12, fontweight='bold')
+        plt.ylabel('Average Score (%)', fontsize=12, fontweight='bold')
+        plt.title('Task Type Performance Analysis', fontsize=16, fontweight='bold')
+        # Add xticks on the middle of the group bars with better formatting
+        plt.xticks(x, task_type_data['name'], rotation=30, ha='right', fontsize=11, fontweight='bold')
+        # Create enhanced legend
+        legend = plt.legend(
+            loc='upper center', bbox_to_anchor=(0.5, -0.15), facecolor='white', edgecolor='#dddddd', shadow=True, ncol=2, fontsize=12
+        )
+        # Add value labels on top of each bar
+        for i, v in enumerate(task_type_data['arthur']):
+            plt.text(i - bar_width / 2, v + 2, str(v), ha='center', fontsize=9, fontweight='bold')
+        for i, v in enumerate(task_type_data['anna']):
+            plt.text(i + bar_width / 2, v + 2, str(v), ha='center', fontsize=9, fontweight='bold')
+        # Add grid
+        plt.grid(True, linestyle='--', alpha=0.7, axis='y')
+        # Add a border to the plot
+        ax = plt.gca()
+        for spine in ax.spines.values():
+            spine.set_edgecolor('#dddddd')
+            spine.set_linewidth(1.5)
+        # Adjust layout
+        plt.tight_layout()
+        return plt.gca()
+    return (plot_task_type_performance,)
 @app.cell
+def _(
+    display_platform_evaluation,
+    platform_summary,
+    plot_platform_radar,
+    plot_task_performance,
+):
+    def analyze_platform(platform_name='DeepSeek'):
+        """Create a comprehensive analysis for a single platform"""
+        # Display the platform name
+        print(f'# AI Platform In-Depth Analysis: {platform_name}\n')
+        # Create the radar chart for metrics
+        print('## Performance Metrics')
+        plot_platform_radar(platform_name)
+        # Show task performance
+        print('\n## Task Performance')
+        plot_task_performance(platform_name)
+        # Display strengths and weaknesses
+        print('\n## Platform Evaluation')
+        display_platform_evaluation(platform_name)
+        # Show platform summary
+        print('\n## Platform Summary')
+        platform_summary(platform_name)
+        return None
+    return (analyze_platform,)
+@app.cell
+def _(compare_all_platforms):
+    # Compare all platforms
+    compare_all_platforms()
     return
 @app.cell
+def _(platforms_data):
+    def platform_selector():
+        """Prints available platforms and prompt for selection"""
+        print('Available platforms for analysis:')
+        for i, platform in enumerate(platforms_data.keys(), 1):
+            print(f'{i}. {platform}')
+        print('\nTo analyze a platform, run:')
+        print('analyze_platform("platform_name")')
+        print('\nTo compare all platforms, run:')
+        print('compare_all_platforms()')
+        return None
+    # Display available platforms
+    platform_selector()
+    return (platform_selector,)
 @app.cell
+def _(compare_all_platforms):
+    compare_all_platforms()
+    return
 @app.cell
+def _():
     return
 @app.cell
+def _(plot_platform_radar_interactive):
+    # This function appears to be defined but not called
+    plot_platform_radar_interactive('DeepSeek')
     return
+@app.cell
+def _(plot_platform_radar_interactive):
+    # This function appears to be defined but not called
+    plot_platform_radar_interactive('DeepSeek')
+    return
+@app.cell
+def _(compare_all_platforms_interactive):
+    # Execute the compare_all_platforms_interactive function
+    compare_all_platforms_interactive()
+    return
+@app.cell
+def _(platform_selector):
+    # Call platform_selector to display available platforms
+    platform_selector()
     return
+@app.cell
+def _():
+    return
+@app.cell
+def _(pd):
+    import json
+    from IPython.display import HTML, display
+    # Convert the agreement data into a Python structure
+    agreement_data = [
+        {'platform': 'Chat GPT', 'arthurValue': 1.5, 'annaValue': 1.25, 'category': 'Helpfulness'},
+        {'platform': 'CoPilot', 'arthurValue': 1.0, 'annaValue': 1.33, 'category': 'Helpfulness'},
+        {'platform': 'DeepSeek', 'arthurValue': 1.33, 'annaValue': 2.0, 'category': 'Helpfulness'},
+        {'platform': 'GC AI', 'arthurValue': 1.4, 'annaValue': 0.5, 'category': 'Helpfulness'},
+        {'platform': 'Notebook LM', 'arthurValue': 0.8, 'annaValue': 1.2, 'category': 'Helpfulness'},
+        {'platform': 'Vecflow', 'arthurValue': 0.6, 'annaValue': 0.6, 'category': 'Helpfulness'},
+        {'platform': 'Chat GPT', 'arthurValue': 1.75, 'annaValue': 1.25, 'category': 'Adequate Length'},
+        {'platform': 'CoPilot', 'arthurValue': 1.2, 'annaValue': 1.33, 'category': 'Adequate Length'},
+        {'platform': 'DeepSeek', 'arthurValue': 2.0, 'annaValue': 1.67, 'category': 'Adequate Length'},
+        {'platform': 'GC AI', 'arthurValue': 1.8, 'annaValue': 1.0, 'category': 'Adequate Length'},
+        {'platform': 'Notebook LM', 'arthurValue': 1.6, 'annaValue': 2.0, 'category': 'Adequate Length'},
+        {'platform': 'Vecflow', 'arthurValue': 1.8, 'annaValue': 1.4, 'category': 'Adequate Length'},
+    ]
+    # Convert pass/fail agreement data
+    pass_fail_agreement = [
+        {'platform': 'Chat GPT', 'arthur': 100, 'anna': 40, 'agreement': 'Disagree'},
+        {'platform': 'CoPilot', 'arthur': 40, 'anna': 60, 'agreement': 'Disagree'},
+        {'platform': 'DeepSeek', 'arthur': 75, 'anna': 100, 'agreement': 'Disagree'},
+        {'platform': 'GC AI', 'arthur': 60, 'anna': 40, 'agreement': 'Disagree'},
+        {'platform': 'Notebook LM', 'arthur': 60, 'anna': 60, 'agreement': 'Agree'},
+        {'platform': 'Vecflow', 'arthur': 60, 'anna': 40, 'agreement': 'Disagree'},
+    ]
+    # Calculate correlations using pandas for accuracy
+    def calculate_correlations():
+        helpfulness_data = pd.DataFrame([item for item in agreement_data if item['category'] == 'Helpfulness'])
+        adequate_length_data = pd.DataFrame([item for item in agreement_data if item['category'] == 'Adequate Length'])
+        pass_fail_data = pd.DataFrame(pass_fail_agreement)
+        helpfulness_correlation = helpfulness_data['arthurValue'].corr(helpfulness_data['annaValue'])
+        adequate_length_correlation = adequate_length_data['arthurValue'].corr(adequate_length_data['annaValue'])
+        pass_rate_correlation = pass_fail_data['arthur'].corr(pass_fail_data['anna'])
+        return {
+            'helpfulness': round(helpfulness_correlation, 2),
+            'adequate_length': round(adequate_length_correlation, 2),
+            'pass_rate': round(pass_rate_correlation, 2),
+        }
+    correlations = calculate_correlations()
+    return (
+        HTML,
+        agreement_data,
+        calculate_correlations,
+        correlations,
+        display,
+        json,
+        pass_fail_agreement,
     )
+@app.cell
+def _(correlations):
+    correlations
     return
+@app.cell
+def _(
+    agree_count,
+    agreement_data,
+    calculate_average_metrics,
+    correlations,
+    disagree_count,
+    np,
+    pass_fail_agreement,
+    pd,
+    plt,
+):
+    def _():
+        def _():
+            def interactive_evaluator_dashboard():
+                """Display an interactive dashboard for evaluator analysis"""
+                from IPython.display import display, Markdown, HTML
+                # Display header
+                display(
+                    HTML("""
+                <div style="background-color: #f8f9fa; padding: 20px; border-radius: 10px; text-align: center; margin-bottom: 20px;">
+                    <h1 style="color: #333; margin-bottom: 10px;">Evaluator Comparison Analysis</h1>
+                    <p style="font-style: italic; color: #666;">Analyzing differences between Arthur's and Anna's evaluations</p>
+                </div>
+                """)
+                )
+                # Display Agreement Section
+                display(Markdown('## Agreement Overview'))
+                # Create side-by-side visualizations
+                fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(18, 7))
+                # Agreement Pie Chart
+                labels = ['Agreement', 'Disagreement']
+                sizes = [agree_count, disagree_count]
+                colors = ['#4CAF50', '#F44336']
+                explode = (0.1, 0)
+                ax1.pie(
+                    sizes,
+                    explode=explode,
+                    labels=labels,
+                    colors=colors,
+                    autopct='%1.1f%%',
+                    shadow=True,
+                    startangle=140,
+                    textprops={'fontsize': 12, 'fontweight': 'bold'},
+                )
+                ax1.set_title('Evaluator Pass/Fail Agreement', fontsize=16, fontweight='bold')
+                # Average Scores Bar Chart
+                avg_df = calculate_average_metrics()
+                # Set width of bars
+                bar_width = 0.35
+                x = np.arange(len(avg_df))
+                # Create bars
+                ax2.bar(
+                    x - bar_width / 2,
+                    avg_df['Arthur'],
+                    width=bar_width,
+                    label="Arthur's Avg",
+                    color='#8884d8',
+                    edgecolor='white',
+                    linewidth=1.5,
+                )
+                ax2.bar(
+                    x + bar_width / 2, avg_df['Anna'], width=bar_width, label="Anna's Avg", color='#82ca9d', edgecolor='white', linewidth=1.5
+                )
+                # Add data labels
+                for i in range(len(x)):
+                    ax2.text(
+                        x[i] - bar_width / 2,
+                        avg_df['Arthur'][i] + 0.05,
+                        f'{avg_df["Arthur"][i]:.2f}',
+                        ha='center',
+                        va='bottom',
+                        fontweight='bold',
+                        fontsize=10,
+                    )
+                    ax2.text(
+                        x[i] + bar_width / 2,
+                        avg_df['Anna'][i] + 0.05,
+                        f'{avg_df["Anna"][i]:.2f}',
+                        ha='center',
+                        va='bottom',
+                        fontweight='bold',
+                        fontsize=10,
+                    )
+                # Customize plot
+                ax2.set_xlabel('Category', fontsize=12, fontweight='bold')
+                ax2.set_ylabel('Average Score', fontsize=12, fontweight='bold')
+                ax2.set_title('Average Scores by Evaluator', fontsize=16, fontweight='bold')
+                ax2.set_xticks(x)
+                ax2.set_xticklabels(avg_df['Category'], fontsize=12)
+                ax2.set_ylim(0, 2.2)
+                ax2.grid(axis='y', linestyle='--', alpha=0.7)
+                ax2.legend(loc='lower center', bbox_to_anchor=(0.5, -0.25), ncol=2, fontsize=12)
+                plt.tight_layout()
+                display(plt.gcf())
+                plt.close()
+                # Now show correlation analysis
+                display(Markdown('## Correlation Analysis'))
+                # Create correlations chart
+                fig, ax = plt.subplots(figsize=(10, 6))
+                metrics = ['Helpfulness', 'Adequate Length', 'Pass Rate']
+                corr_values = [correlations['helpfulness'], correlations['adequate_length'], correlations['pass_rate']]
+                bars = ax.bar(metrics, corr_values)
+                # Colorize bars based on correlation (positive or negative)
+                for i, bar in enumerate(bars):
+                    if corr_values[i] < 0:
+                        bar.set_color('#F44336')  # red for negative correlation
+                    else:
+                        bar.set_color('#4CAF50')  # green for positive correlation
+                # Add correlation values above/below bars
+                for i, v in enumerate(corr_values):
+                    if v >= 0:
+                        ax.text(i, v + 0.05, f'{v:.2f}', ha='center', fontweight='bold')
+                    else:
+                        ax.text(i, v - 0.1, f'{v:.2f}', ha='center', fontweight='bold')
+                # Add reference line at y=0
+                ax.axhline(y=0, color='black', linestyle='-', alpha=0.3)
+                # Set y-axis limits to show the full range -1 to 1
+                ax.set_ylim(-1.1, 1.1)
+                ax.set_title('Evaluator Correlation Analysis', fontsize=14, fontweight='bold')
+                ax.set_ylabel('Correlation Coefficient', fontsize=12)
+                ax.text(
+                    1,
+                    -0.9,
+                    'Range: -1 to 1, where 1 is perfect positive correlation,\n-1 is perfect negative correlation, and 0 is no correlation',
+                    fontsize=8,
+                    ha='center',
+                    style='italic',
+                )
+                plt.tight_layout()
+                display(plt.gcf())
+                plt.close()
+                # Display scatter plots
+                display(Markdown('## Score Comparison Scatter Plots'))
+                # Create a 1x2 grid for helpfulness and adequate length scatter plots
+                fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(18, 7))
+                # Helpfulness Scatter Plot
+                helpfulness_data = [item for item in agreement_data if item['category'] == 'Helpfulness']
+                x1 = [item['arthurValue'] for item in helpfulness_data]
+                y1 = [item['annaValue'] for item in helpfulness_data]
+                platforms1 = [item['platform'] for item in helpfulness_data]
+                scatter1 = ax1.scatter(x1, y1, c='#8884d8', s=100, alpha=0.7)
+                # Add platform labels
+                for i, platform in enumerate(platforms1):
+                    ax1.annotate(platform, (x1[i], y1[i]), textcoords='offset points', xytext=(0, 10), ha='center')
+                # Add axis labels
+                ax1.set_xlabel("Arthur's Rating", fontsize=12)
+                ax1.set_ylabel("Anna's Rating", fontsize=12)
+                ax1.set_title('Helpfulness Correlation', fontsize=14, fontweight='bold')
+                # Set axis limits
+                ax1.set_xlim(0, 2)
+                ax1.set_ylim(0, 2)
+                # Add perfect correlation line
+                ax1.plot([0, 2], [0, 2], 'k--', alpha=0.3)
+                # Add correlation value text
+                ax1.text(0.1, 1.8, f'Correlation: {correlations["helpfulness"]}', fontsize=12, bbox=dict(facecolor='white', alpha=0.5))
+                ax1.grid(True, linestyle='--', alpha=0.3)
+                # Adequate Length Scatter Plot
+                adequate_length_data = [item for item in agreement_data if item['category'] == 'Adequate Length']
+                x2 = [item['arthurValue'] for item in adequate_length_data]
+                y2 = [item['annaValue'] for item in adequate_length_data]
+                platforms2 = [item['platform'] for item in adequate_length_data]
+                scatter2 = ax2.scatter(x2, y2, c='#82ca9d', s=100, alpha=0.7)
+                # Add platform labels
+                for i, platform in enumerate(platforms2):
+                    ax2.annotate(platform, (x2[i], y2[i]), textcoords='offset points', xytext=(0, 10), ha='center')
+                # Add axis labels
+                ax2.set_xlabel("Arthur's Rating", fontsize=12)
+                ax2.set_ylabel("Anna's Rating", fontsize=12)
+                ax2.set_title('Adequate Length Correlation', fontsize=14, fontweight='bold')
+                # Set axis limits
+                ax2.set_xlim(0, 2)
+                ax2.set_ylim(0, 2)
+                # Add perfect correlation line
+                ax2.plot([0, 2], [0, 2], 'k--', alpha=0.3)
+                # Add correlation value text
+                ax2.text(0.1, 1.8, f'Correlation: {correlations["adequate_length"]}', fontsize=12, bbox=dict(facecolor='white', alpha=0.5))
+                ax2.grid(True, linestyle='--', alpha=0.3)
+                plt.tight_layout()
+                display(plt.gcf())
+                plt.close()
+                # Pass Rate Correlation Scatter Plot
+                display(Markdown('## Pass Rate Comparison'))
+                plt.figure(figsize=(10, 6))
+                x = [item['arthur'] for item in pass_fail_agreement]
+                y = [item['anna'] for item in pass_fail_agreement]
+                platforms = [item['platform'] for item in pass_fail_agreement]
+                colors = ['#4CAF50' if item['agreement'] == 'Agree' else '#F44336' for item in pass_fail_agreement]
+                scatter = plt.scatter(x, y, c=colors, s=100, alpha=0.7)
+                # Add platform labels
+                for i, platform in enumerate(platforms):
+                    plt.annotate(platform, (x[i], y[i]), textcoords='offset points', xytext=(0, 10), ha='center')
+                # Add axis labels
+                plt.xlabel("Arthur's Pass Rate (%)", fontsize=12)
+                plt.ylabel("Anna's Pass Rate (%)", fontsize=12)
+                plt.title('Pass Rate Correlation', fontsize=14, fontweight='bold')
+                # Set axis limits
+                plt.xlim(30, 105)
+                plt.ylim(30, 105)
+                # Add perfect correlation line
+                plt.plot([30, 105], [30, 105], 'k--', alpha=0.3)
+                # Add correlation value text
+                plt.text(35, 95, f'Correlation: {correlations["pass_rate"]}', fontsize=12, bbox=dict(facecolor='white', alpha=0.5))
+                # Add legend
+                from matplotlib.lines import Line2D
+                legend_elements = [
+                    Line2D([0], [0], marker='o', color='w', markerfacecolor='#4CAF50', markersize=10, label='Agreement'),
+                    Line2D([0], [0], marker='o', color='w', markerfacecolor='#F44336', markersize=10, label='Disagreement'),
+                ]
+                plt.legend(handles=legend_elements, loc='upper left')
+                plt.grid(True, linestyle='--', alpha=0.3)
+                plt.tight_layout()
+                display(plt.gcf())
+                plt.close()
+                # Platform-specific differences
+                display(Markdown('## Platform-specific Evaluator Differences'))
+                # Calculate platform differences if not already done
+                if not 'display_df' in globals():
+                    platform_differences = []
+                    for platform in set(item['platform'] for item in agreement_data):
+                        helpfulness = next(
+                            (item for item in agreement_data if item['platform'] == platform and item['category'] == 'Helpfulness'), None
+                        )
+                        adequate_length = next(
+                            (item for item in agreement_data if item['platform'] == platform and item['category'] == 'Adequate Length'), None
+                        )
+                        pass_fail = next((item for item in pass_fail_agreement if item['platform'] == platform), None)
+                        if helpfulness and adequate_length and pass_fail:
+                            helpfulness_diff = helpfulness['arthurValue'] - helpfulness['annaValue']
+                            adequate_length_diff = adequate_length['arthurValue'] - adequate_length['annaValue']
+                            pass_rate_diff = pass_fail['arthur'] - pass_fail['anna']
+            return platform_differences.append(
+                {
+                    'Platform': platform,
+                    'Helpfulness Diff': helpfulness_diff,
+                    'Adequate Length Diff': adequate_length_diff,
+                    'Pass Rate Diff': pass_rate_diff,
+                    'Agreement': pass_fail['agreement'],
+                }
+            )
+        platform_differences = []
+        for platform in set(item['platform'] for item in agreement_data):
+            helpfulness = next((item for item in agreement_data if item['platform'] == platform and item['category'] == 'Helpfulness'), None)
+            adequate_length = next(
+                (item for item in agreement_data if item['platform'] == platform and item['category'] == 'Adequate Length'), None
+            )
+            pass_fail = next((item for item in pass_fail_agreement if item['platform'] == platform), None)
+            if helpfulness and adequate_length and pass_fail:
+                helpfulness_diff = helpfulness['arthurValue'] - helpfulness['annaValue']
+                adequate_length_diff = adequate_length['arthurValue'] - adequate_length['annaValue']
+                pass_rate_diff = pass_fail['arthur'] - pass_fail['anna']
+        return platform_differences.append(
+            {
+                'Platform': platform,
+                'Helpfulness Diff': helpfulness_diff,
+                'Adequate Length Diff': adequate_length_diff,
+                'Pass Rate Diff': pass_rate_diff,
+                'Agreement': pass_fail['agreement'],
+            }
+        )
+        platform_diff_df = pd.DataFrame(platform_differences)
+    _()
+    return
+@app.cell
+def _(correlations, plt):
+    # Creating Correlation Analysis Chart
+    fig, ax = plt.subplots(figsize=(10, 6))
+    metrics = ['Helpfulness', 'Adequate Length', 'Pass Rate']
+    corr_values = [correlations['helpfulness'], correlations['adequate_length'], correlations['pass_rate']]
+    bars = ax.bar(metrics, corr_values, color=['#8884d8', '#82ca9d', '#ff7300'])
+    # Colorize bars based on correlation (positive or negative)
+    for i, bar in enumerate(bars):
+        if corr_values[i] < 0:
+            bar.set_color('#F44336')  # red for negative correlation
+        else:
+            bar.set_color('#4CAF50')  # green for positive correlation
+    # Add correlation values above/below bars
+    for i, v in enumerate(corr_values):
+        if v >= 0:
+            ax.text(i, v + 0.05, f'{v:.2f}', ha='center', fontweight='bold')
+        else:
+            ax.text(i, v - 0.1, f'{v:.2f}', ha='center', fontweight='bold')
+    # Add reference line at y=0
+    ax.axhline(y=0, color='black', linestyle='-', alpha=0.3)
+    # Set y-axis limits to show the full range -1 to 1
+    ax.set_ylim(-1.1, 1.1)
+    # Add labels and title
+    ax.set_title('Evaluator Correlation Analysis', fontsize=14, fontweight='bold')
+    ax.set_ylabel('Correlation Coefficient', fontsize=12)
+    ax.text(
+        1,
+        -0.9,
+        'Range: -1 to 1, where 1 is perfect positive correlation,\n-1 is perfect negative correlation, and 0 is no correlation',
+        fontsize=8,
+        ha='center',
+        style='italic',
+    )
+    plt.tight_layout()
+    return ax, bar, bars, corr_values, fig, i, metrics, v
+@app.cell
+def _(agreement_data, correlations, plt):
+    def _():
+        # Create Helpfulness Correlation Scatter Plot
+        helpfulness_data = [item for item in agreement_data if item['category'] == 'Helpfulness']
+        fig, ax = plt.subplots(figsize=(8, 6))
+        x = [item['arthurValue'] for item in helpfulness_data]
+        y = [item['annaValue'] for item in helpfulness_data]
+        platforms = [item['platform'] for item in helpfulness_data]
+        scatter = ax.scatter(x, y, c='#8884d8', s=100, alpha=0.7)
+        # Add platform labels
+        for i, platform in enumerate(platforms):
+            ax.annotate(platform, (x[i], y[i]), textcoords='offset points', xytext=(0, 10), ha='center')
+        # Add axis labels
+        ax.set_xlabel("Arthur's Rating", fontsize=12)
+        ax.set_ylabel("Anna's Rating", fontsize=12)
+        ax.set_title('Helpfulness Correlation', fontsize=14, fontweight='bold')
+        # Set axis limits
+        ax.set_xlim(0, 2)
+        ax.set_ylim(0, 2)
+        # Add perfect correlation line
+        ax.plot([0, 2], [0, 2], 'k--', alpha=0.3)
+        # Add correlation value text
+        ax.text(0.1, 1.8, f'Correlation: {correlations["helpfulness"]}', fontsize=12, bbox=dict(facecolor='white', alpha=0.5))
+        plt.grid(True, linestyle='--', alpha=0.3)
+        return plt.tight_layout()
+    _()
     return
 @app.cell
+def _(agreement_data, pass_fail_agreement, pd):
+    def _():
+        # Create a DataFrame to show platform-specific differences
+        platform_differences = []
+        for platform in set(item['platform'] for item in agreement_data):
+            helpfulness = next((item for item in agreement_data if item['platform'] == platform and item['category'] == 'Helpfulness'), None)
+            adequate_length = next(
+                (item for item in agreement_data if item['platform'] == platform and item['category'] == 'Adequate Length'), None
+            )
+            pass_fail = next((item for item in pass_fail_agreement if item['platform'] == platform), None)
+            if helpfulness and adequate_length and pass_fail:
+                helpfulness_diff = helpfulness['arthurValue'] - helpfulness['annaValue']
+                adequate_length_diff = adequate_length['arthurValue'] - adequate_length['annaValue']
+                pass_rate_diff = pass_fail['arthur'] - pass_fail['anna']
+        return platform_differences.append(
+            {
+                'Platform': platform,
+                'Helpfulness Diff': helpfulness_diff,
+                'Adequate Length Diff': adequate_length_diff,
+                'Pass Rate Diff': pass_rate_diff,
+                'Agreement': pass_fail['agreement'],
+            }
+        )
+        platform_diff_df = pd.DataFrame(platform_differences)
+        # Display platform differences
+        platform_diff_df['Helpfulness Diff'] = platform_diff_df['Helpfulness Diff'].round(1)
+        platform_diff_df['Adequate Length Diff'] = platform_diff_df['Adequate Length Diff'].round(1)
+        platform_diff_df['Pass Rate Diff'] = platform_diff_df['Pass Rate Diff'].astype(int)
+        def style_diff(val):
+            if val > 0:
+                return f'Arthur +{abs(val)}'
+            elif val < 0:
+                return f'Anna +{abs(val)}'
+            else:
+                return 'Equal'
+        # Apply styling and display the data
+        styled_platform_diff = platform_diff_df.copy()
+        styled_platform_diff['Helpfulness'] = styled_platform_diff['Helpfulness Diff'].apply(style_diff)
+        styled_platform_diff['Adequate Length'] = styled_platform_diff['Adequate Length Diff'].apply(style_diff)
+        styled_platform_diff['Pass Rate'] = styled_platform_diff['Pass Rate Diff'].apply(style_diff)
+        display_cols = ['Platform', 'Helpfulness', 'Adequate Length', 'Pass Rate', 'Agreement']
+        display_df = styled_platform_diff[display_cols]
+    _()
     return
+@app.cell
+def _(calculate_average_metrics, np, plt):
+    def plot_average_scores():
+        """Plot the average scores for each category by evaluator"""
+        # Get average data
+        avg_df = calculate_average_metrics()
+        # Set up plot
+        plt.figure(figsize=(10, 6))
+        # Set width of bars
+        bar_width = 0.35
+        x = np.arange(len(avg_df))
+        # Create bars
+        plt.bar(
+            x - bar_width / 2,
+            avg_df['Arthur'],
+            width=bar_width,
+            label="Arthur's Avg. Score",
+            color='#8884d8',
+            alpha=0.8,
+            edgecolor='white',
+            linewidth=1.5,
+        )
+        plt.bar(
+            x + bar_width / 2,
+            avg_df['Anna'],
+            width=bar_width,
+            label="Anna's Avg. Score",
+            color='#82ca9d',
+            alpha=0.8,
+            edgecolor='white',
+            linewidth=1.5,
+        )
+        # Add data labels
+        for i in range(len(x)):
+            plt.text(
+                x[i] - bar_width / 2,
+                avg_df['Arthur'][i] + 0.05,
+                f'{avg_df["Arthur"][i]:.2f}',
+                ha='center',
+                va='bottom',
+                color='#333',
+                fontweight='bold',
+            )
+            plt.text(
+                x[i] + bar_width / 2,
+                avg_df['Anna'][i] + 0.05,
+                f'{avg_df["Anna"][i]:.2f}',
+                ha='center',
+                va='bottom',
+                color='#333',
+                fontweight='bold',
+            )
+        # Customize plot
+        plt.xlabel('Evaluation Category', fontsize=12, fontweight='bold')
+        plt.ylabel('Average Score (0-2 scale)', fontsize=12, fontweight='bold')
+        plt.title('Average Scores by Evaluator', fontsize=14, fontweight='bold')
+        plt.xticks(x, avg_df['Category'], fontsize=11)
+        plt.ylim(0, 2.2)  # Set reasonable y-axis limit
+        plt.legend(loc='upper center', bbox_to_anchor=(0.5, -0.15), shadow=True, ncol=2)
+        plt.grid(axis='y', linestyle='--', alpha=0.7)
+        # Add a border to the plot
+        ax = plt.gca()
+        for spine in ax.spines.values():
+            spine.set_edgecolor('#dddddd')
+            spine.set_linewidth(1.5)
+        plt.tight_layout()
+        return plt.gca()
+    return (plot_average_scores,)
+@app.cell
+def _(agreement_data, pass_fail_agreement, pd):
+    def calculate_average_metrics():
+        """Calculate average metrics for each evaluator and category"""
+        # Process helpfulness data
+        helpfulness_data = [item for item in agreement_data if item['category'] == 'Helpfulness']
+        arthur_helpfulness = sum(item['arthurValue'] for item in helpfulness_data) / len(helpfulness_data)
+        anna_helpfulness = sum(item['annaValue'] for item in helpfulness_data) / len(helpfulness_data)
+        # Process adequate length data
+        adequate_length_data = [item for item in agreement_data if item['category'] == 'Adequate Length']
+        arthur_adequate = sum(item['arthurValue'] for item in adequate_length_data) / len(adequate_length_data)
+        anna_adequate = sum(item['annaValue'] for item in adequate_length_data) / len(adequate_length_data)
+        # Create DataFrame with results
+        avg_df = pd.DataFrame(
+            {
+                'Category': ['Helpfulness', 'Adequate Length'],
+                'Arthur': [arthur_helpfulness, arthur_adequate],
+                'Anna': [anna_helpfulness, anna_adequate],
+            }
+        )
+        return avg_df
+    # Count agreement vs disagreement
+    agree_count = sum(1 for item in pass_fail_agreement if item['agreement'] == 'Agree')
+    disagree_count = sum(1 for item in pass_fail_agreement if item['agreement'] == 'Disagree')
+    return agree_count, calculate_average_metrics, disagree_count
+@app.cell
+def _(plot_average_scores):
+    plot_average_scores()
     return
+@app.cell
+def _(agree_count, ax, calculate_average_metrics, disagree_count, np, plt):
+    def interactive_evaluator_dashboard():
+        """Display an interactive dashboard for evaluator analysis"""
+        from IPython.display import display, Markdown, HTML
+        # Display header
+        display(
+            HTML("""
+        <div style="background-color: #f8f9fa; padding: 20px; border-radius: 10px; text-align: center; margin-bottom: 20px;">
+            <h1 style="color: #333; margin-bottom: 10px;">Evaluator Comparison Analysis</h1>
+            <p style="font-style: italic; color: #666;">Analyzing differences between Arthur's and Anna's evaluations</p>
+        </div>
+        """)
+        )
+        # Display Agreement Section
+        display(Markdown('## Agreement Overview'))
+        # Create side-by-side visualizations
+        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(18, 7))
+        # Agreement Pie Chart
+        labels = ['Agreement', 'Disagreement']
+        sizes = [agree_count, disagree_count]
+        colors = ['#4CAF50', '#F44336']
+        explode = (0.1, 0)
+        ax1.pie(
+            sizes,
+            explode=explode,
+            labels=labels,
+            colors=colors,
+            autopct='%1.1f%%',
+            shadow=True,
+            startangle=140,
+            textprops={'fontsize': 12, 'fontweight': 'bold'},
+        )
+        ax1.set_title('Evaluator Pass/Fail Agreement', fontsize=16, fontweight='bold')
+        # Average Scores Bar Chart
+        avg_df = calculate_average_metrics()
+        # Set width of bars
+        bar_width = 0.35
+        x = np.arange(len(avg_df))
+        # Create bars
+        ax2.bar(x - bar_width / 2, avg_df['Arthur'], width=bar_width, label="Arthur's Avg", color='#8884d8', edgecolor='white', linewidth=1.5)
+        ax2.bar(x + bar_width / 2, avg_df['Anna'], width=bar_width, label="Anna's Avg", color='#82ca9d', edgecolor='white', linewidth=1.5)
+        # Add data labels
+        for i in range(len(x)):
+            ax2.text(
+                x[i] - bar_width / 2,
+                avg_df['Arthur'][i] + 0.05,
+                f'{avg_df["Arthur"][i]:.2f}',
+                ha='center',
+                va='bottom',
+                fontweight='bold',
+                fontsize=10,
+            )
+            ax2.text(
+                x[i] + bar_width / 2,
+                avg_df['Anna'][i] + 0.05,
+                f'{avg_df["Anna"][i]:.2f}',
+                ha='center',
+                va='bottom',
+                fontweight='bold',
+                fontsize=10,
+            )
+        # Customize plot
+        ax2.set_xlabel('Category', fontsize=12, fontweight='bold')
+        ax2.set_ylabel('Average Score', fontsize=12, fontweight='bold')
+        ax
+    return (interactive_evaluator_dashboard,)
+@app.cell
+def _(interactive_evaluator_dashboard):
+    interactive_evaluator_dashboard()
+    return
 if __name__ == "__main__":