Lodestar: Interactive Data Science Notebook

• Lodestar is an interactive computational notebook that automates data science workflows by appending ready-to-run code cells with explanations and outputs.
• The system builds directed recommendation graphs from expert tutorials and over 6,000 public notebooks to model probabilistic transitions between analysis stages.
• It bridges analysis intent and execution by coupling pedagogical guidance with interactive notebook cells, enabling independent learning and rapid experimentation.

Searching arXiv for the specified Lodestar paper and related context. arxiv_search query: (Raghunandan et al., 2022) arxiv_search query: Lodestar Supporting Independent Learning and Rapid Experimentation Through Data-Driven Analysis Recommendations Lodestar is an interactive computational notebook for data science that supports rapid workflow construction and independent learning by presenting ranked, automated recommendations for the next analysis step as ready-to-run code cells. Its central design premise is to bridge high-level analysis intent and low-level executable code: each selected step is appended as a notebook cell with the exact Python code, a short explanation, visual or analytic output, and a provenance-style record of progress. The system derives its recommendations from directed graphs of analysis states built from two sources—manually curated online tutorials and semi-automatically extracted sequences from more than 6,000 public Jupyter notebooks—and models next-step selection as a probabilistic transition over these states (Raghunandan et al., 2022).

1. Problem setting and design goals

Lodestar was introduced in response to a specific difficulty in contemporary data science practice: libraries such as Pandas, scikit-learn, TensorFlow, and visualization grammars and tools change rapidly, best practices shift, and there are few standardized workflows. Cookbook templates are often insufficient because the “right” transformations, visualizations, and models depend strongly on the dataset, task, and analyst. For fledgling data scientists, this produces a dual burden: learning unfamiliar APIs and parameters while also understanding how steps connect across the broader pipeline from cleaning to visualization, modeling, and evaluation (Raghunandan et al., 2022).

The system addresses two gaps. First, it connects analysis intent to executable code by exposing analysis steps as selectable notebook cells rather than requiring prior recall of APIs. Second, it converts observed practice into navigable recommendation graphs, allowing users to learn by selection and inspection rather than by writing workflows entirely from scratch. This suggests a pedagogical model in which workflow construction and workflow comprehension are intentionally coupled: the system does not merely generate code, but exposes code, outputs, and explanatory context as part of the same interaction.

Lodestar’s scope extends beyond visualization recommendation. The paper explicitly places it in the broader data science pipeline, including exploratory data analysis, data cleaning, transformations, modeling, evaluation, and export. That breadth is important because many prior systems in visualization recommendation primarily recommend visual encodings and charts, whereas Lodestar treats analysis as a sequence of executable workflow states rather than as a visualization design problem alone (Raghunandan et al., 2022).

2. Notebook environment, execution model, and system architecture

Lodestar is a web-based interactive computational notebook inspired by Jupyter, Observable, and Colab. A typical session begins when a dataset is loaded, either from CSV or from built-in examples. The system then displays ranked recommendations for possible next steps as clickable buttons. Selecting a recommendation appends a new notebook cell containing the output dataframe, any visualization or analytic result, the exact Python code, a concise description, and a progress tracker. Recommendations are then recomputed conditioned on the new workflow state, allowing iterative construction and later export as a standard .ipynb, CSV, or PNG files (Raghunandan et al., 2022).

The architecture comprises a browser-based notebook interface on the client side, an interactive computing protocol between client and server, a recommendation engine maintaining advisor-specific graphs, and a server-side Python kernel that executes code cells. A Flask server exposes endpoints for data loading, execution, and recommendations. In this design, recommendation and execution are separated but tightly coordinated: the recommender proposes executable blocks, while the server-side kernel realizes them against the current dataframe state.

Each recommendation panel presents up to five suggestions from each of two advisors. The expert advisor is derived from manually curated tutorial sequences, while the crowd advisor is mined semi-automatically from public notebooks. Recommendations within an advisor are ordered by the probability that an analysis block follows from the current state in that advisor’s graph. The interface therefore exposes not one canonical workflow, but two views of practice: what curated instructional materials teach and what a large notebook corpus tends to do next.

A key operational feature is editability of workflow history. Earlier recommendation panels remain interactive, so a prior choice can be replaced; when that occurs, the corresponding notebook cell is replaced and downstream dependent cells are removed to preserve linear consistency. Undo and redo are therefore embodied through reselection and deletion rather than through a separate command history. This linear-consistency constraint reflects the system’s dataframe-in/dataframe-out abstraction and its treatment of workflows as ordered chains of executable blocks.

3. Analysis states, recommendation graphs, and Markovian ranking

Lodestar represents an analysis workflow as a sequence of discrete, executable analysis blocks, each corresponding to a recognizable step such as “first 10 samples,” “group statistics,” “category count,” or “decision tree.” Each block consumes a Pandas dataframe and produces a dataframe, together with any associated visual or analytic outputs. The dataframe-in/dataframe-out convention is central because it provides a uniform chaining model across otherwise heterogeneous operations (Raghunandan et al., 2022).

For each advisor, the system constructs a directed graph $G = (V, E)$ over analysis blocks or equivalence classes of synonymous blocks. Nodes represent analysis states, and edges represent observed transitions between consecutive blocks in workflows. If the extracted ordered sequences are denoted $S_1, \ldots, S_n$ with

$S_i = (B_{i,1}, B_{i,2}, \ldots, B_{i,m_i}),$

then each adjacent pair $(B_{i,t}, B_{i,t+1})$ contributes a directed edge, and edge weights are the empirical frequencies of such transitions across the corpus.

The transition model is formalized by a stochastic matrix

$$P_{u,v} \equiv \Pr(v \mid u) = \frac{c(u \rightarrow v)}{\sum_{v' \in \mathrm{Out}(u)} c(u \rightarrow v')},$$

where $c(u \rightarrow v)$ is the global count of transitions from $u$ to $v$ and $\mathrm{Out}(u)$ is the set of outgoing neighbors of $u$. By construction, for each state $S_1, \ldots, S_n$0, $S_1, \ldots, S_n$1. The recommendation graph is therefore a Markov chain over analysis states in which recommendation context depends only on the last chosen block (Raghunandan et al., 2022).

Given the current state $S_1, \ldots, S_n$2, the score assigned to a possible next block $S_1, \ldots, S_n$3 is simply

$S_1, \ldots, S_n$4

Within each advisor panel, Lodestar displays the top-$S_1, \ldots, S_n$5 actions, with $S_1, \ldots, S_n$6, ranked by this score. In the cold-start case, when no prior state exists, the system suggests root nodes corresponding to first blocks observed in mined or curated sequences, while a drop-down menu exposes the full catalog.

This formulation is deliberately simple. The current system performs no online learning, collaborative filtering, or user personalization. Recommendations are static in the sense that they are mined and curated offline, and then consulted through a Markovian next-step rule during interaction. The paper presents this simplicity as both a practical design choice and a limitation: scoring is fast and transparent, but it does not adapt to user history or dataset semantics beyond avoiding execution failures.

4. Knowledge acquisition, block extraction, and advisor synchronization

Lodestar’s recommendation library is built from two input sources. The first consists of manually curated expert sequences drawn from end-to-end tutorials, whether blog-based or notebook-based, that teach specific analysis tasks with runnable code, step-by-step explanations, and observable outputs. Code cells or snippets are converted into analysis blocks, generalized by removing dataset-specific references, supplied with missing imports or dependencies, normalized to dataframe input and output, deduplicated, and tagged by functionality.

The second source is a crowd corpus of roughly 6,000 public Jupyter notebooks from the Rule et al. corpus. These notebooks are first filtered to retain those containing imports and API calls from common data-science libraries such as Pandas, NumPy, and scikit-learn. Existing cells are then treated as candidate analysis blocks. To canonicalize blocks, the system extracts an API vocabulary $S_1, \ldots, S_n$7 and maps each block $S_1, \ldots, S_n$8 to a normalized term-frequency vector

$S_1, \ldots, S_n$9

where $S_i = (B_{i,1}, B_{i,2}, \ldots, B_{i,m_i}),$0 counts occurrences of API call $S_i = (B_{i,1}, B_{i,2}, \ldots, B_{i,m_i}),$1 in block $S_i = (B_{i,1}, B_{i,2}, \ldots, B_{i,m_i}),$2. These vectors are then clustered with k-means; the authors report that $S_i = (B_{i,1}, B_{i,2}, \ldots, B_{i,m_i}),$3 worked well for the dataset after iterative exploration. From the 200 cluster representatives, 22 blocks were selected as an initial high-quality set for Lodestar’s crowd advisor library, with later expansion through further curation (Raghunandan et al., 2022).

Representative blocks are chosen using a median line-count heuristic to avoid blocks that are trivially short or excessively long. They are then converted into Lodestar-ready functions, stripped of stray side effects such as unrelated prints, supplied with required imports, and harmonized so that they generalize across datasets. Graph construction reconstructs per-notebook sequences from original cell order and merges them into a global frequency-weighted transition graph.

Because users may alternate between expert and crowd recommendations, Lodestar includes a cross-advisor state alignment mechanism based on manually assigned multi-level tags representing high-level workflow stages and functions. Example tags include statistical-sampling, visualization, data-organization, data-cleaning, data-formatting, statistical-summary, train-model, and test-model. When a block is selected in one advisor, the other advisor advances to an appropriate semantically similar node or region based on these tags. The paper describes this as a way to keep both advisors “in sync” while preserving advisor-specific transition probabilities. A plausible implication is that Lodestar separates two notions of state: the literal last block in each advisor’s graph and a higher-level functional region used for cross-graph coordination.

5. Supported analysis actions and interaction design

The system supports a broad range of recommended actions spanning exploratory data analysis, visualization, modeling, evaluation, and reporting. In exploratory analysis, these include preview and sampling operations such as “first 10 samples,” head, tail, and random sampling; statistical summaries such as descriptive statistics, unique counts, and “group statistics”; cleaning and formatting operations such as dropna, type conversion, normalization or standardization, and deduplication; and organizational operations such as filtering, sorting, joins or merges, and pivot or unpivot transformations (Raghunandan et al., 2022).

Visualization recommendations include bar charts for category counts, histograms, scatterplots, and boxplots, together with encoding choices such as grouping by category, facet grids, and axis mappings. Modeling recommendations include linear regression and decision trees, with training and testing blocks represented through tags such as train-model and test-model. Hyperparameters in curated blocks are generalized to work across datasets, after which users may export and tune the resulting workflow in a standard notebook environment.

A concrete scenario in the paper uses a cars dataset. After dataset selection, Lodestar recommends “first 10 samples”; executing it reveals the table and code, after which the system suggests steps such as “group statistics.” That summary exposes that “Origin” is categorical with three values, leading the user to replace the prior choice with “category count,” which produces a bar chart of counts per origin. The resulting notebook can then be exported and continued in Jupyter. This example illustrates both the recommender’s sequential logic and the system’s support for revising earlier choices.

The notebook cells expose five tabs: Output Data Frame, Analysis Results, Script, “What’s this Analysis?”, and Analysis Progress. Recommendation panels are visually separated in the interface and offer up to five suggestions from each advisor, with tooltips and a drop-down for the full catalog. The inclusion of exact code and short explanations is pedagogically central: users can inspect not only what the system proposes, but how that proposal is implemented.

6. Formative evaluation and design implications

Lodestar was evaluated through an IRB-approved formative study with six undergraduate students learning data science. Sessions lasted approximately 60 minutes and involved consent, interview, tutorial, exploratory use, and questionnaire. Two datasets were used: Cars, described as categorical-heavy, and Boston Housing, described as numeric-heavy. The procedure included an initial interview on learning experience and recommender attitudes, a 2-minute introduction plus a 5-minute scripted tutorial, 15–20 minutes of think-aloud exploration, and a post-exploration questionnaire concerning utility, adoption intent, and trust in recommendations (Raghunandan et al., 2022).

The study did not report quantitative statistics such as means or $S_i = (B_{i,1}, B_{i,2}, \ldots, B_{i,m_i}),$4-values. Instead, it was used to refine the system through qualitative feedback, screen and audio recordings, questionnaires, and researcher notes. Participants requested clearer naming, longer descriptions, more explicit tooltips, and better contextualization of what particular steps meant—for example, what “percentages” referred to and how to access the entire dataset. They also wanted better tracking of analysis progress, including clearer staging of workflow phases, and more granular control over data import, code export, and parameter or column customization.

These observations directly motivated several design changes: export to .ipynb was added at both per-cell and whole-notebook levels; the Analysis Progress tracker tab was added; and descriptive tooltips together with clearer step names and labels were introduced. The results are summarized cautiously in the paper: they suggest that participants found Lodestar useful for rapidly creating data science workflows.

The evaluation is therefore best understood as formative evidence rather than as a controlled efficacy study. It documents perceived usefulness, identifies interface and explanation failures, and shows how those failures informed redesign, but it does not establish comparative performance against alternative notebook systems or recommendation methods.

7. Limitations, relation to prior work, and future development

The paper identifies several limitations. Coverage and bias arise because tutorials vary widely in focus and depth, and selecting pedagogically sound end-to-end examples introduces selection bias. The crowdsourced notebook corpus is noisy: many cells are trivial, monolithic, erroneous, or non-functional, so manual curation remains necessary. Generalizability is limited because the initial crowd library contains 22 curated blocks from 200 clusters and covers common operations rather than domain-specific workflows such as bioinformatics, journalism, or computer vision (Raghunandan et al., 2022).

From a modeling perspective, the Markov chain abstraction oversimplifies non-linear and branching analytical practice. Recommendations depend only on the last block, and current Lodestar does not tailor suggestions to dataset schemas, types, or distributions beyond avoiding execution failure. The dataframe-in/dataframe-out convention also excludes non-standard workflows and multi-input computations. Scalability poses an additional challenge: the paper notes that mining the full Rule et al. corpus of approximately 1.25 million notebooks and 600 GB would improve coverage, but would introduce substantial code-analysis and clustering demands.

In relation to prior work, Lodestar is positioned against both visualization recommenders and intelligent notebook or code-mining systems. The paper explicitly references early automatic design work by Mackinlay and systems such as Show Me, Voyager, Voyager 2, Zenvisage, Draco, and VizML, observing that these primarily recommend visual encodings and charts. It also situates itself relative to systems such as Auto-Suggest, deep-RL-generated EDA sessions, Wrex, and Mage, which address portions of the pipeline or emphasize code generation. Lodestar’s stated novelty lies in combining expert-curated and crowd-mined workflow knowledge, organizing that knowledge as graph-based recommendations over executable curated code cells, and synchronizing multiple advisors through shared functional tagging.

Planned future work includes community-driven advisors for domains such as bioinformatics, geospatial analysis, and NLP; reduction of manual editing through better side-effect removal, dependency resolution, and generalization heuristics; dataset-aware recommendation based on schema, types, distributions, and metadata; editable code inside Lodestar with live graph updates through automatic block classification; and more powerful recommendation strategies combining collaborative filtering, content-based models, and deep sequence models such as RNNs. These directions indicate that the 2022 system should be read as a deliberately constrained initial design: it establishes a probabilistic, notebook-native framework for recommendation-driven analysis authoring, while leaving personalization, richer state representations, and broader domain coverage for subsequent work.