Safe Automated Refactoring for Efficient Migration of Imperative Deep Learning Programs to Graph Execution

2025-04-07

AI Summary

This paper addresses the challenge of safely migrating imperative deep learning code to graph execution mode. We propose a static analysis method based on imperative tensor semantics, enabling precise and efficient determination of graph-compatible code while preserving program semantics. Our approach is built upon the WALA/Ariadne framework and integrated into the PyDev Eclipse plugin, supporting end-to-end automatic identification and refactoring of Python deep learning code. Evaluation across 19 real-world projects (132.05 KLOC) shows that 42.56% of functions can be safely refactored, yielding an average runtime speedup of 2.16×. The key contribution is the first formal semantic model for imperative tensors, overcoming inherent limitations of traditional data-flow analysis in modeling dynamic tensor behaviors. This establishes a verifiable, deployable paradigm for automated graph optimization of deep learning programs.

Technology Category

• Machine Learning: Matrix & Tensor Methods
• Computer Vision: Learning & Optimization for CV
• Search and Optimization: Learning to Search

Application Category

• Graph Algorithms and Modeling for the Web: Efficient manipulation of static and dynamic Web-related graphs
• Semantics and Knowledge: Methods, algorithms and applications for the development of semantic models, knowledge graphs and other forms of structured data models with machine-interpretable semantics
• Responsible Web: Human-perceived consequences of algorithmic deployment on the web

Abstract

Efficiency is essential to support responsiveness w.r.t. ever-growing datasets, especially for Deep Learning (DL) systems. DL frameworks have traditionally embraced deferred execution-style DL code -- supporting symbolic, graph-based Deep Neural Network (DNN) computation. While scalable, such development is error-prone, non-intuitive, and difficult to debug. Consequently, more natural, imperative DL frameworks encouraging eager execution have emerged at the expense of run-time performance. Though hybrid approaches aim for the"best of both worlds,"using them effectively requires subtle considerations to make code amenable to safe, accurate, and efficient graph execution. We present an automated refactoring approach that assists developers in specifying whether their otherwise eagerly-executed imperative DL code could be reliably and efficiently executed as graphs while preserving semantics. The approach, based on a novel imperative tensor analysis, automatically determines when it is safe and potentially advantageous to migrate imperative DL code to graph execution. The approach is implemented as a PyDev Eclipse IDE plug-in that integrates the WALA Ariadne analysis framework and evaluated on 19 Python projects consisting of 132.05 KLOC. We found that 326 of 766 candidate functions (42.56%) were refactorable, and an average speedup of 2.16 on performance tests was observed. The results indicate that the approach is useful in optimizing imperative DL code to its full potential.

Problem

• Automated refactoring for imperative DL code migration
• Ensuring safe and efficient graph execution
• Preserving semantics while improving performance

Innovation

• Automated refactoring for imperative DL code
• Novel imperative tensor analysis for safety
• IDE plugin integrating WALA Ariadne framework