Paper-to-Notebook: Upload a Paper PDF and Generate PyTorch Code with One Click

Project Overview: An Automated Approach to Paper Reproduction

In AI research, going from paper to code reproduction has always been a time-consuming and error-prone process. Reproducibility is one of the cornerstones of scientific research, but this problem is particularly acute in deep learning. In 2019, the NeurIPS conference introduced a "reproducibility checklist" requiring authors to provide code and experimental details, but even so, many papers still lack complete open-source implementations. Statistics show that approximately 30%-50% of machine learning papers have no publicly available code, and even when code exists, issues with environment configuration, dependency versions, and random seeds often make it difficult to precisely reproduce results. The traditional manual reproduction workflow typically involves: carefully reading the paper to understand the method, parsing mathematical formulas, designing code architecture, writing implementation code, and debugging runtime errors—a process that can take one to two weeks for a moderately complex paper.

The paper-to-notebook project, open-sourced by the VizuaraAI team, offers an efficient solution: simply upload a research paper's PDF file to automatically generate a runnable PyTorch Jupyter Notebook.

The project is powered by Google's latest Gemini 2.5 Pro large language model, developed in TypeScript, and has already earned 156 stars and 46 forks on GitHub—reflecting strong community demand for automated paper reproduction tools.

Core Features and How It Works

Automatic Conversion from PDF to Executable PyTorch Code

The core value of paper-to-notebook lies in automatically transforming the methodologies, algorithms, and model architectures described in academic papers into structured PyTorch implementation code. PyTorch is an open-source deep learning framework developed by Meta AI Research that has become the dominant choice in academic research since its release in 2017. According to Papers With Code statistics, over 80% of newly published papers choose PyTorch as their implementation framework. PyTorch's dynamic computation graph (Define-by-Run) mechanism makes its coding style closer to standard Python programming, facilitating debugging and comprehension. This is an important reason why paper-to-notebook generates PyTorch code rather than TensorFlow or JAX—the generated code is more readable and better suited as a starting point for learning and verification.

Researchers no longer need to spend hours or even days manually translating formulas and pseudocode from papers into runnable programs.

Gemini 2.5 Pro's Deep Understanding Capabilities

The choice of Gemini 2.5 Pro as the underlying model is no accident. Gemini 2.5 Pro is a flagship multimodal large language model released by Google DeepMind in 2025, representing the latest iteration of the Gemini series. The model employs a Mixture of Experts (MoE) architecture and supports a context window exceeding 1 million tokens, meaning it can process hundreds of pages of complete paper content in a single pass. In code generation benchmarks, Gemini 2.5 Pro performs exceptionally well on evaluations like HumanEval and MBPP, demonstrating significant advantages particularly in complex programming tasks requiring long-chain reasoning. Its multimodal capabilities allow it to not only understand text but also parse mathematical formulas (LaTeX-rendered images), architecture diagrams, and experimental result tables in PDFs—all crucial for paper reproduction scenarios.

This model possesses powerful multimodal understanding capabilities, handling several key aspects required for paper reproduction:

• PDF Content Parsing: Accurately extracting text, mathematical formulas, and diagram information
• Paper Logic Understanding: Grasping the overall architecture and inherent logic of the methodology
• Code Transformation: Converting abstract mathematical descriptions into concrete PyTorch implementations
• Structured Output: Generating Jupyter Notebooks with annotations and explanations

This end-to-end conversion capability is made possible by Gemini 2.5 Pro's excellent performance in code generation and scientific reasoning.

Technical Architecture Analysis

The project uses TypeScript as its primary development language, providing a web interface or API service for users to upload PDFs and retrieve generated Notebooks. TypeScript is a superset of JavaScript developed by Microsoft that offers static type checking and a modern development experience. The choice of TypeScript over Python as the project's development language is based on several considerations: First, the core logic involves calling the Gemini API for text processing and code generation rather than directly running machine learning code; second, the TypeScript ecosystem offers a rich web development toolchain (such as Next.js, Express, etc.) that facilitates building user-friendly upload interfaces and API services; finally, TypeScript's type system helps maintain the reliability of complex prompt engineering logic and API response parsing code.

From a workflow perspective, the system goes through roughly four steps:

1. PDF Parsing: Extracting text, formulas, and structural information from the paper
2. Content Understanding: Using Gemini 2.5 Pro to analyze the paper's core methods and algorithms
3. Code Generation: Transforming the analysis results into PyTorch code
4. Notebook Assembly: Organizing the code, explanatory text, and execution instructions into a standard Jupyter Notebook format

Jupyter Notebook (.ipynb format) is an interactive computational document that supports mixing code, rich text explanations, mathematical formulas, and visualization outputs in a single document. It's stored in JSON format, with each cell capable of independent execution, making it ideal for progressive experimental exploration. In academia and data science, Jupyter Notebook has become the standard tool for sharing research results and teaching. Platforms like Google Colab and Kaggle Kernels natively support this format, meaning files generated by paper-to-notebook can run directly in cloud GPU environments without local configuration.

The entire process is essentially one-click for users, dramatically lowering the technical barrier to paper reproduction.

Three Key Use Cases

Accelerating Paper Reproduction

Paper reproduction is an important part of academic research, but traditional approaches are relatively inefficient. paper-to-notebook can serve as a starting point for reproduction work, reducing the time from reading a paper to running the first version of code from days to minutes.

Deep Learning Teaching Aid

For students and junior researchers learning deep learning, observing how paper methods are transformed into concrete PyTorch code is itself an extremely valuable learning process. Auto-generated Notebooks can serve as reference materials for understanding paper implementation details.

Rapid Prototype Validation

When researchers need to quickly verify whether a paper's method is applicable to their own project, auto-generated code can serve as a rapid prototype, eliminating the time cost of writing from scratch.

Limitations and Usage Recommendations

It's important to note that auto-generated code isn't always perfect. The following aspects may require human intervention:

• Implementation details in complex papers may contain inaccuracies
• Hyperparameter choices need adjustment based on actual datasets
• Data preprocessing logic may need supplementation
• Engineering optimizations in training pipelines need to be added manually

Therefore, paper-to-notebook is better suited as a starting point for paper reproduction rather than a final solution—researchers still need to review, debug, and test the generated code.

Conclusion

paper-to-notebook represents an important direction in AI-assisted research tools—lowering the barrier from theory to practice. This space is developing rapidly, with similar projects including: Elicit and Semantic Scholar for literature search and summarization, GitHub Copilot and Cursor for code-assisted writing, and in the paper reproduction direction, projects like gpt-researcher have previously attempted similar functionality. As large language models simultaneously achieve breakthroughs in long-context understanding, mathematical reasoning, and code generation, end-to-end paper reproduction automation is moving from proof of concept to practical deployment.

paper-to-notebook automates the conversion from paper PDF to runnable PyTorch code, saving researchers significant repetitive work. As the capabilities of large language models like Gemini continue to improve, the accuracy and practicality of such paper reproduction tools will further strengthen, potentially becoming a standard tool in researchers' daily workflows.