Evolutionary neural architecture search method and system based on performance-level agent assistance

Abstract

The present invention provides an evolutionary neural architecture search method and system based on performance-level agent assistance, the method explores the effective representation of neural network architecture from the perspective of graph, and uses graph neural network to extract the characteristics of network architecture. In order to reduce the high resource consumption problem of evolutionary neural architecture search, an agent model for predicting architecture performance level is proposed. Through the prediction of architecture performance level by the agent model, evolutionary neural architecture search can fully explore the search space and search for high-performance network architecture. The present invention designs a crossover operator based on simple paths to retain the effective data processing path in the parent architecture as much as possible, ensuring that the child architecture inherits the excellent characteristics of the parent, thereby improving performance stability. The agent-assisted evolutionary neural architecture search framework of the present invention can search for high-performance neural network architectures at a relatively low cost on task data sets, providing a new perspective and efficient method for the automated design and optimization of neural network architectures.

Description

Technical Field

[0001] The present invention relates to the field of automated machine learning, and in particular to a method and system for searching an evolutionary neural architecture based on a performance-level agent. Background Art

[0002] As an important model of machine learning, neural networks have been successfully applied in computer vision, natural language processing, medical health and other fields. The network architecture determines the feature extraction and representation capabilities of the model. A reasonable architecture can effectively capture important features in the data, thereby improving the performance of the model. Excellent architecture design can bring higher accuracy, efficiency and a wider range of application scenarios. However, designing efficient neural network structures often requires deep expertise and a lot of experimental work, which makes network architecture design a complex and time-consuming task. To solve this problem, neural network architecture search came into being. Neural network architecture search is an automated process that systematically searches and optimizes the architecture of neural networks to find the network structure that best suits a specific task. It aims to reduce the complexity of manually designing network architectures and improve the performance and efficiency of networks. Through architecture search, researchers and engineers can find better network architectures to achieve better results in applications such as computer vision, natural language processing, and speech processing. This method makes the design process of neural networks more intelligent and improves the overall performance of artificial intelligence systems.

[0003] Although neural architecture search has shown great potential in the automated design and optimization of neural network architectures, the expensive computational cost has become a bottleneck restricting its development. A large number of candidate architectures need to be evaluated during the search process, and the evaluation of each architecture usually requires complete training and verification. At the same time, the search process may take weeks or even months, especially when using deep neural networks and large-scale data sets, which leads to huge computing resource consumption and time costs. On the other hand, evolutionary computing has strong adaptability and can optimize neural network architectures for different tasks. The search space of neural network architectures is usually very large and complex, and evolutionary algorithms can effectively explore the space through randomness and diversity mechanisms. However, evolutionary computing based on population mechanisms requires the evaluation of a large number of individual architectures. This has also led to the further development and application of evolutionary neural architecture search.

[0004] In recent years, a proxy-assisted neural architecture search framework has emerged. The proxy model is an effective way to reduce the resource consumption of neural architecture search. As a data-driven method, it establishes a mapping relationship from architecture to performance through existing data to predict the performance of unknown architectures. The proxy model can give the prediction results of architecture performance in milliseconds, and the cost of its construction and maintenance is extremely low. Using cheap proxy model predictions to replace expensive architecture performance evaluations effectively reduces the high consumption of neural architecture search. However, the existing proxy model methods still have problems such as low prediction accuracy and unstable prediction results. How to select efficient proxy indicators and ensure stable and available prediction results are key factors in determining the performance of proxy models. At the same time, the existing evolutionary operators have not been designed according to the characteristics of neural network architectures. How to generate high-performance architectures through efficient evolutionary operators also directly affects the final search results. Therefore, it is very necessary to propose an evolutionary neural architecture search method based on performance-level proxy assistance to achieve an efficient search process. Summary of the invention

[0005] Purpose of the invention: The technical problem to be solved by the present invention is to provide a method and system for searching an evolutionary neural architecture based on a performance-level agent in view of the shortcomings of the prior art. The method comprises the following steps:

[0006] Step 1: Initialize an architecture population, evolve for several generations, and truly evaluate all architecture individuals in the population to obtain real performance and record the existing architecture performance data;

[0007] Step 2: Divide the performance levels of the architecture according to the actual performance, label the levels as training data, and use the training data to train a proxy model. The proxy model establishes a mapping relationship from architecture to performance level, and can predict the performance level of an unknown architecture.

[0008] Step 3: Generate architecture individuals through crossover operators and mutation operators based on simple paths, and use the proxy model to predict the performance level of the architecture individuals. High-level architectures are retained, and low-level architectures are directly eliminated.

[0009] Step 4: The high-level architecture continues to participate in the selection process, evaluates the actual performance of the architecture that is finally retained, and adds the existing architecture performance data; if the conditions are met, the proxy model is updated with the latest architecture performance data to optimize the model performance to adapt to different search stages;

[0010] Step 5: merge the evaluated high-level architecture with the current population and perform environmental selection. In order to maintain the diversity of the population, a tournament selection is used to generate a new population.

[0011] Step 6: Repeat steps 3 to 5 until the stopping condition is met and output the global optimal architecture.

[0012] In step 1, the reason why several generations of evolution are required first is that the proxy model based on performance level prediction requires some high-performance architectures as training samples. Only when the training data set contains both high-performance architectures and low-performance architectures can the proxy model learn the knowledge of performance levels. Therefore, through several generations of evolution, the performance of the architecture population has been improved to a certain extent, ensuring that some high-performance architectures are contained in the training data.

[0013] In step 1, after initializing an architecture population P, evolve G generations, where G is less than or equal to 10, evaluate the performance of each architecture on the task dataset (a dataset collected and prepared for a specific task or goal, used to train, validate, and test the model, and help the model learn the patterns and relationships required for a specific task) and save it in the record Among them represents an architecture-performance pair, is the i-th architecture in the record, is the performance corresponding to the i-th architecture, and N is the record Archive The total number of schemas in .

[0014] In step 2, you first need to divide the layers according to the existing architecture performance data and create a training data set for the proxy model to train the proxy model. The number of layers needs to be determined based on the size and complexity of the search space. Sort the existing architecture data by performance, then divide the architecture into layers according to the number and label the layers accordingly. This will be used for supervised training of the proxy model. Step 2 specifically includes:

[0015] Step 2.1, divide the performance level of the architecture and create a training data set:

[0016] For the record Architectures in , by performance Sort from large to small, set the performance level to K, and the division results are:

[0017] ,

[0018] Data is the proxy model Model A training dataset for supervised training of the model; Represents the Kth level divided, is the number of architectures in the Kth level, K identifies the architecture Level of

[0019] Step 2.2, design the structure of the proxy model:

[0020] Proxy Model ModelIt includes an architecture feature extractor and a level divider, which are coupled to each other to jointly train and complete the tasks of architecture feature extraction and level division;

[0021] The architecture feature extractor includes a graph convolution layer, and the architecture feature extractor extracts the architecture features of the neural network based on the transmission and aggregation of information between nodes to obtain an architecture representation;

[0022] The layer divider includes a fully connected layer, and the layer divider completes the prediction of the performance level of the neural network architecture based on the learning of the architecture representation, and divides the corresponding architecture into the corresponding performance level;

[0023] The neural network architecture can be viewed as a directed acyclic graph, where edges represent connections and nodes represent operations. For graph-structured data, graph neural networks are based on the transmission and aggregation of information between nodes, and can utilize the information encapsulated in the graph structure to obtain an effective architecture representation. Therefore, the architecture feature extractor consists of a certain number of graph convolution layers. The features of each node are usually represented by a feature vector X. These features can be node attributes, embedded representations, or initial features obtained from other sources. In each layer of graph convolution, the feature vector of each node is updated by the feature vectors of neighboring nodes, described as:

[0024] ,

[0025] in, is the activation function; is the adjacency matrix of the graph with self-loops added; D is the degree matrix of all nodes, which is a diagonal matrix and is calculated as: ; is the first Line The elements of the column, is the adjacency matrix Middle The element in the row and column b;

[0026] It is the architecture feature extractor l The trainable weight matrix of the layer, that is, the parameter matrix of this layer; It is the architecture feature extractor l The node feature vector of the layer is the node feature representation obtained by continuously transmitting and aggregating information through the above formula, and , represents the input of the entire architecture feature extractor It is the initial node feature vector X. The node feature information extracted by the graph convolution layer is then combined with all feature information through a global pooling layer to obtain a representation of the architecture in the latent space.

[0027] Next, the architecture representation will be input into the level divider to predict the performance level to which the corresponding architecture belongs; the level divider is composed of a certain number of fully connected layers, which is used to establish a mapping relationship from the architecture representation to the performance level. In the present invention, the architecture feature extraction and performance level division modules are coupled with each other, and the weight parameters of the two modules will be trained and optimized at the same time. This will facilitate the collaborative work of the two modules and complete the extraction of architecture features and the division of performance levels at the same time.

[0028] Step 2.3, the present invention specifically designs a loss function for the training process of the proxy model according to the task characteristics of the proxy model. In neural architecture search, effective architecture representation is the key to successfully achieving efficient search and optimization. On the one hand, the architecture representation should fully reflect the topological structure and operation information of the network architecture. On the other hand, if the architecture representation can be distributed in the latent space according to the performance, then this will be beneficial to the prediction and search process of the proxy model. In other words, the architecture representation in the latent space is preferably able to present a certain distribution according to the performance. For example, the representation of high-performance architectures and low-performance architectures in the latent space should be as principle as possible to minimize the interference with the prediction of the proxy model; architectures with similar performance should be gathered in similar representation areas to facilitate the prediction of the proxy model as much as possible. Accordingly, in the task of predicting performance levels, the architecture representations of the same level should be as close as possible, and the architecture representations of different levels should be as far away as possible. Therefore, in order to achieve efficient architecture representation, it is necessary to design a special loss function.

[0029] First, in the hierarchical partitioning task, the present invention adopts the cross entropy loss function. It is a widely used loss function in deep learning, especially suitable for classification tasks. It measures the difference between the actual label and the predicted probability distribution, which is used to evaluate the prediction effect of the classification model and guide the model training by quantifying the inconsistency between the true category label and the predicted probability distribution. The hierarchical partitioning task can also be considered as a classification task, so the cross entropy loss function can be used to guide the training of the proxy model.

[0030] Design a loss function to guide the training process of the proxy model:

[0031] The loss function of the designed proxy model is expressed as:

[0032] ,

[0033] ,

[0034] ,

[0035] in, is the cross entropy loss function, m is the batch size of the input data, is the level of the i-th architecture in the batch predicted by the surrogate model, is the actual performance level corresponding to the i-th architecture; is the designed feature loss function, feature loss function It aims to guide the model to extract more favorable architectural features. It will reduce the architectural features between the same level and expand the architectural features between different levels, ensuring that architectures with similar performance are mapped to similar areas in the feature space. Among them, the function , It is the architecture representation and architectural representation The Euclidean distance between and is the input of the hierarchical partitioner, i.e., the output of the architecture feature extractor; when When the intermediate parameter , otherwise the intermediate parameter ; It is a critical value parameter that controls the feature distance between different levels of architectures; the greater the difference in levels, the greater the distance between architectural features should be. For architectures at the same level, the closer the distance between them, the better. It is a hyperparameter that controls the importance between two different loss functions. It can also be set as a learnable parameter, allowing the model to automatically determine the optimal value according to the training process. The total loss function L is used to guide the training of the proxy model until convergence.

[0036] In step 3, most of the existing evolutionary neural architecture searches use a crossover method based on the adjacency matrix. First, the adjacency matrix is ​​flattened into a one-dimensional vector, and the node operations are one-hot encoded and connected into a one-dimensional vector. Then the two one-dimensional vectors are concatenated as a representation of an architecture. Based on this vector representation, the traditional crossover operator is used. Since traditional crossover operators are usually designed for linear structures and are not suitable for processing the graph structure of neural networks, they may destroy the effective connection and structure of the original architecture, resulting in unstable performance of the generated sub-architecture. Moreover, ordinary crossover operators are often not intuitive when used on network architectures. Ordinary crossover operators lack an understanding of the characteristics of neural network architectures, resulting in greater randomness in the generated offspring architectures, making it difficult to inherit the excellent characteristics of the parent generation.

[0037] The present invention designs a crossover operator based on a simple path for generating a new architecture. The crossover operator based on a simple path is specially designed for graph structure data, and can better process the topological structure of the neural network, ensuring that the generated child architecture meets expectations. This crossover operator retains the effective data processing path in the parent architecture as much as possible, ensuring that the child architecture inherits the excellent characteristics of the parent, thereby improving performance stability. The crossover process based on a simple path is more intuitive, easy to understand and implement, and can more effectively explore and optimize the neural network architecture. By adopting a crossover operator based on a simple path, the shortcomings of the ordinary crossover operator can be overcome, the neural architecture search can be more effectively performed, and the performance and stability of the final generated architecture can be improved.

[0038] Step 3 specifically includes the following steps:

[0039] Step 3.1, using a simple path-based crossover operator to generate a new architecture;

[0040] In step 3.2, the proxy model is used to predict the performance level of the newly generated architecture.

[0041] Step 3.1 includes:

[0042] Step 3.1.1, select two parent architectures that need to be crossed, regard the architecture as a directed graph, and number all nodes, specifically including: according to the fitness values ​​of all architecture individuals in the population, give high-performance architectures a higher probability of selection, and give low-performance architectures a lower probability of selection, and then select two parent architectures from the population according to the roulette algorithm, perform a crossover operation, regard the two parent architectures as two directed graphs, and number the nodes in each graph in sequence from input nodes to output nodes;

[0043] Step 3.1.2, deconstruct the two directed graphs, obtain all their simple paths, and form a simple path candidate pool, specifically including: for each directed graph, find all its simple paths, that is, the node sequence from the input node to the output node without duplication, and combine all the simple paths into a path candidate pool, retaining the node sequence number and operation;

[0044] In step 3.1.2, for each directed graph, find all its simple paths, that is, the node sequence from the input node to the output node without duplication. In the network architecture, these simple paths are actually different data processing flows, such as a sequence of operations such as convolution-convolution-convolution-average pooling-convolution. Combine all simple paths into a path candidate pool, whose node numbers and operations are retained. The candidate path pool provides a variety of path selections, preserving the efficient data processing path of the parent architecture.

[0045] Step 3.1.3, randomly select several simple paths and reconstruct the directed graph of the sub-architecture, specifically including: the number of paths in the path candidate pool is M, a number of paths L is randomly generated from [1,M], and then L simple paths are randomly selected from the path candidate pool again, and the sub-generation architecture graph is reconstructed from the L simple paths; nodes with the same sequence number are merged into a node of the new graph, and nodes with different sequence numbers are used as newly generated nodes;

[0046] Step 3.1.4, according to different nodes, inherit operations in different ways, including: nodes inherited from the parent architecture, operations are directly retained, and the new nodes generated by merging randomly retain one of the node operations of the two parent architectures with a certain probability (generally 50%); after the intersection of the two parent architectures, a new child architecture is generated; because it can more effectively inherit the excellent characteristics of the parent generation, the crossover operator based on a simple path can speed up the convergence of the algorithm and find a high-performance architecture more quickly. For complex neural network structures, the crossover operator based on a simple path can better capture and utilize the hierarchical and modular characteristics of the network, and is more adaptable.

[0047] Step 3.1.5: Repeat steps 3.1.1 to 3.1.4 until a set number of new architectures are generated.

[0048] Step 3.2 includes:

[0049] Through the constructed proxy model for predicting the performance level of the architecture, the proxy model is used to predict the performance level of the newly generated architecture: for the set performance level K, the newly generated architecture will be divided into K levels, expressed as:

[0050] ,

[0051] in, represents the predicted i-th architecture, is the predicted performance level of the i-th architecture. It is unrealistic to obtain all the performance of each newly generated architecture in sequence, which will cause huge computational and time consumption. Since a proxy model for predicting the performance level of the architecture has been constructed, the present invention uses the proxy model to predict the performance level of the newly generated architecture.

[0052] Step 4 includes:

[0053] Step 4.1, use the architecture feature extractor in the proxy model to obtain all feature representations of the training data, and then calculate the hierarchical center of the performance level;

[0054] Step 4.2, use the architecture feature extractor in the proxy model to obtain the feature representation of each architecture in the high-level layer, calculate the distance between the feature representation and the center of the highest performance layer, and select the architecture closest to the center for performance evaluation;

[0055] In step 4.3, if the update conditions of the proxy model are met, the proxy model is updated using the latest architecture performance data, and the proxy model is iteratively updated online.

[0056] Step 4.1 includes:

[0057] For m architectures, a proxy model is used to extract feature representations for all architectures in the training dataset Data, expressed as:

[0058] ,

[0059] in, Represents the i-th architecture extracted The feature representation of

[0060] According to the performance level, calculate the center C of K levels respectively, and extract each level architecture in turn , calculate the center C of the hierarchy, expressed as:

[0061] ,

[0062] in, represents the level center of the t-th level, represents the number of architectures at the tth level, represents the feature representation of the i-th architecture in the t-th level.

[0063] Step 4.2 includes:

[0064] In the results predicted by the proxy model, obtain the feature representation of each architecture in the highest level, calculate the distance between the feature representation and the center of the highest level, select V architectures with the smallest distance, and the V architectures are the most worthy network architectures to be fully trained using the dataset to obtain the performance of the V architectures on the task dataset, and store the results in the record Archive middle;

[0065] Step 4.3 includes:

[0066] If the proxy model evolves to the set number of generations, that is, after every 10 generations, the latest record is used Archive, continue to use the hierarchical division method to create the latest training data set Data, and use the training data set Data to update the proxy model. Although each generation of updates will obtain a better proxy model, the computing consumption and search time will also increase accordingly. Taking all factors into consideration, updating the proxy model at a certain frequency can reduce computing consumption while also obtaining a proxy model with sufficiently high performance.

[0067] Step 5 includes: merging the latest evaluated architecture with the existing architecture in the current population. The merged population contains a variety of possible architectures, providing a wealth of candidate solutions for the next environmental selection. On the one hand, in order to retain the current optimal architecture, the elite strategy is first used to select the top-ranked architectures for direct retention. At the same time, in order to ensure that the diversity of the population is maintained during the selection process, the subsequent architecture adopts the tournament selection strategy. Tournament selection is a commonly used selection method that randomly selects several individuals in the population for comparison, and then selects the best performing individuals to enter the next generation. This process is repeated until a new population is generated. In this way, while retaining excellent individuals, it is possible to avoid the population from converging to the local optimal solution too early, and maintain the diversity and exploration ability of the population. Ultimately, the quality of the population can be effectively improved during the optimization process, ensuring the diversity of the population, thereby increasing the probability of finding the optimal neural network architecture.

[0068] The present invention also provides an evolutionary neural architecture search system based on performance level agent assistance, comprising:

[0069] Simple path-based evolution operator module: used to generate new neural network architectures and promote the population evolution process;

[0070] Architecture feature extraction module based on graph neural network: used to extract the topological information and operation information of the network architecture and obtain the vector representation of the network architecture;

[0071] Proxy model based on performance tier division: used to establish a mapping relationship from architecture representation to performance tier and predict the performance tier of neural network architecture.

[0072] By constructing a new proxy model, the present invention can effectively reduce the computational consumption of evolutionary neural architecture search and accelerate the search process, better explore the entire search space, and stably search for the optimal neural network architecture. The proxy model based on performance level prediction can accurately and stably give the performance prediction results of unknown architectures to assist the search process. The present invention also proposes to regard the neural network architecture as a directed acyclic graph, use the graph neural network to extract the architecture features, and obtain an effective architecture representation. Compared with the architecture representations previously studied, it has stronger adaptability and functionality. At the same time, based on the characteristics of the network architecture, a crossover operator based on a simple path is designed to retain the efficient data processing path in the network architecture to the greatest extent, and the crossover process is also more intuitive. From the new perspective of graph structure and performance level prediction, it brings new breakthroughs and progress to the field of evolutionary neural architecture search. Compared with the existing evolutionary neural architecture search method, the evolutionary neural architecture search framework composed of the technology proposed in the present invention has better results.

[0073] The beneficial effects of the present invention are:

[0074] The method of the present invention proposes an evolutionary neural architecture search method based on performance level agent assistance for evolutionary neural architecture search. The method extracts architectural feature representation through a graph neural network, and adopts a designed loss function to extract an efficient architectural representation. The network architecture is regarded as a directed graph, and the topological information and operation information in the neural network architecture are extracted through the information transmission mechanism of the graph neural network. The constructed agent model based on performance level prediction can efficiently predict the performance of the architecture from a new perspective of the performance level. The performance prediction of a large number of candidate architectures can be given in a cheap way, replacing the expensive architecture performance evaluation. At the same time, in the application of evolutionary computing in neural architecture search, a crossover operator that conforms to the characteristics of the network architecture is proposed. The crossover operator based on a simple path conforms to the characteristics of the neural network graph structure on the one hand, and on the other hand, it also retains the effective data processing path in the neural network to the greatest extent, and also has high interpretability. The performance level agent-assisted evolutionary neural architecture search method proposed in the present invention increases the fit of evolutionary computing in neural architecture search, and the proposed agent model method effectively reduces resource consumption, which can promote the application of neural architecture search in practical problems, and has high practical value and a wide range of application scenarios. BRIEF DESCRIPTION OF THE DRAWINGS

[0075] Figure 1 It is the algorithm framework diagram of the present invention.

[0076] Figure 2 This is a diagram of the proxy model structure of the present invention.

[0077] Figure 3 A crossover operator description diagram of the present invention.

[0078] Figure 4It is the performance of the architecture and the corresponding Gaussian kernel density estimation curve.

[0079] Figure 5 This is the effect diagram of the proxy model. DETAILED DESCRIPTION

[0080] The present invention will be further described in detail below in conjunction with the accompanying drawings and specific embodiments, and the above and / or other advantages of the present invention will become more clear.

[0081] like Figure 1 As shown, in a specific embodiment of the present invention, an evolutionary neural architecture search method based on performance level agent assistance is proposed. Figure 1 This is a framework diagram of the entire method, starting from initializing the population to outputting the results. On the benchmark dataset for evaluating neural architecture search methods, namely NAS-Bench-101, the implementation process and details of the performance-level proxy-assisted evolutionary neural architecture search method proposed in this invention will be introduced in detail. The method of the invention specifically includes the following steps:

[0082] Step 1: Initialize a schema population P of size N, an empty record Archive , evaluate all architectures in P on the task dataset and obtain their true performance values, recorded in Archive In Chinese, that is:

[0083] ,

[0084] in, is an architecture-performance pair, represents the i-th architecture, represents the performance value corresponding to the i-th architecture, and N is Archive The total number of schemas in .

[0085] Then the population P is evolved for a small number of generations and each newly generated architecture is evaluated, while also adding records Archive .

[0086] Step 2: Record Archive Based on the existing architecture performance data, the layers are divided and the training data set of the proxy model is prepared to train the proxy model. The architectures are sorted by performance, and then divided into K layers according to the number and the corresponding layer labels are added. Then, the proxy model is trained to establish a mapping model from architecture to performance layer.

[0087] Step 2.1: Archive The architectures in are sorted from high to low by performance, and the performance level is set to K. They are divided into K levels by quantity, and the number of architectures in each level is Q:

[0088] ,

[0089] The result of the division is:

[0090] ,

[0091] Data For the proxy model Model The training dataset is used for supervised training of the model. Represents the Kth level divided, is the number of architectures in this level, and K identifies the level of the architecture;

[0092] Step 2.2: Build Figure 2 The proxy model shown in Figure 1 (where C1 represents the number of channels in the input layer and C2 represents the number of channels in the output layer) consists of an architecture feature extractor and a level divider. The architecture feature extractor is based on a graph convolutional layer, and the level divider is based on a fully connected layer. A batch of architectures are input, and after feature extraction, they are input into the level divider, and finally the predicted level is output.

[0093] Step 2.3: Before using the proxy model, use Data The proxy model is trained in a supervised manner, and the loss function adopts the designed loss function until the model converges to obtain the proxy model Model After that, the Model right Data Extract feature representation from all architectures in , and calculate the centers C of K levels respectively according to their performance levels. Indicates request for record Archive The total number of schemas in .

[0094] Step 3: If Figure 3 As shown in the figure, after selecting two parent structures that need to be crossed, all simple paths are deconstructed to form a path pool. A certain number of simple paths are randomly selected from the path pool to reconstruct a new child structure. Then, the proxy model is used Model Predict the performance levels of all generated racks and retain the high-performance level architecture. This includes the following steps:

[0095] Step 3.1: Use a crossover operator based on simple paths to generate a new architecture. Consider the two parent architectures as directed graphs. Starting from the input node of the network architecture, number all nodes in sequence until the output node. Then, obtain all simple paths from the input node to the output node. Merge all the simple paths found by the two parent architectures to form a path pool. Randomly select a certain number of simple paths from the path pool. According to the node sequence number in each simple path, nodes with the same sequence number are merged into one node, and nodes with different sequence numbers are retained separately, thus reconstructing a new architecture. Repeat this process multiple times to generate 10N architectures. .

[0096] Step 3.2: Use the proxy model to predict the performance level of the newly generated architecture. Model right Each architecture in predicts the performance level, and obtains:

[0097] ,

[0098] in, is the i-th architecture Predicted architectural performance levels.

[0099] Step 4: Select promising architectures to evaluate their performance on the target dataset and, if conditions permit, leverage the latest Archive Update the proxy model. This includes the following steps:

[0100] Step 4.1: By Model Get Archive The characteristic representation of all architectures in is: , and then calculate each level center C, expressed as:

[0101] ,

[0102] Where t is a certain performance level, is the number of architectures at level t, is the feature representation of the i-th architecture.

[0103] Step 4.2: Select V high-level architectures. However, there will be three different situations. The first is that the number of architectures in the highest level is greater than V. In this case, the distance between the representation of each architecture in the highest level and the center C of the existing level is calculated, and the V architectures closest to the center C are retained; the second is that the number of architectures in the highest level is less than V but not 0. At this time, all the architectures in the highest level are retained, and the remaining architectures are extracted from the next highest level. The architecture closest to the center of this level is still selected; the third is that the number of architectures in the highest level is 0. At this time, according to the first and second similar situations, architectures are extracted from subsequent levels to make up the number V. Finally, the performance of V architectures on the target dataset is evaluated and the results are incorporated into Archive middle.

[0104] Step 4.3: If the proxy model update conditions are met, the division method in step 2 is used to Archive Perform hierarchical division to obtain a new training data set Data and train it in the same way Model Until convergence.

[0105] Step 5: The evaluated sub-architecture is merged with the current population, participates in environmental selection, and generates the next generation population P. The elite mechanism is adopted, with an elite control rate of 0.1, to select the top 10% of the best architectures from the previous generation population P and directly retain them, ensuring that excellent architectures can be retained; then, in order to maintain the diversity of the population, the tournament selection is adopted to select 90% of the architectures and elite architectures from the previous generation population to form the next generation population.

[0106] Repeat the above steps until the stopping condition is reached, and then output the global optimal architecture as the result.

[0107] NASBench-101 is a benchmark dataset for neural architecture search, which provides a standardized platform for evaluating and comparing different NAS methods. Researchers can use the same dataset and evaluation metrics for comparison, ensuring consistency and repeatability of results. NAS-Bench-101 contains more than 423,000 unique neural network architectures, each of which is evaluated on the CIFAR-10 dataset. This large-scale search space allows researchers to search and optimize across a large collection of architectures. This invention will be experimented on NAS-Bench-101 to verify its effectiveness.

[0108] In testing the crossover operator in the present invention, the performance was compared with random sampling and adjacency matrix-based crossover operators. The adjacency matrix-based crossover operator is often used in existing studies and is therefore selected as the baseline. 2000 architectures were randomly sampled on NAS-Bench-101, and then 2000 architectures were generated by the adjacency matrix-based crossover operator, and finally 2000 architectures were generated by the simple path-based crossover operator. Next, the Gaussian kernel density function of the generated architecture was calculated, and the performance of the architecture and the corresponding Gaussian kernel density estimation curve were plotted, as shown in Figure 2. Figure 4 shown.

[0109] It can be found that the architecture generated by the crossover operator based on the simple path has a higher overall performance than other methods. The performance of a large number of architectures is in a higher performance range, and the performance of the largest number of architectures is also higher than that generated by other methods. In addition, in NAS-Bench-101, the effect of the proxy model is also verified, such as Figure 5 Here is the confusion matrix of the proxy model prediction results. The prediction ability of the proxy model can be clearly seen from the results of the confusion matrix. It can be found that the proxy model predicts the performance level of the architecture with high accuracy.

[0110] The present invention provides a method and system for searching an evolutionary neural architecture based on a performance-level agent. There are many methods and ways to implement the technical solution. The above is only a preferred embodiment of the present invention. It should be pointed out that for ordinary technicians in this technical field, several improvements and modifications can be made without departing from the principles of the present invention. These improvements and modifications should also be regarded as the scope of protection of the present invention. All components not specified in this embodiment can be implemented using existing technologies.

Claims

1. An evolutionary neural architecture search method based on performance-level agent assistance, characterized in that: The method is used for speech processing and comprises the following steps: Step 1: Initialize an architecture population, evolve for several generations, and truly evaluate all architecture individuals in the population to obtain real performance and record the existing architecture performance data; Step 2: Divide the performance levels of the architecture according to the actual performance, label the levels as training data, and use the training data to train a proxy model. The proxy model establishes a mapping relationship from architecture to performance level, and can predict the performance level of an unknown architecture. Step 3: Generate architecture individuals through crossover operators and mutation operators based on simple paths, and use the proxy model to predict the performance level of the architecture individuals. High-level architectures are retained, and low-level architectures are directly eliminated. Step 4: The high-level architecture continues to participate in the selection process, evaluates the actual performance of the architecture that is finally retained, and adds the existing architecture performance data; if the conditions are met, the proxy model is updated with the latest architecture performance data to optimize the model performance to adapt to different search stages; Step 5: merge the evaluated high-level architecture with the current population, perform environment selection, and use tournament selection to generate a new population; Step 6, repeat steps 3 to 5 until the stopping condition is met, and output the global optimal architecture; In step 1, after initializing an architecture population P, evolve G generations, evaluate the performance of each architecture on the task dataset, and save it in the record Among them (Arch i ,y i ) represents an architecture-performance pair, Arch i is the i-th architecture in the record, y i is the performance corresponding to the i-th architecture, and N is the total number of architectures recorded in the Archive; Step 2 includes: Step 2.1, divide the performance level of the architecture and create a training data set: For the architecture in the record archive, by performance i Sort from large to small, set the performance level to K, and the division results are: Data is the training data set of the proxy model Model, which is used for supervised training of the model; Represents the Kth level, N K is the number of architectures in this level, K identifies the architecture Arch i Level of Step 2.2, design the structure of the proxy model: The proxy model Model includes an architecture feature extractor and a level divider. The architecture feature extractor and the level divider are coupled to each other and jointly train and complete the tasks of architecture feature extraction and level division. The architecture feature extractor includes a graph convolution layer, and the architecture feature extractor extracts the architecture features of the neural network based on the transmission and aggregation of information between nodes to obtain an architecture representation; The layer divider includes a fully connected layer, and the layer divider completes the prediction of the performance level of the neural network architecture based on the learning of the architecture representation, and divides the corresponding architecture into the corresponding performance level; In each layer of graph convolution, the feature vector of each node is updated by the feature vectors of neighboring nodes, which can be described as: Where σ is the activation function; is the adjacency matrix of the graph with self-loops added; D is the degree matrix composed of all nodes, calculated as: is the element in the ath row and ath column of the degree matrix D, is the adjacency matrix The element at row a and column b in ; W (l) is the trainable weight matrix of the lth layer of the architecture feature extractor; H (l) is the node feature vector of the lth layer of the architecture feature extractor, and H (0) =X, representing the input H of the entire architecture feature extractor (0) It is the initial node feature vector X. The node feature information extracted by the graph convolution layer is then combined with all feature information through a global pooling layer to obtain a representation of the architecture in the latent space. Next, the architecture representation will be input into the level partitioner to predict the performance level to which the corresponding architecture belongs; Step 2.3, design a loss function to guide the training process of the proxy model: The loss function of the designed proxy model is expressed as: L=L2+λL1, Among them, L1 is the cross entropy loss function, m is the batch size of the input data, is the level of the i-th architecture in the batch predicted by the surrogate model, t i is the actual performance level corresponding to the i-th architecture; L2 is the designed feature loss function, where function ψ(x) = max(x, 0), F(x i ,x j ) represents the architecture represents x i and the schema representation x j The Euclidean distance between i and x j is the input of the hierarchical partitioner, i.e., the output of the architecture feature extractor; when t i =t j When the intermediate parameter y ij =1, otherwise the intermediate parameter y ij =0; margin is the critical value parameter that controls the feature distance between different hierarchical structures; λ is a hyperparameter that controls the importance between two different loss functions; the total loss function L is used to guide the training of the proxy model until convergence; Step 3 includes: Step 3.1, using a simple path-based crossover operator to generate a new architecture; Step 3.2, using the proxy model to predict the performance level of the newly generated architecture; Step 3.1 includes: Step 3.1.1, select two parent architectures that need to be crossed, regard the architecture as a directed graph, and number all nodes, specifically including: according to the fitness values ​​of all architecture individuals in the population, give high-performance architectures a higher probability of selection, and give low-performance architectures a lower probability of selection, and then select two parent architectures from the population according to the roulette algorithm, perform a crossover operation, regard the two parent architectures as two directed graphs, and number the nodes in each graph in sequence from input nodes to output nodes; Step 3.1.2, deconstruct the two directed graphs, obtain all their simple paths, and form a simple path candidate pool, specifically including: for each directed graph, find all its simple paths, that is, the node sequence from the input node to the output node without duplication, and combine all the simple paths into a path candidate pool, retaining the node sequence number and operation; Step 3.1.3, randomly select several simple paths and reconstruct the directed graph of the sub-architecture, specifically including: the number of paths in the path candidate pool is M, a number of paths L is randomly generated from [1,M], and then L simple paths are randomly selected from the path candidate pool again, and the sub-generation architecture graph is reconstructed from the L simple paths; nodes with the same sequence number are merged into a node of the new graph, and nodes with different sequence numbers are used as newly generated nodes; Step 3.1.4, inherit operations in different ways according to different nodes, including: the nodes inherited from the parent architecture are directly retained, and the new nodes generated by merging are randomly retained from the node operations of the two parent architectures; after the intersection of the two parent architectures, a new child architecture is generated; Step 3.1.5, repeat steps 3.1.1 to 3.1.4 until a set number of new architectures are generated; Step 3.2 includes: Through the constructed proxy model for predicting the performance level of the architecture, the proxy model is used to predict the performance level of the newly generated architecture: for the set performance level K, the newly generated architecture will be divided into K levels, expressed as: Among them, Arch i represents the predicted i-th architecture, is the predicted performance level of the i-th architecture.

2. The performance-level agent-assisted evolutionary neural architecture search method according to claim 1, characterized in that: Step 4 includes: Step 4.1, use the architecture feature extractor in the proxy model to obtain all feature representations of the training data, and then calculate the hierarchical center of the performance level; Step 4.2, use the architecture feature extractor in the proxy model to obtain the feature representation of each architecture in the high-level layer, calculate the distance between the feature representation and the center of the highest performance layer, and select the architecture closest to the center for performance evaluation; In step 4.3, if the update conditions of the proxy model are met, the proxy model is updated using the latest architecture performance data, and the proxy model is iteratively updated online.

3. The performance-level agent-assisted evolutionary neural architecture search method according to claim 2 is characterized in that: Step 4.1 includes: For m architectures, a proxy model is used to extract feature representations for all architectures in the training dataset Data, expressed as: Among them, X i Represents the extracted i-th architecture Arch i The feature representation of According to the performance level, calculate the center C of K levels respectively, and extract each level architecture in turn Calculate the center C of the hierarchy, expressed as: Among them, C t represents the level center of the tth level, m t represents the number of architectures at the tth level, represents the feature representation of the i-th architecture in the t-th level.

4. The performance-level agent-assisted evolutionary neural architecture search method according to claim 3 is characterized in that: Step 4.2 includes: In the results predicted by the proxy model, obtain the feature representation of each architecture in the highest level, calculate the distance between the feature representation and the center of the highest level, select V architectures with the smallest distance, and the V architectures are the network architectures most worthy of full training with the dataset, so as to obtain the performance of the V architectures on the task dataset, and store the results in the record Archive; Step 4.3 includes: If the proxy model evolution reaches the set number of generations, the latest record Archive is used, and the hierarchical division method is used to create the latest training data set Data, and the training data set Data is used to update the proxy model.

5. The performance-level agent-assisted evolutionary neural architecture search system implemented by the performance-level agent-assisted evolutionary neural architecture search method according to any one of claims 1 to 4 is characterized in that: include: Simple path-based evolution operator module: used to generate new neural network architectures and promote the population evolution process; Architecture feature extraction module based on graph neural network: used to extract the topological information and operation information of the network architecture and obtain the vector representation of the network architecture; Proxy model based on performance tier division: used to establish a mapping relationship from architecture representation to performance tier and predict the performance tier of neural network architecture.

Images