Deep Learning Model Development Tools with API Compatibility Layers
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
The inconsistency between low-level and high-level APIs in deep learning frameworks necessitates significant code input for system development, and parallel training with multiple computing devices faces issues like data imbalance and inefficient evaluation due to separate code requirements.
Innovation Solution
A high-level API is designed to reuse low-level API functions through a call path, enabling automatic data handling and evaluation result aggregation, reducing code input and facilitating flexible model training, evaluation, and prediction with minimal developer effort.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Ease of operation
If high-level API is used with fixed pattern, then ease of operation is improved, but device complexity increases due to code transformation requirements
Solution Approach 1:
The patent introduces a compatibility layer as an intermediary component between the high-level API and low-level API. This compatibility layer automatically transforms high-level API calls into corresponding low-level API implementations, eliminating the need for manual code transformation while maintaining the simplicity of high-level usage patterns.
Solution Approach 2:
The patent creates virtual copies of low-level API functions through the compatibility layer. When a high-level API function is called, the compatibility layer generates appropriate low-level API calls dynamically, allowing the same code to work across different implementation levels without modification.
2Adaptability or versatility
If low-level API is applied in complex scene model, then adaptability is improved, but device complexity increases due to large amount of codes needed
Solution Approach 1:
The patent segments the API into distinct high-level and low-level layers with clear separation of concerns. The high-level API provides abstract, domain-specific functions while the low-level API handles implementation details. This segmentation allows developers to use high-level functions for complex models without managing the underlying complexity manually.
Solution Approach 2:
The compatibility layer serves multiple functions: it acts as an API translator, provides abstraction, enables both high-level and low-level usage modes, and ensures consistency across different API versions. This multi-functionality reduces overall system complexity while maintaining adaptability.
3Adaptability or versatility
If separate code requirements are used for parallel training with multiple computing devices, then adaptability is improved, but device complexity increases and development time increases
Solution Approach 1:
The compatibility layer automatically handles parallel training configuration and data distribution across multiple computing devices without requiring separate manual code. The system self-adjusts to the number of devices and automatically partitions data and coordinates training tasks, eliminating the need for developers to write separate parallel training code.
Data Source
AI summary
Embodiments of the present disclosure provide a method and apparatus of training a model, an electronic device, a storage medium and a development system, which relate to a field of deep learning. The method may include calling a training preparation component to set at least a loss function and an optimization function for training the model, in response to determining that a training preparation instruction is received. The method further includes calling a training component to set a first data reading component, in response to determining that a training instruction is received. The first data reading component is configured to load a training data set for training the model. In addition, the method may further include training the model based on the training data set from the first data reading component, by using the loss function and the optimization function through the training component.