Deep learning model structure design training verification method and device, equipment and medium

Abstract

The invention relates to the technical field of model construction, and provides a deep learning model structure design training verification method and device, equipment and a medium. The method comprises the steps of obtaining a training data set and an evaluation data set through preprocessing and grouping marking of original scene task data, screening out a candidate model structure from a model structure data set according to network structure configuration data, and carrying out model training and scene verification on the candidate model structure according to the training data set to screen out a qualified model set. And performing scene performance evaluation on each model in the qualified model set according to the evaluation data set to generate a performance index corresponding to each model, and screening out an optimal model from the qualified model set according to the task demand data and the performance indexes. According to the method, the search space is constructed, the NAS technology based on differentiation and evolution is used for rapid screening, and the model structure is optimized in the iteration process of training and verification, so that the high-precision model adaptive to the production scene is rapidly obtained.

Description

Technical Field

[0001] This application relates to the field of model building technology, and in particular to a method, apparatus, device and medium for deep learning model structure design, training and verification. Background Technology

[0002] The requirements for deep learning model architecture design, training, and validation are to ensure the model's adaptability and deployability to the target scenario from end to end. First, the original scenario data must be finely preprocessed and grouped (distinguishing between training / validation / testing, considering class imbalance and temporal distribution), and targeted data augmentation and annotation strategies should be formulated to improve robustness. Second, at the structural level, the search space and resource constraints (latency, computing power, storage, energy consumption, etc.) need to be clearly defined, and multi-dimensional performance indicators (precision, recall, AP, inference time, computing power consumption, etc.) should be used as design and selection criteria. The training phase requires stable optimization strategies, reasonable regularization and early stopping mechanisms, and repeatable hyperparameter search processes. Validation requires scenario-based inference evaluation, cross-domain / cross-time generalization testing, and versioned performance recording to support deployment decisions.

[0003] Existing design, training, and validation methods can be broadly categorized into two types: expert manual design and automated methods. Expert manual methods rely on existing network backbones (such as the ResNet / Transformer series) and complete the process through transfer learning, empirical network modification, and manual parameter tuning. Automated methods include NAS based on reinforcement learning or evolutionary algorithms, differentiable NAS (such as DARTS-like approaches), and automated hyperparameter search (grid / random / Bayesian optimization) and AutoML platforms. Training commonly employs standard optimizers (SGD / Adam), common data augmentation and regularization techniques, and validation primarily uses holdout sets, k-fold datasets, or standard benchmark datasets for evaluation. Before deployment, compression methods such as pruning, quantization, and distillation are often performed to meet resource constraints. Existing methods suffer from fragmented processes and insufficient scenario closure: either they rely heavily on human experience, leading to low design efficiency and difficulty in scenario adaptation, or they adopt a single NAS or training process but lack tight-coupled feedback with real-world scenario verification, making it impossible to achieve iterative optimization between training and verification metrics (especially multi-metric weighting, inference cost, and scenario adaptability). As a result, the selected model cannot simultaneously achieve accuracy, robustness, or resource adaptability in the actual production environment, resulting in low efficiency in verification and screening and poor engineering feasibility. Summary of the Invention

[0004] In view of this, this application provides a method, apparatus, device and medium for deep learning model structure design, training and verification, to solve the problem of insufficient closed-loop degree in the production scenario during the model structure generation process.

[0005] The first aspect of this application provides a method for designing, training, and validating deep learning model structures, the method comprising: Step S1: Preprocess and group the acquired raw scene task data to obtain training data set and evaluation data set; Step S2: Based on the preset network structure configuration data, select candidate model structures from the preset model structure dataset; Step S3: Based on the training data set, perform model training and scenario verification on the candidate model structure to select a qualified model set; Step S4: Perform scene performance evaluation processing on each model in the qualified model set according to the evaluation data group, and generate performance indicators corresponding to each model; Step S5: Based on the preset task requirement data and the performance indicators, select the best model from the qualified model set.

[0006] In an optional implementation, the preprocessing and grouping of the acquired raw scene task data to obtain training data sets and evaluation data sets includes: Based on the data attributes of the acquired original scene task data, the original scene task data is classified to obtain scene task datasets corresponding to each data type. Based on the data type, perform data cleaning, format conversion, and normalization on each type of data in the scenario task dataset to obtain a standardized dataset; By using a preset type-to-enhancement-strategy mapping table, the data in the normalized dataset are enhanced according to the data type to obtain an enhanced dataset. Using a preset type-to-labeling strategy mapping table, the augmented dataset is labeled with model targets according to the data type to obtain a target labeled dataset. The target labeled dataset is then divided into a training data group and an evaluation data group according to a preset grouping ratio.

[0007] In an optional implementation, the step of selecting candidate model structures from a preset model structure dataset based on preset network structure configuration data includes: The preset network structure configuration data is parsed and processed to construct the model structure search space data; The model structure search space data is subjected to continuous relaxation of structural units and gradient optimization to generate a model architecture parameter set; Based on the model architecture parameter set, a seed model structure set is selected from the preset model structure dataset; The performance feedback iterative screening process is performed on each model structure in the seed model structure set to obtain candidate model structures.

[0008] In an optional implementation, the step of training the candidate model structure and performing scene verification based on the training data set to select a qualified model set includes: Step S31: Iteratively train the model parameters of the candidate model structure according to the parameter training dataset to construct an initial model; Step S32: Perform inference verification on the initial model based on the scene verification dataset to calculate the precision and recall of the initial model; Step S33: Weight the precision and recall according to the preset weight coefficients to generate the scene fit value corresponding to the initial model; Step S34: Update the preset iteration value according to the preset update method, and update the network structure configuration data according to the scene adaptability value through the preset network structure configuration update method; When the scene adaptability value reaches the preset qualified threshold, the initial model is regarded as a qualified model; When the scene adaptability value does not reach the qualified threshold and the iteration value does not reach the preset iteration threshold, repeat steps S2 to S34 until the iteration value reaches the iteration threshold.

[0009] In an optional implementation, the step of performing scene performance evaluation on each model in the qualified model set based on the evaluation data group to generate performance indicators corresponding to each model includes: Based on the test data, forward inference processing is performed on each model in the qualified model set to record the inference time and output data of each model, and the computational cost of each model is calculated. Based on the test data, the corresponding target data is obtained from the evaluation data set, and the precision, recall and mean precision of each model are calculated based on the target data and the model output data. According to a preset data combination format, the inference time, computational cost, precision, recall, and mean precision are combined into the performance metrics of the corresponding model.

[0010] In an optional implementation, the step of performing continuous relaxation and gradient optimization on the structural units of the model structure search space data to generate a model architecture parameter set includes: Step S211: Extract the internal connection data of the structural units, the number of structural nodes, and the set of each candidate execution operation from the model structure search space data to generate the model structure search feature set corresponding to each candidate structure. Step S212: Perform weight initialization processing on each operation in the candidate execution operation set through a preset first random initialization method to obtain the architecture weight variables corresponding to each operation; Step S213: Search the feature set according to the model structure using the preset second random initialization method, initialize the training parameters of the candidate structures, and obtain the regular network parameters corresponding to each candidate structure. Step S214: Perform gradient optimization on the conventional network parameters according to the architecture weight variables to update the conventional network parameters; Step S215: Perform gradient optimization on the architecture weight variables according to the conventional network parameters to update the architecture weight variables; Step S216: Calculate the average change of the architecture weight variables before and after the update, and update the preset iteration round number value according to the preset update method; Repeat steps S214 to S216 until the number of iterations reaches a preset threshold or the average change is less than a preset threshold, and extract the architecture weight variables from the model structure search feature set to generate the model architecture parameter set.

[0011] In an optional implementation, the step of performing performance feedback iterative screening on each model structure in the seed model structure set to obtain candidate model structures includes: Step S221: Randomly perturb the parameters of each model structure in the seed model structure set to generate a derived model structure, and create an initial population based on each model structure in the seed model structure set and the derived model structure using a preset population creation method. Step S222: Perform fast proxy training on each model structure in the initial population according to the parameter training dataset in the evolutionary screening data group to generate proxy models corresponding to each model structure, and perform inference verification on the proxy models according to the scenario verification dataset in the evolutionary screening data group to calculate the fitness score corresponding to each proxy model. Step S223: Select the parent population from the initial population according to the fitness score through a preset performance screening method, and perform crossover recombination and random mutation processing on each model structure in the parent population according to the preset crossover probability and mutation probability to generate the offspring model structure set corresponding to each model structure. Step S224: Update the initial population according to the parent population and the offspring model structure set, and update the preset generation value according to the preset update method; Repeat steps S222 to S224 above, and calculate the score increase of the highest fitness score in the initial population before and after the update, until the score increase is less than a preset progress threshold or the evolution generation value reaches a preset generation threshold, so as to use the model structure corresponding to the highest fitness score in the updated initial population as a candidate model structure.

[0012] A second aspect of this application provides a deep learning model architecture design, training, and verification apparatus, the apparatus comprising: The task labeling module is used to preprocess and group the acquired raw scene task data to obtain training data sets and evaluation data sets. A data management module connected to the task labeling module is used to store the training data set and the evaluation data set; The structural design module is used to receive model structure design instructions input by the user and generate network structure configuration data according to the model structure design instructions; The model training module, which connects the data management module and the structure design module, is used to select candidate model structures from the preset model structure dataset according to the preset network structure configuration data, and to train the candidate model structures to generate an initial model. The model verification module, which connects the data management module and the model training module, is used to perform scene verification processing on the initial model based on the training data set to filter out a qualified model set, and to perform scene performance evaluation processing on each model in the qualified model set based on the evaluation data set to generate performance indicators corresponding to each model. The result management module, which is connected to the model validation module, is used to select the best model from the qualified model set based on the preset task requirement data and the performance indicators.

[0013] A third aspect of this application provides an electronic device, the electronic device including a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the computer program to implement the steps of the deep learning model structure design, training, and verification method as described above.

[0014] The fourth aspect of this application provides a computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements the steps of the deep learning model structure design, training, and verification method as described above.

[0015] In summary, this application includes at least the following beneficial technical effects: 1. By combining a visual structural design interface with automated neural network structure search, manual trial-and-error design is transformed into automated search and rapid candidate screening, which can shorten the structural design time from the traditional weeks to a few days, thereby significantly improving R&D efficiency and reducing labor costs.

[0016] 2. The structure search is coupled with training / validation in real time (the structure configuration is updated by the feedback of the indicators), and multiple scenarios / multiple sets of validation data and weighted indicators (precision, recall, etc.) are introduced to judge the qualified model, thereby improving the model's adaptability and robustness in real production scenarios. Attached Figure Description

[0017] To more clearly illustrate the technical solutions in the embodiments of this application or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0018] Figure 1 This is a flowchart of a deep learning model structure design, training, and verification method provided in an embodiment of this application; Figure 2 This is a functional block diagram of a deep learning model structure design, training, and verification device provided in an embodiment of this application; Figure 3 This is a schematic diagram of the structure of the electronic device provided in the embodiments of this application. Detailed Implementation

[0019] The technical solutions of the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, and not all embodiments. Based on the embodiments of this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application.

[0020] like Figure 1 The diagram shows a flowchart of a deep learning model structure design, training, and verification method provided in an embodiment of this application. The deep learning model structure design, training, and verification method provided in this embodiment includes the following steps.

[0021] Step S1: Preprocess and group the acquired raw scene task data to obtain training data set and evaluation data set.

[0022] It should be understood that raw scenario task data specifically refers to a multimodal raw data set directly related to the production environment in which the model is expected to be deployed. This data includes, but is not limited to, images, videos, audio, and text. These data originate directly from the target application scenario, such as surveillance video streams in intelligent security systems, high-resolution device images in industrial quality inspection, audio clips recorded by voice interaction devices, or dialogue text in customer service systems. The acquisition of raw scenario task data involves collection and aggregation from sensors, databases, log files, or public data sources. Raw scenario task data provides a realistic, diverse, and task-matched material foundation for model design and verification, ensuring that model development closely aligns with actual needs from the outset and avoiding insufficient model generalization ability due to data bias.

[0023] First, the original scene task data is categorized based on its data attributes to allow for appropriate preprocessing methods for different data types. For example, image processing focuses on pixel matrices, audio processing on sound spectrum, and text processing on word sequences and semantics. Data attributes include, but are not limited to, file format, encoding method, data structure, and signal dimensions. For instance, video files encapsulated in .mp4 or .avi formats are distinguished from audio files encoded in .wav or .mp3 formats, and structured tabular text is distinguished from natural language paragraph text. Through automated recognition or metadata-based classification, the original mixed data stream is organized into several homogeneous scene task datasets, such as image datasets, video datasets, audio datasets, and text datasets. Subsequently, based on the determined data types, data cleaning, format conversion, and normalization are performed on each data point in each scene task dataset. Data cleaning aims to remove or correct damaged, low-quality, or irrelevant samples. For image data, cleaning operations include detecting and removing completely blurred, overexposed, or heavily compressed images; for audio data, it may be necessary to filter out recordings with excessive background noise or excessively long silent sections. The data cleaning and processing described above provide clean input for model training. Format conversion aims to unify all data into a standardized format required for internal system processing. For example, it decodes images of various encodings into RGB pixel matrices and adjusts them to a specified size, resamples audio at different sampling rates to a uniform frequency, or unifies various text encodings to UTF-8. Format unification eliminates the complexity of data reading and parsing, ensuring a smooth processing pipeline. Normalization adjusts the numerical feature scale of the data to a consistent range, such as linearly scaling image pixel values ​​from 0-255 to 0-1, or performing zero-mean normalization. Normalization accelerates the convergence of the model training process and improves the numerical stability of the optimization process.

[0024] To personalize augmentation processing for different types of data and introduce reasonable data variations that conform to real-world variability into the data used for model training and validation, thereby expanding the diversity of training data, this paper proposes a method. Based on a normalized dataset, a pre-defined type-to-augmentation-policy mapping table is used to obtain augmentation policies corresponding to each data type. This allows for augmentation processing of each sample in the dataset according to its data type. The type-to-augmentation-policy mapping table defines a series of augmentation transformation operations and their parameter ranges applicable to each data type. For example, for images, mapping policies might include random horizontal flipping, random rotation, color dithering, and random cropping; for audio, policies might include time stretching, pitch transformation, and adding background noise; and for text, it might involve synonym replacement and random deletion. The type-to-augmentation-policy mapping table in this application can be configured and expanded according to task requirements, providing the model with richer learning samples, thereby enhancing the model's robustness and generalization ability to unseen scenarios and effectively combating overfitting. Next, targeted target annotation is performed on each type of data according to the pre-defined type-to-annotation-policy mapping table. This mapping table associates data types with corresponding automated annotation algorithms or tools. For example, for image data, if the task is object detection, the mapping strategy might be to call a pre-trained general object detection model for initial bounding box annotation, followed by manual verification and correction. For audio data, if the task is speech recognition, the mapping strategy might be to access an automatic speech recognition service to generate initial text transcription. For text data, if the task is named entity recognition, rule-based or pre-trained model-based entity extraction tools might be used. Through the above automated pre-annotation operations, each data sample is assigned a machine-readable "ground truth" or "label," such as the bounding box coordinates of target objects in an image, the corresponding transcript in audio, and the location and category of entities in text. The obtained object annotation dataset serves as the absolute basis for training and performance evaluation of supervised learning models.

[0025] Finally, according to the preset grouping ratio, the labeled target dataset is randomly divided into a training data group and an evaluation data group. The grouping ratio (e.g., 7:3 or 8:2) must ensure that the two groups maintain a balanced class distribution, i.e., following the principle of stratified sampling. The training data group will be mainly used for training and adjusting model parameters, while the evaluation data group serves as the final performance test for the model during the development phase, simulating the model's performance when faced with new, unseen data. This division is crucial; it strictly isolates the data used in the model learning process from the data used in the final evaluation process, ensuring the unbiasedness and reliability of the performance evaluation results, directly addressing the potential problem in the background technology that "improper validation set division and incomplete metrics can easily lead to performance degradation in actual deployment." Through the above operations, the complete preparation process from raw multimodal data to two datasets with clear objectives, standardized formats, and clear annotations lays a solid and high-quality data foundation for model structure search, training, validation, and evaluation.

[0026] Step S2: Based on the preset network structure configuration data, select candidate model structures from the preset model structure dataset.

[0027] It should be understood that network structure configuration data originates from the infrastructure blueprint defined by algorithm engineers through a visual interface. This blueprint describes the macroscopic skeleton of the network in a structured data format (such as JSON or YAML), specifying, for example, that the network consists of multiple repeating structural units (Cells), each containing a predetermined number of nodes, and defining the allowed connection directions and patterns between nodes. By parsing the obtained network structure configuration data, the defined topological constraints and component libraries are extracted, thus formally constructing the model structure search space data. This model structure search space data precisely defines a structured and finite scope, containing the hard connection framework that all models to be searched must adhere to (i.e., the connection data within structural units, the number of structural nodes), and the set of soft operations available at each allowed connection location (i.e., the set of candidate operations, such as 3x3 depthwise separable convolution, 5x5 standard convolution, max pooling, identity connection, etc.). The constructed model structure search space data transforms fuzzy design requirements into a computer-readable and optimizable mathematical problem, providing a standardized basis for model structure retrieval.

[0028] Subsequently, the first stage of neural network architecture search is performed. In this embodiment, the first stage employs a neural network architecture search based on a differentiable algorithm. A model architecture parameter set that can guide operation selection is generated based on the model architecture search space data obtained above. First, the internal connection data of structural units, the number of structural nodes, and the set of candidate execution operations contained in the model architecture search space data are extracted to construct a differentiable supernetwork (i.e., the model architecture search feature set) that can be used to characterize the model architecture design requirements (i.e., candidate structures). In the differentiable supernetwork, each candidate structure corresponds to a specific set of operation choices, and the continuous relaxation technique transforms the selection of discrete operations on each connection edge into a weighted summation of the outputs of all candidate operations. To achieve this transformation, an initial architecture weight variable is assigned to each candidate execution operation on each edge through a preset first random initialization method (e.g., sampling from a uniform distribution); simultaneously, the trainable parameters (e.g., the weight matrix of the convolutional kernel) contained in each candidate execution operation are initialized through a preset second random initialization method (e.g., Xavier initialization) to obtain the conventional network parameters. Among them, the architecture weight variable determines the relative importance of different candidate execution operations in the final mixed output; the regular network parameters represent the inherent computational power of each candidate execution operation.

[0029] Furthermore, the gradient optimization operation in the first stage of this application adopts the following alternating iterative two-level optimization operation: While ensuring that all obtained architectural weight variables (hereinafter denoted as set α) remain unchanged, the output of each candidate execution operation set in the differentiable supernetwork is determined by a weighted sum of a fixed set of α values, thus forming a composite of candidate execution operations with a defined mixing ratio—the computation graph. Subsequently, a batch of data is randomly sampled from the parameter training dataset obtained in step S1 and input into the computation graph. The data flows through each node of the computation graph, and each candidate execution operation (such as a 3x3 convolutional layer) transforms the input data based on its current regular network parameters (hereinafter denoted as set w, containing parameters such as kernel weights and biases). The outputs of all operations are weighted according to their corresponding α values ​​and passed to subsequent nodes, ultimately yielding the network's predicted output. The predicted output is compared with the true labels attached to the input parameter training dataset (i.e., the standard answer that should correspond to the output after modulo processing of the input parameter training dataset, obtained through pre-performed model trials) to calculate a scalar loss value (e.g., calculated using the cross-entropy loss function used for classification). Next, backpropagation is performed along the computation graph based on the loss value. For example, the partial derivative of the loss value with respect to each variable (i.e., set w) in the computation graph is calculated sequentially using the chain rule, thereby obtaining the gradient vector of the loss with respect to each regular network parameter. Finally, for each parameter in set w... ,implement: ,in It is the preset network parameter learning rate. The loss value is denoted as . The above operations enable the training of the internal parameters of each candidate operation, given structural preferences (i.e., fixed architecture weight variables), so that they can fit the training data.

[0030] While ensuring the obtained set w remains unchanged, a batch of data is randomly sampled from the scene verification dataset of the training data group obtained in step S1 (ensuring this data has not been used in the above operations), and the batch data is input into the hypernetwork computation graph after the regular network parameters are updated for forward propagation. At this time, since the set w is fixed, the internal computation of the operation is deterministic, but the output of each set of candidate operation executions is still weighted and mixed by a variable set α. The differentiable hypernetwork generates predictions again, and here the predicted output is compared with the true labels attached to the input scene verification dataset to calculate a new scalar loss value (reflecting the generalization performance of different operation mixing methods (determined by set α) under the current set w). Then, backpropagation is performed specifically for set α: the gradient of the loss value with respect to each architecture weight variable is calculated. Since set α directly participates in the weighted summation operation, its gradient indicates the potential direction of the impact of fine-tuning the operation weights on the verification loss. Finally, the architecture weights are updated according to the gradient descent rule: for each weight variable in set α ,implement ,in It is the preset architecture weight learning rate. The loss value is denoted as . The above operations enable the hybrid approach of the entire network to perform better on unseen validation data under the existing operational capabilities (i.e., with fixed conventional network parameters), thereby driving the architecture weight variables to tilt towards those operations that can improve the model's generalization ability.

[0031] After completing one full alternating iterative two-layer optimization operation, the mean of the absolute values ​​of the differences between the values ​​of all architecture weight variables before and after this update (i.e., the average change) is calculated. Simultaneously, the iteration count, which records the total number of alternations, is incremented by 1. Then, a termination logic check is performed: if the iteration count reaches a preset threshold, or the average change is less than a preset threshold, the optimization is considered converged or budgeted, and the alternating iterative two-layer optimization operation is terminated. Otherwise, the alternating iterative two-layer optimization operation is repeated based on the updated architecture weight variables and regular network parameters. After the loop terminates, all architecture weight variables are extracted from the final model to form a dense model architecture parameter set. This model architecture parameter set is not a directly executable model, but rather a "blueprint scoring table," where the architecture weight variables corresponding to each operation in each candidate execution operation set represent the relative importance of that operation as evaluated in the continuous relaxation space.

[0032] After obtaining the model architecture parameter set, a seed model structure set is selected from a pre-defined model structure dataset containing all possible discrete candidate combinations of execution operations. The selection operation used in this application is based on the magnitude of the architecture weight variables. For example, for each set of candidate execution operations in a differentiable supernetwork, the candidate execution operation with the highest architecture weight variable is selected. By combining all selected candidate execution operations, a specific discrete neural network structure is obtained. Selecting the top K candidate execution operation combinations with the highest architecture weight variables, or sampling multiple combinations with high architecture weight variables, forms the seed model structure set. The seed model structure set represents the architecture direction corresponding to the most promising model structure in the first stage of this application (i.e., the differentiable search stage).

[0033] Subsequently, a second stage of neural network architecture search is performed. In this embodiment, the second stage employs an evolutionary algorithm-based neural network architecture search. Its goal is to perform refined performance feedback iterative screening on the seed model architecture set generated in the first stage, thereby obtaining the final candidate model architecture. First, for each model architecture in the seed model architecture set (serving as a baseline individual), several derived model architectures are generated by applying random perturbations to its structural encoding (e.g., randomly replacing the operation type of a layer, or randomly adjusting the number of channels in a connection). The set of all baseline individuals and their derived individuals is then constructed as the initial population.

[0034] Next, in the evolutionary iteration cycle of the second stage of this application, each generation iteration includes the following four steps: fitness assessment, selection, reproduction, and population renewal: In the fitness evaluation phase, for each individual model structure in the current population, a rapid surrogate training is first performed to assess its potential: using a parameter training dataset from an evolutionarily selected dataset specifically partitioned from the training dataset, the network corresponding to that individual model structure is fully trained in a few epochs (e.g., 5 training cycles) to update all its weight parameters, thus obtaining a surrogate model with preliminary performance. Subsequently, the surrogate model is used for inference using a scenario validation dataset from the evolutionarily selected dataset: the validation data is input into the model to obtain a predicted output, and this prediction is compared with the true labels attached to the dataset to calculate a pre-defined performance evaluation metric (e.g., classification accuracy). The value of this metric is then mapped to the fitness score of that individual model structure.

[0035] In the selection phase, based on the calculated fitness scores of all individual model structures, a predetermined number of high-fitness individuals are selected from the current population using a pre-defined selection strategy (e.g., tournament selection) to form the parent generation. This selection process simulates the "survival of the fittest" principle in natural selection, ensuring that model structures with stronger scene adaptability are preserved. In the reproduction phase, individuals in the parent generation are randomly paired, and a structural crossover operation is performed with a pre-defined crossover probability: exchanging a portion of the structural codes of two paired individuals (e.g., exchanging the connection methods of a complete module in the network) to explore combinations of different desirable traits. Then, for each offspring individual produced after crossover, a structural mutation operation is performed with a pre-defined mutation probability: randomly modifying a bit or part of its code (e.g., changing an activation function from ReLU to SiLU). Crossover and mutation together introduce new structural changes, which are crucial for exploring the model structure search space and avoiding getting trapped in local optima. In the population update phase, the offspring model structure set generated through crossover and mutation, along with several optimal individuals directly retained from the current population based on fitness scores (i.e., model structures in the parent generation), are merged to form the next generation population. At the same time, increment the recorded generation number by 1.

[0036] After completing one iteration of the "evaluation-selection-breeding-update" evolutionary cycle, an iteration termination judgment is made. The judgment condition used in this application is: whether the evolutionary generation value has reached a preset generation threshold, or whether the score improvement of the highest fitness score in the population within a consecutive preset generation is less than a preset progress threshold. If either of these judgment conditions is met, the evolutionary iteration process terminates. Then, one or more individual model structures with the highest fitness scores are selected from the initial population of the final generation, and output as the final candidate model structure. If the termination condition is not met, the initial population of the new generation is used as the current population, and the above evolutionary iteration cycle is repeated. Through the above performance feedback iterative screening operation, a population-based heuristic search and competitive optimization are performed on the discrete model structure space, effectively supplementing the shortcomings of the first-stage continuous gradient search, together constituting a complete and efficient hybrid automatic model structure screening operation from coarse screening to refinement.

[0037] Step S3: Based on the training data set, perform model training and scenario verification on the candidate model structure to select a qualified model set.

[0038] It should be understood that the training data set is explicitly divided into a parameter training dataset for model parameter learning and a scenario validation dataset for performance verification. These two datasets are mutually exclusive to ensure the objectivity of the evaluation. First, the candidate model structure is instantiated as a concrete, weight-initialized neural network. Then, batches of data are continuously drawn from the parameter training dataset and input into the network. Standard forward propagation is performed to obtain predictions. These predictions are compared with the true labels inherent in the data using a loss function (such as cross-entropy loss) to obtain the loss value. Then, the gradient of the loss value relative to all network weight parameters is calculated using the backpropagation algorithm, and these weight parameters are updated based on the gradient using an optimizer (such as Adam). By repeating the above iterative training operation of the model parameters until the preset training epochs or convergence conditions are reached, an initial model that has completed parameter learning and is capable of task processing is finally produced.

[0039] Subsequently, the trained initial model undergoes rigorous inference validation to quantify its performance. The obtained initial model weights are then placed in inference mode. Next, a batch of data is extracted from the scene validation dataset and input into the model. The model performs forward propagation on the data and outputs prediction results. The system then compares these prediction results item by item with the pre-known true labels accompanying the scene validation dataset. Based on the statistical results of the comparison, two core performance metrics are calculated: precision and recall. Precision measures how many of the model's positive class predictions are correct, and its formula is: Precision = Number of correctly identified positive samples / Total number of positive samples identified by the model. Recall measures how many of the actual positive samples are correctly identified by the model, and its formula is: Recall = Number of correctly identified positive samples / Total number of actual positive samples. Taking object detection as an example, if the model predicts 100 bounding boxes on the validation set, of which 80 match the ground truth boxes well (considered as true examples), while the entire validation set actually contains 120 true objects, then the precision is 80 / 100=0.8 and the recall is 80 / 120≈0.667.

[0040] After obtaining precision and recall, the two are weighted and fused according to preset weight coefficients to generate the scenario fit value corresponding to the initial model. This application uses a linear weighting formula: Scenario Fit Value = β × Precision + (1-β) × Recall, where β is a weight coefficient preset between 0 and 1, used to adjust the relative importance of precision and recall according to specific task requirements. For example, in a financial fraud detection scenario, the cost of falsely identifying a normal transaction as fraud may be very high, thus requiring a higher precision; β can be set to 0.7. In a medical lesion screening scenario, the cost of missed detections is extremely high, thus requiring a higher recall; β can be set to 0.3. The scenario fit value, as a single comprehensive score, intuitively reflects the overall performance of the model in a specific business scenario.

[0041] Subsequently, iterative decisions are made based on performance feedback data. First, the iteration value recording the global attempt count is incremented by 1 according to a preset update method. Next, the system determines whether the scene fit value has reached a preset qualified threshold. If it has, it indicates that the performance of the initial model generated after training the current candidate model structure meets the requirements, and the system includes the initial model in the qualified model set. Through the above iterative decision judgment, the effectiveness of the structure is verified in real time by the training results. If the scene fit value has not reached the qualified threshold, and the iteration value has not exceeded the preset iteration threshold (to prevent infinite iteration loop operation), this application uses a key adaptive algorithm to update the preset network structure configuration. The input of this algorithm is the currently unqualified scene fit value and possible historical search information, and the output is a modification suggestion for the initial network structure configuration data on which step S2 depends. For example, the algorithm may analyze that the current performance bottleneck is due to insufficient receptive field of the model, and thus add more large-size convolution candidate operations in the configuration data; or it may determine that the connection is too complex, leading to overfitting, and thus simplify the connection topology within the unit. Subsequently, the system re-executes the entire S2 process based on the updated network structure configuration data to generate a new, targeted optimized candidate model structure, and then re-enters a new round of training and validation in step S3 until a qualified model is generated or the global iteration limit is reached.

[0042] Step S4: Perform scene performance evaluation processing on each model in the qualified model set according to the evaluation data group, and generate the performance index corresponding to each model.

[0043] It should be understood that the evaluation dataset consists of two core components: test data and its corresponding target data. Test data is a set of samples specifically reserved from the original scenario task data and preprocessed, but not involved in any training or validation processes. Its data format is consistent with the parameter training dataset and scenario validation dataset. Target data consists of the true labels or standard answers of these test data samples, which are known in advance and obtained through manual verification or high-precision automated annotation. Using a completely independent evaluation dataset for model performance evaluation can truly reflect the model's generalization ability when facing new and unknown data. First, the qualified model is loaded into the specified inference hardware environment (such as a CPU or a specific type of GPU) and switched to inference mode, where operations used only for training, such as Dropout layers, are disabled. Then, batches of samples are sequentially or randomly drawn from the test data portion of the evaluation dataset and input into the model for forward inference processing. The system uses a high-precision timer to record the time elapsed from the start of data input to obtaining the complete model output data. This process is repeated multiple times, and after eliminating any initialization overhead, the average time per inference is calculated; this is the model's inference time, measured in milliseconds. Meanwhile, the system performs computational analysis on the network structure diagram of the static analysis model, typically measuring computational cost in floating-point operations (FLOPs). For convolutional layers, FLOPs can be approximated as: output feature map height × output feature map width × number of input channels × number of output channels × kernel height × kernel width; for fully connected layers, it is input dimension × output dimension. The total computational cost of the model is obtained by summing the computational costs of all layers. By recording inference time and computational cost, the system accurately quantifies the model's operational efficiency and resource consumption. For example, in embedded devices or mobile deployment scenarios, a computationally intensive and slow-inference model, no matter how high its accuracy, is not practical.

[0044] After completing the efficiency evaluation, the system moves on to a deep quantitative analysis of the model's predictive accuracy. This is achieved using the model output data from the previous forward inference process of a qualified model, as well as target data directly obtained from the evaluation data set that strictly corresponds to the test data. Depending on the specific task type, the system performs different comparison calculations. Taking object detection as a typical example, the model output typically consists of multiple predicted bounding boxes and their associated class confidence scores and location coordinates, while the target data consists of labeled ground truth bounding boxes and their classes. First, based on a preset intersection-over-union (IoU) threshold (e.g., IoU > 0.5), each predicted bounding box is matched against all ground truth bounding boxes to determine whether it is a true positive, false positive, or false negative. A true positive is a predicted bounding box that correctly matches a ground truth bounding box and correctly predicts the class; a false positive is a predicted bounding box that does not match any ground truth bounding box or has an incorrect class prediction; a false negative is a ground truth bounding box that is not matched by any predicted bounding box. Based on these statistics, the model's precision and recall are calculated. The precision formula is: Precision = Number of True Positives / (Number of True Positives + Number of False Positives). The recall rate is calculated as: Recall = Number of true positives / (Number of true positives + Number of false negatives). Precision measures the reliability of the model's positive predictions; high precision means the model produces almost no false positives. Recall measures the model's ability to detect all true positive samples; high recall means very few false negatives. Precision and recall at a single threshold are insufficient to fully reflect model performance; therefore, the mean precision (mAP) is further calculated. This metric is calculated by first obtaining the precision-recall curves for different confidence thresholds, then interpolating the recall on these curves and calculating the average precision to obtain the mean precision for a single class. Finally, the arithmetic mean of the mean precision for all classes is calculated to obtain the mAP value. mAP comprehensively reflects the overall detection accuracy of the model under different confidence requirements and is a recognized core evaluation metric in the field of object detection.

[0045] Finally, the system integrates all the quantitative results generated during the evaluation process (including inference time and computational cost representing efficiency, and precision, recall, and mean precision representing accuracy) into a structured, machine-readable performance metric object based on a preset data combination format. This preset format can be a JSON object with fixed fields, a dictionary, or a database record. This standardized combination method ensures direct comparability of results from different models and different evaluation batches.

[0046] Step S5: Based on the preset task requirement data and the performance indicators, select the best model from the qualified model set.

[0047] Task requirement data is a structured configuration file or data object predefined by system users (such as algorithm engineers or product managers) before the process starts or the model is deployed. Its content clearly specifies the specific requirements and priorities for various dimensions of model performance in the target application scenario. For example, for a real-time facial recognition access control system deployed on an edge computing device, the task requirement data might explicitly stipulate that the model's single-frame inference time must be less than 100 milliseconds (real-time constraint), the model's file size must be less than 10MB (storage constraint), and, while ensuring the former two, the highest possible facial recognition accuracy (accuracy target) should be pursued. For a medical image analysis system running on a cloud server, its task requirement data might primarily focus on the model's lesion detection rate (i.e., recall), requiring it to exceed 99%, while the time required for a single analysis might only need to be controlled within 5 seconds, with relatively relaxed constraints on model computation. The role of task requirement data is to transform vague business language into clear mathematical constraints and weighting coefficients that can be directly compared and calculated with technical indicators, providing calculable input for model selection decisions. First, the task requirement data needs to be parsed and transformed into a quantitative evaluation function applicable to each model's performance metric set. This process typically includes two main stages: constraint satisfaction judgment and multi-objective comprehensive scoring. In the constraint satisfaction judgment stage, the system checks whether the performance metrics of each model in the qualified model set fully meet the hard constraints defined in the task requirement data. For example, it compares whether each model's "inference time" is lower than the "maximum allowable latency" specified in the requirements, whether its "computational load" is lower than the "maximum computing power budget," and whether its "recall rate" is higher than the "minimum acceptable recall rate." If any hard metric fails to meet the standard, it means that the model cannot be feasiblely deployed in the target scenario, and the model will be immediately excluded from the candidate list.

[0048] Within the subset of models selected through hard constraints, the system initiates a multi-objective comprehensive scoring phase for fine-grained ranking. This phase first normalizes various performance metrics to eliminate differences in units and numerical ranges between different metrics (such as time in milliseconds, computational complexity of billions of floating-point operations, and precision percentage), making them comparable. Normalization can be based on the maximum and minimum values ​​of each metric within the model subset. For example, for positive metrics (such as precision, recall, and mAP), the normalized value = (current model metric value - minimum metric value in the subset) / (maximum metric value in the subset - minimum metric value in the subset); for negative metrics (such as inference time and computational complexity), the normalized value = (maximum metric value in the subset - current model metric value) / (maximum metric value in the subset - minimum metric value in the subset). After normalization, all metric values ​​are mapped to the [0,1] interval, where 1 represents the best performance for that metric within the subset. Subsequently, the system performs a weighted linear fusion of the normalized indicators based on the soft weight coefficients defined in the task requirement data, calculating the comprehensive score for each model. The weight coefficients explicitly express the relative importance the business side places on different performance dimensions. For example, in an edge real-time scenario, the task requirement data might set the weights as follows: inference time 0.5, model size 0.3, and recognition accuracy 0.2. Then, a model's comprehensive score would be calculated using the following formula: Comprehensive Score = (Time Weight Coefficient × Inference Time) + (Size Weight Coefficient × Model Size) + (Accuracy Weight Coefficient × Precision). Finally, the system sorts all models that pass the hard constraints in descending order based on the calculated comprehensive scores. The model with the highest score is determined as the best model for the current task requirement. In some application scenarios, multiple models may need to be deployed to form an integrated system or for A / B testing; therefore, the system can also be configured to output the top N models with the highest comprehensive scores as the optimal model set. Once the optimal model is determined, the system generates a structured decision report, which includes the identifier of the selected model, its original performance metrics, overall score, and detailed logs of each stage of the decision-making process. This report, along with the model's weight file, is stored in the model repository and triggers the subsequent deployment pipeline.

[0049] This application applies to the field of model building technology. It obtains training and evaluation data sets by preprocessing and grouping raw scene task data. Candidate model structures are selected from the model structure dataset based on network structure configuration data. Model training and scene validation are performed on the candidate model structures using the training data set to select a qualified model set. Scene performance evaluation is conducted on each model in the qualified model set using the evaluation data set to generate corresponding performance metrics for each model. Finally, the best model is selected from the qualified model set based on task requirements data and performance metrics. This application constructs a search space and utilizes NAS technology based on differentiability and evolution to quickly select and optimize model structures during the iterative training and validation process, thereby rapidly obtaining high-precision models adapted to production scenarios.

[0050] like Figure 2 The diagram shown is a functional block diagram of a deep learning model structure design, training, and verification device provided in an embodiment of this application.

[0051] In some embodiments, the deep learning model architecture design training and verification device 2 may include multiple functional modules composed of computer program segments. The computer programs for each program segment in the deep learning model architecture design training and verification device 2 may be stored in the server's memory and executed by at least one processor to perform (see details). Figure 1 (Description) Functions of deep learning model structure design, training, and verification methods.

[0052] In this embodiment, the deep learning model structure design, training, and verification device 2 can be divided into multiple functional modules according to its functions. These functional modules may include: a task labeling module 21, a data management module 22, a structure design module 23, a model training module 24, a model verification module 25, and a result management module 26. The module referred to in this invention is a series of computer program segments that can be executed by at least one processor and perform a fixed function, stored in memory. In this embodiment, the functions of each module will be detailed in subsequent embodiments.

[0053] The task labeling module 21 is used to collect raw scene task data (e.g., images, videos, text, etc.) and execute preset data algorithms or programs to preprocess and group the raw scene task data. Preprocessing operations include, but are not limited to, data cleaning, formatting, normalization, and data augmentation (e.g., flipping, rotating, scaling, etc.). Automated pre-labeling operations support dozens of data labeling methods, covering data formats such as images, audio, video, and text.

[0054] In an optional implementation, the task marking module 21 is used for: Based on the data attributes of the acquired original scene task data, the original scene task data is classified to obtain scene task datasets corresponding to each data type. Based on the data type, perform data cleaning, format conversion, and normalization on each type of data in the scenario task dataset to obtain a standardized dataset; By using a preset type-to-enhancement-strategy mapping table, the data in the normalized dataset are enhanced according to the data type to obtain an enhanced dataset. Using a preset type-to-labeling strategy mapping table, the augmented dataset is labeled with model targets according to the data type to obtain a target labeled dataset. The target labeled dataset is then divided into a training data group and an evaluation data group according to a preset grouping ratio.

[0055] The data management module 22, which is bidirectionally connected to the task labeling module 21, receives the data (i.e., the training data set and the evaluation data set) input from the task labeling module 21 and classifies and stores the input data. The storage operation further includes creating a corresponding index dataset for the input data, providing a data retrieval interface for the connected model training module 24 and model validation module 25 through the index dataset, and providing dataset version management for the input data.

[0056] The structure design module 23, bidirectionally connected to the model training module 24, provides a visual neural network structure design interface for users to input model structure design instructions, supporting drag-and-drop combination of neural network module layers in the model structure. Simultaneously, the structure design module 23 generates network structure configuration data (e.g., convolutional kernel size, stride, activation function, etc.) based on the model structure design instructions, so that the network structure configuration data can be directly passed to the model training module 24.

[0057] The model training module 24, which connects to the data management module 22, is used for high-performance distributed training based on GPU / TPU. It supports breakpoint resume training, mixed precision training, and automatic parameter tuning. It combines neural network structure search technology to automatically perform full training on the optimal model structure found, and performs performance evaluation in the model validation module 25. The results are fed back to the model structure design module for iterative optimization.

[0058] In an optional implementation, the model training module 24 is configured to: The preset network structure configuration data is parsed and processed to construct the model structure search space data; The model structure search space data is subjected to continuous relaxation of structural units and gradient optimization to generate a model architecture parameter set; Based on the model architecture parameter set, a seed model structure set is selected from the preset model structure dataset; The performance feedback iterative screening process is performed on each model structure in the seed model structure set to obtain candidate model structures.

[0059] In an optional implementation, the model training module 24 is further configured to: Step S211: Extract the internal connection data of the structural units, the number of structural nodes, and the set of each candidate execution operation from the model structure search space data to generate the model structure search feature set corresponding to each candidate structure. Step S212: Perform weight initialization processing on each operation in the candidate execution operation set through a preset first random initialization method to obtain the architecture weight variables corresponding to each operation; Step S213: Search the feature set according to the model structure using the preset second random initialization method, initialize the training parameters of the candidate structures, and obtain the regular network parameters corresponding to each candidate structure. Step S214: Perform gradient optimization on the conventional network parameters according to the architecture weight variables to update the conventional network parameters; Step S215: Perform gradient optimization on the architecture weight variables according to the conventional network parameters to update the architecture weight variables; Step S216: Calculate the average change of the architecture weight variables before and after the update, and update the preset iteration round number value according to the preset update method; Repeat steps S214 to S216 until the number of iterations reaches a preset threshold or the average change is less than a preset threshold, and extract the architecture weight variables from the model structure search feature set to generate the model architecture parameter set.

[0060] In an optional implementation, the model training module 24 is further configured to: Step S221: Randomly perturb the parameters of each model structure in the seed model structure set to generate a derived model structure, and create an initial population based on each model structure in the seed model structure set and the derived model structure using a preset population creation method. Step S222: Perform fast proxy training on each model structure in the initial population according to the parameter training dataset in the evolutionary screening data group to generate proxy models corresponding to each model structure, and perform inference verification on the proxy models according to the scenario verification dataset in the evolutionary screening data group to calculate the fitness score corresponding to each proxy model. Step S223: Select the parent population from the initial population according to the fitness score through a preset performance screening method, and perform crossover recombination and random mutation processing on each model structure in the parent population according to the preset crossover probability and mutation probability to generate the offspring model structure set corresponding to each model structure. Step S224: Update the initial population according to the parent population and the offspring model structure set, and update the preset generation value according to the preset update method; Repeat steps S222 to S224 above, and calculate the score increase of the highest fitness score in the initial population before and after the update, until the score increase is less than a preset progress threshold or the evolution generation value reaches a preset generation threshold, so as to use the model structure corresponding to the highest fitness score in the updated initial population as a candidate model structure.

[0061] The model validation module 25, which is bidirectionally connected to the model training module 24, is used to evaluate the performance of the candidate model structures selected by the model training module 24 (including metrics such as precision, recall, F1 score, and mAP), and generate comparative analysis data based on the performance evaluation results, so as to send the comparative analysis data to the result management module 26.

[0062] In an optional implementation, the model validation module 25 is used for: Step S31: Iteratively train the model parameters of the candidate model structure according to the parameter training dataset to construct an initial model; Step S32: Perform inference verification on the initial model based on the scene verification dataset to calculate the precision and recall of the initial model; Step S33: Weight the precision and recall according to the preset weight coefficients to generate the scene fit value corresponding to the initial model; Step S34: Update the preset iteration value according to the preset update method, and update the network structure configuration data according to the scene adaptability value through the preset network structure configuration update method; When the scene adaptability value reaches the preset qualified threshold, the initial model is regarded as a qualified model; When the scene adaptability value does not reach the qualified threshold and the iteration value does not reach the preset iteration threshold, repeat steps S2 to S34 until the iteration value reaches the iteration threshold.

[0063] In an optional implementation, the model verification module 25 is further configured to: Based on the test data, forward inference processing is performed on each model in the qualified model set to record the inference time and output data of each model, and the computational cost of each model is calculated. Based on the test data, the corresponding target data is obtained from the evaluation data set, and the precision, recall and mean precision of each model are calculated based on the target data and the model output data. According to a preset data combination format, the inference time, computational cost, precision, recall, and mean precision are combined into the performance metrics of the corresponding model.

[0064] The result management module 26, which connects to the model validation module 25, is used to store and display the training and validation results (i.e., the best model), generate performance reports and graphs based on task requirements data and performance indicators, and provide an interface for downloading and deploying the best model.

[0065] It should be understood that the various variations and specific embodiments of the methods provided in the above embodiments are also applicable to the deep learning model structure design training and verification device of this embodiment. Through the foregoing detailed description of the deep learning model structure design training and verification method, those skilled in the art can clearly understand the implementation method of the deep learning model structure design training and verification device of this embodiment. For the sake of brevity, it will not be described in detail here.

[0066] like Figure 3 The diagram shown is a structural schematic of an electronic device provided in an embodiment of this application.

[0067] In a preferred embodiment of the present invention, the electronic device 3 may include, but is not limited to, a memory 31, at least one processor 32, and at least one communication bus 33.

[0068] Those skilled in the art should understand that Figure 3 The structure of the electronic device 3 shown does not constitute a limitation of the embodiments of the present invention. The electronic device 3 may also include more or fewer other hardware or software than shown, or different component arrangements.

[0069] In some embodiments, the electronic device 3 is a device capable of automatically performing numerical calculations and / or information processing according to pre-set or stored instructions, and its hardware includes, but is not limited to, microprocessors, application-specific integrated circuits, programmable gate arrays, digital processors, and embedded devices.

[0070] It should be noted that the electronic device 3 is merely an example. Other existing or future electronic products that are suitable for this application should also be included within the scope of protection of this application and are incorporated herein by reference.

[0071] In some embodiments, the memory 31 stores a computer program that, when executed by the at least one processor 32, implements all or part of the steps in the deep learning model architecture design, training, and verification method described above. The memory 31 includes read-only memory (ROM), programmable read-only memory (PROM), erasable programmable read-only memory (EPROM), one-time programmable read-only memory (OTPROM), electrically-erasable programmable read-only memory (EEPROM), compact disc read-only memory (CD-ROM) or other optical disc storage, disk storage, magnetic tape storage, or any other computer-readable medium capable of carrying or storing data. Further, the computer-readable storage medium may primarily include a program storage area and a data storage area, wherein the program storage area may store an operating system, at least one application program required for a function, etc.

[0072] In some embodiments, the at least one processor 32 is the control unit of the electronic device 3, connecting various components of the electronic device 3 via various interfaces and lines. It executes programs or modules stored in the memory 31 and calls data stored in the memory 31 to perform various functions and process data. For example, when the at least one processor 32 executes the computer program stored in the memory 31, it implements all or part of the steps of the deep learning model structure design training and verification method described in this application embodiment; or it implements all or part of the functions of the deep learning model structure design training and verification device. The at least one processor 32 may be composed of integrated circuits, such as a single-packaged integrated circuit or multiple integrated circuits with the same or different functions, including combinations of one or more central processing units (CPUs), microprocessors, digital processing chips, graphics processors, and various control chips.

[0073] In some embodiments, the at least one communication bus 33 is configured to enable communication between the memory 31 and the at least one processor 32, etc. Although not shown, the electronic device 3 may also include a power supply (e.g., a battery) to power the various components. Preferably, the power supply can be logically connected to the at least one processor 32 via a power management device, thereby enabling functions such as charging, discharging, and power consumption management. The power supply may also include one or more DC or AC power supplies, recharging devices, power fault detection circuits, power converters or inverters, power status indicators, and other arbitrary components. The electronic device 3 may also include various sensors, Bluetooth modules, Wi-Fi modules, etc., which will not be described in detail here.

[0074] The integrated unit implemented as a software functional module described above can be stored in a computer-readable storage medium. This software functional module, stored in a storage medium, includes several instructions to cause an electronic device (which may be a personal computer, electronic device, or network device, etc.) or processor to execute portions of the methods described in the various embodiments of this application.

[0075] In the several embodiments provided in this application, it should be understood that the disclosed apparatus and methods can be implemented in other ways. For example, the apparatus embodiments described above are merely illustrative; for instance, the division of modules is only a logical functional division, and other division methods may be used in actual implementation.

[0076] The modules described as separate components may or may not be physically separate. The components shown as modules may or may not be physical units; they may be located in one place or distributed across multiple network units. Some or all of the modules can be selected to achieve the purpose of this embodiment according to actual needs.

[0077] The above are all preferred embodiments of this application, and are not intended to limit the scope of protection of this application. Therefore, all equivalent changes made in accordance with the structure, shape and principle of this application should be covered within the scope of protection of this application.

Claims

1. A deep learning model structure design training and verification method, characterized in that, The method includes: Step S1: Preprocess and group the acquired raw scene task data to obtain training data set and evaluation data set; Step S2: Based on the preset network structure configuration data, select candidate model structures from the preset model structure dataset; Step S3: Based on the training data set, perform model training and scenario verification on the candidate model structure to select a qualified model set; Step S4: Perform scene performance evaluation processing on each model in the qualified model set according to the evaluation data group, and generate performance indicators corresponding to each model; Step S5: Based on the preset task requirement data and the performance indicators, select the best model from the qualified model set. 2.The method of claim 1, wherein, The preprocessing and grouping of the acquired raw scene task data to obtain training data sets and evaluation data sets includes: Based on the data attributes of the acquired original scene task data, the original scene task data is classified to obtain scene task datasets corresponding to each data type. Based on the data type, perform data cleaning, format conversion, and normalization on each type of data in the scenario task dataset to obtain a standardized dataset; By using a preset type-to-enhancement-strategy mapping table, the data in the normalized dataset are enhanced according to the data type to obtain an enhanced dataset. Using a preset type-to-labeling strategy mapping table, the augmented dataset is labeled with model targets according to the data type to obtain a target labeled dataset. The target labeled dataset is then divided into a training data group and an evaluation data group according to a preset grouping ratio. 3.The method of claim 1, wherein, The step of selecting candidate model structures from a preset model structure dataset based on preset network structure configuration data includes: The preset network structure configuration data is parsed and processed to construct the model structure search space data; The model structure search space data is subjected to continuous relaxation of structural units and gradient optimization to generate a model architecture parameter set. Based on the model architecture parameter set, a seed model structure set is selected from the preset model structure dataset; The performance feedback iterative screening process is performed on each model structure in the seed model structure set to obtain candidate model structures. 4.The method of claim 1, wherein the training dataset comprises a parameter training dataset and a scenario validation dataset. The step of training and validating the candidate model structures based on the training data set to select a qualified model set includes: Step S31: Iteratively train the model parameters of the candidate model structure according to the parameter training dataset to construct an initial model; Step S32: Perform inference verification on the initial model based on the scene verification dataset to calculate the precision and recall of the initial model; Step S33: Weight the precision and recall according to the preset weight coefficients to generate the scene fit value corresponding to the initial model; Step S34: Update the preset iteration value according to the preset update method, and update the network structure configuration data according to the scene adaptability value through the preset network structure configuration update method; When the scene adaptability value reaches the preset qualified threshold, the initial model is regarded as a qualified model; When the scene adaptability value does not reach the qualified threshold and the iteration value does not reach the preset iteration threshold, repeat steps S2 to S34 until the iteration value reaches the iteration threshold. 5.The method of claim 1, wherein the evaluation dataset comprises test data and corresponding target data. The step of performing scene performance evaluation on each model in the qualified model set based on the evaluation data group, and generating performance indicators corresponding to each model, includes: Based on the test data, forward inference processing is performed on each model in the qualified model set to record the inference time and output data of each model, and the computational cost of each model is calculated. Based on the test data, the corresponding target data is obtained from the evaluation data set, and the precision, recall and mean precision of each model are calculated based on the target data and the model output data. According to a preset data combination format, the inference time, computational cost, precision, recall, and mean precision are combined into the performance metrics of the corresponding model. 6.The method of training and verifying a deep learning model structure design according to claim 3, wherein, The step of performing continuous relaxation and gradient optimization on the structural units of the model structure search space data to generate a model architecture parameter set includes: Step S211: Extract the internal connection data of the structural units, the number of structural nodes, and the set of each candidate execution operation from the model structure search space data to generate the model structure search feature set corresponding to each candidate structure. Step S212: Perform weight initialization processing on each operation in the candidate execution operation set through a preset first random initialization method to obtain the architecture weight variables corresponding to each operation; Step S213: Search the feature set according to the model structure using the preset second random initialization method, initialize the training parameters of the candidate structures, and obtain the regular network parameters corresponding to each candidate structure. Step S214: Perform gradient optimization on the conventional network parameters according to the architecture weight variables to update the conventional network parameters; Step S215: Perform gradient optimization on the architecture weight variables according to the conventional network parameters to update the architecture weight variables; Step S216: Calculate the average change of the architecture weight variables before and after the update, and update the preset iteration round number value according to the preset update method; Repeat steps S214 to S216 until the number of iterations reaches a preset threshold or the average change is less than a preset threshold, and extract the architecture weight variables from the model structure search feature set to generate the model architecture parameter set.

7. The method of claim 3, wherein the training dataset comprises an evolutionary screening dataset. The step of performing performance feedback iterative screening on each model structure in the seed model structure set to obtain candidate model structures includes: Step S221: Randomly perturb the parameters of each model structure in the seed model structure set to generate a derived model structure, and create an initial population based on each model structure in the seed model structure set and the derived model structure using a preset population creation method. Step S222: Perform fast proxy training on each model structure in the initial population according to the parameter training dataset in the evolutionary screening data group to generate proxy models corresponding to each model structure, and perform inference verification on the proxy models according to the scenario verification dataset in the evolutionary screening data group to calculate the fitness score corresponding to each proxy model. Step S223: Select the parent population from the initial population according to the fitness score through a preset performance screening method, and perform crossover recombination and random mutation processing on each model structure in the parent population according to the preset crossover probability and mutation probability to generate the offspring model structure set corresponding to each model structure. Step S224: Update the initial population according to the parent population and the offspring model structure set, and update the preset generation value according to the preset update method; Repeat steps S222 to S224 above, and calculate the score increase of the highest fitness score in the initial population before and after the update, until the score increase is less than a preset progress threshold or the evolution generation value reaches a preset generation threshold, so as to use the model structure corresponding to the highest fitness score in the updated initial population as a candidate model structure.

8. A deep learning model structure design training and verification device applied to the deep learning model structure design training and verification method of claim 1, characterized in that, The device includes: The task labeling module is used to preprocess and group the acquired raw scene task data to obtain training data sets and evaluation data sets. A data management module connected to the task labeling module is used to store the training data set and the evaluation data set; The structural design module is used to receive model structure design instructions input by the user and generate network structure configuration data according to the model structure design instructions; The model training module, which connects the data management module and the structure design module, is used to select candidate model structures from the preset model structure dataset according to the preset network structure configuration data, and to train the candidate model structures to generate an initial model. The model verification module, which connects the data management module and the model training module, is used to perform scene verification processing on the initial model based on the training data set to filter out a qualified model set, and to perform scene performance evaluation processing on each model in the qualified model set based on the evaluation data set to generate performance indicators corresponding to each model. The result management module, which is connected to the model validation module, is used to select the best model from the qualified model set based on the preset task requirement data and the performance indicators.

9. An electronic device, comprising: The electronic device includes a memory, a processor, and a computer program stored in the memory and executable on the processor. When the processor executes the computer program, it implements the steps of the deep learning model structure design, training, and verification method according to any one of claims 1 to 7.

10. A computer-readable storage medium having stored thereon a computer program, characterized in that, When the computer program is executed by the processor, it implements the steps of the deep learning model structure design, training, and verification method according to any one of claims 1 to 7.

Images