AI-based domestic environment application offline deployment method, equipment and medium

Abstract

The invention discloses an AI-based localized environment application offline deployment method and device and a medium. The method comprises the steps that a localized environment is pre-detected based on probe service, a system layer configuration list is generated, heterogeneous features are extracted through a dual-channel deep learning model based on the system layer configuration list, and adaptive priority labels of the heterogeneous features are generated; the method comprises the following steps: analyzing an application program through static analysis and dynamic scanning technologies, constructing a dependency list, and constructing a version compatibility atlas based on metadata of a domestic operating system warehouse; generating a minimum-cost replacement path by using a graph attention network, performing hash check on each dependency packet, and generating an incremental update packet through a differential packaging algorithm; the resource occupation condition of the system is monitored in real time through a reinforcement learning model so as to dynamically optimize a deployment sequence and a resource allocation strategy, a deployment log is analyzed based on a natural language processing model, an error type is recognized, a repair operation is triggered, and application offline deployment is achieved.

Description

Technical Field

[0001] This application relates to the field of artificial intelligence technology, and in particular, to an offline deployment method, device, and medium for domesticated environment applications based on AI. Background Art

[0002] In the field of domesticated information technology, with the rapid popularization of domestic CPU architectures and operating systems, the complexity of environment adaptation faced by application deployment has increased significantly. Traditional deployment schemes rely on manual configuration of environment parameters, troubleshooting of dependency conflicts, and preparation of offline resource packages. This process is not only time-consuming and laborious but also difficult to adapt to the diverse combinations of heterogeneous hardware and operating systems. Especially in classified scenarios or closed network environments, offline deployment requires collecting a large number of dependency packages in advance and verifying their compatibility. Manual operations are prone to deployment failures due to issues such as version omissions and architecture mismatches, severely restricting the large-scale implementation of domesticated applications.

[0003] In the prior art, environment adaptation mostly uses static scripts or predefined templates, lacking the ability to perceive the dynamic characteristics of the target environment and making it difficult to accurately predict the adaptation requirements of hardware and system configurations. For example, differences in instruction sets of different architectures may cause compilation failures of dependency packages, and traditional schemes cannot automatically generate cross-architecture compatible deployment strategies. In addition, the resolution of dependency conflicts highly depends on manual experience. Existing tools can only match dependency versions based on simple rules and cannot effectively handle the compatibility issues of multi-level nested dependencies, resulting in insufficient stability of the application after deployment. In the offline scenario, the manual packaging and transmission of dependency packages are inefficient, and there is a lack of security reinforcement mechanisms, making it easy to introduce non-trusted source software packages and posing security risks.

[0004] The existing deployment process lacks the ability of dynamic optimization, and the resource allocation strategy is rigid, making it difficult to adjust task priorities according to the real-time system load. For example, deploying large-scale dependency packages in a high-load environment is likely to cause resource competition, leading to process blocking or system crashes. At the same time, traditional schemes lack the ability of intelligent analysis of the logs generated during the deployment process, and error troubleshooting relies on manual intervention, unable to achieve self-healing of exceptions. Such defects not only extend the deployment cycle but also increase the operation and maintenance costs and failure risks. Summary of the Invention

[0005] Embodiments of this application provide an offline deployment method, device, and medium for domesticated environment applications based on AI to solve the above technical problems.

[0006] On the one hand, embodiments of this application provide an offline deployment method for domesticated environment applications based on AI, including:

[0007] Perform pre - detection on the domestic environment based on a pre - deployed probe service, generate a system - level configuration list, and based on the system - level configuration list, extract heterogeneous features through a dual - channel deep - learning model to generate an adaptation priority label for the heterogeneous features;

[0008] Parse the application program through static analysis and dynamic scanning technologies, construct a dependency list, and based on the metadata of the domestic operating system repository, construct a version compatibility graph corresponding to the dependency list;

[0009] Use a graph attention network to generate a minimum - cost replacement path corresponding to the version compatibility graph, perform hash verification for each dependent package, and generate an incremental update package through a differential packaging algorithm;

[0010] Real - time monitor the system resource occupancy through a reinforcement - learning model to dynamically optimize the deployment order and resource allocation strategy, and analyze the deployment logs based on a natural - language - processing model to identify error types and trigger repair operations to achieve offline application deployment.

[0011] In an implementation manner of the present application, performing pre - detection on the domestic environment based on a pre - deployed probe service and generating a system - level configuration list specifically includes:

[0012] Deploy a probe service in the domestic environment, and based on the probe service, call system commands to collect hardware information in the domestic environment; the hardware information includes CPU model, instruction - set support, memory capacity, and disk capacity;

[0013] Detect the operating - system information, and integrate the hardware information and the operating - system information into a system - level configuration list; the operating - system information includes operating - system version, kernel version, and installed software - package information.

[0014] In an implementation manner of the present application, extracting heterogeneous features through a dual - channel deep - learning model and generating an adaptation priority label for the heterogeneous features specifically includes:

[0015] Extract local features from the system - level configuration list through a convolutional neural network, and perform sequence modeling on the local features through a Transformer model to capture the temporal and dependency relationships between configurations;

[0016] Generate an adaptation priority label corresponding to the hardware and system configuration through supervised learning and based on the model outputs of the convolutional neural network and the Transformer model.

[0017] In an implementation manner of the present application, parsing the application program through static analysis and dynamic scanning technologies and constructing a dependency list specifically includes:

[0018] Perform static analysis on the source code of the application through an abstract syntax tree, extract explicit dependencies at compile time, and run the application in a sandbox environment to capture implicit dependencies at runtime through dynamic link analysis;

[0019] Merge the explicit dependencies and the implicit dependencies to obtain a complete dependency list, and construct a dependency graph corresponding to the dependency list.

[0020] In an implementation manner of the present application, use a graph attention network to generate a minimum-cost replacement path corresponding to the version compatibility graph, specifically including:

[0021] Model the dependency conflicts in the version compatibility graph through a graph attention network;

[0022] Calculate the similarity between model nodes, and assign corresponding conflict weights to the edges between model nodes according to the similarity;

[0023] Based on the conflict weights, evaluate the conflict cost corresponding to each dependency package, and select the minimum-cost replacement path among multiple conflict costs.

[0024] In an implementation manner of the present application, perform hash verification on each dependency package, and generate an incremental update package through a differential packaging algorithm, specifically including:

[0025] For each dependency package, perform hash calculation on the dependency package through the SM3 algorithm to obtain the corresponding hash value;

[0026] Compare the hash value with the standard hash value, and in the case where the hash value does not match the standard hash value, mark the dependency package as an untrusted source package;

[0027] Classify the dependency packages, and perform incremental compression on the classified dependency packages through a differential packaging algorithm to generate an incremental update package.

[0028] In an implementation manner of the present application, use a reinforcement learning model to monitor the system resource occupancy in real time to dynamically optimize the deployment order and resource allocation strategy, specifically including:

[0029] Use a deep Q network to monitor the system resource occupancy in the domestic environment in real time; the system resource occupancy includes CPU and memory usage rates;

[0030] Dynamically adjust the deployment order of tasks according to the CPU and memory usage rates, and calculate a reward value according to the deployment result;

[0031] Feed back the reward value to the deep Q network to optimize the resource allocation strategy.

[0032] In one implementation of the present application, after analyzing the deployment logs based on a natural language processing model, identifying error types and triggering repair operations to implement the offline deployment of the application, the method further includes:

[0033] Simulating user requests through an API testing tool to verify whether the core business logic of the application is running properly;

[0034] Detecting memory leaks, CPU occupancy, and response time after offline deployment, and comparing the system resource occupancy before and after the offline deployment of the application to achieve performance verification;

[0035] Checking whether the file permission configuration, open ports, and log audit rules meet the preset security and compliance requirements to achieve security verification;

[0036] Generating a risk heat map of the application according to the verification results, and marking potential problems in the risk heat map.

[0037] On the other hand, an embodiment of the present application further provides an offline deployment device for applications in a domesticated environment based on AI, and the device includes:

[0038] At least one processor;

[0039] And a memory communicatively connected to the at least one processor;

[0040] Wherein, the memory stores instructions executable 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 an offline deployment method for applications in a domesticated environment based on AI as described above.

[0041] On the other hand, an embodiment of the present application further provides a non-volatile computer storage medium storing computer-executable instructions, and when the computer-executable instructions are executed, an offline deployment method for applications in a domesticated environment based on AI as described above is implemented.

[0042] An embodiment of the present application provides an offline deployment method, device, and medium for applications in a domesticated environment based on AI, including at least the following beneficial effects:

[0043] By generating a system-level configuration list and adaptation priority tags through pre-detection, it can accurately identify the adaptation requirements of different hardware and system configurations, automatically generate the optimal adaptation plan, thoroughly solve the problems of low adaptation efficiency and poor compatibility caused by relying on manual experience in traditional methods, and significantly reduce the deployment threshold in the domesticated environment. Using a graph attention network to generate the minimum-cost replacement path to ensure the version compatibility of dependent packages, it can automatically resolve version conflict problems, avoid omissions or misjudgments caused by manual intervention, and greatly improve the success rate of offline deployment; by using the SM3 algorithm to perform hash verification on dependent packages and comparing with the official trusted source hash values to exclude untrusted source packages, it guarantees the deployment security from the source. At the same time, it adopts a differential packaging algorithm to generate incremental update packages, only transmitting the changed parts, reducing the volume of offline packages and transmission time. Combining a reinforcement learning model to monitor the system resource occupancy, dynamically adjusting the deployment order and resource allocation strategy, it can avoid deployment interruptions caused by resource contention and significantly shorten the overall deployment cycle. By real-time analyzing log data, it automatically identifies common error types such as missing dependencies and insufficient permissions, and triggers predefined repair strategies, reducing the need for manual intervention. BRIEF DESCRIPTION OF THE DRAWINGS

[0044] The drawings described herein are used to provide a further understanding of the present application, form a part of the present application, and the illustrative embodiments and descriptions thereof of the present application are used to explain the present application, and do not constitute an improper limitation to the present application. In the drawings:

[0045] Figure 1 is a schematic flow chart of a method for offline deployment of applications in a domesticated environment based on AI provided by an embodiment of the present application;

[0046] Figure 2 is a schematic internal structure diagram of a device for offline deployment of applications in a domesticated environment based on AI provided by an embodiment of the present application. DETAILED DESCRIPTION OF THE EMBODIMENTS

[0047] To make the objectives, technical solutions, and advantages of the present application clearer, the technical solutions of the present application will be clearly and completely described below in conjunction with the specific embodiments and corresponding drawings of the present application. Obviously, the described embodiments are only a part of the embodiments of the present application, rather than all of the embodiments. Based on the embodiments in the present application, all other embodiments obtained by those of ordinary skill in the art without creative efforts shall fall within the protection scope of the present application.

[0048] The following will detail the technical solutions provided by each embodiment of the present application in conjunction with the drawings.

[0049] Figure 1 is a schematic flow chart of a method for offline deployment of applications in a domesticated environment based on AI provided by an embodiment of the present application.

[0050] The implementation of the analysis method involved in the embodiments of this application can be a terminal device or a server, and this application does not impose special restrictions on this. For the convenience of understanding and description, the following embodiments will be described in detail taking the server as an example.

[0051] It should be noted that the server can be a single device or a system composed of multiple devices, that is, a distributed server, and this application does not make specific limitations on this.

[0052] As Figure 1 shown, a domestic environment application offline deployment method based on AI provided by the embodiments of this application includes:

[0053] Step 101: Pre-detect the domestic environment based on the pre-deployed probe service to generate a system layer configuration list, and based on the system layer configuration list, extract heterogeneous features through a dual-channel deep learning model to generate an adaptation priority label for the heterogeneous features.

[0054] In this embodiment, the probe service is the initial module of the deployment process, and its core function is to comprehensively detect the hardware and operating system of the target domestic environment by calling system-level commands. It should be noted that the probe service needs to be pre-deployed to the target environment and run in a non-intrusive manner. Exemplarily, the probe service obtains the CPU model, supported instruction set, and memory capacity by executing the lscpu command. It should be noted that the CPU models in the embodiments of this application are such as Kunpeng 920 and Loongson 3A5000, and the instruction sets are such as ARMv8 and LoongArch. The disk partition information, such as the mount point and storage capacity, is collected through the lsblk command. The operating system kernel version is read through the uname -r command, and the installed software packages and their version numbers are listed through the rpm -qa or dpkg -l command. It can be understood that after the above information is integrated in a structured data such as JSON format, the generated system layer configuration list can be used as the input basis for subsequent adaptation strategies.

[0055] Specifically, the dual-channel deep learning model is used to process heterogeneous features in the system layer configuration inventory. The first channel adopts a Convolutional Neural Networks (CNN), whose input is the original data of hardware information and system configuration. The hardware information includes CPU instruction set, memory capacity, etc., and the system configuration includes kernel version, software package list, etc. The CNN extracts local features through convolutional layers, such as the compatibility mode between specific instruction sets and operating system versions. The second channel adopts a Transformer model to perform sequence modeling on the feature vectors output by the CNN, capturing the temporal correlations between configurations, such as the dependency changes of hardware drivers after operating system upgrades. It should be noted that the model is trained through supervised learning, optimizing parameters based on historical adaptation datasets, and finally outputting adaptation priority labels, such as "Prioritize adaptation for Kunpeng 920 + Tongxin UOS 20". The historical adaptation data is marked with adaptation success labels for different configuration combinations. Hardware and operating system information is collected through the probe service and integrated into the system layer configuration inventory, providing a data basis for the adaptation decision of the subsequent dual-channel model.

[0056] Step 102: Parse the application program through static analysis and dynamic scanning techniques, construct a dependency list, and based on the metadata of the domestic operating system repository, construct a version compatibility graph corresponding to the dependency list.

[0057] In this embodiment, dependency resolution is divided into two stages: static analysis and dynamic scanning. Exemplarily, static analysis parses the source code of the application program through Abstract Syntax Tree (AST) technology. Specifically, the AST converts the code into a tree structure and traverses the nodes in the tree structure to extract explicit dependencies. For example, the names and version numbers of third-party libraries referenced by the import statement in the code. It can be understood that explicit dependencies only cover the content declared at compile time, while implicit dependencies dynamically loaded at runtime need to be captured through dynamic scanning. Implicit dependencies include shared library files, environment variables, etc.

[0058] It should be noted that dynamic scanning is implemented by running the application program in a sandbox environment. Exemplarily, the sandbox environment is an isolated virtualized container. When the application program is executed in the container, the system monitors the.so files, configuration file paths, and environment variable dependencies loaded during its runtime through dynamic link analysis (such as the ldd command). After merging the static analysis results and the dynamic scanning results, a complete dependency list is generated, and the dependency relationship is represented in a graph structure. The nodes are dependency packages, and the edges represent the reference relationships between packages.

[0059] Furthermore, the construction of the version compatibility graph is based on the metadata of the domestic operating system repository, such as openEuler and UOS. Specifically, the metadata includes the CPU architecture supported by the dependent package, the operating system version, the compatibility relationship with other packages, etc. Exemplarily, the graph is stored in a graph database, such as Neo4j. The node attributes include the package name, version number, and architecture type, and the edge attributes describe the compatibility rules, such as "package Av1.2 is compatible with package B v3.4". It can be understood that by associating the dependency list with the version compatibility graph, the system can quickly identify potential conflicts of dependent packages in the target environment. For example, a certain library only supports the x86 architecture, while the target environment is the ARM architecture. The complete dependency list and relationship graph are constructed through AST static analysis and sandbox dynamic scanning technology, providing data support for subsequent dependency conflict resolution.

[0060] Step 103: Use the graph attention network to generate the minimum-cost replacement path corresponding to the version compatibility graph, perform hash verification for each dependent package, and generate an incremental update package through the differential packaging algorithm.

[0061] In this embodiment, the resolution of dependency conflicts is achieved through the Graph Attention Network (GAT). It should be noted that there may be multiple conflict paths for dependent packages in the version compatibility graph. For example, package A depends on package B v1.0, but the target environment only supports package B v2.0. Exemplarily, GAT encodes the features of the nodes in the graph, that is, the dependent packages, extracts their attributes such as version number, architecture support, and compatibility rules, and calculates the similarity between nodes through the attention mechanism. Specifically, for the conflicting edges, such as the incompatibility between package A and package B versions, GAT assigns a conflict weight to each edge. The higher the weight, the greater the replacement cost. For example, replacing package B may cause other dependency chains to break. It can be understood that the system traverses all possible replacement paths, evaluates the total conflict cost of each path, such as the compatibility impact of replacing package C and the installation time, and finally selects the minimum-cost path, that is, replacing the conflicting package B with the compatible package D. By modeling dependency conflicts with GAT and generating the minimum-cost replacement scheme, the compatibility and deployment stability of dependent packages can be ensured.

[0062] Furthermore, security hardening and incremental packaging are performed for each dependent package. Exemplarily, hash verification is implemented through the SM3 algorithm. Specifically, the system calculates the hash of the dependent package file to generate a unique hash value, and compares it with the hash value of the official trusted source, such as the openEuler repository. If the hash values do not match, the dependent package is marked as a non-trusted source package, and this dependent package is prohibited from being added to the offline deployment package. It should be noted that hash verification can effectively prevent the introduction of tampered or malicious dependent packages, ensuring deployment security. Subsequently, the dependent packages are classified into basic environment packages, application core packages, and dynamic patch packages. Basic environment packages are such as system libraries, application core packages are such as business code dependencies, and dynamic patch packages are such as hotfix scripts. The differential packaging algorithm only compresses the newly added or modified files to generate an incremental update package. It should be noted that the differential packaging algorithm is, for example, rsync-based incremental compression. It can be understood that this method significantly reduces the volume of the offline package. For example, only 10% of the changed content is transmitted, improving the offline deployment efficiency.

[0063] Step 104: The system resource occupancy is monitored in real time through a reinforcement learning model to dynamically optimize the deployment order and resource allocation strategy, and the deployment logs are analyzed based on a natural language processing model to identify error types and trigger repair operations, realizing the offline deployment of the application.

[0064] In this embodiment, the reinforcement learning model used is the Deep Q-Network (DQN), which is used to dynamically optimize the deployment process. It should be noted that the DQN monitors the system resource metrics of the target environment in real time, such as CPU usage, memory occupancy, and disk I / O rate, and adjusts the priorities of the deployment tasks according to the current load. Exemplarily, during low-load periods, such as when the CPU usage is below 30%, the model preferentially schedules the installation tasks of large-scale dependent packages, such as database engines; during high-load periods, such as when the CPU usage exceeds 70%, it switches to lightweight tasks, such as writing configuration files. Specifically, after each deployment action such as installation, configuration, and service startup is completed, the system calculates reward values such as reduced task duration and reduced resource consumption, and feeds the reward values back to the DQN model, thereby optimizing the subsequent deployment strategy. It can be understood that this mechanism forms a closed-loop optimization to ensure the maximization of resource utilization.

[0065] Meanwhile, the log data generated during the deployment process is analyzed in real time through a natural language processing model, such as the BERT model. Exemplarily, the BERT model performs semantic parsing on the log text to identify common error types, such as "Missing dependency package: numpy==1.21" or "Insufficient permissions: / opt directory is not writable". Specifically, after classifying the errors, the model automatically triggers predefined repair strategies. For example, retrieve the matching numpy version from the offline package and install it, or call the chmod command to adjust the directory permissions. It should be noted that this can significantly reduce the need for manual intervention and ensure the continuity of the deployment process. After the deployment is completed, the system verifies the core business logic, such as user login and data query, through an API testing tool, detects memory leaks and CPU occupancy peaks, and checks whether the file permissions and open ports meet the security and compliance requirements. The final generated risk heat map report annotates potential problems, such as services with high resource occupancy and files with abnormal permissions, in a visual form, providing accurate optimization guidelines for operation and maintenance.

[0066] The above is the method embodiment proposed in this application. Based on the same inventive concept, the embodiment of this application also provides an AI-based offline deployment device for domesticated environment applications, and its structure is as Figure 2 shown.

[0067] Figure 2 FIG. is the internal structure schematic diagram of an AI-based offline deployment device for domesticated environment applications provided by the embodiment of this application. As Figure 2 shown, the device includes:

[0068] At least one processor;

[0069] And a memory communicatively connected to the at least one processor;

[0070] Wherein, the memory stores instructions executable by the at least one processor, and the instructions are executed by the at least one processor to enable the at least one processor to:

[0071] Pre-detect the domesticated environment based on a pre-deployed probe service, generate a system layer configuration list, and based on the system layer configuration list, extract heterogeneous features through a dual-channel deep learning model to generate an adaptation priority label for the heterogeneous features;

[0072] Parse the application program through static analysis and dynamic scanning technologies, construct a dependency list, and based on the metadata of the domestic operating system repository, construct a version compatibility map corresponding to the dependency list;

[0073] Utilize a graph attention network to generate a minimum cost replacement path corresponding to the version compatibility map, perform hash verification on each dependency package, and generate an incremental update package through a differential packaging algorithm;

[0074] Monitor the system resource occupancy in real time through a reinforcement learning model to dynamically optimize the deployment order and resource allocation strategy, and analyze the deployment logs based on a natural language processing model to identify error types and trigger repair operations, so as to achieve offline application deployment.

[0075] The embodiments of the present application also provide a non-volatile computer storage medium storing computer-executable instructions that, when executed, are capable of:

[0076] Pre-detect the domestic environment based on a pre-deployed probe service to generate a system layer configuration list, and based on the system layer configuration list, extract heterogeneous features through a dual-channel deep learning model to generate an adaptation priority label for the heterogeneous features;

[0077] Parse the application program through static analysis and dynamic scanning technologies to build a dependency list, and build a version compatibility map corresponding to the dependency list based on the metadata of the domestic operating system repository;

[0078] Use a graph attention network to generate the minimum cost replacement path corresponding to the version compatibility map, perform hash verification on each dependency package, and generate an incremental update package through a differential packaging algorithm;

[0079] Monitor the system resource occupancy in real time through a reinforcement learning model to dynamically optimize the deployment order and resource allocation strategy, and analyze the deployment logs based on a natural language processing model to identify error types and trigger repair operations, so as to achieve offline application deployment.

[0080] The various embodiments in the present application are all described in a progressive manner. The same or similar parts among the various embodiments can be referred to each other, and the key points of each embodiment are the differences from other embodiments. In particular, for the device and medium embodiments, since they are basically similar to the method embodiments, the description is relatively simple, and the relevant parts can refer to the partial description of the method embodiments.

[0081] The above describes specific embodiments of the present application. Other embodiments are within the scope of the appended claims. In some cases, the actions or steps recited in the claims can be performed in a different order than in the embodiments and still achieve the desired result. Additionally, the processes depicted in the figures do not necessarily require the particular order or sequential order shown to achieve the desired result. In certain implementations, multitasking and parallel processing are also possible or may be advantageous.

[0082] The devices and media provided by the embodiments of the present application correspond one-to-one with the methods. Therefore, the devices and media also have beneficial technical effects similar to those of their corresponding methods. Since the beneficial technical effects of the methods have been described in detail above, the beneficial technical effects of the devices and media are not elaborated here.

[0083] Those skilled in the art will understand that the embodiments of the present application can be provided as a method, a system, or a computer program product. Therefore, the present application can take the form of a completely hardware embodiment, a completely software embodiment, or an embodiment combining software and hardware aspects. Moreover, the present application can take the form of a computer program product implemented on one or more computer-usable storage media (including but not limited to disk storage, CD-ROM, optical storage, etc.) that contain computer-usable program code.

[0084] The present application is described with reference to the flowcharts and / or block diagrams of methods, devices (systems), and computer program products according to the embodiments of the present application. It should be understood that each flow and / or block in the flowchart and / or block diagram, as well as the combination of flows and / or blocks in the flowchart and / or block diagram, can be implemented by computer program instructions. These computer program instructions can be provided to the processor of a general-purpose computer, a special-purpose computer, an embedded processor, or other programmable data processing devices to generate a machine, such that the instructions executed by the processor of the computer or other programmable data processing devices generate a device for implementing the functions specified in Figure 1 one or more flows Figure 1 or a combination of multiple flows and / or blocks

[0085] These computer program instructions can also be stored in a computer-readable memory that can direct a computer or other programmable data processing device to work in a specific manner, such that the instructions stored in the computer-readable memory generate a manufactured article including an instruction device that implements the functions specified in Figure 1 one or more flows Figure 1 or a combination of multiple flows and / or blocks

[0086] These computer program instructions can also be loaded onto a computer or other programmable data processing device, such that a series of operation steps are performed on the computer or other programmable device to generate a computer-implemented process, and thus the instructions executed on the computer or other programmable device provide steps for implementing the functions specified in Figure 1 one or more flows Figure 1 or a combination of multiple flows and / or blocks

[0087] In a typical configuration, a computing device includes one or more processors (CPUs), an input / output interface, a network interface, and a memory.

[0088] The memory may include non-permanent memory in the form of computer-readable media, such as random access memory (RAM) and / or non-volatile memory, such as read-only memory (ROM) or flash RAM. The memory is an example of computer-readable media.

[0089] Computer-readable media includes both permanent and non-permanent, removable and non-removable media that can store information by any method or technology. The information can be computer-readable instructions, data structures, program modules, or other data. Examples of computer storage media include, but are not limited to, phase change memory (PRAM), static random access memory (SRAM), dynamic random access memory (DRAM), other types of random access memory (RAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), flash memory or other memory technologies, compact disc read-only memory (CD-ROM), digital versatile disc (DVD) or other optical storage, magnetic cassettes, magnetic tape disk storage or other magnetic storage devices, or any other non-transitory media that can be used to store information that can be accessed by a computing device. As defined herein, computer-readable media does not include transitory media such as modulated data signals and carrier waves.

[0090] It should also be noted that the term "comprising", "including" or any other variation thereof is intended to cover non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements does not include only those elements but also other elements not expressly listed, or elements that are inherent to such process, method, article, or apparatus. Without further limitation, an element defined by the statement "comprising an..." does not exclude the presence of additional identical elements in the process, method, article, or apparatus that comprises the element.

[0091] The above description is only for the embodiments of the present application and is not intended to limit the present application. For those skilled in the art, various changes and modifications can be made to the present application. Any modifications, equivalent replacements, improvements, etc. made within the spirit and principle of the present application shall be included within the scope of the claims of the present application.

Claims

1. An offline deployment method for domesticated environment applications based on AI, characterized in that, The method includes: Pre-detecting the domestic environment based on a pre-deployed probe service to generate a system layer configuration list, and based on the system layer configuration list, extracting heterogeneous features through a dual-channel deep learning model to generate an adaptation priority label for the heterogeneous features; Parsing the application program through static analysis and dynamic scanning techniques to construct a dependency list, and based on the metadata of the domestic operating system repository, constructing a version compatibility map corresponding to the dependency list; Using a graph attention network to generate a minimum cost replacement path corresponding to the version compatibility map, and performing hash verification for each dependency package, and generating an incremental update package through a differential packaging algorithm; Real-time monitoring the system resource occupancy through a reinforcement learning model to dynamically optimize the deployment order and resource allocation strategy, and analyzing the deployment log based on a natural language processing model to identify error types and trigger repair operations to achieve offline application deployment.

2. The offline deployment method for domestic environment applications based on AI according to claim 1, characterized in that Pre-detecting the domestic environment based on a pre-deployed probe service to generate a system layer configuration list, specifically including: Deploying a probe service in the domestic environment, and based on the probe service, calling system commands to collect hardware information in the domestic environment; the hardware information includes CPU model, instruction set support, memory capacity, and disk capacity; Detecting the operating system information, and integrating the hardware information and the operating system information into a system layer configuration list; the operating system information includes operating system version, kernel version, and installed software package information.

3. The offline deployment method for domestic environment applications based on AI according to claim 1 is characterized in that, Extracting heterogeneous features through a dual-channel deep learning model to generate an adaptation priority label for the heterogeneous features, specifically including: Extracting local features from the system layer configuration list through a convolutional neural network, and performing sequence modeling on the local features through a Transformer model to capture the temporal and dependency relationships between configurations; Generating an adaptation priority label corresponding to the hardware and system configuration through supervised learning and based on the model outputs of the convolutional neural network and the Transformer model.

4. An off-line deployment method for domestic environment applications based on AI according to claim 1, characterized in that, Parsing the application program through static analysis and dynamic scanning techniques to construct a dependency list, specifically including: Performing static analysis on the source code of the application program through an abstract syntax tree to extract explicit dependencies during compilation, and running the application program in a sandbox environment to capture implicit dependencies during runtime through dynamic link analysis; Merging the explicit dependencies and the implicit dependencies to obtain a complete dependency list, and constructing a dependency relationship graph corresponding to the dependency list.

5. The offline deployment method for domestic environment applications based on AI according to claim 1, characterized in that Using a graph attention network to generate a minimum cost replacement path corresponding to the version compatibility map, specifically including: Modeling the dependency conflicts in the version compatibility map through a graph attention network; Calculating the similarity between model nodes, and assigning corresponding conflict weights to the edges between model nodes according to the similarity; Based on the conflict weights, evaluating the conflict cost corresponding to each dependency package, and selecting the minimum cost replacement path among multiple conflict costs.

6. The offline deployment method for domesticated environment applications based on AI according to claim 1, wherein Performing hash verification for each dependency package, and generating an incremental update package through a differential packaging algorithm, specifically including: For each dependent package, perform hash calculation on the dependent package through the SM3 algorithm to obtain the corresponding hash value; Compare the hash value with the standard hash value, and in the case where the hash value does not match the standard hash value, mark the dependent package as a non-trusted source package; Classify the dependent packages, and through a differential packaging algorithm, perform incremental compression on the classified dependent packages to generate an incremental update package.

7. A method for offline deployment of a domestic environment application based on AI according to claim 1, characterized in that, Real-time monitor the system resource occupancy through a reinforcement learning model to dynamically optimize the deployment order and resource allocation strategy, specifically including: Through a deep Q network, real-time monitor the system resource occupancy in the domesticated environment; the system resource occupancy includes CPU and memory usage rates; Dynamically adjust the deployment order of tasks according to the CPU and the memory usage rate, and calculate a reward value according to the deployment result; Feed back the reward value to the deep Q network to optimize the resource allocation strategy.

8. An off-line deployment method for domestic environment applications based on AI according to claim 1, characterized in that After implementing the offline deployment of the application based on analyzing the deployment log by a natural language processing model, identifying error types and triggering repair operations, the method further includes: Simulate user requests through an API testing tool to verify whether the core business logic of the application program is running normally; Detect the memory leak, CPU occupancy rate, and response time after offline deployment, and compare the system resource occupancy before and after the offline deployment of the application program to achieve performance verification; Check whether the file permission configuration, open ports, and log audit rules meet the preset security and compliance requirements to achieve security verification; Generate a risk heat map of the application program according to the verification results, and mark potential problems in the risk heat map.

9. An AI-based domestic environment application offline deployment device, characterized in that, The device includes: At least one processor; And a memory communicatively connected to the at least one processor; Wherein, the memory stores instructions executable 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 a method for offline deployment of an application in a domesticated environment based on AI as described in any one of claims 1-8.

10. A non-volatile computer storage medium stores computer-executable instructions, characterized in that, When the computer-executable instructions are executed, a method for offline deployment of an application in a domesticated environment based on AI as described in any one of claims 1-8 is implemented.

Images