A container running method based on artificial intelligence

Abstract

The application discloses a container running method based on artificial intelligence, comprising the following steps: scanning a basic image to generate a unique gene code, constructing a behavior portrait library, and training a model with historical data to label an extended image; then, calculating the similarity of a user input image and the portrait library gene, screening high similarity images, evaluating the combination success rate, and sorting and recommending after eliminating conflict images; when distributing, the image is fragmented, verification information is generated, node reputation points are calculated, high reputation nodes are selected for parallel transmission, and the target node is reorganized for integrity verification; the scheme realizes accurate recommendation and conflict prediction of image combination, ensures efficient and complete distribution, improves the intelligent degree of image management, reduces the deployment failure rate, optimizes resource utilization, and provides a stable and expandable image management scheme for a containerized environment.

Description

Technical Field

[0001] This invention relates to the field of computer software technology, and in particular to a container operation method based on artificial intelligence. Background Technology

[0002] In an environment where container technology is widely used, image management and distribution face numerous challenges. Traditional container image management methods lack effective extraction and utilization of deep image characteristics, making it difficult to accurately grasp the compatibility and functional relationships between images. During image deployment, deployment failures often occur due to dependency conflicts, version incompatibility, and other issues that cannot be predicted or avoided in advance. Furthermore, the lack of intelligent scheduling mechanisms during image distribution prevents the dynamic selection of optimal transmission paths based on node status, leading to network congestion, transmission failures, and other problems that impact container operating efficiency and stability, making it difficult to meet the needs of large-scale containerized applications.

[0003] With the continuous development of container technology, the number of container images has exploded, placing higher demands on the accurate recommendation and efficient distribution of images. Current technologies often rely on simple rules for image recommendation, failing to comprehensively consider factors such as image functionality, compatibility, and conflicts. This results in a low success rate for recommended image combinations, making it difficult to meet diverse user needs. In the image distribution stage, traditional methods lack effective integrity verification mechanisms, failing to ensure the accuracy of image data during distribution. Furthermore, the selection of distribution nodes lacks scientific evaluation, and the distribution strategy cannot be dynamically adjusted based on actual node performance, leading to low distribution efficiency and hindering the application of container technology in complex scenarios. Summary of the Invention

[0004] This application provides an AI-based container operation method that enables accurate recommendation and conflict prediction of image combinations, ensuring efficient and complete distribution, improving the intelligence level of image management, reducing deployment failure rate, and optimizing resource utilization.

[0005] This application provides an artificial intelligence-based container running method, including:

[0006] S1, scan the hierarchical hash and metadata of the base image, generate a unique gene code, and store it in the extended image behavior profile library;

[0007] S2 extracts image combination features based on historical deployment extension records, and dynamically updates the tag library by using a real-time compatibility prediction model to label the extension images; the tags include functional, compatibility and conflict tags.

[0008] S3, calculate the gene similarity between the user input image and the image database, filter high similarity images, use the prediction model to evaluate the combination success rate, remove images with known conflicts according to the conflict records in the tag database, and sort them by combination success rate.

[0009] S4. Based on the number of user requests, extract the Top-N mirror images from the sorted candidate list as the recommendation results;

[0010] S5: Divide the image into shards, generate content hashes and logical location coordinates for each shard, and summarize the root hash value, total number of shards, and target node list as the basis for distribution verification; calculate node reputation scores based on historical transmission success rate and response speed.

[0011] S6 prioritizes high-reputation nodes as the initial source, transmits fragments in parallel and monitors progress in real time, and the target nodes reassemble according to coordinates and verify integrity through root hash.

[0012] Preferably, the dynamically updated tag library specifically includes: extracting image combination information from all historical deployment records, including base image, extended image, deployment environment parameters, and final deployment results; generating a unique gene code for each base image; labeling functional tags according to the image's purpose using keyword matching; recording the mapping relationship between the base image gene code and the extended image for successfully deployed combinations to form a compatibility knowledge base; extracting structured data as auxiliary features; training an initial model using historical data, inputting image functions, gene codes, and structured data combination features, outputting a compatibility score; feeding the results back to the model after each new deployment; strengthening the compatibility association between the current gene code and the extended image for successful cases; updating the conflict feature library for failed cases; adjusting the model's prediction weights for similar combinations; when a new image is added to the library, automatically matching a predefined functional category based on its description or metadata; adding a base image gene code tag to the extended image when the model predicts a success probability exceeding a threshold; automatically associating with the conflict feature library when the model predicts a high failure probability, generating specific conflict tags, and recording conflict solutions.

[0013] Preferably, the generation of the unique gene code includes: performing a comprehensive scan of the file system layer by layer from the bottom layer upwards; performing hash calculations recursively on the files and directories scanned at each layer; calculating the hash value of each file in the directory; combining the file hash values ​​with the relevant information of the directory itself to calculate the hash value of the directory; sequentially connecting the hash values ​​of each layer in a top-down or bottom-up order to form a complete hierarchical hash chain that can uniquely identify the file system state of each layer of the base image; extracting key structured data from the base image, including but not limited to operating system, architecture information, dependency library versions, and environment variables, and obtaining all environment variables set in the image and their corresponding values; concatenating the generated hierarchical hash chain and the extracted structured metadata in a certain order; processing the concatenated data string using the SHA-256 algorithm; the SHA-256 algorithm converts the input data string of arbitrary length into a hash value of fixed length, which is the gene code vector of the base image.

[0014] Preferably, step S5 specifically includes: setting a fixed fragment size of 128KB; if the last fragment is less than 128KB, it is processed according to the actual size; if the image has been fragmented, checking whether the fragmentation strategy is consistent, otherwise re-fragmenting; starting from the beginning of the image file, cutting at 128KB intervals to generate a continuous fragment sequence, and assigning a unique logical location coordinate to each fragment; calculating a hash value for each fragment, concatenating all fragment hashes in a fixed order, and calculating the top-level "root hash"; recording the core information root hash value, the total number of fragments, and the target node list, generating a mapping table between fragments and logical locations, and packaging it into a verification metadata file.

[0015] Preferably, the step of generating a mapping table between shards and logical locations and packaging it into a verification metadata file includes: obtaining transmission task data of the target nodes in the past 24 hours from the monitoring system, including: success_count, failure_count, and average response time avg_latency; normalizing and calculating a weighted score for the success rate and response speed, and removing nodes with a reputation score below a threshold; if a node experiences an anomaly during transmission, temporarily lowering its reputation score and triggering a recalculation; sorting the target node list from high to low reputation score; selecting Top-K nodes for redundant distribution; and proportionally allocating some shards to the next best nodes if high-reputation nodes are overloaded.

[0016] Preferably, step S5 further includes:

[0017] S51 collects the raw data of each slice and calculates the entropy value by weighted summation;

[0018] S52 performs a comprehensive diagnosis of distributed clusters from five dimensions to locate the root causes of anomalies; these five dimensions include files, resources, network, security, and dependencies.

[0019] S53, Based on the associated root causes located by the five-dimensional diagnosis, determine the abnormal segments and suspected abnormal segments;

[0020] S54 performs multi-objective decision-making value assessment on suspected abnormal segments and introduces quantum lock enhancement technology to implement differentiated locking strategies according to different scenarios;

[0021] S55, construct a dynamic gravity model to simulate the gravitational effect of sharding in a distributed cluster;

[0022] S56 dynamically adjusts the transmission path of fragments based on real-time network topology information.

[0023] Preferably, the calculation of the entropy value includes: the core data being the original data of shard access frequency, timeliness value, and correlation dependency. The timeliness value is calculated using an exponential decay model, with the following formula: ,in, The attenuation coefficient is... The time since the last update of the shard; dependency ratio is recorded through static code analysis and runtime tracing, recording the dependencies between the shard and other shards, containers, and services, and the dependency complexity is quantified into direct and indirect dependencies. Therefore, the comprehensive dependency score = number of direct dependencies × 0.7 + depth of indirect dependencies × 0.3; combining these three parameters, the entropy index of the shard is generated, with the formula: Where F is the normalized value of access frequency, V is the normalized value of timeliness, and D is the normalized value of association dependency. , , The default values ​​for the weighting coefficients are 0.4, 0.3, and 0.3, respectively.

[0024] Preferably, the step of locating the root cause of anomalies specifically involves: sorting the five-dimensional anomaly events by timestamp and identifying concurrently occurring related anomalies; pre-setting anomaly association rules and automatically matching diagnostic results; performing root cause reasoning by calling the domain knowledge base for complex scenarios, reproducing the anomaly conditions in the test environment, and confirming whether the same problem is triggered; taking remedial measures based on the root cause and observing whether the anomaly is eliminated; and summarizing the anomaly types, impact range, and severity found in the five-dimensional diagnosis, and displaying the anomaly association path in the form of a timeline and dependency graph.

[0025] Preferably, in step S51, calculating the entropy value further includes:

[0026] Extract multi-dimensional data features from the shards to generate a unique entropy flow fingerprint that reflects changes in the shard state;

[0027] A spatiotemporal correlation network is constructed to associate the states of the fragments in different times and spaces, and the dependency relationship between the fragments is simulated using the concept of quantum entanglement;

[0028] Based on entropy flow fingerprinting and spatiotemporal correlation networks, the fragments are restored to their state at a certain point in the past by using a time inversion algorithm.

[0029] Preferably, the step of restoring the shards to a past state using a time inversion algorithm specifically includes: determining the target time point to be traced back based on the need for historical tracing; searching for the entropy flow fingerprint of shards near the target time point in the spatiotemporal correlation network; finding the shard state fingerprint closest to the target time point by matching it with a pre-generated fingerprint database; using the matched shard state fingerprint and the spatiotemporal correlation network, applying the time inversion algorithm to gradually deduce the historical state of the shards from the target time point; the time inversion algorithm considers the correlation between shards and the state transition rules, and restores the state of the shards before the target time point through iterative calculation; and obtaining the corresponding business data and operating indicators from the historical data storage based on the inverted shard state to achieve a complete restoration of the shard's historical state.

[0030] One or more technical solutions provided in this application have at least the following technical effects or advantages:

[0031] By generating a unique genetic code for each base image and constructing a behavioral profile library, and combining this with historical deployment data to train a real-time compatibility prediction model, this solution achieves accurate image combination recommendations and conflict prediction. Employing a sharded transmission and dynamic reputation node scheduling mechanism ensures efficient and complete image distribution, while root hash verification guarantees data reliability. This solution significantly improves the intelligence level of image management, reduces deployment failure rates, optimizes resource utilization, and provides a stable and scalable image lifecycle management solution for containerized environments.

[0032] By collecting multi-dimensional data from fragmented data and calculating entropy values, anomalies are accurately located. Five-dimensional diagnosis quickly identifies the root cause and handles abnormal and suspected abnormal fragments in a graded manner. After multi-objective evaluation of suspected abnormal fragments, quantum lock enhancement technology is introduced to achieve differentiated locking. Combined with a dynamic gravity model and path adjustment based on real-time topology, the distribution and communication of fragments in the distributed cluster are effectively optimized. This enables rapid and accurate handling of anomalies, reduces the impact of faults, improves cluster stability and resource utilization, and ensures business continuity. At the same time, quantum lock technology enhances security and operational flexibility.

[0033] By generating entropy flow fingerprints that accurately reflect changes in container sharding status through intelligent feature selection, uniqueness and stability are ensured. Artificial intelligence is used to simulate and quantify the spatiotemporal correlation of container sharding, and an intuitive network topology is constructed. With the help of intelligent matching and time inversion algorithms, container sharding can be quickly and accurately restored to its state at a specific point in the past, and its historical state can be fully restored, effectively improving the efficiency and accuracy of container operation status tracing and fault diagnosis. Attached Figure Description

[0034] Figure 1 This is a flowchart illustrating an artificial intelligence-based container operation method according to an embodiment of the present invention. Detailed Implementation

[0035] To facilitate understanding of the present invention, a more complete description of this application will be given below with reference to the accompanying drawings, which illustrate preferred embodiments of the invention. However, the invention can be implemented in many different forms and is not limited to the embodiments described herein. Rather, these embodiments are provided to enable a more thorough and complete understanding of the disclosure of the present invention.

[0036] Unless otherwise defined, all technical and scientific terms used herein have the same meaning as commonly understood by one of ordinary skill in the art to which this invention pertains; the terminology used herein in the description of the invention is for the purpose of describing particular embodiments only and is not intended to limit the invention; the term "and / or" as used herein includes any and all combinations of one or more of the associated listed items.

[0037] Example 1: Figure 1 This is a flowchart illustrating an artificial intelligence-based container operation method according to an embodiment of the present invention.

[0038] like Figure 1 As shown, an artificial intelligence-based container running method includes the following steps:

[0039] S1 scans the hierarchical hash and metadata of the base image, generates a unique gene code, and stores it in the extended image behavior profile library.

[0040] Specifically, starting from the bottom layer, the file system is fully scanned layer by layer upwards. For each file and directory scanned at each layer, a recursive hash calculation is performed. First, the hash value of each file in the directory is calculated separately. Then, these file hash values ​​are combined with relevant information about the directory itself (such as permissions, timestamps, etc.) to calculate the hash value of the directory. The hash values ​​of each layer are then concatenated sequentially from top to bottom or bottom to top to form a complete hierarchical hash chain that uniquely identifies the state of each layer of the base image's file system.

[0041] Extract key structured data from the base image, including but not limited to the operating system (OS) type, specifying whether the operating system the image is based on is Linux, Windows, or another operating system; architecture information, such as x86, ARM, etc.; dependency library versions, recording the specific version numbers of various dependency libraries used in the image; and environment variables, obtaining all environment variables set in the image and their corresponding values.

[0042] The previously generated hierarchical hash chain and the extracted structured metadata are concatenated in a specific order. For example, the hierarchical hash chain can be concatenated first, followed by the metadata, or a specific concatenation rule can be defined according to actual needs to combine the two into a complete data string. The concatenated data string is then processed using the SHA-256 algorithm. The SHA-256 algorithm converts an input data string of arbitrary length into a fixed-length (64-character) hash value. This hash value is the genetic code vector of the base image (this vector is unique and can serve as a unique identifier for the base image).

[0043] The generated gene coding vectors are stored in a specially designed extended mirror behavioral profile library. During storage, corresponding indexes and relationships need to be established to enable quick and accurate querying and retrieval of the gene coding information of the base image.

[0044] Retrieve relevant log files from the image repository (log files record various operation information in the image repository, including deployment records of extended images). Perform a detailed analysis of the retrieved image repository logs, filtering out all deployment records of extended images. Each deployment record should include base image information (e.g., base image A), extended image information (e.g., extended image X), and deployment result (success or failure). Store the extracted extended images and their corresponding tag information in a time-series database. Time-series databases can record data changes in chronological order, making them suitable for storing deployment record information with time attributes. When storing, ensure that the recorded timestamps are accurate so that the deployment status and usage status of extended images at different times can be clearly tracked.

[0045] S2 extracts image combination features based on historical deployment extension records, adds functional, compatibility and conflict tags to the extended images through a real-time compatibility prediction model, and dynamically updates the tag library.

[0046] The functional, compatibility, and conflict tags include: Functional tags, categorized according to the image's function (e.g., web server, database); Compatibility tags, recording the base image gene codes for successful combinations (e.g., base image A_Gene:a1b2c3...); Conflict tags, recording dependency conflicts that caused failure (e.g., glibc version incompatibility).

[0047] Specifically, image combination information is extracted from all historical deployment records, including the base image, extended images, deployment environment parameters, and the final deployment result (success / failure). Invalid or duplicate records are filtered out, image naming conventions are standardized, and a unique genetic code is generated for each base image (refer to the process of generating a unique genetic code in step S1).

[0048] Based on the intended use of the images, functional tags are labeled using keyword matching. For successfully deployed combinations, the mapping relationship between the base image's genetic code and extended images is recorded to form a compatibility knowledge base. Simultaneously, structured data is extracted as auxiliary features. For failed deployment combinations, logs are analyzed to pinpoint the causes of conflicts, recording the conflict type and the involved images and versions.

[0049] The initial model is trained using historical data, with inputs being mirror combination features (functional + gene coding + structured data) and outputs being a compatibility score (success probability). After each new deployment, the results are fed back to the model. For successful cases, the compatibility association between the current gene coding and the extended mirror is strengthened, and for failed cases, the conflict feature library is updated, and the model's prediction weights for similar combinations are adjusted.

[0050] When a new image is added to the database, it is automatically matched to a predefined functional category based on its description or metadata. When the model's prediction success probability exceeds a threshold, a base image gene coding tag is added to the extended image. When the model's prediction failure probability is high, it is automatically associated with a conflict feature library to generate specific conflict tags and record conflict solutions.

[0051] S3. Calculate the genetic similarity between the user input image and the image database. After filtering images with high similarity, use a prediction model to evaluate the success rate of the combination. Based on the conflict records in the tag database, remove images with known conflicts and sort them by the success rate of the combination.

[0052] Specifically, it receives image information submitted by users (such as image name, version number, function description, dependency list, etc.), extracts key feature fields, parses keywords in the function description, maps them to predefined function category tags, and extracts dependent libraries and their version ranges to generate dependency feature vectors.

[0053] Load all annotated gene-coded mirror images from the tag library (each image contains gene codes, functional tags, and compatibility / conflict records). Compare the dependency feature vectors of the user image with those of the images in the library one by one. Calculate the dependency library overlap rate between the user image and the image images. For overlapping dependency libraries, assess version range compatibility (e.g., if the user requires glibc>=2.28, and the image image uses glibc-2.30, the score will be higher). If the functional tags match, assign additional similarity bonuses. Calculate the total similarity score according to preset weights (e.g., dependency matching 60%, version compatibility 30%, functional tags 10%).

[0054] Mirrors with similarity scores higher than a preset threshold (defined as 70 in this application) are retained to generate a candidate list. If mirrors with duplicate functions exist in the candidate list, only the 1-2 with the highest similarity are retained to avoid recommendation redundancy. For each candidate mirror, the features of the user-input mirror are combined with the features of the candidate mirror to generate the input vector (gene-code pair) required by the prediction model, with additional environmental context (such as the operating system version and hardware architecture of the target deployment environment). The real-time compatibility prediction model is called to output the combined success rate probability value. If the model supports uncertainty estimation, the prediction confidence is recorded.

[0055] For each candidate image, check the tag library for any conflict records with the user-input image (e.g., "the user image's glibc-2.28 conflicts with the candidate image's openssl-1.1.0"). If a known conflict chain exists between the candidate image's dependencies and the user image's dependencies (e.g., A depends on B, B conflicts with C, and the user image uses C), remove all candidate images with direct or indirect conflicts and update the recommendation list.

[0056] Sort by success rate from highest to lowest; if success rates are the same, prioritize mirror images with higher similarity. If there are subtle differences in functional tags (e.g., "time series database" vs. "relational database"), prioritize those that fit better. If there are resolvable conflicts, sort by resolvability complexity in descending order.

[0057] Generate a detailed report for each recommended image, including: combination success rate and confidence level; similarity score and key matching features (e.g., "dependency library overlap rate 90%"). If conflicts exist, list conflict details and suggested solutions (e.g., "upgrade the user image's glibc to 2.30").

[0058] S4: Based on the number of user requests, extract the Top-N mirror images from the sorted candidate list as the recommendation results.

[0059] Where N is the user-specified quantity or the system default threshold. It should be noted that the user-specified quantity N is a positive integer.

[0060] Specifically, it determines whether the user has explicitly specified the number of recommendations (e.g., requesting "recommend 5 images"). If not specified, the system default threshold (3 images are recommended by default) is used. If N exceeds the total length of the candidate list, it is automatically adjusted to the maximum available number of candidates (e.g., if the user requests 10, but the candidate list only has 7, then 7 are used).

[0061] Obtain the candidate image list sorted by combination success rate from the output of the previous stage (S3). Confirm that each image in the list contains information such as image identifier (name, version number), combination success rate and confidence level, similarity score and functional tags, conflict records (if any), and list status check. If the candidate list is empty (e.g., all images are removed due to conflicts), trigger the exception handling process (e.g., return "no available recommendations" or suggest the user adjust input conditions).

[0062] Based on the user-specified N or a default threshold, extract the first N mirror images starting from the head of the sorted list. For example, if the sorted list is [Mirror A (95%), Mirror B (90%), Mirror C (85%), ...], and the user requires N=2, then Mirror A and Mirror B will be extracted.

[0063] If N=0, return an empty list and prompt the user to re-enter a valid number. If N=1, directly return the first-ranked image without further processing. If the user's requested number changes (e.g., the user changes from "recommend 3" to "recommend 5"), re-execute the truncation operation.

[0064] If the user requests recommendations covering diverse functionalities (e.g., "1 database + 1 cache"), check the functional label distribution of the Top-N images. If functional duplication exists (e.g., the first 3 are all database images), retain the image with the highest success rate and replace the duplicates with subsequent images featuring different functionalities. If the diversity requirement cannot be met, mark the results with a "functionality duplication warning". If multiple images belong to different versions of the same base image (e.g., MySQL 8.0 and MySQL 5.7), only retain the version with the highest success rate, unless the user explicitly requests a comparison of multiple versions.

[0065] S5 divides the image into 128KB fragments, generates a content hash and logical location coordinates for each fragment, and summarizes the root hash value, total number of fragments, and target node list as the basis for distribution verification; calculates the node reputation score based on historical transmission success rate and response speed.

[0066] Specifically, a fixed fragment size is set to 128KB (if the last fragment is less than 128KB, it is processed according to the actual size). If the image has been fragmented (e.g., if historical fragment records exist), the fragmentation strategy is checked to ensure consistency; otherwise, fragmentation is performed again.

[0067] Starting from the header of the image file, it is cut into consecutive shards at 128KB intervals (shard 1, shard 2... shard N). Each shard is assigned a unique logical location coordinate (e.g., shard number / total number of shards, for example, 3 / 10 represents the 3rd shard out of 10 shards). The shards are temporarily stored in a cache or temporary directory to avoid repeatedly reading the original image. A hash value is calculated for each shard; for example, the hash of shard 1 is H1, shard 2 is H2, and so on. All shard hashes are concatenated in a fixed order (ascending shard number) to calculate the top-level "root hash" (MerkleRoot hash) for global verification.

[0068] Record core information such as the root hash value (serving as the final verification identifier for image integrity), the total number of shards, and the target node list (obtained from the scheduling policy from the IP addresses or identifiers of the nodes to be distributed with the image, such as node A and node B)). Generate a mapping table between shards and their logical locations (e.g., shard 3 → 3 / 10) for location during transmission. Package the root hash, total number of shards, target node list, and shard index table into a verification metadata file.

[0069] Obtain transmission task data for the target node over the past 24 hours from the monitoring system, including: number of successful transmissions (success_count), number of failed transmissions (fail_count), and average response time (avg_latency, in milliseconds). Define a success rate weight (70%) and a response speed weight (30%). Normalize the success rate and response speed, and calculate a weighted score: Reputation Score = (0.7 × normalized_success) + (0.3 × normalized_speed). Example: If node A has a success rate of 90% and an average latency of 200ms (threshold 500ms), then the score is 0.7 × 0.9 + 0.3 × 0.6 = 0.81.

[0070] Nodes with a reputation score below the threshold (0.5) are removed to avoid selecting unreliable targets. If a node experiences an anomaly during transmission, its reputation score is temporarily lowered and a recalculation is triggered. The target node list is sorted from highest to lowest reputation score. Top-K nodes (K=2) are selected for redundant distribution to improve fault tolerance. If high-reputation nodes are overloaded, a portion of the shards is proportionally allocated to the next best nodes.

[0071] The sharding index table is split by node (e.g., node A is responsible for shards 1-5, and node B is responsible for shards 6-10). An independent transmission task is generated for each node, along with verification information (the hash value of the target shard). The number of concurrent transmissions per node is limited to avoid network congestion.

[0072] Upon receiving a fragment, a node immediately calculates its local hash and compares it with the fragment hash in the metadata. If they do not match, the node requests a retransmission of the fragment. After all fragments have been transmitted, the node reassembles the image according to the fragment index table, calculates the root hash, and compares it with the value in the checksum packet to ensure integrity.

[0073] For failed shards, a maximum of 3 retries are triggered, each time selecting the second-best reputation node. If all nodes fail, distribution is paused and an alarm is triggered, recording the reason for the failure. The transmission status (success / failure), node selection, and hash verification result for each shard are recorded. Example log entry: Shard 3 → Node A → Success → Hash H1 match. After each transmission, the node reputation score is dynamically adjusted based on the result (e.g., +0.01 points for success, -0.05 points for failure).

[0074] S6 prioritizes high-reputation nodes as the initial source, transmits fragments in parallel and monitors progress in real time, and the target nodes reassemble according to coordinates and verify integrity through root hash.

[0075] Specifically, the latest calculated node reputation score is obtained from stage S5, and the reputation score weight is dynamically adjusted based on real-time monitoring data. The candidate node list is sorted from highest to lowest reputation score, and nodes with reputation scores below the threshold (0.6) are removed to avoid unreliable transmission. If multiple high-reputation nodes exist, nodes with closer network topology distance to the target node (such as those in the same region or ISP) are prioritized. The top-1 reputable node is selected as the initial transmission source (e.g., node A), and the top-2 to top-3 nodes are selected as backup sources for rapid switching in case of primary source failure. Example: If the primary source node A fails to transmit, the system automatically switches to node B to continue transmitting the remaining fragments.

[0076] Split the total fragments according to node capabilities (e.g., node A is responsible for fragments 1-5, node B is responsible for fragments 6-10), prioritizing the allocation of more fragments to high-reputation nodes, but avoiding excessive load on a single node (e.g., a single node can handle a maximum of 60% of the fragments). Send a transmission instruction to each selected source node, including: a list of target nodes (the IPs of the nodes that need to receive the fragment), the logical coordinates of the fragment (e.g., fragment 3 / 10), and the content hash (for verification).

[0077] The source node pushes fragments to multiple target nodes simultaneously (e.g., node A transmits fragment 1 to nodes X and Y in parallel), and each transmission thread independently records its status (e.g., number of bytes sent, transmission rate). The number of concurrent transmissions per node is dynamically adjusted, and the rate is automatically limited based on network bandwidth feedback (e.g., packet loss rate) to avoid congestion.

[0078] The target node sends a transmission progress report to the control center every 5 seconds. The progress data includes: the current fragment sequence number and total number of fragments, the number of bytes transmitted and the total size, and the instantaneous transmission rate (KB / s). If fragment transmission is interrupted (e.g., three consecutive heartbeat timeouts), an alarm is immediately triggered and marked as "failure". Example alarm: Node X failed to transmit fragment 2, error code: NETWORK_TIMEOUT.

[0079] The transmission status of each fragment is displayed as a progress bar (e.g., "Fragment 4 / 10 → Node Y → 65%)", and abnormal fragments are highlighted. If the transmission progress of a fragment is severely lagging (e.g., below 30% of the average progress), it is automatically switched from the slow node to the backup source node.

[0080] The target node temporarily stores the received fragments in a cache directory according to logical coordinates (e.g., fragment 1 / 10). Example cache path: / tmp / mirror_chunks / nodeX / chunk_3_of_10. A local hash is calculated for each fragment and compared with the hash value in the transmission command. If they do not match, a request is made to the control center to retransmit the fragment (and the reputation score of the corresponding source node is lowered). Based on the fragment index table (e.g., fragment 1 → fragment 2 → ... → fragment N), the fragments are sequentially assembled into a complete image file. Example merge command (logical description): catchunk_1chunk_2...chunk_10>final_image.iso. If a fragment transmission fails and cannot be retransmitted, the entire image is marked as "incomplete" and the reassembly is terminated.

[0081] Calculate the top-level hash for the reconstructed complete image file to generate a local root hash value (local_root_hash). Perform a strict comparison between local_root_hash and the root_hash in the verification metadata generated in the S5 phase. If local_root_hash == "A1B2C3..." (metadata value), the verification passes. Otherwise, trigger an image corruption alarm and record the difference hash value.

[0082] If the verification passes, return a "image complete" status to the control center and release the temporary cached fragments. Example success log: Node X image reassembly successful, root hash matched, time taken 12 seconds. If the verification fails, mark the image as "unavailable," retransmit the missing or corrupted fragments from the backup source node, and if multiple retries still fail, report a serious fault and require manual intervention.

[0083] The technical solutions described in the embodiments of this application above have at least the following technical effects or advantages:

[0084] By generating a unique genetic code for each base image and constructing a behavioral profile library, and combining this with historical deployment data to train a real-time compatibility prediction model, this solution achieves accurate image combination recommendations and conflict prediction. Employing a sharded transmission and dynamic reputation node scheduling mechanism ensures efficient and complete image distribution, while root hash verification guarantees data reliability. This solution significantly improves the intelligence level of image management, reduces deployment failure rates, optimizes resource utilization, and provides a stable and scalable image lifecycle management solution for containerized environments.

[0085] Example 2: In Example 1, when a suspected anomaly occurs in a distributed cluster shard, a unified strategy is used for anomaly localization and handling. However, different shards differ significantly in their roles within the cluster, business criticality, traffic impact, and dependencies, and the anomaly manifestations and root causes are also diverse. Faced with these complex and diverse scenarios, the unified strategy struggles to accurately adapt, lacking in accuracy of anomaly detection, timeliness of processing, and rational resource utilization, thus failing to meet the requirements for efficient and stable operation of the distributed cluster. To achieve more accurate and flexible handling of shard anomalies and improve overall cluster performance, Example 2 is proposed for optimization and improvement.

[0086] In some embodiments, the image is fragmented into 128KB segments. Step S5 further includes:

[0087] S51 collects the raw data of each slice and calculates the entropy value by weighted summation.

[0088] The core data consists of raw data on shard access frequency, timeliness value, and dependency. The timeliness value is calculated using an exponential decay model, with the following formula: ,in, This is the attenuation coefficient (e.g., 0.1 / hour). This represents the time since the last update of the shard. Dependency is measured through static code analysis and runtime tracing, recording the dependencies between the shard and other shards, containers, and services. Dependency complexity is quantified into direct dependencies (the number of times a shard is directly called by other components) and indirect dependencies (the depth of the shard's association with other components through middleware). The overall dependency score is calculated as: Direct dependency count × 0.7 + Indirect dependency depth × 0.3. Combining these three parameters, the entropy metric for the shard is generated. The formula is: Where F is the normalized value of access frequency, V is the normalized value of timeliness, and D is the normalized value of association dependency. , , The weighting coefficients (default values ​​are 0.4, 0.3, and 0.3 respectively) are used. If the entropy value exceeds 1 or is lower than 0, the normalization parameters are re-verified or the weights are adjusted. For slices with sudden entropy changes (such as entropy value change > 0.5 in a single calculation), secondary diagnosis (S52 five-dimensional diagnosis) is triggered.

[0089] S52 performs a comprehensive diagnosis of distributed clusters from five dimensions to locate the root causes of anomalies.

[0090] The five dimensions include files, resources, network, security, and dependencies.

[0091] Specifically, the process involves locating cluster issues caused by abnormal file storage, access, or integrity; identifying cluster performance degradation due to resource bottlenecks or waste; determining communication failures caused by network latency, packet loss, or topology problems; recording cluster risks caused by security attacks or configuration errors; and clarifying service unavailability issues caused by broken dependencies between components or excessively long call chains. Five-dimensional anomaly events are sorted by timestamp to identify concurrently occurring related anomalies (e.g., file access failure and network packet loss coinciding); pre-setting anomaly association rules (e.g., "network packet loss rate > 5% → file transfer timeout") to automatically match diagnostic results; and using domain knowledge bases for root cause reasoning in complex scenarios. Abnormal conditions are reproduced in a test environment (e.g., limiting network bandwidth to 1Mbps for a node) to confirm whether the same problem is triggered. Remedial measures are taken based on the root cause, and the anomaly is observed to resolve. The types, scope, and severity of anomalies discovered in the five-dimensional diagnosis are summarized, and the anomaly association paths are displayed in the form of a timeline and dependency graph.

[0092] S53. Based on the associated root causes located by the five-dimensional diagnosis, determine the abnormal segments and suspected abnormal segments.

[0093] For abnormal shards, an immediate cleanup operation is performed; for suspected abnormal shards, an automatic migration mechanism is set up to migrate the suspected abnormal shards to a suitable node based on the system's real-time load and resource distribution.

[0094] Specifically, the root causes identified by the five-dimensional diagnostics are mapped to specific shards (file dimension: if the root cause is a storage media failure on a node, locate all storage shards on that node; resource dimension: if the root cause is a memory leak on a node, mark the computation shards with high memory usage on that node; network dimension: if the root cause is a high packet loss rate in a subnet, identify all communication shards within that subnet; security dimension: if the root cause is an attack on a node, isolate all service shards on that node; dependency dimension: if the root cause is the unavailability of a dependent service, mark the business shards that strongly depend on that service), identifying abnormal and suspected abnormal shards. Anomaly level judgment criteria are defined: an abnormal shard meets any of the following conditions: directly causing business interruption; three or more dimensions in the five-dimensional diagnostics are simultaneously abnormal (e.g., network packet loss + storage failure + resource exhaustion). A suspected abnormal shard meets any of the following conditions: a single-dimensional anomaly but not affecting business; the response latency of a dependent service exceeds the threshold but has not completely failed.

[0095] In the cluster metadata management system, mark the abnormal shard status as UNHEALTHY, stop new requests from being assigned to that shard, and notify the load balancer to remove the abnormal shard node from the service pool. If abnormal shards are concentrated on a single node (e.g., more than 3 abnormal shards), mark that node as QUARANTINE and prohibit new shard scheduling. Continuously track the five-dimensional metrics of suspected abnormal shards; if any metric consistently exceeds the specified range, trigger a migration assessment. Filter nodes with resource utilization below the safety threshold, prioritizing nodes in the same data center or availability zone as the original node to reduce migration latency. If a shard depends on a specific service, select a node where that service has been deployed and verify whether the target node meets the shard's operating conditions (e.g., disk space, port usage). Prepare a fast rollback path in case of migration failure. For stateless shards, directly start the instance on the new node and synchronize the configuration; for stateful shards, migrate the metadata first, then synchronize incremental data. Route a small amount of traffic to the new shard to verify functionality; after confirmation, update the service discovery registry and switch all traffic to the new shard. After the migration is complete, keep the original shard running for 10 minutes to monitor for any recurrence of anomalies. Once no anomalies are confirmed, stop the original shard process and clean up resources.

[0096] S54 performs multi-objective decision-making value assessment on suspected abnormal segments and introduces quantum lock enhancement technology to implement differentiated locking strategies according to different scenarios.

[0097] Among them, multi-objective decision value assessment considers three factors: cost (migration cost and lock-in cost), risk (probability of failure escalation and probability of dependency chain), and business value (criticality and traffic impact).

[0098] Specifically, the indicators of each dimension are normalized to the range of [0,1], the weights are dynamically adjusted according to the business scenario, and the comprehensive value score is calculated: score = business value weight × business value + risk weight × (1 - failure upgrade probability) - cost weight × migration cost. Based on the score, suspected abnormal segments are classified and processed.

[0099] A unique quantum key is generated for each suspected anomalous shard, bound to the shard metadata, and the lock state is synchronized to the cluster coordinator in real time via quantum entanglement. Scenario-specific locking strategies are defined (e.g., quantum confusion locking for high-security scenarios, and quantum annealing for high-concurrency scenarios to optimize lock combinations). A quantum random number generator (QRNG) is deployed on the cluster edge nodes to generate an initial quantum key for each container, and the key is securely transmitted to the control plane via the quantum key distribution protocol (QKD). The container runtime is modified to support quantum lock API calls. The container runtime sends a lock request to the quantum lock manager, carrying the shard ID and expected lock time. The manager generates a quantum entangled pair, returns half of the key to the runtime, and stores the other half in distributed quantum storage. The runtime uses the quantum key to hash the shard state and compares the result with the hash stored in the manager: if they match, the shard enters a "quantum locked" state; otherwise, a degradation process is triggered (e.g., reverting to a traditional mutex lock). The runtime sends an unlock request, and the manager destroys the remote key copy via quantum teleportation. Lock logs are recorded to the quantum blockchain to ensure audit immutability. In the event of a quantum storage failure, the system automatically switches to a pre-loaded classical key (valid for 24 hours) and triggers a quantum hardware redundancy switch. During network isolation, shards are allowed to continue operating locally using "quantum tokens," and the state is synchronized via quantum error correction codes after the partition recovers.

[0100] Track metrics such as quantum lock operation time, shard migration success rate, and business impact duration by collecting hardware-level data via quantum sensors. If locking high-value shards leads to an increase in business timeout rates, automatically reduce their quantum lock priority and increase classical lock timeout times. If the quantum lock failure rate is <0.1%, gradually expand the applicable scenarios for quantum locks (e.g., from database shards to microservice instances). In cases of sudden traffic surges, temporarily disable quantum locks for low-value shards to free up resources for high-value shards. Quickly calculate the optimal lock combination using the quantum annealing algorithm. Enable "quantum obfuscation locks" on shards suspected of being attacked, making it impossible for attackers to predict lock release times (through random qubit flipping). For frequently locked shards (e.g., cache shards locked more than 10 times per minute), use a quantum key pool to reduce generation overhead. Preload the quantum keys of frequently used shards into the Trusted Execution Environment (TEE) to shorten the initial lock latency to <1ms.

[0101] S55 constructs a dynamic gravity model to simulate the gravitational effect of shards in a distributed cluster.

[0102] S56 dynamically adjusts the transmission path of fragments based on real-time network topology information.

[0103] The Dijkstra algorithm is used to dynamically adjust the transmission path of fragments. The triggering conditions are divided into periodic triggering (recalculating the path of all active fragments every minute) and event triggering (detecting link failure or sudden increase in fragment communication volume).

[0104] The technical solutions described in the embodiments of this application above have at least the following technical effects or advantages:

[0105] By collecting multi-dimensional data from fragmented data and calculating entropy values, anomalies are accurately located. Five-dimensional diagnosis quickly identifies the root cause and handles abnormal and suspected abnormal fragments in a graded manner. After multi-objective evaluation of suspected abnormal fragments, quantum lock enhancement technology is introduced to achieve differentiated locking. Combined with a dynamic gravity model and path adjustment based on real-time topology, the distribution and communication of fragments in the distributed cluster are effectively optimized. This enables rapid and accurate handling of anomalies, reduces the impact of faults, improves cluster stability and resource utilization, and ensures business continuity. At the same time, quantum lock technology enhances security and operational flexibility.

[0106] Example 3: In Example 2, the historical traceability fails after the abnormal shards are cleaned up. Because the shard data is deleted, there is a lack of complete historical information to support subsequent reviews of system operation history, investigation of potential problems, or compliance audit requirements. This poses a challenge to the stable operation and security management of the distributed cluster. To solve this problem, Example 3 improves upon Example 2 by constructing a complete historical traceability system to ensure effective historical traceability even after shard cleanup.

[0107] In some embodiments, calculating the entropy value in step S51 further includes:

[0108] S511 extracts multi-dimensional data features from the shards and generates an entropy flow fingerprint that is uniquely identified and reflects changes in the shard state.

[0109] Specifically, leveraging the data mining and analysis capabilities of artificial intelligence, data is collected from multiple dimensions of container shards, including but not limited to basic information of container shards (such as shard ID, associated container service, node location, etc.), operational metrics (such as access frequency, response time, resource utilization, etc.), dependencies (dependencies with other container shards, containers, and services), and business data (such as the type of task processed, data volume, etc.). AI-based feature selection algorithms, such as deep learning-based feature importance assessment algorithms, machine learning-based information gain, and chi-square tests, are used to filter features that significantly influence the state of container shards from the collected data. These features should accurately reflect the operational status and trends of container shards while reducing data redundancy and improving computational efficiency. The selected features are encoded and converted into a digital form that can be processed by a computer. The encoded features are combined and AI encryption techniques, such as neural network-based encryption algorithms, are used to generate entropy flow fingerprints for container shards. Entropy flow fingerprints should be unique and stable, meaning that fingerprints are different for different container shards, and the fingerprints of the same container shard at different times should reflect changes in its state. For example, a hash algorithm can be used to encrypt the feature combination to generate a fixed-length fingerprint string.

[0110] S512 constructs a spatiotemporal correlation network to associate the states of the fragments in different times and spaces, and uses the concept of quantum entanglement to simulate the dependencies between fragments.

[0111] Specifically, based on the historical state records of container shards, a time series of container shard states is established in chronological order. Using artificial intelligence time series analysis techniques, the changing relationships between container shard states at different times are analyzed to determine the patterns and influencing factors of state transitions. For example, by analyzing the changes in the access frequency of container shards at different points in time, peak and trough access periods can be identified, along with the reasons for these changes.

[0112] Considering the physical location and logical relationships of container shards in a distributed cluster, establish spatial associations between container shards. Use artificial intelligence relationship analysis algorithms to analyze the dependencies, communication relationships, and data interactions between container shards, determining the degree of mutual influence between them. For example, if a failure in one container shard causes malfunctions in several other container shards, then there is a strong spatial association between these container shards.

[0113] By leveraging the concept of quantum entanglement and combining it with artificial intelligence simulation and quantization techniques, the temporal and spatial relationships between container fragments are simulated and quantified. An entanglement degree index is defined to measure the tightness of the correlation between container fragments. The entanglement degree can be calculated based on factors such as the strength of dependencies between container fragments, communication frequency, and data transmission volume. For example, a weighted average method can be used to calculate the entanglement degree between container fragments, with weights determined by the influence of different factors on the operation of the container fragments using an artificial intelligence weight optimization algorithm.

[0114] By treating container fragments as nodes and the entanglement between container fragments as edge weights, a spatiotemporal relational network is constructed. This network can intuitively display the relationships between container fragments in different times and spaces, providing network topology support for subsequent historical state restoration.

[0115] S513, based on entropy flow fingerprinting and spatiotemporal correlation network, restores the state of a fragment to a certain point in the past by using a time inversion algorithm.

[0116] Specifically, based on the need for historical tracing, the target time point to be traced back is determined. This time point can be a specific moment or a period of time. For example, when troubleshooting a container service failure, it is necessary to trace back to a period of time before the failure occurred to understand the system's operational status.

[0117] In spatiotemporal relational networks, based on a target time point, the entropy flow fingerprints of container shards near that time point are searched. By matching these fingerprints against a pre-generated fingerprint database, artificial intelligence similarity matching algorithms, such as deep learning-based similarity measurement models, are used to find the container shard state fingerprint closest to the target time point. For example, a similarity calculation algorithm (cosine similarity) is used to compare the similarity between the target fingerprint and fingerprints in the database, selecting the fingerprint with the highest similarity as the matching result.

[0118] Based on the matched container fragment state fingerprints and spatiotemporal correlation networks, a time inversion algorithm is used to progressively deduce the historical states of container fragments from the target time point. The time inversion algorithm considers the correlations and state transition patterns between container fragments, and reconstructs the state of the container fragments before the target time point through iterative calculations. For example, based on the entanglement degree and state transition model between container fragments, the state parameters of the container fragment at the previous time step are calculated.

[0119] Based on the container sharding state obtained through inversion, relevant business data and operational metrics are retrieved from historical data storage to achieve a complete restoration of the historical state of container sharding. For example, information such as the type of container sharding processing task and the amount of data processed is associated with records in the historical database to obtain specific business data content.

[0120] The technical solutions described in the embodiments of this application above have at least the following technical effects or advantages:

[0121] By generating entropy flow fingerprints that accurately reflect changes in container sharding status through intelligent feature selection, uniqueness and stability are ensured. Artificial intelligence is used to simulate and quantify the spatiotemporal correlation of container sharding, and an intuitive network topology is constructed. With the help of intelligent matching and time inversion algorithms, container sharding can be quickly and accurately restored to its state at a specific point in the past, and its historical state can be fully restored, effectively improving the efficiency and accuracy of container operation status tracing and fault diagnosis.

[0122] The above description is merely a preferred embodiment of the present invention and is not intended to limit the invention. For those skilled in the art, the present invention can have various modifications and variations. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the scope of protection of the present invention.

Claims

1. A container operation method based on artificial intelligence, characterized in that, include: S1, scan the hierarchical hash and metadata of the base image, generate a unique gene code, and store it in the extended image behavior profile library; S2 extracts image combination features based on historical deployment extension records, adds functional, compatibility and conflict tags to the extended image tags through a real-time compatibility prediction model, and dynamically updates the tag library. The dynamic update tag library extracts image combination information from historical deployment records, including base image, extended image, deployment environment parameters and results, generates a unique gene code for each base image, and labels it with functional tags according to its purpose; For successful deployment combinations, the mapping relationship between the base mirror gene code and the extended mirror is recorded to form a compatibility knowledge base, and structured data is extracted as auxiliary features. The initial model is trained using historical data, with mirror function, gene code, and structured data combination features as input, and a compatibility score is output. After each new deployment, the results are fed back to the model to strengthen the compatibility association between the gene code of successful cases and the extended mirror, update the conflict feature library of failed cases, and adjust the model prediction weights. When a new mirror is added to the library, the function classification is automatically matched. If the model predicts a success probability exceeding a threshold, a gene code label is added. If the failure probability is high, a conflict label is generated by associating with the conflict library and the solution is recorded. S3, calculate the gene similarity between the user input image and the image database, filter high similarity images, use the prediction model to evaluate the combination success rate, remove images with known conflicts according to the conflict records in the tag database, and sort them by combination success rate. S4, based on the number of user requests, extract the Top-N mirror images from the sorted candidate list as the recommendation results; where N is the number specified by the user or the system default threshold, and N is a positive integer; S5: Divide the image into shards, generate content hashes and logical location coordinates for each shard, and summarize the root hash value, total number of shards, and target node list as the basis for distribution verification; calculate node reputation scores based on historical transmission success rate and response speed. S6 prioritizes high-reputation nodes as the initial source, transmits fragments in parallel and monitors progress in real time, and the target nodes reassemble according to coordinates and verify integrity through root hash.

2. The container operation method based on artificial intelligence as described in claim 1, characterized in that, The process of generating a unique gene code includes: performing a comprehensive scan of the file system layer by layer from the bottom up; performing hash calculations recursively on the files and directories scanned at each layer; calculating the hash value for each file within a directory; combining the file hash values ​​with relevant information about the directory itself to calculate the hash value for that directory; concatenating the hash values ​​of each layer sequentially, either from top to bottom or bottom to top, to form a complete hierarchical hash chain that uniquely identifies the file system state of each layer of the base image; extracting key structured data from the base image, including operating system, architecture information, dependency library versions, and environment variables, and obtaining all environment variables set in the image and their corresponding values; concatenating the generated hierarchical hash chain and the extracted structured metadata in a specific order; processing the concatenated data string using the SHA-256 algorithm; and converting the input data string of arbitrary length into a fixed-length hash value, which is the gene code vector of the base image.

3. The container operation method based on artificial intelligence as described in claim 1, characterized in that, S5 specifically includes: setting a fixed shard size of 128KB; if the last shard is less than 128KB, it is processed according to the actual size; if the image has been sharded, check whether the sharding strategy is consistent, otherwise re-shard; starting from the beginning of the image file, cut it at 128KB intervals to generate a continuous shard sequence, and assign a unique logical location coordinate to each shard; calculate the hash value for each shard, concatenate all shard hashes in a fixed order, and calculate the top-level "root hash"; record the core information root hash value, the total number of shards, and the target node list, generate a mapping table between shards and logical locations, and package it into a verification metadata file.

4. The container operation method based on artificial intelligence as described in claim 3, characterized in that, The process of generating a mapping table between shards and logical locations and packaging it into a verification metadata file includes: obtaining transmission task data of target nodes in the past 24 hours from the monitoring system, including: success_count, failure_count, and average response time avg_latency; normalizing and calculating a weighted score for success rate and response speed, and removing nodes with reputation scores below a threshold; if a node experiences an anomaly during transmission, temporarily lowering its reputation score and triggering a recalculation; sorting the target node list from high to low reputation score; selecting Top-K nodes for redundant distribution; and proportionally allocating some shards to suboptimal nodes if high-reputation nodes are overloaded.

5. The container operation method based on artificial intelligence as described in claim 1, characterized in that, The S5 also includes: S51 collects the raw data of each slice and calculates the entropy value by weighted summation; S52 performs a comprehensive diagnosis of distributed clusters from five dimensions to locate the root causes of anomalies; these five dimensions include files, resources, network, security, and dependencies. S53, Based on the associated root causes located by the five-dimensional diagnosis, determine the abnormal segments and suspected abnormal segments; S54 performs multi-objective decision-making value assessment on suspected abnormal segments and introduces quantum lock enhancement technology to implement differentiated locking strategies according to different scenarios; S55, construct a dynamic gravity model to simulate the gravitational effect of sharding in a distributed cluster; S56 dynamically adjusts the transmission path of fragments based on real-time network topology information.

6. The container operation method based on artificial intelligence as described in claim 5, characterized in that, The calculation of entropy includes: core data such as shard access frequency, timeliness value, and dependency; and the calculation of timeliness value using an exponential decay model, with the formula as follows: ,in, The attenuation coefficient is... The time since the last update of the shard; dependency ratio is recorded through static code analysis and runtime tracing, recording the dependencies between the shard and other shards, containers, and services, and the dependency complexity is quantified into direct and indirect dependencies. Therefore, the comprehensive dependency score = number of direct dependencies × 0.7 + depth of indirect dependencies × 0.3; combining these three parameters, the entropy index of the shard is generated, with the formula: Where F is the normalized value of access frequency, V is the normalized value of timeliness, and D is the normalized value of association dependency. , , The default values ​​for the weighting coefficients are 0.4, 0.3, and 0.3, respectively.

7. The container operation method based on artificial intelligence as described in claim 6, characterized in that, The specific steps for locating the root cause of anomalies are as follows: sorting the five-dimensional anomaly events by timestamp and identifying concurrently occurring related anomalies; pre-setting anomaly association rules and automatically matching diagnostic results; performing root cause reasoning by calling the domain knowledge base for complex scenarios, reproducing the anomaly conditions in the test environment, and confirming whether the same problem is triggered; taking remedial measures based on the root cause and observing whether the anomaly is eliminated; summarizing the anomaly types, impact range, and severity found in the five-dimensional diagnosis, and displaying the anomaly association path in the form of a timeline and dependency graph.

8. The container operation method based on artificial intelligence as described in claim 5, characterized in that, In step S51, calculating the entropy value further includes: Extract multi-dimensional data features from the shards to generate a unique entropy flow fingerprint that reflects changes in the shard state; A spatiotemporal correlation network is constructed to associate the states of the fragments in different times and spaces, and the dependency relationship between the fragments is simulated using the concept of quantum entanglement; Based on entropy flow fingerprinting and spatiotemporal correlation networks, the fragments are restored to their state at a certain point in the past by using a time inversion algorithm.

9. The container operation method based on artificial intelligence as described in claim 8, characterized in that, The process of restoring a shard to its state at a specific point in the past using a time-reversal algorithm includes: determining the target time point to be traced back based on the need for historical tracing; searching for the entropy flow fingerprint of shards near the target time point in a spatiotemporal correlation network; finding the shard state fingerprint closest to the target time point by matching it with a pre-generated fingerprint database; using the matched shard state fingerprint and the spatiotemporal correlation network, and applying the time-reversal algorithm to progressively deduce the historical state of the shard from the target time point; the time-reversal algorithm considers the correlation between shards and the state transition rules, and restores the state of the shard before the target time point through iterative calculation; and obtaining the corresponding business data and operational indicators from historical data storage based on the inverted shard state to achieve a complete restoration of the shard's historical state.

Images