Machine Learning System Architecture Search via Directed Graph Path Selection
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing methods for automatic architecture search in neural networks are inefficient in terms of memory usage and cannot effectively draw architectures with branches and multiple outputs during training, particularly for tasks like object detection and multi-task networks.
Innovation Solution
A method is introduced to create a machine learning system with multiple outputs by selecting paths in a directed graph, where additional nodes are used as outputs for object detection, and the system is trained efficiently, allowing for the discovery of more optimal and smaller architectures through cost function optimization and probabilistic edge drawing.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If gradient-based training of the complete one-shot model is modified for multi-output tasks, then the network can have several outputs for tasks like object detection and semantic segmentation, but memory efficiency deteriorates and training becomes less efficient
Solution Approach 1:
The patent segments the training process by separately training the shared backbone network and the task-specific heads. The backbone network is trained once and frozen, while each task-specific head (object detection head, segmentation head) is trained independently on its respective task. This segmentation allows multi-output capability without requiring the entire model to be trained simultaneously in memory, thus resolving the memory efficiency problem.
Solution Approach 2:
The patent extracts the task-specific processing logic into separate head modules that are detached from the main training loop. The object detection head and segmentation head are extracted as independent components that process features from the frozen backbone separately. This extraction allows the system to handle multiple outputs without increasing the memory burden of the core training process.
2Productivity
If individual architectures are drawn from the one-shot model by selecting a single path from input to output node, then training can be performed efficiently, but architectures with branches and multiple outputs cannot be discovered
Solution Approach 1:
The patent segments the architecture search process into two independent phases: (1) searching for the optimal backbone architecture by drawing single paths from input to output node, and (2) independently selecting task-specific heads for each task. This segmentation allows efficient training of the backbone while enabling the discovery of specialized architectures for each task through separate head selection, thus resolving the contradiction between training efficiency and multi-output capability.
Solution Approach 2:
The patent adds a new dimension to the architecture search by introducing task-specific head selection as a separate search space. Instead of searching for multi-output architectures in a single path selection, the system searches for backbone architecture in one dimension (single path) and task-specific heads in another dimension (independent selections). This dimensional separation enables both efficient training and multi-output architecture discovery.
3Extent of automation
If the one-shot model is constructed as a directed graph with nodes representing data and edges representing operations, then the search space can be systematically explored, but the model size becomes very large making individual architecture drawing difficult
Solution Approach 1:
The patent segments the large one-shot model into a compact backbone search space and separate task-specific head configurations. By freezing the backbone after training and treating task heads as independent components, the system maintains automatic architecture search capability through graph-based path selection while reducing the effective model size that needs to be managed during training and inference.
Solution Approach 2:
The patent extracts task-specific operations from the main one-shot model graph into separate head modules. This extraction removes the complexity of managing multi-output paths within the core graph structure, allowing the system to maintain a manageable model size while still enabling automatic architecture search for the backbone and independent configuration for task-specific heads.
Data Source
AI summary
A method for creating a machine learning system which is designed for segmentation and object detection in images. The method includes: providing a directed graph; selecting a path through the graph, at least one additional node being selected from this subset, a path through the graph from the input node along the edges via the additional node up to the output node being selected; creating a machine learning system as a function of the selected path; and training the machine learning system created.