Added files

Dockerfile

@@ -1,16 +1,16 @@
-FROM python:3.12
-COPY --from=ghcr.io/astral-sh/uv:0.4.20 /uv /bin/uv
-
-RUN useradd -m -u 1000 user
-ENV PATH="/home/user/.local/bin:$PATH"
-ENV UV_SYSTEM_PYTHON=1
-
-WORKDIR /app
-
-COPY --chown=user ./requirements.txt requirements.txt
-RUN uv pip install -r requirements.txt
-
-COPY --chown=user . /app
-USER user
-
-CMD ["marimo", "run", "app.py", "--host", "0.0.0.0", "--port", "7860"]
+FROM python:3.12
+COPY --from=ghcr.io/astral-sh/uv:0.4.20 /uv /bin/uv
+
+RUN useradd -m -u 1000 user
+ENV PATH="/home/user/.local/bin:$PATH"
+ENV UV_SYSTEM_PYTHON=1
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN uv pip install -r requirements.txt
+
+COPY --chown=user . /app
+USER user
+
+CMD ["marimo", "run", "app.py", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,13 +1,13 @@
----
-title: Political Ideology
-emoji: 🍃
-colorFrom: indigo
-colorTo: purple
-sdk: docker
-pinned: true
-license: mit
-short_description: Political Ideology Analysis
----
-
-Check out marimo at <https://github.com/marimo-team/marimo>
-Check out the configuration reference at <https://huggingface.co/docs/hub/spaces-config-reference>
+---
+title: marimo app template
+emoji: 🍃
+colorFrom: indigo
+colorTo: purple
+sdk: docker
+pinned: true
+license: mit
+short_description: Template for deploying a marimo application to HF
+---
+
+Check out marimo at <https://github.com/marimo-team/marimo>
+Check out the configuration reference at <https://huggingface.co/docs/hub/spaces-config-reference>

app.py

@@ -1,470 +1,329 @@
-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__":
-    app.run()
+import marimo
+
+__generated_with = "0.9.14"
+app = marimo.App(width="full")
+
+
+@app.cell(hide_code=True)
+def __(mo):
+    mo.md(
+        """
+        # Political Ideologies Analysis
+
+        This project provides a detailed analysis of political ideologies using data from the Huggingface Political Ideologies dataset. The code leverages various data science libraries and visualization tools to map, analyze, and visualize political ideology text data.
+        Project Structure
+
+        This analysis is based on huggingface dataset repository. <br>
+        You can visit right [here](https://huggingface.co/datasets/JyotiNayak/political_ideologies)
+        """
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def __():
+    import marimo as mo
+    import pandas as pd
+    import numpy as np
+
+    import matplotlib.pyplot as plt
+    import seaborn as sns
+    import altair as alt
+
+    from gensim.models import Word2Vec
+    from sklearn.manifold import TSNE
+
+    mo.md("""
+    ## 1. Import all libraries needed
+
+    The initial cells import the necessary libraries for data handling, visualization, and word embedding.
+    """)
+    return TSNE, Word2Vec, alt, mo, np, pd, plt, sns
+
+
+@app.cell(hide_code=True)
+def __(mo):
+    mo.md(
+        """
+        Here are the mapped of label and issue type columns.
+
+        ```yaml
+        Label Mapping: {'conservative': 0, 'liberal': 1 }
+        Issue Type Mapping: {
+            'economic': 0, 'environmental': 1,
+            'family/gender': 2, 'geo-political and foreign policy': 3,
+            'political': 4, 'racial justice and immigration': 5,
+            'religious': 6, 'social, health and education': 7
+        }
+        ```
+        """
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def __(mo, pd):
+    df = pd.concat(
+        [pd.read_parquet(f'{name}.parquet') for name in ['train', 'val', 'test']], 
+        axis=0,
+    )
+
+    df = df.drop('__index_level_0__', axis=1)
+
+    mo.md("""
+    ## 2. Dataset Loading
+
+    The dataset files (`train.parquet`, `val.parquet`, and `test.parquet`) are loaded, concatenated, and cleaned to form a single DataFrame (df). Columns are mapped to readable labels for ease of understanding.
+    """)
+    return (df,)
+
+
+@app.cell(hide_code=True)
+def __():
+    label_mapping = {
+        'conservative': 0, 
+        'liberal': 1
+    }
+
+    issue_type_mapping = {
+        'economic': 0,
+        'environmental': 1,
+        'family/gender': 2,
+        'geo-political and foreign policy': 3,
+        'political': 4,
+        'racial justice and immigration': 5,
+        'religious': 6,
+        'social, health and education': 7
+    }
+    return issue_type_mapping, label_mapping
+
+
+@app.cell(hide_code=True)
+def __(issue_type_mapping, label_mapping):
+    label_mapping_reversed = {v: k for k, v in label_mapping.items()}
+    issue_type_mapping_reversed = {v: k for k, v in issue_type_mapping.items()}
+
+    print(label_mapping_reversed)
+    print(issue_type_mapping_reversed)
+    return issue_type_mapping_reversed, label_mapping_reversed
+
+
+@app.cell(hide_code=True)
+def __(df, issue_type_mapping_reversed, label_mapping_reversed, mo):
+    df['label_text'] = df['label'].replace(label_mapping_reversed)
+    df['issue_type_text'] = df['issue_type'].replace(issue_type_mapping_reversed)
+
+    labels_grouped = df['label_text'].value_counts().rename_axis('label_text').reset_index(name='counts')
+    issue_types_grouped = (
+        df["issue_type_text"]
+        .value_counts()
+        .rename_axis("issue_type_text")
+        .reset_index(name="counts")
+    )
+
+    mo.md("""
+    ## 3. Mapping Labels and Issue Types
+
+    Two dictionaries map labels (conservative and liberal) and issue types (e.g., economic, environmental, etc.) to numerical values for machine learning purposes. Reversed mappings are created to convert numerical labels back into their text form.
+    """)
+    return issue_types_grouped, labels_grouped
+
+
+@app.cell(hide_code=True)
+def __(df):
+    df.iloc[:, :6].head(7)
+    return
+
+
+@app.cell(hide_code=True)
+def __(mo):
+    mo.md(
+        """
+        ## 4. Visualizing Data Distributions
+
+        Bar plots visualize the proportions of conservative vs. liberal ideologies and the count of different issue types. These provide an overview of the dataset composition.
+        """
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def __(alt, labels_grouped, mo):
+    mo.ui.altair_chart(
+        alt.Chart(labels_grouped).mark_bar(
+            fill='#4C78A8',
+            cursor='pointer',
+        ).encode(
+            x=alt.X('label_text', axis=alt.Axis(labelAngle=0)),
+            y='counts:Q'
+        )
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def __(alt, issue_types_grouped, mo):
+    mo.ui.altair_chart(
+        alt.Chart(issue_types_grouped)
+        .mark_bar(
+            fill="#4C78A8",
+            cursor="pointer",
+        )
+        .encode(
+            x=alt.X(
+                "issue_type_text:O",
+                axis=alt.Axis(
+                    labelAngle=-10, labelAlign="center", labelPadding=10
+                ),
+            ),
+            y="counts:Q",
+        )
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def __(mo):
+    mo.md(
+        """
+        ## 5. Word Embedding with Word2Vec
+
+        Using Word2Vec, word embeddings are created from text statements in the dataset. The model trains on tokenized sentences, generating a 100-dimensional embedding for each word. Statements are averaged to form document-level embeddings.
+        """
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def __(Word2Vec, df):
+    df['tokens'] = df['statement'].apply(lambda x: x.lower().split())
+    word2vec_model = Word2Vec(sentences=df['tokens'], vector_size=100, window=5, min_count=1, seed=0)
+    return (word2vec_model,)
+
+
+@app.cell(hide_code=True)
+def __(np, word2vec_model):
+    def get_doc_embedding(tokens):
+        vectors = [word2vec_model.wv[word] for word in tokens if word in word2vec_model.wv]
+        if vectors:
+            return np.mean(vectors, axis=0)
+        else:
+            return np.zeros(word2vec_model.vector_size)
+    return (get_doc_embedding,)
+
+
+@app.cell(hide_code=True)
+def __(df, get_doc_embedding, np):
+    df['embedding'] = df['tokens'].apply(get_doc_embedding)
+    embeddings_matrix = np.vstack(df['embedding'].values)
+    return (embeddings_matrix,)
+
+
+@app.cell(hide_code=True)
+def __(mo):
+    mo.md(
+        """
+        ## 6. Dimensionality Reduction with TSNE
+
+        Embeddings are projected into a 2D space using TSNE for visualization. The embeddings are colored by issue type, showing clusters of similar statements.
+        """
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def __(TSNE, alt, df, embeddings_matrix, plt, sns):
+    tsne = TSNE(n_components=2, random_state=0)
+    tsne_results = tsne.fit_transform(embeddings_matrix)
+    df['x'] = tsne_results[:, 0]
+    df['y'] = tsne_results[:, 1]
+
+    # Brush for selection
+    brush = alt.selection_interval()
+    size = 350
+
+    plt.figure(figsize=(10, 6))
+    sns.scatterplot(data=df, x='x', y='y', hue='issue_type_text', palette='Set1', s=100)
+    plt.title("2D Visualization of Text Data by Ideology (Word2Vec Embeddings)")
+    plt.xlabel("t-SNE Dimension 1")
+    plt.ylabel("t-SNE Dimension 2")
+    plt.legend(title='Ideology')
+    plt.show()
+    return brush, size, tsne, tsne_results
+
+
+@app.cell(hide_code=True)
+def __(mo):
+    mo.md(
+        """
+        ## 7. Interactive Visualizations
+
+        Interactive scatter plots in Altair show ideology and issue types in 2D space. A brush selection tool allows users to explore specific points and view tooltip information.
+
+        ### Combined Scatter Plot
+
+        Combines the two scatter plots into a side-by-side visualization for direct comparison of ideologies vs. issue types.
+        Running the Code
+
+        Run the code using the marimo.App instance. This notebook can also be run as a standalone Python script:
+        """
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def __(alt, brush, df, mo, size):
+    points1 = alt.Chart(df, height=size, width=size).mark_point().encode(
+        x='x:Q',
+        y='y:Q',
+        color=alt.condition(brush, 'label_text', alt.value('grey')),
+        tooltip=['x:Q', 'y:Q', 'statement:N', 'label_text:N'] 
+    ).add_params(brush).properties(title='By Political Ideologies')
+
+    scatter_chart1 = mo.ui.altair_chart(points1)
+
+    points2 = alt.Chart(df, height=size, width=size).mark_point().encode(
+        x='x:Q',
+        y='y:Q',
+        color=alt.condition(brush, 'issue_type_text', alt.value('grey')),
+        tooltip=['x:Q', 'y:Q', 'statement:N', 'issue_type:N'] 
+    ).add_params(brush).properties(title='By Issue Types')
+
+    scatter_chart2 = mo.ui.altair_chart(points2)
+
+    combined_chart = (scatter_chart1 | scatter_chart2)
+    combined_chart
+    return combined_chart, points1, points2, scatter_chart1, scatter_chart2
+
+
+@app.cell(hide_code=True)
+def __(combined_chart):
+    combined_chart.value[['statement', 'label_text', 'issue_type_text']]
+    return
+
+
+@app.cell(hide_code=True)
+def __(combined_chart):
+    combined_chart.value['statement']
+    return
+
+
+@app.cell(hide_code=True)
+def __(mo):
+    mo.md(
+        r"""
+        ## Data Insights
+
+        - Ideology Distribution: Visualizes proportions of conservative and liberal ideologies.
+        - Issue Types: Bar plot reveals the diversity and frequency of issue types in the dataset.
+        - Word Embeddings: Using TSNE for 2D projections helps identify clusters in political statements.
+        - Interactive Exploration: Offers detailed, interactive views on ideology vs. issue type distribution.
+
+        This code provides a thorough analysis pipeline, from data loading to interactive visualizations, enabling an in-depth exploration of political ideologies.
+        """
+    )
+    return
+
+
+if __name__ == "__main__":
+    app.run()

development.md

@@ -1,8 +1,8 @@
-# Development
-
-## Testing your Dockerfile locally
-
-```bash
-docker build -t marimo-app .
-docker run -it --rm -p 7860:7860 marimo-app
-```
+# Development
+
+## Testing your Dockerfile locally
+
+```bash
+docker build -t marimo-app .
+docker run -it --rm -p 7860:7860 marimo-app
+```

requirements.txt

@@ -1,5 +1,15 @@
-marimo
-# Or a specific version
-# marimo>=0.9.0
-
-# Add other dependencies as needed
+marimo
+pandas
+numpy
+
+matplotlib
+seaborn
+altair
+
+genism
+scikit-learn
+
+# Or a specific version
+# marimo>=0.9.0
+
+# Add other dependencies as needed

test.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:456a6384233fbbabd92593dc17ff9b5aec305a51a63aea36c621c0142c2d0ac3
+size 71633

train.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a81fd1847b0a8b57e908bf8e03bc0e020c8f876aedbed45126a17af89adae18e
+size 552587

val.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:20dc1daddb20ac5749d4984e9685bbc9e96e1d5d44afec5a144e3acfcf5d7f9e
+size 75360