Challenges and Opportunities in Improving AI Systems

Brahim mahmoudi -

Introduction

Artificial Intelligence (AI) is a constantly evolving field powered by advanced technologies that enable the simulation of intelligent behaviors. Among its subdomains, machine learning (ML) plays a central role by facilitating the analysis of massive datasets and the development of models capable of making accurate predictions. These advancements are largely supported by robust technological tools, especially libraries and Application Programming Interfaces (APIs), which provide developers with the means to design, train, and deploy complex systems efficiently. Popular APIs in this domain, such as TensorFlow, PyTorch, Scikit-learn, and Keras, offer powerful capabilities to manage a variety of tasks, from image recognition to anomaly detection, and natural language understanding.

However, the increasing reliance on these libraries comes with significant challenges related to system quality, security, and performance. Unlike traditional software with predictable update cycles, ML libraries evolve rapidly, frequently integrating new features, bug fixes, and performance improvements. This dynamic environment forces developers to continually adapt their applications, often leading to technical debt and compatibility issues. Furthermore, ML systems are particularly sensitive to quality defects such as configuration errors, operational inefficiencies, and software bugs, which can have critical implications for their performance and security, especially in high-stakes fields like healthcare, finance, and cybersecurity [3,6].

A key factor exacerbating these challenges is the ubiquity of Python in the ML domain. Python has become the most widely used programming language worldwide on platforms like GitHub [2] and has established itself as the de facto standard for AI application development, thanks to its extensive collection of ML libraries and its rich ecosystem [1]. However, Python’s dynamic nature, which allows type and behavior checks to occur at runtime rather than during compilation, increases the susceptibility of Python-based systems to runtime errors and inefficiencies stemming from poor resource management or suboptimal configurations. In this context, dynamic analysis is crucial for diagnosing and resolving quality defects in ML applications, as it captures runtime behaviors that static tools often miss [3].

To address these challenges, there is a growing need to automatically optimize ML-based applications by identifying and correcting their quality defects and bugs.

Misused APIs

APIs provide standardized ways to perform complex operations, such as model training, data preprocessing, or tensor manipulation. Despite their utility, studies indicate that 30-40% of API usages in ML projects are prone to misconfigurations or inefficiencies.[1] These issues range from redundant API calls to improper resource management, such as misallocating CPU vs. GPU tasks.

A 2024 review of GitHub projects [2] showed startling trends:

  • 46% of projects lacked proper unit tests. Without tests, API misuses often go undetected until they lead to critical failures.
  • Popular repositories like TensorFlow and PyTorch, with over 180,000 stars collectively, attract widespread adoption but also suffer from thousands of unresolved issues, many tied to improper API usage.

A Multi-Vendor Ecosystem Adds Complexity

The problem intensifies with the proliferation of vendor-specific APIs. Leading platforms like Google (TensorFlow), Meta (PyTorch), and Microsoft (ONNX) introduce new functionalities at a rapid pace. While this fosters innovation, it creates a fragmented landscape where developers struggle to keep up with updates, ensuring compatibility, and optimal configurations.

Key challenges include:

  1. Version mismatches: API upgrades often break existing code, especially for ML pipelines heavily reliant on specific library behaviors.

  2. Inconsistent documentation: Developers frequently encounter ambiguities in API usage instructions, leading to improper implementations.

  3. Vendor lock-in risks: Applications built on proprietary APIs risk long-term inefficiencies if migration becomes necessary due to vendor strategy changes.

The chart above illustrates the adoption of popular machine learning APIs in open-source projects as of 2024 [2]. These APIs each serve specific roles in the AI ecosystem:

  1. TensorFlow (40%): A versatile library widely used for building and training deep learning models. It supports tasks like image recognition, natural language processing, and more.
  2. PyTorch (35%): Known for its dynamic computational graph, PyTorch is favored for research and rapid prototyping, especially in cutting-edge AI applications.
  3. Scikit-learn (15%): A go-to library for classical machine learning algorithms, including regression, classification, and clustering, often used in academic and industry settings for non-deep learning tasks.
  4. Keras (10%): A high-level API that runs on top of TensorFlow, making it easier to design and train neural networks with a user-friendly interface.
  5. XGBoost (8%): A specialized library for gradient boosting algorithms, frequently applied in tabular data competitions and business analytics.
  6. LightGBM (6%): Similar to XGBoost but optimized for speed and scalability, particularly useful for large datasets.
  7. CatBoost (5%): Known for handling categorical data effectively, CatBoost is another gradient boosting library that excels in real-world applications.

The Quality of APIs

While APIs are foundational to AI development, their quality often varies significantly. High-quality APIs provide clear documentation, robust error handling, and backward compatibility. However, many APIs, especially those from less mature frameworks, suffer from:

  • Ambiguous or outdated documentation: This leads to misunderstandings and misuses by developers.
  • Unclear error messages: Poor diagnostics make troubleshooting time-consuming and error-prone.
  • Lack of testing features: APIs that do not integrate well with testing frameworks leave room for hidden bugs to proliferate.

Even in mature APIs, updates and patches can introduce breaking changes that destabilize dependent systems. These issues underscore the need for continuous monitoring, testing, and the use of best practices in API interaction.

Addressing the Problem: Dynamic Analysis and Standardization

Traditional methods to address API issues, such as static code analysis, are insufficient for dynamic languages like Python, which dominates the ML landscape. Errors in Python often surface only during runtime, making dynamic analysis indispensable.

Dynamic analysis allows developers to [3]:

  • Monitor real-time API interactions, capturing inefficiencies and misconfigurations.
  • Diagnose issues that emerge only in execution environments, such as tensor mismatches or inefficient memory usage.
  • Propose automated corrections, reducing developer workload and improving system robustness.

Another crucial step is promoting industry-wide standards for API usage. A catalog of best practices, based on systematic research, can provide clear guidance for developers to [4,5]:

  1. Optimize configurations for widely used APIs.
  2. Integrate automated testing for detecting API-specific issues early.
  3. Encourage sustainable coding practices that align with both technical and environmental goals.

Quantifying the Impact

If addressed effectively, these measures could yield:

  • Faster development cycles through reduced debugging time.
  • A Decrease in resource costs, with energy savings contributing to lower carbon footprints.
  • A Reduction in unresolved issues for popular ML repositories, improving software quality across the ecosystem.

Conclusion: APIs as a Pillar of AI Excellence

APIs are at the heart of modern AI systems, but their misuse is a growing concern that undermines progress. With rising adoption rates and an increasingly complex ecosystem, addressing API-related challenges must be a priority. By adopting dynamic analysis tools and standardizing best practices, we can unlock the true potential of AI, ensuring that its applications are not only innovative but also efficient, secure, and sustainable.

References

[1] MSPowerUser.
"AI Statistics 2023: Trends and Adoption Rates."Accessed November 18, 2024 at https://mspoweruser.com/fr/ai-statistics/

[2] GitHub. The State of the Octoverse 2024: Top Languages Over the Years. Accessed November 18, 2024 at https://octoverse.github.com/#top-languages-over-the-years

[3] Dilhara, M., Ketkar, A., Dig, D.: Pyevolve: Automating frequent code changes in python ml systems. In: Proceedings of the 45th International Conference on Software Engineering (ICSE ’23) (2023). https://doi.org/10.1109/ICSE48619.2023.00091

[4] Zhang, H., Cruz, L., van Deursen, A.: Code smells for machine learning applications. In: Proceedings of the 1st Conference on AI Engineering - Software Engineering for AI (CAIN 22) (2022). https://doi.org/10.1145/3522664.3528620

[5] Wei, M., Harzevili, N.S., Huang, Y., Yang, J., Wang, J., Wang, S.: Demystifying and detecting misuses of deep learning apis. In: Proceedings of the IEEE/ACM 46th International Conference on Software Engineering (ICSE ’24) (2024). https://doi.org/10.1145/3597503.3639177

[6] Dilhara, M., Ketkar, A., Sannidhi, N., Dig, D.: Discovering repetitive code changes in python ml systems. In: Proceedings of the 44th International Conference on Software Engineering (ICSE ’22) (2022). https://doi.org/10.1145/3510003.3510225