new

README.md

@@ -11,3 +11,11 @@ short_description: A bulk labelling interface for binary text classification
 
 Check out marimo at <https://github.com/marimo-team/marimo>
 Check out the configuration reference at <https://huggingface.co/docs/hub/spaces-config-reference>
+
+Make sure you set your [access token](https://huggingface.co/blog/password-git-deprecation) before pushing/pulling. 
+
+```bash
+git remote set-url origin https://<user_name>:<token>@huggingface.co/<repo_path>
+git pull origin
+git push origin
+```

app.py

@@ -1,469 +1,291 @@
-import marimo
-
-__generated_with = "0.9.2"
-app = marimo.App()
-
-
-@app.cell
-def __():
-    import marimo as mo
-
-    mo.md("# Welcome to marimo! Updated! 🌊🍃")
-    return (mo,)
+# /// script
+# requires-python = "==3.10"
+# dependencies = [
+#     "marimo",
+#     "polars==1.23.0",
+#     "sentence-transformers==3.4.1",
+#     "umap-learn==0.5.7",
+#     "llvmlite==0.44.0",
+#     "altair==5.5.0",
+#     "scikit-learn==1.6.1",
+#     "numpy==2.1.3",
+#     "mohtml==0.1.2",
+# ]
+# ///
 
+import marimo
 
-@app.cell
-def __(mo):
-    slider = mo.ui.slider(1, 22)
-    return (slider,)
+__generated_with = "0.11.9"
+app = marimo.App(width="medium")
 
 
 @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}
-        """
-    )
+def _(mo):
+    mo.md("""### Bulk labelling demo""")
     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
+def _(mo, use_default_switch):
+    mo.stop(use_default_switch.value)
 
-@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
+    uploaded_file = mo.ui.file(kind="area")
+    uploaded_file
+    return (uploaded_file,)
 
 
-@app.cell(hide_code=True)
-def __(mo):
-    mo.md(
-        """
-        ## 1. Reactive execution
+@app.cell
+def _(mo):
+    use_default_switch = mo.ui.switch(False, label="Use default dataset")
+    use_default_switch
+    return (use_default_switch,)
 
-        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.
+@app.cell
+def _(mo):
+    pos_label = mo.ui.text("pos", placeholder="positive label name")
+    neg_label = mo.ui.text("neg", placeholder="negative label name")
+    return neg_label, pos_label
 
-        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
+def _(mo, pl, uploaded_f7ile, uploaded_file, use_default_switch):
+    mo.stop(not use_default_switch.value and len(uploaded_file.value) == 0 , mo.md("**Submit a dataset or use default one to continue.**"))
 
-@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
+    if use_default_switch.value:
+        df = pl.read_csv("spam.csv")
+    else:
+        df = pl.read_csv(uploaded_f7ile.value[0].contents)
+    
+    texts = df["text"].to_list()
+    return df, texts
 
 
 @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
+def _(SentenceTransformer, mo, texts):
+    with mo.status.spinner(subtitle="Creating embeddings ...") as _spinner:
+        tfm = SentenceTransformer("all-MiniLM-L6-v2")
+        X = tfm.encode(texts)
+    return X, tfm
 
 
-@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
+def _(X, mo):
+    with mo.status.spinner(subtitle="Running UMAP ...") as _spinner:
+        from umap import UMAP
 
+        umap_tfm = UMAP()
+        X_tfm = umap_tfm.fit_transform(X)
+    return UMAP, X_tfm, umap_tfm
 
-@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
+def _(add_label, mo, neg_label, pos_label, undo):
+    btn_spam = mo.ui.button(label=f"Annotate {neg_label.value}", on_click=lambda d: add_label(neg_label.value))
+    btn_ham = mo.ui.button(label=f"Annotate {pos_label.value}", on_click=lambda d: add_label(pos_label.value))
+    btn_undo = mo.ui.button(label="Undo", on_click=lambda d: undo())
+    return btn_ham, btn_spam, btn_undo
 
-@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
+def _(chart, get_label, neg_label, pos_label, set_label):
+    def add_label(lab):
+        current_labels = get_label()
+        if lab == neg_label.value: 
+            new_ham = list(set(current_labels[pos_label.value]).difference(chart.value["index"]))
+            new_spam = list(set(current_labels[neg_label.value]).union(chart.value["index"]))
+        if lab == pos_label.value:
+            new_ham = list(set(current_labels[pos_label.value]).union(chart.value["index"]))
+            new_spam = list(set(current_labels[neg_label.value]).difference(chart.value["index"]))
 
-@app.cell(hide_code=True)
-def __(mo):
-    mo.md(
-        """
-        ## 2. UI elements
+        set_label({neg_label.value: new_spam, pos_label.value: new_ham})
+    return (add_label,)
 
-        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`.
-        """
-    )
+@app.cell
+def _(
+    br,
+    btn_ham,
+    btn_spam,
+    btn_undo,
+    chart,
+    form,
+    json_download,
+    mo,
+    neg_label,
+    pos_label,
+    switch,
+):
+    mo.vstack([
+        mo.md("Assign label names"), 
+        mo.hstack([pos_label, neg_label]),
+        mo.md("Explore the data"),
+        mo.hstack([btn_ham, btn_spam, btn_undo, switch, json_download]),
+        br(),
+        form if switch.value else "", 
+        br() if switch.value else "",
+        chart
+    ])
     return
 
 
 @app.cell
-def __(mo):
-    mo.md("""**🌊 Some UI elements.** Try interacting with the below elements.""")
+def _(chart):
+    chart.value["text"]
     return
 
 
 @app.cell
-def __(mo):
-    icon = mo.ui.dropdown(["🍃", "🌊", "✨"], value="🍃")
-    return (icon,)
+def _(chart, get_label, neg_label, pos_label, set_label):
+    def undo():
+        current_labels = get_label()
+        new_spam = set(current_labels[neg_label.value]).difference(chart.value["index"])
+        new_ham = set(current_labels[pos_label.value]).difference(chart.value["index"])
+        set_label({neg_label.value: list(new_spam), pos_label.value: list(new_ham)})
+    return (undo,)
 
 
 @app.cell
-def __(icon, mo):
-    repetitions = mo.ui.slider(1, 16, label=f"number of {icon.value}: ")
-    return (repetitions,)
+def _():
+    from mohtml import br
+    return (br,)
 
 
 @app.cell
-def __(icon, repetitions):
-    icon, repetitions
+def _(get_label):
+    get_label()
     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
+def _(mo, neg_label, pos_label):
+    get_label, set_label = mo.state({pos_label.value: [], neg_label.value: []})
+    return get_label, set_label
 
 
-@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
+@app.cell
+def _(mo):
+    text_input = mo.ui.text_area(label="Reference sentences")
+    form = mo.md("""{text_input}""").batch(text_input=text_input).form()
+    return form, text_input
 
-        ```
-        marimo edit
-        ```
 
-        in a terminal to start the marimo notebook server. From here
-        you can create a new notebook or edit existing ones.
+@app.cell
+def _(df_emb, labels, mo):
+    from collections import Counter
 
+    with mo.status.spinner(subtitle="Starting UI ...") as _spinner:
+        df_emb
 
-        **Running as apps.** Use
+    Counter(labels)
+    return (Counter,)
 
-        ```
-        marimo run notebook.py
-        ```
 
-        to start a webserver that serves your notebook as an app in read-only mode,
-        with code cells hidden.
+@app.cell
+def _(df_emb, mo, pl):
+    import json
 
-        **Convert a Jupyter notebook.** Convert a Jupyter notebook to a marimo
-        notebook using `marimo convert`:
+    data = df_emb.filter(pl.col("label") != "unlabeled").select("text", "label").to_dicts()
 
-        ```
-        marimo convert your_notebook.ipynb > your_app.py
-        ```
+    json_download = mo.download(
+        data=json.dumps(data).encode("utf-8"),
+        filename="data.json",
+        mimetype="application/json",
+        label="Download JSON",
+    )
+    return data, json, json_download
 
-        **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
+@app.cell
+def _(df_emb, mo, scatter):
+    chart = mo.ui.altair_chart(scatter(df_emb))
+    return (chart,)
 
-        Start a tutorial with `marimo tutorial`; for example,
 
-        ```
-        marimo tutorial dataflow
-        ```
+@app.cell
+def _(mo):
+    switch = mo.ui.switch(False, label="Use search")
+    return (switch,)
 
-        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
+def _(alt, neg_label, pos_label, switch):
+    def scatter(df):
+        return (alt.Chart(df)
+        .mark_circle()
+        .encode(
+            x=alt.X("x:Q"),
+            y=alt.Y("y:Q"),
+            color=alt.Color("sim:Q") if switch.value else alt.Color("label:N", scale=alt.Scale(
+               domain=['unlabeled', pos_label.value, neg_label.value],
+               range=['steelblue', 'green', 'red']
+            ))
+        ).properties(width=500, height=500))
+    return (scatter,)
 
-@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.
-        """
+@app.cell
+def _(
+    X,
+    X_tfm,
+    cosine_similarity,
+    form,
+    get_label,
+    neg_label,
+    np,
+    pl,
+    pos_label,
+    texts,
+    tfm,
+):
+    df_emb = (
+        pl.DataFrame({
+            "x": X_tfm[:, 0], 
+            "y": X_tfm[:, 1], 
+            "index": range(X.shape[0]), 
+            "text": texts
+        }).with_columns(sim=pl.lit(1))
     )
-    return
 
+    if form.value:
+        query = tfm.encode([form.value["text_input"]])
+        similarity = cosine_similarity(query, X)[0]
+        df_emb = df_emb.with_columns(sim=similarity)
 
-@app.cell
-def __(mo, tips):
-    mo.accordion(tips)
-    return
+    spam = set(get_label()[neg_label.value])
+    ham = set(get_label()[pos_label.value])
 
+    labels = []
+    for i in range(df_emb.shape[0]):
+        if i in spam:
+            labels.append(neg_label.value)
+        elif i in ham:
+            labels.append(pos_label.value)
+        else:
+            labels.append("unlabeled")
 
-@app.cell(hide_code=True)
-def __(mo):
-    mo.md("""## Finally, a fun fact""")
-    return
+    df_emb = df_emb.with_columns(label=np.array(labels))
+    return df_emb, ham, i, labels, query, similarity, spam
 
 
-@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.
-        """
+@app.cell
+def _():
+    import marimo as mo
+    import polars as pl
+    from sentence_transformers import SentenceTransformer
+    import altair as alt
+    import numpy as np
+    from sklearn.metrics.pairwise import cosine_similarity
+    from sklearn.linear_model import LogisticRegression
+    return (
+        LogisticRegression,
+        SentenceTransformer,
+        alt,
+        cosine_similarity,
+        mo,
+        np,
+        pl,
     )
-    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__":