A multi-convolution graph optimization method for quantization model of neural network training
By incorporating convolution, batch normalization, and ReLU activation operations in neural networks, the problem of slow inference speed and large memory consumption of deep learning models on resource-limited devices is solved, achieving efficient inference speed and accuracy preservation.
Patent Information
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- HEFEI JUNZHENG TECH CO LTD
- Filing Date
- 2025-01-08
- Publication Date
- 2026-07-10
AI Technical Summary
Existing deep learning models suffer from high computational resource requirements, high energy consumption, and reduced detection accuracy when inference on resource-limited devices. This is especially true when reducing input resolution or compressing network depth, which leads to a decrease in detection accuracy.
By reorganizing and merging operators in the neural network computation graph, and combining computational units with sequential dependencies, such as convolution, batch normalization, and ReLU activation operations, composite operators are formed, reducing the overhead of storing and retrieving intermediate results and improving inference efficiency.
While ensuring detection accuracy, it significantly reduces model detection inference time and memory usage, and improves inference speed and computing resource utilization.
Smart Images
Figure CN122366541A_ABST
Abstract
Description
Technical Field
[0001] This invention belongs to the field of deep learning model compression and acceleration technology, and specifically relates to a multi-convolutional graph optimization method for training quantization models of neural networks. Background Technology
[0002] Compression and acceleration of deep learning models are important research topics. As deep learning is increasingly applied across various fields, the size and complexity of these models are constantly increasing, leading to huge demands on computing resources and high energy consumption. Therefore, how to effectively compress and accelerate deep learning models has become a hot research topic.
[0003] In today's era of rapid development in artificial intelligence technology, deep learning models have demonstrated outstanding performance in fields such as image recognition and natural language processing. However, the complexity and computational demands of these models also present significant challenges, especially when performing inference on resource-constrained devices.
[0004] Deep learning models, especially convolutional neural networks (CNNs), typically contain a large number of computational layers and activation functions. These layers and functions are computed layer by layer during inference, producing intermediate results. In traditional inference methods, the results of each layer are stored separately in memory for use by the next layer. While this approach is intuitive, it increases memory read / write overhead and access latency, thus impacting inference speed.
[0005] Currently, among existing technologies, reducing the input resolution of the model or compressing the network depth are effective methods to reduce the inference time of quantized models on the board, such as the Ingenic T41. However, these methods also have a certain impact on the detection accuracy of the model's board-side inference.
[0006] Reducing the input resolution of a model can decrease the processing time for each input data point, thereby accelerating the overall inference speed. However, lower input resolution means less information per pixel, which may lead to the loss of some detailed information. For example, in image processing tasks, reducing the resolution can cause subtle edge information and texture features to be ignored, thus affecting the model's final detection accuracy. Specifically, if a high-resolution medical image is reduced to a low resolution for inference, some key lesion features may be lost, leading to misdiagnosis or missed diagnosis. Furthermore, for object detection tasks, reducing the input resolution blurs the scale information of the target object, thus affecting localization accuracy and detection performance.
[0007] Compressing network depth is a common method to reduce inference time. By reducing the number of network layers and parameters, computational complexity can be significantly reduced, and inference speed can be improved. However, compressing network depth can also negatively impact detection accuracy. Shallower network structures may not be able to fully learn complex feature representations, especially when dealing with complex backgrounds or multi-class targets. For example, in natural language processing tasks, deep networks can capture long-range dependencies in text, while shallow networks may lack this ability, leading to decreased accuracy in semantic understanding. Similarly, in image classification tasks, shallower network structures may not be able to effectively extract high-level abstract features, thus affecting classification accuracy.
[0008] While reducing input resolution and compressing network depth can effectively reduce inference time to some extent, they inevitably impact the model's detection accuracy. Therefore, in practical applications, it is necessary to repeatedly and thoroughly weigh the relationship between speed and accuracy based on the specific task requirements in order to optimize the model's performance. Summary of the Invention
[0009] To address the aforementioned issues, the purpose of this application is to significantly reduce model detection inference time and memory usage while maintaining detection accuracy by utilizing an innovative operator fusion method. This is achieved by merging multiple computational units, reducing the overhead of storing and retrieving intermediate results, thereby improving inference efficiency.
[0010] Specifically, this invention provides a multi-convolutional graph optimization method for training quantization models in neural networks. This method reorganizes and merges operators in the computation graph, integrating multiple independent computational operations into a single composite operation. It combines computational units with sequential dependencies in neural networks, such as convolution operations, batch normalization operations, and ReLU activation operations, into a single composite operator. This allows operations that would otherwise be performed separately in multiple steps to be completed in the same step. The convolution operation is a core component of Convolutional Neural Networks (CNNs), using a learnable convolutional kernel to slide across the input data and extract local features. The batch normalization operation standardizes the mean and variance of each batch of data, ensuring a relatively stable distribution of inputs at each layer of the network, and is a technique used to accelerate neural network training. The ReLU activation operation is an activation function that sets the negative part of the input value to 0 while keeping the positive part unchanged, introducing non-linear features.
[0011] The method combines four separate convolution operators into a single fusion operator, which includes two convolutions with a kernel of 3 and two convolutions with a kernel of 1, and includes the following steps:
[0012] S1. Traverse the entire neural network graph and check the attributes of the original multi-nodes: First, traverse the entire structure of the neural network to find multi-convolutional structures that meet specific conditions; the specific conditions include the connection relationship between multi-convolutions, the size of the convolution kernel, the stride parameter of the convolution, and other relevant features set manually according to the fusion conditions, i.e., parameter attributes that meet the fusion requirements.
[0013] S2. The creation of new nodes, the assignment of parameters from the original multi-nodes to the new nodes, and the clearing of the original multi-nodes include:
[0014] Create a new fusion layer operator node to store all parameters of the multi-convolutions that need to be fused: Once a multi-convolution structure that meets the fusion requirements is found, a new fusion layer operator node will be created, which will be responsible for integrating the computation functions of the four convolution operators.
[0015] Assigning input-output connections and parameters: After creating a new fusion layer operator node, assign the input-output connections and related parameters of all nodes in the original multi-convolution structure to the fusion layer operator; in this way, the fusion layer operator can correctly execute its fused computational task.
[0016] Remove nodes from a specific structure: After constructing the fusion layer operator, remove all nodes from the original multi-convolutional structure; simplify the structure of the neural network and reduce unnecessary computational burden;
[0017] S3. Update the neural network graph, i.e., update the entire neural network graph: Finally, based on the connection relationships between neural network nodes, update the entire neural network graph again to ensure that other parts of the neural network can correctly interact with the new fusion layer operator.
[0018] Step S1 further includes:
[0019] S1.1. Update node name mapping:
[0020] Use node_name_map.update(graph) to update the name mapping of all nodes in the graph for faster lookup later;
[0021] S1.2. Traverse each node:
[0022] By iterating through all nodes in the graph, the current node is obtained using graph->mutable_node(i); S1.3. Obtain target device attributes:
[0023] Set the device name for which the fusion operation will take effect, and then use the get_node_attr function to retrieve the device attributes of the current node from the node attributes; if the retrieval fails, log the error message.
[0024] S1.4. Initialize flags and counters:
[0025] Set Boolean flags K33S1 and K33S2 to indicate whether the corresponding convolution operation has been found;
[0026] Initialize the counter pws1_node_counter to record the number of PWS1 nodes that meet the criteria;
[0027] S1.5. Check K33S1 operation:
[0028] Check if the current node is "KQUANTIZE_CONV2D" and is compatible with the target device; obtain the node's input attributes, kernel size, and stride information to confirm whether it meets the K33S1 condition, i.e., a 3x3 kernel with a stride of (1,1);
[0029] If the condition is met, set K33S1 to true;
[0030] S1.6. Search for K33S2:
[0031] Find other nodes (consumers) that use the output of the current node, and iterate through these consumers;
[0032] Check if the consumer has a K33S2 convolution kernel with a stride of (2,2);
[0033] If found, set K33S2 to true;
[0034] S1.7. Count PWS1 nodes:
[0035] For the consumer of K33S2, find other nodes in its output and check if these nodes are PWS1 (1x1 convolution kernel, stride (1,1));
[0036] If a matching PWS1 node is found, update the counter.
[0037] Step S2 further includes:
[0038] S2.1, Merging Nodes: If the found nodes meet the conditions, then begin merging:
[0039] S2.2, Change the operation type of the current node to merge operation:
[0040] KMERGE_QUANTIZE_K33FOCUSK3S2PWS1PWS1;
[0041] S2.3, create a temporary node attr_temp to store the attributes of the current node, and update its attributes to a prefixed form;
[0042] S2.4, clear the attributes of the current node and copy the attributes of the temporary node back;
[0043] S2.5, update the properties of K33S2 and modify its inputs so that the merged nodes can be used as new inputs.
[0044] Step S3 further includes updating the graph:
[0045] If node merging has occurred, the update_graph function is called to reflect the changes during the merging process.
[0046] The convolution nodes of the method include convolution operations, batch normalization operations, and ReLU activation operations. Any computational unit with sequential dependencies can become the object of fusion. It also includes pooling operations and fully connected layer operations.
[0047] Therefore, the advantage of this application is:
[0048] To maximize inference efficiency while ensuring detection accuracy, an innovative method is proposed: operator fusion technology to reduce the inference time of neural network detection algorithms on chips such as the Ingenic T41. Specifically, the multi-convolution operator fusion method proposed in this invention successfully reduces the detection time and memory usage of the model on development boards such as the Ingenic T41 by optimizing the computation and memory access process. Taking the YOLOv5 single-humanoid detection algorithm as an example, with an input resolution of 640x480x3, the model detection time is reduced from 18.575ms to 17.305ms, and the model memory usage is reduced from 10384K to 9320K. Attached Figure Description
[0049] The accompanying drawings, which are provided to further illustrate the invention and form part of this application, are not intended to limit the scope of the invention.
[0050] Figure 1 This is a flowchart illustrating the method.
[0051] Figure 2 This is a schematic diagram of the node connection relationships before operator fusion in this method.
[0052] Figure 3 This is a schematic diagram of the node connection relationship after operator fusion in this method. Detailed Implementation
[0053] To better understand the technical content and advantages of the present invention, the present invention will now be described in further detail with reference to the accompanying drawings.
[0054] The fundamental principle of compression and acceleration technologies lies in the in-depth analysis and optimization of the computation graph in neural network models. Specifically, it aims to reduce the overhead of operator execution gaps and improve the utilization of device computing resources by splitting, reorganizing, and merging the logic of the existing network computation graph. This process can not only significantly improve the inference speed of the model, but also reduce the amount of computation without changing the model's output, thus enabling the model to run more efficiently in resource-constrained environments.
[0055] Achieving this goal is no easy task. It requires designing a sophisticated algorithm to automatically identify and fuse operators that can be combined. This demands a high degree of intelligence in the algorithm, enabling it to accurately determine which operators can be safely fused together without introducing additional errors or affecting the model's accuracy. It also necessitates code-level modifications to the model, replacing previously independent network layers or operators with the fused operations. While this step is challenging, its success can lead to significant performance improvements.
[0056] This method recombines and merges operators in the computation graph, enabling multiple independent computational operations to be integrated into a single composite operation. Specifically, it combines computational units with sequential dependencies (such as convolution, batch normalization, and ReLU activation) into a single composite operator. This allows operations that previously required separate execution in multiple steps to be completed in a single step, thereby reducing the storage requirements for intermediate results and the number of memory accesses.
[0057] For example, when processing a typical convolutional neural network, convolution, batch normalization, and ReLU activation operations might be combined into a single composite operator. In this combined mode, the output of the convolution operation no longer needs to be stored separately in memory; instead, it is directly used as the input to the batch normalization operation. Similarly, the output of the batch normalization operation also does not need to be stored and is directly passed to the ReLU activation operation. This approach not only reduces memory read / write operations but also lowers the overhead of data migration between different storage levels, thereby improving overall inference speed.
[0058] Furthermore, operator fusion can optimize the utilization of computing resources. In traditional inference processes, each computational unit executes independently, which leads to underutilization of computing resources (such as GPU streaming multiprocessors). However, operator fusion can combine multiple computational tasks into a single task, thereby utilizing computing resources more efficiently and further improving inference performance.
[0059] Therefore, in addition to direct algorithm improvements, this technology utilizes hardware features for optimization measures such as parallel computing to further accelerate the inference process. For example, on the Ingenic T41 chip, by fully leveraging its parallel computing capabilities, the originally serial computing task can be decomposed into multiple parallel tasks, thereby significantly reducing the overall inference time.
[0060] In summary, this invention reduces the inference time of neural network detection algorithm models on the T41 chip through operator fusion technology, which not only improves the inference speed and accuracy of the model, but also reduces the demand for computing resources.
[0061] Specifically, this application relates to a multi-convolutional graph optimization method for training quantization models in neural networks. The method reorganizes and merges operators in the computation graph, integrating multiple independent computational operations into a single composite operation. This combines computational units with sequential dependencies in neural networks, such as convolution operations, batch normalization operations, and ReLU activation operations, into a single composite operator. This allows operations that would otherwise be performed separately in multiple steps to be completed in the same step. The convolution operation is a core component of Convolutional Neural Networks (CNNs), using a learnable convolutional kernel to slide across the input data and extract local features. The batch normalization operation standardizes the mean and variance of each batch of data, ensuring a relatively stable distribution of inputs at each layer of the network, and is a technique used to accelerate neural network training. The ReLU activation operation is a commonly used activation function that introduces non-linear features by setting the negative part of the input value to 0 while keeping the positive part unchanged.
[0062] The specific implementation combines four separate convolution operators into a single fusion operator, consisting of two convolutions with a kernel of 3 and two convolutions with a kernel of 1. This fusion operator is designed to improve the performance and efficiency of neural networks. Specifically, as... Figure 1 As shown, the method of this fusion operator follows these steps:
[0063] S1. Traverse the entire neural network graph and check the attributes of the original multi-nodes: First, traverse the entire structure of the neural network to find multi-convolutional structures that meet specific conditions; the specific conditions include the connection relationship between multi-convolutions, the size of the convolution kernel, the stride parameter of the convolution, and other related features that are manually set according to the fusion conditions, i.e., some parameter attributes that meet the fusion requirements.
[0064] S2. The creation of new nodes, the assignment of parameters from the original multi-nodes to the new nodes, and the clearing of the original multi-nodes include:
[0065] Create a new fusion layer operator node to store all parameters of the multi-convolutions that need to be fused: Once a multi-convolution structure that meets the fusion requirements is found, a new fusion layer operator node will be created, which will be responsible for integrating the computation functions of the four convolution operators.
[0066] Assigning input-output connections and parameters: After creating a new fusion layer operator node, assign the input-output connections and related parameters of all nodes in the original multi-convolution structure to the fusion layer operator; in this way, the fusion layer operator can correctly execute its fused computational task.
[0067] Remove nodes from a specific structure: After constructing the fusion layer operator, remove all nodes from the original multi-convolutional structure; simplify the structure of the neural network and reduce unnecessary computational burden;
[0068] S3. Update the neural network graph, i.e., update the entire neural network graph: Finally, based on the connection relationships between neural network nodes, update the entire neural network graph again to ensure that other parts of the neural network can correctly interact with the new fusion layer operator.
[0069] In this way, this application implements an efficient convolution operator fusion method, which helps improve the training speed and performance of neural networks. At the same time, this method also helps reduce model complexity, making it easier to understand and optimize.
[0070] like Figure 2 and Figure 3 As shown, the implementation process of this method involves checking, counting, and updating node attributes. The following are the detailed steps and logical explanations of the operator fusion operation:
[0071] Step S1 further includes:
[0072] S1.1. Update node name mapping:
[0073] Use node_name_map.update(graph) to update the name mapping of all nodes in the graph for faster lookup later;
[0074] S1.2. Traverse each node:
[0075] By iterating through all nodes in the graph, the current node is obtained using graph->mutable_node(i); S1.3. Obtain target device attributes:
[0076] Set the device name for which the fusion operation will take effect, for example, the target device is set to "T40" by default, and then use the get_node_attr function to get the device attributes of the current node from the node attributes; if the retrieval fails, log the error information;
[0077] S1.4. Initialize flags and counters:
[0078] Set Boolean flags K33S1 and K33S2 to indicate whether the corresponding convolution operation has been found;
[0079] Initialize the counter pws1_node_counter to record the number of PWS1 nodes that meet the criteria;
[0080] S1.5. Check K33S1 operation:
[0081] Check if the current node is "KQUANTIZE_CONV2D" and is compatible with the target device; obtain the node's input attributes, kernel size, and stride information to confirm whether it meets the K33S1 condition, i.e., a 3x3 kernel with a stride of (1,1);
[0082] If the condition is met, set K33S1 to true;
[0083] S1.6. Search for K33S2:
[0084] Find other nodes (consumers) that use the output of the current node, and iterate through these consumers;
[0085] Check if the consumer has a K33S2 convolution kernel with a stride of (2,2);
[0086] If found, set K33S2 to true;
[0087] S1.7. Count PWS1 nodes:
[0088] For the consumer of K33S2, find other nodes in its output and check if these nodes are PWS1 (1x1 convolution kernel, stride (1,1));
[0089] If a matching PWS1 node is found, update the counter.
[0090] Step S2, merging nodes, includes:
[0091] S2.1, Merge Nodes: If the found nodes meet the conditions (e.g.) Figure 2 If the four nodes K33S1, K33S2, K11S1, and K11S1 shown meet the requirements, then the merging process begins:
[0092] S2.2, Change the operation type of the current node to merge operation:
[0093] KMERGE_QUANTIZE_K33FOCUSK3S2PWS1PWS1;
[0094] S2.3, create a temporary node attr_temp to store the attributes of the current node, and update its attributes to a prefixed form;
[0095] S2.4, clear the attributes of the current node and copy the attributes of the temporary node back;
[0096] S2.5, update the properties of K33S2 and modify its inputs so that the merged nodes can be used as new inputs.
[0097] The updated diagram is described in step S3:
[0098] If node merging has occurred, the update_graph function is called to reflect these changes.
[0099] Through the above steps, the operator fusion operation effectively merges multiple convolution operations into one, thereby improving computational efficiency and adapting to the needs of specific hardware.
[0100] It is worth noting that operator fusion is not limited to the convolution, batch normalization, and ReLU activation operations mentioned above. The convolution nodes in this method include convolution operations, batch normalization operations, and ReLU activation operations. Any computational unit with sequential dependencies can be the object of fusion, such as pooling operations and fully connected layer operations. By flexibly applying operator fusion methods, optimal inference schemes can be designed for different network structures and application scenarios.
[0101] The operator fusion method of this invention effectively reduces the time consumption and memory usage of model detection and inference while ensuring detection accuracy. This method not only improves inference speed but also reduces the demand for hardware resources, enabling deep learning models to run more efficiently in resource-constrained environments. This innovative achievement undoubtedly provides new ideas and possibilities for the deployment and application of deep learning models on resource-limited devices. In the future, with the continuous development of deep learning technology, this operator fusion technology will play an important role in more fields and scenarios, promoting the popularization and application of artificial intelligence technology.
[0102] Although preferred embodiments of the present application have been described, those skilled in the art, upon learning the basic inventive concept, can make other changes and modifications to these embodiments. Therefore, the appended claims are intended to be interpreted as including the preferred embodiments as well as all changes and modifications falling within the scope of the embodiments of the present application.
[0103] Finally, it should be noted that in this document, relational terms such as "first" and "second" are used only to distinguish one entity or operation from another, and do not necessarily require or imply any such actual relationship or order between these entities or operations. Furthermore, the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or terminal device that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or terminal device. Without further limitations, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, method, article, or terminal device that includes said element.
[0104] The above description is merely a preferred embodiment of the present invention and is not intended to limit the present invention. For those skilled in the art, various modifications and variations can be made to the embodiments of the present invention. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the protection scope of the present invention.
Claims
1. A method for optimizing multi-convolutional graphs in training quantization models for neural networks, characterized in that, The method reorganizes and merges operators in the computation graph, integrating multiple independent computational operations into a single composite operation. It combines computational units with sequential dependencies in neural networks, such as convolution, batch normalization, and ReLU activation, into a single composite operator. This allows operations that would otherwise be performed separately in multiple steps to be completed in the same step. The convolution operation is a core component of Convolutional Neural Networks (CNNs), using a learnable convolutional kernel to slide across the input data and extract local features. The batch normalization operation standardizes the mean and variance of each batch of data, maintaining a relatively stable distribution of inputs at each layer of the network, and is a technique used to accelerate neural network training. The ReLU activation operation is an activation function that sets the negative part of the input value to 0 while keeping the positive part unchanged, introducing non-linear features.
2. The multi-convolutional graph optimization method for training quantization models of neural networks according to claim 1, characterized in that, The method combines four separate convolution operators into a single fusion operator, which includes two convolutions with a kernel of 3 and two convolutions with a kernel of 1, and includes the following steps: S1. Traverse the entire neural network graph and check the attributes of the original multi-nodes: First, traverse the entire structure of the neural network to find multi-convolutional structures that meet specific conditions; the specific conditions include the connection relationship between multi-convolutions, the size of the convolution kernel, the stride parameter of the convolution, and other relevant features set manually according to the fusion conditions, i.e., parameter attributes that meet the fusion requirements. S2. The creation of new nodes, the assignment of parameters from the original multi-nodes to the new nodes, and the clearing of the original multi-nodes include: Create a new fusion layer operator node to store all parameters of the multi-convolutions that need to be fused: Once a multi-convolution structure that meets the fusion requirements is found, a new fusion layer operator node will be created, which will be responsible for integrating the computation functions of the four convolution operators. Assigning input-output connections and parameters: After creating a new fusion layer operator node, assign the input-output connections and related parameters of all nodes in the original multi-convolution structure to the fusion layer operator; in this way, the fusion layer operator can correctly execute its fused computational task. Remove nodes from a specific structure: After constructing the fusion layer operator, remove all nodes from the original multi-convolutional structure; simplify the structure of the neural network and reduce unnecessary computational burden; S3. Update the neural network graph, i.e., update the entire neural network graph: Finally, based on the connection relationships between neural network nodes, update the entire neural network graph again to ensure that other parts of the neural network can correctly interact with the new fusion layer operator.
3. The multi-convolutional graph optimization method for training quantization models of neural networks according to claim 1, characterized in that, Step S1 further includes: S1.
1. Update node name mapping: Use node_name_map.update(graph) to update the name mapping of all nodes in the graph for faster lookup later; S1.
2. Traverse each node: By iterating through all nodes in the graph, the current node is obtained using graph->mutable_node(i); S1.
3. Obtain target device attributes: Set the device name for which the fusion operation will take effect, and then use the get_node_attr function to retrieve the device attributes of the current node from the node attributes; if the retrieval fails, log the error message. S1.
4. Initialize flags and counters: Set Boolean flags K33S1 and K33S2 to indicate whether the corresponding convolution operation has been found; Initialize the counter pws1_node_counter to record the number of PWS1 nodes that meet the criteria; S1.
5. Check K33S1 operation: Check if the current node is "KQUANTIZE_CONV2D" and is compatible with the target device; Obtain the node's input attributes, kernel size, and stride information to confirm whether it meets the K33S1 condition, i.e., a 3x3 kernel with a stride of (1,1). If the condition is met, set K33S1 to true; S1.
6. Search for K33S2: Find other nodes (consumers) that use the output of the current node, and iterate through these consumers; Check if the consumer has a K33S2 convolution kernel with a stride of (2,2); If found, set K33S2 to true; S1.
7. Count PWS1 nodes: For the consumer of K33S2, find other nodes in its output and check if these nodes are PWS1 (1x1 convolution kernel, stride (1,1)); If a matching PWS1 node is found, update the counter.
4. The multi-convolutional graph optimization method for training quantization models of neural networks according to claim 1, characterized in that, Step S2 further includes: S2.1, Merging Nodes: If the found nodes meet the conditions, then begin merging: S2.2, Change the operation type of the current node to merge operation: KMERGE_QUANTIZE_K33FOCUSK3S2PWS1PWS1; S2.3, create a temporary node attr_temp to store the attributes of the current node, and update its attributes to a prefixed form; S2.4, clear the attributes of the current node and copy the attributes of the temporary node back; S2.5, update the properties of K33S2 and modify its inputs so that the merged nodes can be used as new inputs.
5. The multi-convolutional graph optimization method for training quantization models of neural networks according to claim 1, characterized in that, Step S3 further includes updating the graph: If node merging has occurred, the update_graph function is called to reflect the changes during the merging process.
6. The multi-convolutional graph optimization method for training quantization models of neural networks according to claim 1, characterized in that, The convolution nodes of the method include convolution operations, batch normalization operations, and ReLU activation operations. Any computational unit with sequential dependencies can become the object of fusion. It also includes pooling operations and fully connected layer operations.