Application deployment method, device and storage medium based on cloud computing power

Abstract

This application discloses a cloud computing-based application deployment method, device, and storage medium. This application relates to the field of digital data processing technology. The cloud computing-based application deployment method includes: extracting demand features from a demand form and meeting materials in response to the demand form and the meeting materials; matching a training model and training data based on the demand features; deploying a development environment based on the training model and the training data; in response to the training operation of the development environment, calling the reserved computing power of the user corresponding to the demand form, generating a dedicated model and packaging it into a model encryption deployment package; and deploying the model encryption deployment package to front-end and back-end applications. This application can achieve the technical effect of accelerating the implementation of artificial intelligence applications.

Description

Technical Field

[0001] The present application relates to the field of digital data processing technology, and in particular to an application deployment method, device and storage medium based on cloud computing power. Background Art

[0002] With the rapid development of artificial intelligence (AI), the deep integration of AI (artificial intelligence) and hardware has become a key trend in digital transformation. From AI health assistants monitoring physiological data in real time, to intelligent devices collecting high-precision sensor information in industrial scenarios, to AI-powered creative content generation and 24 / 7 AI customer service systems, AI applications are gradually penetrating vertical sectors such as healthcare, manufacturing, and entertainment.

[0003] However, there's a gap in the coordinated adaptation of algorithms and hardware. For example, AI models require optimized computing power allocation for specific hardware. Edge computing devices, for example, are limited by power consumption and struggle to support large neural networks. Furthermore, hardware iterations often lead to algorithm compatibility issues, and changes in new sensor data formats can cause model failures, forcing developers to repeatedly adjust model architectures.

[0004] Therefore, the development cycle of AI application software is significantly longer than that of traditional software, making it difficult to quickly become competitive. Summary of the Invention

[0005] The main purpose of this application is to provide an application deployment method, device and storage medium based on cloud computing power, aiming to solve the technical problem that the development cycle of AI application software is significantly longer than that of traditional software, making it difficult to quickly form competitiveness.

[0006] To achieve the above objectives, the present application provides a cloud computing power-based application deployment method, which is applied to a computing power leasing platform. The cloud computing power-based application deployment method includes:

[0007] In response to the demand form and the conversation materials, extracting demand features from the demand form and the conversation materials;

[0008] Matching the training and recommendation model and training and recommendation data according to the demand characteristics;

[0009] Deploy a development environment based on the training model and the training data;

[0010] In response to the training and pushing operation of the development environment, the reserved computing power of the user corresponding to the demand form is called to generate a dedicated model and encapsulate it into a model encryption deployment package;

[0011] Deploy the model encryption deployment package to the front-end and back-end applications.

[0012] In one embodiment, the step of extracting demand features from the demand form and the interview materials in response to the demand form and the interview materials includes:

[0013] Performing speech recognition on the interview data to generate unstructured text data;

[0014] Performing cross-modal semantic association between the unstructured text data and the structured field data of the demand form using a pre-trained multimodal alignment model, wherein the multimodal alignment model uses a bidirectional attention mechanism to calculate a correlation matrix between the form fields and the dialogue text;

[0015] Key semantic fragments are filtered according to the association matrix to generate the requirement characteristics including hardware type identifier, computing power requirement level and data security requirements, wherein the hardware type identifier includes the processor architecture, memory capacity and interface protocol feature coding of the target device.

[0016] In one embodiment, before the step of performing cross-modal semantic association between the unstructured text data and the structured field data of the requirement form using a pre-trained multimodal alignment model, the following steps are included:

[0017] Constructing an annotated hardware requirement corpus, wherein the training data of the hardware requirement corpus includes triples of form fields, dialogue texts, and corresponding hardware type identifiers;

[0018] A contrastive learning loss function is used to constrain the cosine similarity of form dialogue pairs with the same hardware type in the feature space to be higher than that of heterogeneous samples.

[0019] The parsing robustness of the model to ambiguous representations is enhanced based on adversarial sample generation to obtain the multimodal alignment model.

[0020] In one embodiment, the step of matching the training model and the training data according to the demand characteristics includes:

[0021] Parsing the hardware type identifier in the requirement characteristics and screening candidate training models based on a processor architecture compatibility map, where the map pre-stores a mapping relationship between different hardware platforms and the support status of neural network operators;

[0022] Dynamically prune candidate training and inference models according to the computing power requirement level to generate the training and inference model that meets the memory capacity constraint of the target device;

[0023] Based on data security requirements, a privacy computing channel is constructed, initial data matching the required scenario labels are extracted from distributed data sources, and the training data protected by differential privacy is generated through a homomorphic encryption algorithm.

[0024] In one embodiment, the step of deploying a development environment based on the training model and the training data includes:

[0025] According to the framework type of the training model, match the corresponding version of the runtime dependency library from the preset container template library to build a basic container image including the framework interpreter and model conversion tool chain;

[0026] Parsing the interface protocol feature code of the hardware type identifier in the requirement feature, injecting the target hardware driver layer into the basic container image, and generating a hardware-adapted training and push execution environment;

[0027] Mount the differentially private training data to the container storage volume and automatically generate a data preprocessing script that matches the input and output format of the training model;

[0028] Configure environment variable parameters, including the model service port number, computing resource quota, and monitoring probe collection frequency, to complete the development environment deployment.

[0029] In one embodiment, the step of, in response to the training and pushing operation of the development environment, calling the reserved computing power of the user corresponding to the demand form, generating a dedicated model, and packaging it into a model encryption deployment package includes:

[0030] Based on the container runtime environment of the development environment, the dynamic scheduling strategy of the reserved computing power is analyzed to generate resource allocation parameters and computing power constraints;

[0031] Based on the resource allocation parameters, the training batch size and the memory usage ratio are dynamically adjusted through a reinforcement learning-driven resource allocation algorithm, and a gradient update parameter is output that adapts to the target hardware computing power threshold;

[0032] Based on the gradient update parameters and the data privacy requirements marked in the requirement form, a differential privacy budget is dynamically allocated to the training dataset through a privacy computing gateway to generate a feature tensor sequence with privacy protection labels;

[0033] The model weights corresponding to the feature tensor sequence are encrypted layer by layer using a homomorphic encryption algorithm, wherein the encryption key is generated by a dual-factor hybrid of the user identity identifier in the requirement form and the hardware device fingerprint;

[0034] Inject the encrypted model weights into the hardware acceleration module based on the trusted execution environment, and integrate them with the inference driver library corresponding to the gradient update parameters to generate an initial deployment package;

[0035] The runtime environment of the initial deployment package is simulated according to the computing power constraint conditions to generate the model encryption deployment package containing the national secret algorithm verification code.

[0036] In one embodiment, the step of deploying the model encryption deployment package to the front-end and back-end applications includes:

[0037] Parse the integrity check code in the model encrypted deployment package, verify the integrity of the deployment package using the national encryption algorithm, and simultaneously verify the consistency of the hardware device fingerprint with the registered device information in the requirement form;

[0038] Based on the hardware acceleration module of the trusted execution environment, an isolated model execution sandbox is created on the target device, and the encrypted model weights and inference driver library are loaded. The sandbox is configured to only allow access to the training and inference data through the privacy computing channel;

[0039] Dynamically select the training model based on the front-end application interface protocol characteristics, wherein the training model includes an operator acceleration library that matches the target processor architecture, and injects the model weights into the pre-allocated area of the video memory through memory mapping technology;

[0040] A gateway is deployed in the backend service container, and an input data format converter and an output result encryption module are configured. The converter automatically adjusts the number of concurrent threads for batch inference based on the computing power requirement level in the demand characteristics.

[0041] In one embodiment, before the step of, in response to the training and pushing operation of the development environment, calling the reserved computing power of the user corresponding to the demand form, generating a dedicated model, and packaging it into a model encryption deployment package, the following steps are included:

[0042] Analyze the computing power requirement level, task concurrency peak, and model complexity parameters in the requirement form to generate initial computing power resource allocation parameters;

[0043] Based on the computing power consumption records in the historical training database, a time series prediction model is used to calculate the computing power requirement baseline value of the target scenario. The baseline value includes three-dimensional constraint indicators: video memory occupancy rate, floating-point operation volume, and memory bandwidth utilization rate.

[0044] According to the hardware architecture identifier in the requirement form, the processor instruction set support map is matched to select candidate computing power types that meet the computing power requirement baseline value;

[0045] Based on the reinforcement learning algorithm, Pareto optimization of resource utilization and energy consumption ratio of candidate computing power types is performed to generate a dynamic scheduling strategy that includes computing power threshold ranges, time window constraints, and elastic scaling rules;

[0046] The dynamic scheduling policy is bound to the target hardware resource pool, and a reserved computing power identifier with a timestamp is generated to identify the reserved computing power.

[0047] In addition, to achieve the above-mentioned purpose, the present application also provides an application deployment device based on cloud computing power, and the application deployment device based on cloud computing power includes: a memory, a processor, and a computer program stored on the memory and capable of running on the processor, and the computer program is configured to implement the steps of the application deployment method based on cloud computing power as described above.

[0048] In addition, to achieve the above-mentioned purpose, the present application also provides a storage medium, which is a computer-readable storage medium, and the computer-readable storage medium stores a program for implementing the application deployment method based on cloud computing power. The program for implementing the application deployment method based on cloud computing power is executed by the processor to implement the steps of the application deployment method based on cloud computing power as described above.

[0049] The present application provides an application deployment method based on cloud computing power. The present application first extracts the demand features in the demand form and the meeting materials in response to the demand form and the meeting materials; matches the training and pushing model and the training and pushing data according to the demand features; deploys the development environment based on the training and pushing model and the training and pushing data; responds to the training and pushing operation of the development environment, calls the reserved computing power of the user corresponding to the demand form, generates a dedicated model and encapsulates it into a model encryption deployment package; deploys the model encryption deployment package to the front-end and back-end applications, thereby solving the technical problem in the related technology that the development cycle of AI application software is significantly longer than that of traditional software and it is difficult to quickly form competitiveness, and achieves the technical effect of accelerating the implementation of AI applications. BRIEF DESCRIPTION OF THE DRAWINGS

[0050] The accompanying drawings, which are incorporated in and constitute a part of this specification, illustrate embodiments consistent with the present application and, together with the description, serve to explain the principles of the present application.

[0051] In order to more clearly illustrate the embodiments of the present application or the technical solutions in the prior art, the following briefly introduces the drawings required for use in the embodiments or the description of the prior art. Obviously, for ordinary technicians in this field, other drawings can be obtained based on these drawings without any creative work.

[0052] Figure 1 A flowchart of the first embodiment of the cloud computing-based application deployment method of this application is provided;

[0053] Figure 2 A flowchart of the fifth embodiment of the cloud computing-based application deployment method of this application is provided;

[0054] Figure 3 A flowchart illustrating a sixth embodiment of the cloud computing-based application deployment method of this application is provided;

[0055] Figure 4 This is a schematic diagram of the hardware structure involved in the cloud computing-based application deployment device embodiment of this application.

[0056] The purpose, features and advantages of this application will be further explained in conjunction with the embodiments and with reference to the accompanying drawings. DETAILED DESCRIPTION

[0057] It should be understood that the specific embodiments described herein are only used to explain the technical solutions of the present application and are not intended to limit the present application.

[0058] In order to better understand the technical solution of the present application, a detailed description will be given below in conjunction with the accompanying drawings and specific implementation methods.

[0059] Currently, there's a gap in the coordinated adaptation of algorithms and hardware. For example, AI models require optimized computing power allocation for specific hardware. Edge computing devices, for example, are limited by power consumption and struggle to support large neural networks. Furthermore, hardware iterations often lead to algorithm compatibility issues, and changes in new sensor data formats can cause model failures, forcing developers to repeatedly adjust model architectures. As a result, the development cycle for AI application software is significantly longer than that of traditional software, making it difficult to quickly achieve competitiveness.

[0060] The main solution of this application is to extract demand features from demand forms and meeting materials; match training models and training data based on these demand features; deploy a development environment based on the training models and training data; and, in response to training operations in the development environment, invoke the reserved computing power of the user corresponding to the demand form to generate a dedicated model and encapsulate it into an encrypted model deployment package; and deploy the encrypted model deployment package to front-end and back-end applications. This achieves the technical effect of accelerating the implementation of AI applications.

[0061] It should be noted that the execution entity of this embodiment can be a computing power leasing platform, or a computing service device with data processing, network communication, and program execution functions, such as a tablet computer, personal computer, mobile phone, etc., or a cloud computing application deployment device capable of implementing the above functions, etc. This embodiment does not specifically limit this. The following uses the computing power leasing platform as an example to illustrate this embodiment and the following embodiments.

[0062] Based on this, the first embodiment of this application proposes an application deployment method based on cloud computing power, please refer to Figure 1 The cloud computing-based application deployment method includes steps S10 to S50:

[0063] Step S10 : In response to the demand form and the meeting materials, extracting demand features from the demand form and the meeting materials.

[0064] In this embodiment, the demand form refers to the structured data filled out by the user on the computing power leasing platform, including fields such as hardware type, computing power requirement level, and data security level. The meeting materials refer to the technical communication records between the user and the platform, including unstructured data in the form of voice, text, or video.

[0065] As an optional implementation, speech recognition technology is used to convert conversation materials into text (e.g., real-time transcription based on WebRTC (Web Real-Time Communication)). A pre-trained multimodal alignment model, such as a variant of CLIP (Contrastive Language-Image Pre-training), is then used to perform cross-modal semantic association between the structured form fields and the unstructured text in the requirements form. For example, if a user verbally mentions "needing a GPU (Graphics Processing Unit) that supports AVX512 (Advanced Vector Extensions 512)," the system will automatically map this to the "Processor Architecture" field on the form and generate an encoding identifier.

[0066] Step S20: Matching the training and recommendation model and the training and recommendation data according to the demand characteristics.

[0067] In this embodiment, the training and inference model refers to a machine learning model adapted to the target hardware architecture, such as TensorFlowLite or ONNX Runtime (Open Neural Network Exchange Runtime), and the training and inference data refers to a privacy-protected training data set that must meet differential privacy or homomorphic encryption requirements.

[0068] As an optional implementation, candidate models are filtered from a pre-built processor architecture compatibility map based on hardware type identifiers in the requirement features, such as the number of NVIDIA CUDA (Compute Unified Device Architecture) cores and ARM NEON (Advanced SIMD extension) instruction set support. For example, if the requirement feature includes "FP16 (16-bit Floating Point) precision support," model versions that only support FP32 (32-bit Floating Point) are automatically excluded, and the number of model layers is dynamically pruned to adapt to the target device memory capacity.

[0069] Step S30: deploying a development environment based on the training model and the training data.

[0070] In this embodiment, the development environment includes a containerized runtime environment, a hardware driver layer, and a data preprocessing tool chain.

[0071] As an optional implementation, a base image matching the training and inference model framework, such as PyTorch 2.1 and CUDA 11.7, is pulled from the container template library and injected into the target hardware driver. Differentially private data can be loaded by mounting encrypted storage volumes, such as block devices encrypted using LUKS (Linux Unified Key Setup), and automatically generating data preprocessing scripts, such as normalizing image data to tensor format.

[0072] Step S40, in response to the training and pushing operation of the development environment, calling the reserved computing power of the user corresponding to the demand form, generating a dedicated model and packaging it into a model encryption deployment package.

[0073] In this embodiment, the reserved computing power refers to the cloud computing resource quota applied for in advance by the user, including GPU video memory, floating-point computing capacity and time window constraints. The model encryption deployment package contains the executable file of the encrypted model weights, inference driver library and integrity check code.

[0074] As an optional implementation, reinforcement learning algorithms such as PPO (Proximal Policy Optimization) dynamically adjust training batch sizes to ensure that GPU memory utilization does not exceed 80% of the reserved computing power. Homomorphic encryption algorithms such as CKKS (Cheon-Kim-Kim-Song) are used to encrypt model weights layer by layer. The encryption key is generated by combining the user ID (identifier) and the device fingerprint, such as the TPM (Trusted Platform Module) chip identifier. The final deployment package generates a checksum using the SM3 (Commercial Cryptography Algorithm Standard) national encryption algorithm to ensure transmission integrity.

[0075] Step S50: deploy the model encryption deployment package to the front-end and back-end applications.

[0076] In this embodiment, the front-end application refers to the user interaction interface, which needs to be adapted to the lightweight inference engine; the back-end application refers to the model inference service of the cloud server, which needs to support high concurrency and elastic scaling.

[0077] As an optional implementation, a subset of lightweight inference engines, such as TensorFlow.js or Core ML (Core Machine Learning), is dynamically loaded on the front end, injecting encrypted weights into a pre-allocated area of graphics memory using memory mapping technology. A RESTful API (Representational State Transfer Application Programming Interface) gateway is deployed on the back end, configuring a batch inference thread pool that automatically adjusts the number of concurrent inferences based on computing power requirements. An integrated exception circuit breaker module monitors inference latency and resource usage in real time.

[0078] For example, in a smart medical image analysis system deployment scenario,

[0079] The user fills out a structured form, selecting the hardware type as "NVIDIA A100 GPU cluster" (supporting the AVX512 instruction set), the computing power requirement as "high-performance computing," and the data security requirement as "HIPAA (Health Insurance Portability and Accountability Act) compliance." Platform technicians discuss the data size with the user, including a 200TB lung CT image dataset, model requirements (the 3D U-Net model must support FP16 precision), and interface protocols (RESTful API latency ≤ 200ms). Key parameters are extracted using the speech recognition engine and associated with the form fields to generate the "Hardware Architecture Identifier: CUDA 11.8 + TensorRT (Tensor Runtime) 8.6."

[0080] Based on LSTM (Long Short-Term Memory) predictions, 80 A100 GPUs were reserved. Reinforcement learning was used to generate a resource allocation plan, with 64 GPUs used during training and elastically scaled down to 16 GPUs during inference, resulting in a 23% improvement in energy efficiency. A PyTorch 2.1 and CUDA 11.8 container image was deployed, configured with the NVLink (NVIDIA high-speed interconnect) driver, and cross-node gradient synchronization was achieved through the RDMA (Remote Direct Memory Access) network.

[0081] Model weights were encrypted using a two-factor key and injected into a Trusted Execution Environment (TEE) to isolate access to medical data. An automatic scaling policy was configured for the backend Kubernetes cluster (CPU / GPU utilization threshold: 80%). TensorFlow.js was integrated on the frontend to enable browser-based preview of medical digital imaging and communication. Ultimately, demand resolution time was reduced to 15 minutes, GPU fragmentation was reduced to 3.2%, and the system passed HIPAA audits.

[0082] In this embodiment, by responding to the demand form and the meeting materials, the demand features in the demand form and the meeting materials are extracted; the training model and the training data are matched according to the demand features; the development environment is deployed based on the training model and the training data; in response to the training operation of the development environment, the reserved computing power of the user corresponding to the demand form is called, a dedicated model is generated and packaged into a model encryption deployment package; the model encryption deployment package is deployed to the front-end and back-end applications, which significantly reduces the development time cost of AI applications.

[0083] Based on any of the above embodiments, in the second embodiment of the present application, step S10 includes:

[0084] Step S11: Perform speech recognition on the conversation data to generate unstructured text data.

[0085] In this embodiment, conversation data refers to the real-time communication recordings between users and computing power rental platform technicians, which need to be converted into a processable text format. Unstructured text data refers to conversation content that is not in a predefined format, including demand information described in natural language.

[0086] As an optional implementation, a Whisper-based speech recognition engine is used to transcribe recordings into text in real time. Natural language processing (NLP) technology is used to remove redundant modal particles and extract key parameters such as "FP16 precision support" and "200ms response delay" and other structured fields.

[0087] Step S12: Perform cross-modal semantic association between the unstructured text data and the structured field data of the demand form through a pre-trained multimodal alignment model, wherein the multimodal alignment model uses a bidirectional attention mechanism to calculate the correlation matrix between the form fields and the dialogue text.

[0088] In this example, the multimodal alignment model refers to a deep learning model that integrates structured form fields, such as "hardware type" and "computing power requirement level," with unstructured conversation text. The bidirectional attention mechanism achieves bidirectional semantic alignment by calculating a correlation matrix between form fields and conversation text. For example, the weighted matching of a form's "processor architecture" field with the "AVX512 instruction set required" description in a conversation is used.

[0089] As an optional implementation, attention weights are calculated in the feature space for the "memory capacity" field in the form and descriptions such as "at least 64GB of video memory" in the conversation to generate a correlation matrix, and semantic segments with a matching degree higher than 0.8 are screened out.

[0090] Step S13, filtering key semantic fragments according to the association matrix, and generating the requirement characteristics including the hardware type identifier, computing power requirement level and data security requirements, wherein the hardware type identifier includes the processor architecture, memory capacity and interface protocol feature coding of the target device.

[0091] In this embodiment, the hardware type identifier includes a coding combination of the processor architecture, memory capacity, and interface protocol of the target device. The data security requirement refers to the privacy protection level selected by the user.

[0092] As an optional implementation, the filtered semantic fragments are encoded and mapped, for example, "NVIDIAA100 GPU" is encoded as "CUDA11.8+TensorRT 8.6", and a JSON format requirement feature file is generated in combination with the computing power requirement level such as HPC level.

[0093] This embodiment significantly shortens the demand analysis cycle and reduces the risk of resource mismatch due to human misjudgment through automated speech recognition and intelligent association of structured and unstructured data, while meeting the privacy compliance requirements of high-security scenarios such as healthcare and finance.

[0094] Optionally, before step S12, the following steps are included:

[0095] Step A10: constructing a labeled hardware requirement corpus, wherein the training data of the hardware requirement corpus includes triples of form fields, dialogue texts, and corresponding hardware type identifiers.

[0096] In this embodiment, each piece of training data in the hardware requirements corpus consists of three parts: form fields: structured data filled in by the user, such as "Processor architecture: NVIDIA A100." Conversation text: unstructured communication records between the user and platform technicians, such as the transcribed text "A GPU that supports CUDA 11.8 is required." Hardware type identifier: a code that uniquely identifies the hardware configuration, such as "NV-A100-80G-PCIe4." Triple relationships: the three must strictly correspond. For example, "Memory capacity: 64GB" in the form and "At least 64GB of video memory" in the conversation must be associated with the same hardware identifier.

[0097] As an optional implementation, a semi-automated annotation process is adopted. First, regular expressions are used to extract form field keywords, then NLP technology is combined to extract hardware parameters from the conversation text, and finally triples are generated by expert review.

[0098] For example, a piece of training data can be represented as:

[0099] json

[0100] {

[0101] "Form Field": {"Processor Architecture": "NVIDIA A100", "Memory Capacity": "64GB"},

[0102] "Dialogue text": "A graphics card that supports CUDA 11.8 is required, with a minimum of 64GB of video memory."

[0103] "Hardware Type Identifier": "NV-A100-64G-CUDA11.8"

[0104] }

[0105] In step A20, a contrastive learning loss function is used to constrain the cosine similarity of form dialogue pairs of the same hardware type in the feature space to be higher than that of heterogeneous samples.

[0106] In this example, the learning objective is to compare the cosine similarity between the form field and the conversation text for the same hardware type in feature space to be greater than 0.85, and the similarity between different hardware types to be less than 0.3. Triplet Loss is used as the loss function with a margin of 0.5 to ensure that similar samples are closer together and different samples are farther apart.

[0107] As an alternative implementation, taking the hardware identifier "NVIDIA A100" as an example, we select its corresponding form field, such as "Processor Architecture: A100," as the anchor. Positive examples are associated dialogue text, such as "A100 graphics card required," and negative examples are dialogue text for other hardware types, such as "AMD MI250 required." During model training, the distance between the anchor and the positive examples is minimized, while the distance between the anchor and the negative examples is maximized.

[0108] Step A30: generating an enhanced model for parsing robustness to ambiguous representations based on adversarial samples to obtain the multimodal alignment model.

[0109] In this embodiment, adversarial examples include fuzzy expressions and noise interference. The adversarial training method is to add adversarial examples to the training set and iteratively optimize the model parameters so that it can still accurately associate semantics in a noisy environment.

[0110] As an optional implementation, the Fast Gradient Symbolic Method (FGSM) is used to generate adversarial examples. For example, by perturbing the original conversation text "64GB of video memory required," the model is generated as "64GB of video memory required" or "approximately 64GB of video memory required." This forces the model to learn to ignore spelling errors and ambiguous quantifiers. After adversarial training, the model's parsing accuracy for ambiguous expressions increased from 78% to 95%.

[0111] This embodiment significantly reduces manual intervention in the demand analysis process through structured triple data, contrastive learning optimization and adversarial training.

[0112] Based on any of the above embodiments, in the third embodiment of the present application, the step of matching the training and recommendation model and the training and recommendation data according to the demand characteristics includes:

[0113] Step S21, parse the hardware type identifier in the requirement feature, and screen candidate training models based on a processor architecture compatibility map, where the map pre-stores a mapping relationship between different hardware platforms and the support status of neural network operators.

[0114] In this embodiment, the hardware type identifier is composed of parameters such as the processor architecture code, memory capacity, and interface protocol, and is used to uniquely identify the hardware configuration of the target device. The processor architecture compatibility map pre-stores the support status of different hardware platforms for neural network operators, such as NVIDIA GPU support for CUDA operators, Huawei Ascend support for CANN operators, and ARM architecture support for Neon instruction set acceleration models.

[0115] As an optional implementation, the hardware type identifier field is extracted from the requirements form and parsed into subfields such as processor architecture, memory capacity, and interface protocol. These subfields are then matched against the processor architecture compatibility map to filter out a list of hardware platforms that support the target operator, such as FP16 mixed precision. Models that do not meet the requirements are filtered out based on hardware parameters, such as memory capacity ≥ 64GB, ultimately generating a list of candidate training and inference models.

[0116] The compatibility map is maintained through a dynamic update mechanism. For example, when a hardware platform is detected to have newly added support for TensorRT 8.6, the ResNet-50-TRT8.6 model is automatically added to the candidate list. Prioritize matching the computing power requirement level during screening. For example, "HPC-level" corresponds to models that support mixed-precision computing.

[0117] Step S22: Dynamically prune the candidate training and inference models according to the computing power requirement level to generate the training and inference model that meets the memory capacity constraint of the target device.

[0118] In this embodiment, computing power requirements are categorized into "edge computing level" (parameter count ≤ 5 million, memory ≤ 512MB), "general computing level" (parameter count ≤ 100 million, memory ≤ 8GB), and "HPC level" (unlimited parameter count). Dynamic pruning reduces model complexity through knowledge distillation, quantization compression, and channel pruning. A memory simulator is used to verify that the pruned model meets peak memory usage requirements on the target device.

[0119] As an optional implementation, the system receives a list of candidate training and inference models and a computing power requirement as input. It then performs static analysis on these models, calculating their floating-point operations and peak memory usage, and sets pruning thresholds based on the computing power requirement. It removes redundant modules, such as the Dropout layer in BERT, and applies quantization techniques, such as INT8 quantization, to further reduce the model size. Ultimately, it generates a set of lightweight models adapted to the target device.

[0120] For edge devices, a layered pruning strategy is adopted. First, attention heads irrelevant to downstream tasks in the BERT-large model are removed, and then the fully connected layer is quantized to 8 bits, ultimately reducing the model memory usage to meet the memory constraints of edge devices.

[0121] In step S23, a privacy computing channel is constructed based on data security requirements, initial data matching the required scenario labels is extracted from the distributed data source, and the training data protected by differential privacy is generated through a homomorphic encryption algorithm.

[0122] In this embodiment, the privacy-preserving computing channel is designed based on a zero-trust architecture. It establishes encrypted links with distributed data sources, such as medical imaging repositories and financial transaction repositories, through bidirectional TLS authentication, ensuring that data transmission cannot be tampered with. Differential privacy protection utilizes the Paillier homomorphic encryption algorithm to encrypt sensitive fields, such as patient IDs. During the data aggregation phase, Laplace noise λ=0.1 is added to prevent individual records from being reverse-engineered.

[0123] As an optional implementation, raw data matching the required scenario labels, such as medical images and financial transaction records, is extracted from a distributed database and encrypted via TLS 1.3 to establish a secure data transmission channel. Paillier homomorphic encryption is applied to sensitive fields, such as patient ID and transaction amount, to ensure data confidentiality during storage and transmission. Gaussian noise is added during data aggregation to achieve differential privacy protection and meet GDPR compliance requirements. This ultimately generates an encrypted training dataset.

[0124] Initial data matching the required scenario labels is extracted from distributed nodes, and data alignment is performed using a federated learning framework to generate a differentially private dataset. The accuracy of the model decreases minimally during training, meeting compliance requirements.

[0125] This embodiment achieves a balance between the end-to-end efficiency and security of the training and push system through the linkage of three technologies: hardware adaptation, model lightweighting, and privacy computing, thereby reducing the deployment cost in highly sensitive scenarios.

[0126] Based on any of the above embodiments, in the fourth embodiment of the present application, the step of deploying a development environment based on the training model and the training data includes:

[0127] Step S31: According to the framework type of the training model, the corresponding version of the runtime dependency library is matched from the preset container template library to build a basic container image including the framework interpreter and the model conversion tool chain.

[0128] In this embodiment, the framework type of the training and inference model refers to the deep learning framework on which the model submitted by the user is based, including but not limited to TensorFlow, PyTorch, ONNX, etc. The framework type determines the computing library, tool chain and compatibility requirements required for the model to run. Container template library: a standardized runtime environment image pre-set for a variety of AI frameworks, including corresponding versions of CUDA, cuDNN, NCCL and other dependent libraries, as well as framework interpreters such as Python interpreters, model conversion tool chains such as ONNXRuntime, TensorRT and other components, for quickly generating container images adapted to the target framework. Basic container image: a Docker image that includes a framework interpreter, a model conversion tool chain and a runtime dependency library, which serves as the underlying operating basis of the training and inference environment and supports model loading, reasoning and conversion operations.

[0129] As an optional implementation, extract the framework type field of the training model from the requirement form, parse the framework name and version number; at the same time, query the metadata index of the container template library to obtain a list of image templates that match the framework type. According to the framework version number, filter the image template that supports this version from the template library. Dynamically add the runtime dependency libraries and tool chains required by the target framework to the base image. Perform multi-stage construction on the image, remove unnecessary debugging files and intermediate products, and finally generate a lightweight basic container image. Generate a basic container image that includes the framework interpreter, model conversion tool chain, and runtime dependency libraries, and store it in a private image repository for subsequent deployment in the training environment.

[0130] Through the preset container template library and automated matching mechanism, the construction time of the basic container image is shortened and the image size is reduced, which significantly improves the initialization efficiency of the training and promotion environment while ensuring the compatibility of the framework version and the hardware platform.

[0131] Step S32: parse the interface protocol feature code of the hardware type identifier in the requirement feature, inject the target hardware driver layer into the basic container image, and generate a hardware-adapted training and push execution environment.

[0132] In this embodiment, the hardware type identifier includes hardware feature information such as processor architecture, interface protocol, and memory capacity, which is used to describe the computing power and connection characteristics of the target device. The target hardware driver layer supports the driver and operator library for specific hardware, ensuring that the model can efficiently utilize hardware resources.

[0133] As an optional implementation, parse the hardware type identifier field in the requirement form and extract subfields such as processor architecture, interface protocol, and memory capacity. Determine the driver requirements of the target hardware based on the interface protocol feature encoding. Inject the driver library of the target hardware into the base container image through the dynamic library loading mechanism, and configure the environment variables to point to the driver path. Run the hardware compatibility test script to verify the compatibility of the driver layer and the base image to ensure that the model can call the hardware acceleration function normally. Generate a training and push execution environment adapted to the target hardware, including a complete driver layer and an optimized base image to support hardware accelerated reasoning.

[0134] Through the dynamic driver injection mechanism, the training and execution environment has a higher adaptation rate for heterogeneous hardware such as GPUs and NPUs, and its inference performance is improved compared to general images.

[0135] Step S33: Mount the differentially privately protected training data to the container storage volume, and automatically generate a data preprocessing script that matches the input and output format of the training model.

[0136] In this example, differentially private data: training datasets protected by homomorphic encryption or noise injection techniques, ensuring data privacy during transmission and computation. Data preprocessing scripts: automated scripts that convert encrypted data into model input formats, supporting automated feature extraction, normalization, and other operations.

[0137] As an optional implementation, an encrypted training and inference data volume is mounted from a distributed storage system, and the data's encryption format and storage structure are analyzed. The encrypted data is loaded through a decryption module within the container, and its integrity is verified. Based on the input layer configuration of the training and inference model, a preprocessing script is automatically generated, including logic for data decryption, normalization, and bucketing. Differential privacy validation is performed on the decrypted data to ensure the unidentification of individual records. A training and inference dataset and preprocessing script are generated that matches the model's input format, allowing for direct use in model training and inference.

[0138] Through the automated data preprocessing mechanism, data loading and conversion efficiency is improved, while privacy compliance requirements are met and the risk of data leakage is reduced.

[0139] Step S34: Configure environment variable parameters, including the model service port number, computing resource quota, and monitoring probe collection frequency, to complete the development environment deployment.

[0140] In this example, computing resource quotas are used to limit CPU / GPU resource usage through container orchestration tools, ensuring that the model runs within the specified hardware resource range. Monitoring probes collect metrics such as inference latency and video memory usage for real-time monitoring of the model's running status.

[0141] As an optional implementation, extract parameters such as the required computing power level, service port, and monitoring frequency from the requirements form. Set resource quotas for the container, such as GPU memory ≤ 32GB and CPU core count ≤ 20. Inject the monitoring module and configure the sampling frequency and metric reporting path. Verify the legitimacy of the environment variables to ensure correct configuration. After the development environment is deployed, the container will have resource isolation, performance monitoring, and service exposure capabilities to support the stable operation of training and push tasks.

[0142] Through refined resource management and monitoring mechanisms, computing power utilization is improved, inference latency is reduced, and real-time performance analysis and troubleshooting are supported.

[0143] Based on any of the above embodiments, in the fifth embodiment of the present application, refer to Figure 2 In response to the training and pushing operation of the development environment, the steps of calling the reserved computing power of the user corresponding to the demand form, generating a dedicated model and packaging it into a model encryption deployment package include:

[0144] Step S41: Based on the container runtime environment of the development environment, the dynamic scheduling strategy of the reserved computing power is analyzed to generate resource allocation parameters and computing power constraints.

[0145] In this embodiment, the container runtime environment of the development environment: it is a lightweight virtualization technology that can package applications and their dependencies into independent containers to maintain a consistent operating state in different environments. Common container runtime environments such as the Docker runtime provide basic capabilities for operations such as creating, starting, and stopping containers. Dynamic scheduling strategy for reserved computing power: this is a strategy that flexibly adjusts the allocation of computing power resources based on different application scenarios and time requirements. For example, more computing power is allocated during business peak periods, and computing power allocation is reduced during low periods to improve resource utilization. Resource allocation parameters: refers to the specific parameters used when scheduling computing power resources, such as the number of CPU cores, the number of GPUs, the size of memory, etc., which are used to clarify the amount of resources available for each task. Computing power constraints: restrictions on the use of computing power, such as the maximum allowable power consumption, specific hardware model requirements, etc., to ensure that the use of computing power meets specific specifications and requirements.

[0146] As an optional implementation, first, within the development environment's container runtime, use a container management tool such as Kubernetes to obtain current resource status information. Next, the dynamic scheduling policy for computing power reserved by the user in the demand form is parsed. This policy may exist in the form of a configuration file or code. Based on the parsed results and the current resource status, specific resource allocation parameters are generated, such as allocating four CPU cores and one GPU to a training task. Computing power constraints are also determined based on user requirements and hardware characteristics, such as a maximum power consumption limit of 200 watts.

[0147] Step S42: According to the resource allocation parameters, the training batch size and the video memory occupancy ratio are dynamically adjusted through a reinforcement learning-driven resource allocation algorithm, and a gradient update parameter that adapts to the target hardware computing power threshold is output.

[0148] In this embodiment, the resource allocation algorithm driven by reinforcement learning is: reinforcement learning is a machine learning method that uses an intelligent agent to interact with the environment and continuously try different behaviors to maximize the cumulative reward. In the resource allocation scenario, the intelligent agent dynamically adjusts the resource allocation strategy based on the current resource status and task requirements to achieve optimal resource utilization. Training batch size: The number of samples selected from the training data set each time during deep learning training. The appropriate batch size can affect the training speed and model performance. Video memory usage ratio: The proportion of GPU video memory occupied by the model during training. Reasonable control of the video memory usage ratio can avoid video memory overflow and improve training efficiency. Gradient update parameter: In deep learning, gradient update is a key step in optimizing model parameters. The gradient update parameter determines the amplitude and direction of the model parameter update in each iteration. Target hardware computing power threshold: The maximum computing power load that the target hardware can withstand. Exceeding this threshold may cause hardware performance degradation or failure.

[0149] As an optional implementation, the generated resource allocation parameters are fed into a reinforcement learning-driven resource allocation algorithm. This algorithm uses training batch size and memory usage as adjustable actions, and the model's training speed, accuracy, and resource utilization as reward functions. By continuously interacting with the training environment, the algorithm dynamically adjusts the training batch size and memory usage, allowing the model training process to adapt to the target hardware's computing power threshold. Ultimately, it outputs the optimal gradient update parameters under the current resource allocation for subsequent model training.

[0150] Step S43: Based on the gradient update parameters and the data privacy requirements marked in the requirement form, a differential privacy budget is dynamically allocated to the training dataset through a privacy computing gateway to generate a feature tensor sequence with privacy protection labels.

[0151] In this embodiment, data privacy requirements: requirements for training data privacy protection explicitly stated by the user in the requirement form, such as the degree of anonymization of the data, data access rights, etc. Privacy computing gateway: a middleware used to protect data privacy, which can perform encryption, desensitization and other processing on the data, while supporting data calculation and analysis under the premise of privacy protection. Differential privacy budget: Differential privacy is a technology used to protect data privacy. The differential privacy budget is used to control the amount of noise that can be introduced during the data release process to balance the availability and privacy of the data. Feature tensor sequence: In deep learning, data is usually represented in the form of tensors. A feature tensor sequence refers to a tensor sequence formed by arranging the features in the training data set in a certain order. Privacy protection label: A label added to each feature tensor to identify whether the tensor has been processed for privacy protection and how it has been processed.

[0152] As an optional implementation, based on the obtained gradient update parameters and the data privacy requirements specified in the requirements form, the privacy computing gateway first analyzes the training dataset to determine the sensitivity of each data sample. Then, based on the principles of differential privacy, it dynamically allocates a differential privacy budget, introducing varying degrees of noise for data samples of varying sensitivity. During this processing, a privacy-preserving label is added to each feature tensor, indicating the type of privacy-preserving treatment it has undergone. Finally, a sequence of privacy-labeled feature tensors is generated for subsequent model training.

[0153] In step S44, a homomorphic encryption algorithm is used to encrypt the model weights corresponding to the feature tensor sequence layer by layer, wherein the encryption key is generated by a two-factor mixing of the user identity identifier in the requirement form and the hardware device fingerprint.

[0154] In this embodiment, homomorphic encryption algorithm: a special encryption algorithm that allows specific calculations to be performed on encrypted data without decrypting the data first. The calculation result is the same as the result of the same calculation on the plaintext data after decryption. Model weight: In the deep learning model, the weight is the core parameter of the model, which determines the learning ability and performance of the model. User identity identifier: information used to uniquely identify the user, such as user name, user ID, etc. Hardware device fingerprint: a unique identifier composed of various feature information of the hardware device, such as CPU model, MAC address, etc. Two-factor hybrid generation: the user identity identifier and hardware device fingerprint are used as two factors, and they are mixed through a specific algorithm to generate an encryption key to increase the security of the key.

[0155] As an optional implementation, the model weights corresponding to the generated sequence of privacy-labeled feature tensors are encrypted layer by layer using a homomorphic encryption algorithm. During the encryption process, the user identity identifier is obtained from the requirements form, and the hardware device fingerprint is obtained using a hardware information collection tool. These two factors are then input into a pre-designed key generation algorithm to generate an encryption key. This encryption key is used to encrypt each layer of the model weights, ensuring the security of the model weights during transmission and storage.

[0156] Step S45: inject the encrypted model weights into the hardware acceleration module based on the trusted execution environment, and integrate them with the inference driver library corresponding to the gradient update parameters to generate an initial deployment package.

[0157] In this embodiment, the Trusted Execution Environment (TEE) is a hardware security technology that provides an isolated execution environment where the code and data running in the environment are protected from external malware. Hardware Accelerator Module is a hardware device specifically designed to accelerate computing tasks, such as a GPU or FPGA. Inference Driver Library is a software library used to drive the hardware acceleration module to perform model inference, which provides interfaces and functions for interacting with the hardware device. Initial Deployment Package is a data package containing encrypted model weights, an inference driver library, and related configuration information, used for subsequent model deployment.

[0158] As an optional implementation, the encrypted model weights are injected into a hardware acceleration module based on a trusted execution environment. The hardware acceleration module provides a secure storage and execution environment to ensure that the encrypted model weights are not leaked. At the same time, the inference driver library corresponding to the gradient update parameters obtained in step S42 is integrated with the encrypted model weights. The inference driver library is responsible for interacting with the hardware acceleration module to implement the reasoning function of the model. Finally, the encrypted model weights, inference driver library, and related configuration information are packaged into an initial deployment package to prepare for subsequent deployment.

[0159] Step S46: simulate the runtime environment of the initial deployment package according to the computing power constraint condition to generate the model encryption deployment package containing the national secret algorithm verification code.

[0160] In this embodiment, runtime environment simulation: The initial deployment package is tested and verified by simulating the actual runtime environment to ensure its proper operation in actual operation. National Secret Algorithm Check Code: National Secret Algorithms are cryptographic algorithms independently developed in my country, such as SM2, SM3, and SM4. The National Secret Algorithm Check Code is a checksum value obtained by hashing the initial deployment package using the National Secret Algorithm and is used to verify the integrity and authenticity of the deployment package. Model Encrypted Deployment Package: An encrypted deployment package containing the National Secret Algorithm Check Code is used for secure deployment into the target environment.

[0161] As an optional implementation, a runtime environment simulation tool is used to simulate the initial deployment package based on the generated computing power constraints. During the simulation, the initial deployment package's resource usage is monitored to ensure that it operates within the computing power constraints. If the simulation passes, the initial deployment package is hashed using a national encryption algorithm, such as the SM3 algorithm, to generate a national encryption algorithm verification code. This national encryption algorithm verification code is added to the initial deployment package, ultimately generating a model encrypted deployment package containing the national encryption algorithm verification code. This deployment package can be securely deployed to the target environment, ensuring the security and integrity of the model.

[0162] Based on any of the above embodiments, in the sixth embodiment of the present application, refer to Figure 3The step of deploying the model encryption deployment package to the front-end and back-end applications includes:

[0163] Step S51, parse the integrity check code in the model encrypted deployment package, verify the integrity of the deployment package through the national encryption algorithm, and synchronously verify the consistency of the hardware device fingerprint with the registered device information in the demand form.

[0164] In this embodiment, the model encryption deployment package: a data package containing encrypted model weights, inference driver library and related configuration information, which is used to securely deploy the model. Integrity check code: a fixed-length value obtained by calculating the deployment package content using a specific algorithm such as the national secret algorithm, which is used to verify whether the deployment package has been tampered with during transmission or storage. National secret algorithm: a series of cryptographic algorithms independently developed by my country, such as SM2, SM3, SM4, etc., which have high security and reliability and are used to ensure the confidentiality, integrity and authenticity of information. Hardware device fingerprint: a unique identifier composed of various characteristic information of the hardware device, such as CPU model, MAC address, hard disk serial number, etc., which is used to identify and verify the identity of the device. Device information registered in the demand form: device-related information pre-registered by the user in the demand form, including device model, hardware configuration, etc., is used for comparison and verification with the actual deployed device.

[0165] As an optional implementation, after receiving the model encrypted deployment package, first extract the integrity check code from the deployment package. Then, use the same national encryption algorithm, such as the SM3 algorithm, to recalculate the content of the deployment package to obtain a new check code. Compare the newly calculated check code with the extracted integrity check code. If the two are consistent, it means that the integrity of the deployment package has not been destroyed. At the same time, obtain the hardware device fingerprint of the current target device through the hardware information collection tool. Compare the obtained hardware device fingerprint with the device information registered in the requirement form to check whether the two are consistent. If the hardware device fingerprint matches the registered device information, you can continue with the subsequent deployment operation; otherwise, terminate the deployment and issue a security warning.

[0166] In step S52, based on the hardware acceleration module of the trusted execution environment, an isolated model execution sandbox is created on the target device, and the encrypted model weights and inference driver library are loaded, wherein the sandbox is configured to only allow access to the training and inference data through the privacy computing channel.

[0167] In this embodiment, hardware acceleration module: a hardware device specifically used to accelerate computing tasks, such as GPU, FPGA, etc., which can significantly improve the reasoning speed of the model. Model running sandbox: an isolated operating environment used to limit the access rights of the model, ensure that the model runs in a safe environment, and prevent damage to the target device. Encrypted model weights: encrypted model parameters to ensure the security of the model during transmission and storage. Inference driver library: a software library used to drive the hardware acceleration module to perform model reasoning, providing interfaces and functions for interacting with hardware devices. Privacy computing channel: a secure communication channel used to transmit and calculate data while protecting data privacy, such as using technologies such as homomorphic encryption and differential privacy.

[0168] As an optional implementation, an isolated model execution sandbox is created using the target device's hardware acceleration module based on a trusted execution environment (TEE). This sandbox is a separate execution environment, isolated from the rest of the target device to ensure that model execution does not impact other device functions. The encrypted model weights and integrated inference driver library are loaded into the sandbox. During the loading process, the model weights are decrypted within the TEE to ensure data security.

[0169] The sandbox can be configured to only allow access to training data through private computing channels. This ensures the privacy of training data during transmission and use, preventing data leakage. For example, training data can be encrypted using homomorphic encryption, eliminating the need to decrypt the data during sandbox computations, thus achieving privacy protection.

[0170] Step S53: Dynamically select the training model based on the front-end application interface protocol characteristics, wherein the training model includes an operator acceleration library that matches the target processor architecture, and injects the model weights into the pre-allocated area of the video memory through memory mapping technology.

[0171] In this embodiment, the front-end application interface protocol features: the characteristics of the protocol followed for communication between the front-end application and the back-end service, including data format, request method, response format, etc., are used to determine a suitable training and inference model. Target processor architecture: the architecture of the processor used by the target device, such as x86, ARM, etc. Different processor architectures have an impact on the running efficiency of the model. Operator acceleration library: a function library optimized for a specific processor architecture, containing efficient implementations of various computing operators, which can accelerate the reasoning process of the model. Memory mapping technology: a technology that maps the physical memory of a disk file or other device to the virtual address space of a process. This technology can directly access disk files or device memory to improve data transmission efficiency. Video memory pre-allocated area: an area pre-allocated in the GPU video memory, used to store model weights and intermediate calculation results to reduce the overhead of video memory allocation and release.

[0172] As an optional implementation, the front-end application interface protocol characteristics are analyzed and, based on these characteristics, the most suitable model is dynamically selected from available training and inference models. For example, if the front-end application requires real-time response, a model with faster inference speed may be selected; if the front-end application processes image data, a model suitable for image recognition may be selected. The selected training and inference model should include an operator acceleration library that matches the target processor architecture. This fully utilizes the target processor's performance and improves the model's inference efficiency. For example, for an x86-based processor, an operator acceleration library optimized for x86 can be selected; for an ARM-based processor, an operator acceleration library optimized for ARM can be selected. Memory mapping technology is used to inject the encrypted model weights, then decrypted in the sandbox, into a pre-allocated area of video memory. Through memory mapping, model weights can be mapped directly from disk or other storage devices into video memory, eliminating data copying and transmission overhead and improving data access speed. Furthermore, the use of a pre-allocated area of video memory reduces the time required to allocate and release video memory, further improving the model's inference performance.

[0173] Step S54: deploy a gateway in the backend service container, configure an input data format converter and an output result encryption module, and the converter automatically adjusts the number of concurrent threads of batch inference according to the computing power requirement level in the demand characteristics.

[0174] In this embodiment, the backend service container: uses containerization technology such as Docker to package the backend service into an independent running unit for easy deployment and management. Gateway: As the entrance to the backend service, it is responsible for receiving requests from the front-end application and forwarding the requests to the corresponding service module. It can also perform operations such as filtering, routing, and current limiting on the requests. Input data format converter: used to convert the input data sent by the front-end application into a format that can be processed by the training and inference model, such as converting image data in different formats into a unified format. Output result encryption module: encrypts the output results of the training and inference model to protect the privacy and security of the data, such as using a symmetric encryption algorithm to encrypt the results. Computing power requirement level in the requirement characteristics: the level of computing power requirements proposed by the user in the requirement form, such as high, medium, and low, which is used to guide the allocation and adjustment of resources. The number of concurrent threads for batch inference: when performing batch inference, the number of threads running simultaneously. Reasonable adjustment of the number of concurrent threads can improve inference efficiency.

[0175] As an optional implementation, a gateway is deployed in the backend service container as a unified entry point for the entire backend service. The gateway can be implemented using open-source gateway frameworks such as Nginx and Kong. The gateway's routing rules are configured to accurately forward requests from frontend applications to the corresponding training and inference model service modules. An input data format converter is configured in the gateway. This converter can perform conversions based on the data format sent by the frontend application and the data format required by the training and inference model. For example, if the frontend application sends image data in JPEG format, but the training and inference model requires image data in PNG format, the converter can convert the JPEG image to a PNG image. Furthermore, an output result encryption module is configured in the gateway. After the training and inference model completes inference, the output result encryption module encrypts the output using a pre-configured encryption algorithm (such as AES) to ensure the security of the results during transmission.

[0176] The input data format converter automatically adjusts the number of concurrent threads for batch inference based on the computing power requirement level in the demand profile. If the computing power requirement is high, the number of concurrent threads can be increased to fully utilize hardware resources and improve inference speed. If the computing power requirement is low, the number of concurrent threads can be reduced to reduce energy consumption and resource usage. For example, by monitoring hardware resource usage, the number of concurrent threads can be dynamically adjusted to achieve optimal resource allocation.

[0177] Based on any of the above embodiments, in Embodiment 7 of the present application, in response to the training and pushing operation of the development environment, before the step of calling the reserved computing power of the user corresponding to the demand form, generating a dedicated model, and packaging it into a model encryption deployment package, the steps include:

[0178] Step B10: parse the computing power requirement level, task concurrency peak, and model complexity parameters in the requirement form to generate initial computing power resource allocation parameters.

[0179] In this embodiment, computing power requirement level: the level of computing power required by users based on their own business needs, such as high, medium, and low levels, which reflects the approximate requirements for computing speed and processing power. Task concurrency peak: the maximum number of tasks that the system needs to process simultaneously within a specific time period, reflecting the processing pressure of the system under peak load. Model complexity parameters: relevant parameters that describe the complexity of the model, such as the number of layers, number of neurons, number of parameters, etc. of the model, which affect the computing resources required for model training and inference. Initial computing power resource allocation parameters: parameters for allocating computing power resources that are preliminarily determined based on the information obtained from the above analysis, such as the number of CPU cores, number of GPUs, memory size, etc.

[0180] As an optional implementation method, first, extract the computing power requirement level, task concurrency peak and model complexity parameters from the requirement form. You can use tools such as regular expressions and data parsing libraries to parse the text or structured data in the requirement form. For example, if the requirement form is a JSON file, you can use Python's json library to parse it. Based on the extracted parameters, combine the preset rules or empirical formulas to generate the initial computing power resource allocation parameters. For example, if the computing power requirement level is high, the task concurrency peak is large and the model complexity is high, then more CPU cores, GPUs and larger memory can be allocated. A parameter mapping table can be established to determine the corresponding initial computing power resource allocation parameters based on different parameter combinations.

[0181] Step B20, based on the computing power consumption records in the historical training database, calculate the computing power requirement baseline value of the target scenario through the time series prediction model, where the baseline value includes three-dimensional constraint indicators of video memory occupancy rate, floating-point operation volume and memory bandwidth utilization rate.

[0182] In this embodiment, historical training database: a database that stores data related to computing power consumption during previous model training processes, including the computing power usage of different tasks and different models during training. Computing power consumption records: records the usage of various computing power indicators during each model training process, such as video memory occupancy, floating-point operations, memory bandwidth utilization, and other data that changes over time. Time series prediction model: a model used to analyze time series data and make predictions, such as ARIMA, LSTM, etc., which predicts future computing power requirements by learning from historical data. Target scenario: a specific business scenario in which the user currently needs to perform model training or inference. Computing power requirement baseline value: a reasonable computing power requirement reference value under the target scenario, composed of constraint indicators in three dimensions: video memory occupancy, floating-point operations, and memory bandwidth utilization.

[0183] As an optional implementation, extract computing power consumption records related to the target scenario from the historical training database. Filtering can be performed based on conditions such as task type, model type, and hardware environment. Organize the extracted computing power consumption records into time series data and train them using an appropriate time series prediction model. For example, use the ARIMA model in Python's statsmodels library or the LSTM model in the tensorflow library. After training the model, input relevant information about the target scenario and predict the baseline values of video memory occupancy, floating-point operations, and memory bandwidth utilization in the target scenario as a reference for computing power requirements.

[0184] Step B30: Match the processor instruction set support map based on the hardware architecture identifier in the requirement form and filter the candidate computing power types that meet the computing power requirement baseline value.

[0185] In this embodiment, the hardware architecture identifier is used to uniquely identify the hardware architecture type, such as x86, ARM, or GPU architecture, reflecting the hardware's basic characteristics and instruction set support. The processor instruction set support map is a map that records the instruction set information supported by different processor architectures, showing the correspondence between various instruction sets and hardware architectures. Candidate computing power types are different types of computing resources that meet the baseline computing power requirement, such as different CPU and GPU models.

[0186] As an optional implementation, obtain the hardware architecture identifier from the requirements form. Based on this identifier, search for the corresponding instruction set information in the processor instruction set support map. Combined with the obtained computing power requirement baseline, filter the various available computing power types. Check whether the hardware architecture of each computing power type supports the required instruction set and meets the baseline requirements for video memory occupancy, floating-point operations, and memory bandwidth utilization. Filter out candidate computing power types that meet the requirements.

[0187] Step B40: Perform Pareto optimization of resource utilization and energy consumption ratio of candidate computing power types based on a reinforcement learning algorithm to generate a dynamic scheduling strategy that includes computing power threshold intervals, time window constraints, and elastic scaling rules.

[0188] In this embodiment, reinforcement learning algorithm: A machine learning algorithm such as Q-learning and A3C, which uses an intelligent agent to interact with its environment and continuously try different behaviors to maximize cumulative rewards. Resource utilization and energy consumption ratio: A metric that measures the relationship between computing resource utilization efficiency and energy consumption, reflecting the proportion of computing resources that can be effectively utilized while consuming a certain amount of energy. Pareto optimization: An optimization method that cannot improve a single objective without compromising other objectives, used to find the optimal balance between resource utilization and energy consumption ratio. Computing power threshold range: The allowed range of computing power usage, specifying the minimum and maximum computing power usage to ensure that the system operates within a reasonable computing power range. Time window constraint: A restriction on computing power usage time, such as the maximum computing power that can be used within a certain time period, to meet business needs and resource management requirements. Elastic scaling rules: Rules that dynamically adjust computing power resources based on changes in business load, such as increasing computing power during peak business hours and reducing computing power during low business hours. Dynamic scheduling strategy: Dynamically adjusts computing power allocation strategies based on different business scenarios and resource status, including computing power threshold ranges, time window constraints, and elastic scaling rules.

[0189] As an optional implementation, candidate computing power types are used as optional actions in the reinforcement learning algorithm, and resource utilization and energy consumption ratio are used as reward functions. The environmental state is defined as information such as the current business load and resource usage. Using the reinforcement learning algorithm for training, the intelligent agent selects different candidate computing power types under different environmental states and maximizes the reward function by continuously interacting with the environment. During the training process, the idea of Pareto optimization is adopted to minimize energy consumption while improving resource utilization. Based on the training results, a dynamic scheduling strategy is generated that includes computing power threshold ranges, time window constraints, and elastic scaling rules. For example, based on the peak and trough times of the business, the computing power threshold ranges for different time periods are determined; based on the rate of change of the business load, elastic scaling rules are formulated.

[0190] Step B50: Bind the dynamic scheduling policy to the target hardware resource pool and generate a reserved computing power identifier with a timestamp to identify the reserved computing power.

[0191] In this embodiment, the target hardware resource pool is a collection of computing resources available for allocation, including various types of hardware devices, such as servers and GPU clusters. A timestamp records the specific time an event occurs, used to identify when the reserved computing power was generated. A reserved computing power identifier uniquely identifies the reserved computing power resource, including information such as the dynamic scheduling policy and generation time.

[0192] As an optional implementation, the dynamic scheduling policy generated in step 4 is bound to the target hardware resource pool. The hardware resources can be allocated and used according to the dynamic scheduling policy by configuring the corresponding scheduling rules in the management system of the hardware resource pool. A timestamped identifier is generated for the reserved computing power resources. A unique identifier can be generated using a UUID algorithm, and the current timestamp information is added to the identifier. The identifier is associated with the reserved computing power resources for subsequent resource management and tracking. For example, the identifier and the corresponding computing power resource information are recorded in the database of the computing power rental platform to facilitate user query and use.

[0193] The present application provides an application deployment device based on cloud computing power, which includes: at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores instructions that can be executed by the at least one processor, and the instructions are executed by the at least one processor so that the at least one processor can execute the application deployment method based on cloud computing power in the above-mentioned embodiment one.

[0194] Reference below Figure 4 , which shows a schematic diagram of the structure of a cloud computing-based application deployment device suitable for implementing the embodiments of the present application. The cloud computing-based application deployment device in the embodiments of the present application may include, but is not limited to, mobile terminals such as mobile phones, laptops, digital broadcast receivers, personal digital assistants (PDAs), tablet computers, and vehicle-mounted terminals, as well as fixed terminals such as digital TVs and desktop computers. Figure 4 The cloud computing-based application deployment device shown is only an example and should not bring any limitations to the functions and scope of use of the embodiments of the present application.

[0195] like Figure 4As shown, the cloud computing-based application deployment device may include a processing device 1001 (e.g., a central processing unit, a graphics processing unit, etc.), which can perform various appropriate actions and processes based on programs stored in a read-only memory (ROM) 1002 or programs loaded from a storage device 1003 into a random access memory (RAM) 1004. RAM 1004 also stores various programs and data required for the operation of the cloud computing-based application deployment device. Processing device 1001, ROM 1002, and RAM 1004 are interconnected via a bus 1005. An input / output (I / O) interface 1006 is also connected to the bus. Typically, the following systems can be connected to I / O interface 1006: input device 1007 including, for example, a touch screen, touchpad, keyboard, mouse, image sensor, microphone, accelerometer, gyroscope, etc.; output device 1008 including, for example, a liquid crystal display (LCD), speaker, vibrator, etc.; storage device 1003 including, for example, a magnetic tape, hard disk, etc.; and communication device 1009. Communication device 1009 can allow the cloud computing-based application deployment device to communicate with other devices wirelessly or by wire to exchange data. Although the figure shows a cloud computing-based application deployment device with various systems, it should be understood that implementation or presence of all the illustrated systems is not required. More or fewer systems may alternatively be implemented or present.

[0196] In particular, according to the embodiments disclosed in the present application, the processes described above with reference to the flowcharts can be implemented as computer software programs. For example, the embodiments disclosed in the present application include a computer program product comprising a computer program carried on a computer-readable medium, the computer program comprising program code for executing the method shown in the flowchart. In such an embodiment, the computer program can be downloaded and installed from a network via a communication device, or installed from a storage device 1003, or installed from a ROM 1002. When the computer program is executed by the processing device 1001, the above-mentioned functions defined in the method of the embodiment disclosed in the present application are executed.

[0197] The cloud computing power-based application deployment device provided in this application adopts the cloud computing power-based application deployment method in the above-mentioned embodiment to solve the technical problem that the development cycle of AI application software is significantly longer than that of traditional software, making it difficult to quickly form competitiveness. Compared with the existing technology, the beneficial effects of the cloud computing power-based application deployment device provided in this application are the same as those of the cloud computing power-based application deployment device provided in the above-mentioned embodiment, and the other technical features of the cloud computing power-based application deployment device are the same as those disclosed in the method of the previous embodiment, and are not further described here.

[0198] It should be understood that the various parts disclosed in this application can be implemented using hardware, software, firmware, or a combination thereof. In the description of the above embodiments, specific features, structures, materials, or characteristics can be combined in any one or more embodiments or examples in a suitable manner.

[0199] The above description is merely a specific embodiment of the present application, but the scope of protection of the present application is not limited thereto. Any changes or substitutions that can be easily conceived by a person skilled in the art within the technical scope disclosed in this application should be included in the scope of protection of this application. Therefore, the scope of protection of this application should be based on the scope of protection of the claims.

[0200] The present application provides a computer-readable storage medium having computer-readable program instructions (i.e., computer programs) stored thereon, and the computer-readable program instructions are used to execute the cloud computing power-based application deployment method in the above-mentioned embodiment.

[0201] The computer-readable storage medium provided herein may be, for example, a USB flash drive, but is not limited to electrical, magnetic, optical, electromagnetic, infrared, or semiconductor systems, systems, or devices, or any combination thereof. More specific examples of computer-readable storage media may include, but are not limited to, an electrical connection having one or more wires, a portable computer disk, a hard disk, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM), flash memory, optical fiber, a portable compact disk read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination thereof. In this embodiment, the computer-readable storage medium may be any tangible medium that contains or stores a program that can be used by or in conjunction with an instruction execution system, system, or device. The program code contained on the computer-readable storage medium may be transmitted using any suitable medium, including, but not limited to, wires, optical cables, radio frequency (RF), etc., or any suitable combination thereof.

[0202] The above-mentioned computer-readable storage medium may be included in the application deployment device based on cloud computing power; or it may exist independently without being assembled into the application deployment device based on cloud computing power.

[0203] The above-mentioned computer-readable storage medium carries one or more programs. When the above-mentioned one or more programs are executed by an application deployment device based on cloud computing power, the application deployment device based on cloud computing power: responds to the demand form and the meeting materials, extracts the demand features in the demand form and the meeting materials; matches the training and promotion model and the training and promotion data according to the demand features; deploys the development environment based on the training and promotion model and the training and promotion data; responds to the training and promotion operation of the development environment, calls the reserved computing power of the user corresponding to the demand form, generates a dedicated model and encapsulates it into a model encryption deployment package; and deploys the model encryption deployment package to the front-end and back-end applications.

[0204] Computer program code for performing the operations of the present application may be written in one or more programming languages, or a combination thereof, including object-oriented programming languages such as Java, Smalltalk, C++, and conventional procedural programming languages such as "C" or similar programming languages. The program code may be executed entirely on the user's computer, partially on the user's computer, as a stand-alone software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In the case of a remote computer, the remote computer may be connected to the user's computer via any type of network, including a local area network (LAN) or a wide area network (WAN), or may be connected to an external computer (e.g., via the Internet using an Internet service provider).

[0205] The flow charts and block diagrams in the accompanying drawings illustrate the possible architecture, functions and operations of the systems, methods and computer program products according to various embodiments of the present application. In this regard, each box in the flow chart or block diagram can represent a module, program segment or a part of code, and the module, program segment or a part of code contains one or more executable instructions for realizing the specified logical function. It should also be noted that in some alternative implementations, the functions marked in the box can also occur in a different order than that marked in the accompanying drawings. For example, two boxes represented in succession can actually be executed substantially in parallel, and they can sometimes be executed in the opposite order, depending on the functions involved. It should also be noted that each box in the block diagram and / or flow chart, and the combination of the boxes in the block diagram and / or flow chart can be implemented by a dedicated hardware-based system that performs the specified function or operation, or can be implemented by a combination of dedicated hardware and computer instructions.

[0206] The modules described in the embodiments of the present application may be implemented in software or hardware, wherein the name of a module does not necessarily limit the unit itself.

[0207] The computer-readable storage medium provided in this application is a computer-readable storage medium that stores computer-readable program instructions (i.e., a computer program) for executing the aforementioned cloud computing-based application deployment method. This computer-readable storage medium can address the technical issue of AI application software development cycles being significantly longer than traditional software, making it difficult to quickly achieve competitiveness. Compared to the prior art, the beneficial effects of the computer-readable storage medium provided in this application are the same as those of the cloud computing-based application deployment method provided in the aforementioned embodiments, and are not further elaborated here.

[0208] An embodiment of the present application provides a computer program product, including a computer program, which, when executed by a processor, implements the steps of the above-mentioned cloud computing power-based application deployment method.

[0209] The computer program product provided in this application can address the technical issue of AI application software development cycles being significantly longer than traditional software, making it difficult to quickly achieve competitiveness. Compared to the prior art, the beneficial effects of the computer program product provided in the embodiments of this application are the same as those of the cloud computing-based application deployment method provided in the aforementioned embodiments, and are not further elaborated here.

[0210] The above are only preferred embodiments of the present application and do not limit the patent scope of the present application. Any equivalent structure or equivalent process transformation made using the contents of the present application specification and drawings, or directly or indirectly applied in other related technical fields, are also included in the patent processing scope of the present application.

Claims

1. A cloud computing-based application deployment method, characterized in that: Applied to a computing power leasing platform, the cloud computing power-based application deployment method includes: In response to the demand form and the conversation materials, extracting demand features from the demand form and the conversation materials; Matching the training and recommendation model and training and recommendation data according to the demand characteristics; Deploy a development environment based on the training model and the training data; In response to the training and pushing operation of the development environment, based on the container runtime environment of the development environment, a dynamic scheduling strategy for the reserved computing power of the user corresponding to the demand form is parsed to generate resource allocation parameters and computing power constraints; Based on the resource allocation parameters, the training batch size and the memory usage ratio are dynamically adjusted through a reinforcement learning-driven resource allocation algorithm, and a gradient update parameter is output that adapts to the target hardware computing power threshold; Based on the gradient update parameters and the data privacy requirements marked in the requirement form, a differential privacy budget is dynamically allocated to the training dataset through a privacy computing gateway to generate a feature tensor sequence with privacy protection labels; The model weights corresponding to the feature tensor sequence are encrypted layer by layer using a homomorphic encryption algorithm, wherein the encryption key is generated by a dual-factor hybrid of the user identity identifier in the requirement form and the hardware device fingerprint; Inject the encrypted model weights into the hardware acceleration module based on the trusted execution environment, and integrate them with the inference driver library corresponding to the gradient update parameters to generate an initial deployment package; Perform runtime environment simulation on the initial deployment package according to the computing power constraint conditions to generate a model encryption deployment package containing a national secret algorithm check code; Parse the integrity check code in the model encrypted deployment package, verify the integrity of the deployment package using the national encryption algorithm, and simultaneously verify the consistency of the hardware device fingerprint with the registered device information in the requirement form; Based on the hardware acceleration module of the trusted execution environment, an isolated model execution sandbox is created on the target device, and the encrypted model weights and inference driver library are loaded. The sandbox is configured to only allow access to the training and inference data through the privacy computing channel; Dynamically select the training model based on the front-end application interface protocol characteristics, wherein the training model includes an operator acceleration library that matches the target processor architecture, and injects the model weights into the pre-allocated area of the video memory through memory mapping technology; A gateway is deployed in the backend service container, and an input data format converter and an output result encryption module are configured. The converter automatically adjusts the number of concurrent threads for batch inference based on the computing power requirement level in the demand characteristics.

2. The method according to claim 1, wherein The step of extracting demand features from the demand form and the conversation materials in response to the demand form and the conversation materials includes: Performing speech recognition on the interview data to generate unstructured text data; Performing cross-modal semantic association between the unstructured text data and the structured field data of the demand form using a pre-trained multimodal alignment model, wherein the multimodal alignment model uses a bidirectional attention mechanism to calculate a correlation matrix between the form fields and the dialogue text; Key semantic fragments are filtered according to the association matrix to generate the requirement characteristics including hardware type identifier, computing power requirement level and data security requirements, wherein the hardware type identifier includes the processor architecture, memory capacity and interface protocol feature coding of the target device.

3. The method according to claim 2, wherein Before the step of performing cross-modal semantic association between the unstructured text data and the structured field data of the requirement form using the pre-trained multimodal alignment model, the method includes: Constructing an annotated hardware requirement corpus, wherein the training data of the hardware requirement corpus includes triples of form fields, dialogue texts, and corresponding hardware type identifiers; A contrastive learning loss function is used to constrain the cosine similarity of form dialogue pairs with the same hardware type in the feature space to be higher than that of heterogeneous samples. The parsing robustness of the model to ambiguous representations is enhanced based on adversarial sample generation to obtain the multimodal alignment model.

4. The method according to claim 1, wherein The step of matching the training and inference model and the training and inference data according to the demand characteristics includes: Parsing the hardware type identifier in the requirement characteristics and screening candidate training models based on a processor architecture compatibility map, where the map pre-stores a mapping relationship between different hardware platforms and the support status of neural network operators; Dynamically prune candidate training and inference models according to the computing power requirement level to generate the training and inference model that meets the memory capacity constraint of the target device; Based on data security requirements, a privacy computing channel is constructed, initial data matching the required scenario labels are extracted from distributed data sources, and the training data protected by differential privacy is generated through a homomorphic encryption algorithm.

5. The method according to claim 1, wherein The step of deploying a development environment based on the training model and the training data includes: According to the framework type of the training model, match the corresponding version of the runtime dependency library from the preset container template library to build a basic container image including the framework interpreter and model conversion tool chain; Parsing the interface protocol feature code of the hardware type identifier in the requirement feature, injecting the target hardware driver layer into the basic container image, and generating a hardware-adapted training and push execution environment; Mount the differentially private training data to the container storage volume and automatically generate a data preprocessing script that matches the input and output format of the training model; Configure environment variable parameters, including the model service port number, computing resource quota, and monitoring probe collection frequency, to complete the development environment deployment.

6. The method according to claim 1, wherein Before the step of, in response to the training and pushing operation of the development environment, parsing the dynamic scheduling policy of the reserved computing power of the user corresponding to the demand form based on the container runtime environment of the development environment, and generating resource allocation parameters and computing power constraints, the steps include: Analyze the computing power requirement level, task concurrency peak, and model complexity parameters in the requirement form to generate initial computing power resource allocation parameters; Based on the computing power consumption records in the historical training database, a time series prediction model is used to calculate the computing power requirement baseline value of the target scenario. The baseline value includes three-dimensional constraint indicators: video memory occupancy rate, floating-point operation volume, and memory bandwidth utilization rate. According to the hardware architecture identifier in the requirement form, the processor instruction set support map is matched to select candidate computing power types that meet the computing power requirement baseline value; Based on the reinforcement learning algorithm, Pareto optimization of resource utilization and energy consumption ratio of candidate computing power types is performed to generate a dynamic scheduling strategy that includes computing power threshold ranges, time window constraints, and elastic scaling rules; The dynamic scheduling policy is bound to the target hardware resource pool, and a reserved computing power identifier with a timestamp is generated to identify the reserved computing power.

7. An application deployment device based on cloud computing power, characterized in that: The cloud computing power-based application deployment device includes: a memory, a processor, and a computer program stored on the memory and executable on the processor, wherein the computer program is configured to implement the steps of the cloud computing power-based application deployment method as described in any one of claims 1 to 6.

8. A storage medium, characterized in that: The storage medium is a computer-readable storage medium, and a computer program is stored on the computer-readable storage medium. When the computer program is executed by a processor, the steps of the cloud computing power-based application deployment method as described in any one of claims 1 to 6 are implemented.

Images