A large model-driven DataAI Plus system

Abstract

This invention discloses a large-model-driven DataAI Plus system, relating to the field of artificial intelligence technology. It includes a data acquisition module that collects structured operational data, unstructured log data, and multimodal external data in real time, performs data cleaning, format alignment, and feature extraction to generate a unified time-series feature vector set. An analysis module inputs the unified time-series feature vector set into a large-model intelligent hub and generates a system health status assessment matrix and anomaly detection report through cross-modal correlation analysis. A decision-making module generates an optimization strategy instruction set based on the system health status assessment matrix and anomaly detection report through an autonomous decision-making mechanism. This invention achieves deep fusion and dynamic optimization of multimodal data through a large-model intelligent hub, fundamentally improving the self-perception accuracy and self-optimization efficiency of the database system, and realizing truly intelligent autonomous operation and maintenance.

Description

Technical Field

[0001] This invention relates to the field of artificial intelligence technology, and in particular to a large model-driven DataAI Plus system. Background Technology

[0002] In recent years, with the deepening application of artificial intelligence technology in the field of database management, autonomous database systems based on machine learning have gradually automated tasks such as performance tuning and security patch management. Traditional methods rely on rule engines and statistical models for anomaly detection and resource optimization, while new-generation systems are beginning to introduce neural networks to process structured logs and performance metrics.

[0003] The existing technology has the following limitations: First, it lacks cross-modal data fusion capabilities and cannot establish semantic associations between heterogeneous data such as text logs, performance charts and voice alarms, resulting in blind spots in system state cognition; Second, the adaptive optimization mechanism is rigid, with most systems adopting a decision-making mode based on preset rules, making it difficult to achieve dynamic evolution of strategies through multimodal feedback. Summary of the Invention

[0004] In view of the aforementioned existing problems, the present invention is proposed.

[0005] Therefore, this invention provides a large model-driven DataAI Plus system to solve the problems of insufficient multimodal operation and maintenance data fusion and rigid adaptive optimization mechanisms, which lead to cognitive blind spots in database systems and difficulties in dynamic strategy evolution.

[0006] To solve the above-mentioned technical problems, the present invention provides the following technical solution: This invention provides a large model-driven DataAI Plus system, which includes: The data acquisition module collects structured operation and maintenance data, unstructured log data, and multimodal external data in real time, performs data cleaning, format alignment, and feature extraction, and generates a unified time-series feature vector set. The analysis module inputs a unified time-series feature vector set into the intelligent hub of the large model, and generates a system health status assessment matrix and anomaly detection report through cross-modal correlation analysis. The decision-making module generates an optimization strategy instruction set based on the system health status assessment matrix and anomaly detection reports through an autonomous decision-making mechanism. The execution module sends the strategy instruction set to the database kernel layer, automatically performs index reconstruction, resource scheduling and transaction rollback operations, and generates strategy execution results. The update module continuously monitors the strategy execution results, collects system performance data and multimodal operation and maintenance feedback, generates a reinforcement learning training sample set, inputs the reinforcement learning training sample set into the large model intelligent hub for reinforcement learning training, and updates the knowledge base and weight parameters.

[0007] As a preferred embodiment of the large model-driven DataAI Plus system described in this invention, the structured operation and maintenance data includes CPU utilization, memory usage, disk I / O throughput, and network traffic metrics; the unstructured log data includes database slow query logs, transaction logs, and error logs; and the multimodal external data includes operation and maintenance documents, screenshots, and voice recordings.

[0008] As a preferred embodiment of the large model-driven DataAI Plus system described in this invention, the data cleaning, format alignment, and feature extraction include the following steps: The collected multimodal raw data is processed by outlier removal, missing value imputation and noise filtering to generate a normalized dataset; The normalized dataset is converted into a unified time-series format through timestamp synchronization and semantic mapping to obtain a time-series aligned data stream. The temporal feature extractor, frequency domain feature extractor, and semantic feature extractor are used to perform multi-dimensional feature mining on the time-aligned data stream, forming a unified temporal feature vector set.

[0009] As a preferred embodiment of the large model-driven DataAI Plus system described in this invention, the large model intelligent hub adopts a fusion architecture of a pre-trained language model and a time series prediction model.

[0010] As a preferred embodiment of the large model-driven DataAI Plus system described in this invention, the step of generating a system health status assessment matrix and anomaly detection report through cross-modal correlation analysis includes the following steps: After receiving a unified temporal feature vector set, the large model intelligent hub performs cross-modal semantic alignment through a self-attention mechanism to generate an inter-modal correlation weight matrix. By performing feature fusion and context modeling on the intermodal correlation weight matrix, a cross-modal joint representation vector is obtained; The database system managed by the large-scale intelligent central hub utilizes cross-modal joint representation vectors to perform multi-dimensional evaluation of the system status and anomaly detection, thereby obtaining a system health status evaluation matrix and anomaly detection report.

[0011] As a preferred embodiment of the large model-driven DataAI Plus system described in this invention, the step of generating an optimization strategy instruction set through an autonomous decision-making mechanism includes the following steps. A multi-strategy collaborative generation mechanism performs in-depth analysis and decision reasoning on the system health status assessment matrix and anomaly detection report to obtain a preliminary set of optimization strategies. The initial set of optimization strategies is verified and optimized by using historical operation and maintenance cases stored in the pre-set knowledge base to obtain the verified strategy solution. The validated strategy scheme is evaluated using a multi-objective particle swarm optimization algorithm, which balances resource consumption with performance gains, and an optimized strategy instruction set is generated.

[0012] As a preferred embodiment of the large model-driven DataAI Plus system described in this invention, the automatic execution of index reconstruction, resource scheduling, and transaction rollback operations to generate strategy execution results includes the following steps. The optimization strategy instruction set is parsed to obtain the index rebuilding instruction, and the index structure optimization operation is executed by calling the database kernel interface through the execution module, generating the index rebuilding execution result. Based on the index reconstruction execution result, the resource scheduler is triggered to perform dynamic resource allocation and load balancing adjustment, and a resource scheduling execution report is generated. Initiate transaction monitoring based on the resource scheduling execution report, identify abnormal transactions in the resource scheduling execution report, detect and roll back abnormal transactions, and generate transaction rollback operation logs; The index reconstruction execution results, resource scheduling execution reports, and transaction rollback operation logs are integrated into the policy execution results.

[0013] As a preferred embodiment of the large model-driven DataAI Plus system described in this invention, the continuous detection strategy execution result includes the following steps. After receiving the strategy execution results, the multimodal output interface extracts key performance indicators and operation log information through data parsing to generate structured output data; Structured output data is transformed into performance metrics and topology diagrams through multimodal conversion to generate visual operation and maintenance reports; Visualized operation and maintenance reports, voice broadcast warnings, and dynamic demonstration videos are integrated into a multimodal operation and maintenance data set. Through real-time collection and analysis of the multimodal operation and maintenance data set, evaluation data on the effectiveness of policy execution is generated.

[0014] As a preferred embodiment of the large model-driven DataAI Plus system described in this invention, the following steps are included in the process of continuously detecting the execution results of the strategy, collecting system performance data and multimodal operation and maintenance feedback, and generating a reinforcement learning training sample set: The system receives performance data and multimodal operation and maintenance feedback in real time through a multi-source data acquisition interface. The system performance data and multimodal operation and maintenance output data are verified for integrity and noise filtered through a data quality assessment mechanism to generate a standardized feedback dataset. The standardized feedback dataset is processed by feature standardization and sample labeling to generate a reinforcement learning training sample set.

[0015] As a preferred embodiment of the large model-driven DataAI Plus system described in this invention, the step of inputting the reinforcement learning training sample set into the large model intelligent hub for reinforcement learning training includes the following steps: The reinforcement learning training sample set is input into the policy network and value network of the large model's intelligent hub. The policy gradient and value function parameters are calculated through the proximal policy optimization algorithm to generate updated policy network parameters and value function parameters. The updated policy network parameters and value function parameters are optimized through multi-objective fusion to obtain the advantage function. The advantage function parameters are then calculated using the generalized advantage estimation algorithm to generate the final weight parameters. The final weight parameters are deployed to the online inference environment of the large model's intelligent hub for reinforcement learning training.

[0016] The beneficial effects of this invention are as follows: This invention achieves deep fusion and dynamic optimization of multimodal data through a large-scale intelligent central model, resulting in three significant benefits: First, cross-modal correlation analysis maps text logs, visual charts, and voice data to a unified feature space, enabling the system to identify hidden fault modes that traditional methods cannot detect. Second, a reinforcement learning-based autonomous decision-making mechanism utilizes multimodal feedback to continuously optimize strategies, improving the accuracy of index reconstruction and resource scheduling. Third, the closed-loop feedback system transforms complex operation and maintenance results into intuitive visual reports through multimodal outputs such as text-generated graphs and text-generated videos, reducing the need for manual intervention. This multimodal collaboration and dynamic evolution capability fundamentally improves the self-awareness accuracy and self-optimization efficiency of the database system, achieving truly intelligent autonomous operation and maintenance. Attached Figure Description

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

[0018] Figure 1 This is a schematic diagram of the DataAI Plus system driven by large models.

[0019] Figure 2 This is a schematic diagram of the data acquisition module.

[0020] Figure 3 This is a schematic diagram of the analysis module.

[0021] Figure 4 This is a schematic diagram of the decision-making module. Detailed Implementation

[0022] To make the above-mentioned objects, features and advantages of the present invention more apparent and understandable, the specific embodiments of the present invention will be described in detail below with reference to the accompanying drawings.

[0023] Many specific details are set forth in the following description in order to provide a full understanding of the invention. However, the invention may also be practiced in other ways different from those described herein, and those skilled in the art can make similar extensions without departing from the spirit of the invention. Therefore, the invention is not limited to the specific embodiments disclosed below.

[0024] Secondly, the term "one embodiment" or "embodiment" as used herein refers to a specific feature, structure, or characteristic that may be included in at least one implementation of the present invention. The phrase "in one embodiment" appearing in different places in this specification does not necessarily refer to the same embodiment, nor is it a single or selective embodiment that is mutually exclusive with other embodiments.

[0025] Reference Figures 1-4 As one embodiment of the present invention, this embodiment provides a large model-driven DataAIPlus system, comprising the following steps: The data acquisition module collects structured operation and maintenance data, unstructured log data, and multimodal external data in real time, performs data cleaning, format alignment, and feature extraction, and generates a unified time-series feature vector set.

[0026] Specifically, it includes the following steps: Collect structured operation and maintenance data, unstructured log data, and multimodal external data.

[0027] Structured operation and maintenance data includes CPU utilization, memory utilization, disk I / O throughput, and network traffic metrics; unstructured log data includes database slow query logs, transaction logs, and error logs; and multimodal external data includes operation and maintenance documents, screenshots, and voice recordings.

[0028] The collected multimodal raw data is processed by outlier removal, missing value imputation and noise filtering to generate a normalized dataset.

[0029] In practice, the process involves identifying and removing observations that significantly deviate from the normal range from the collected multimodal raw data. This is achieved by identifying and removing data points that deviate from the normal range through statistical distribution, thus generating a pre-cleaned dataset. The pre-cleaned dataset is then filled with missing or invalid values ​​using linear interpolation or the K-nearest neighbor algorithm to generate a complete dataset. Finally, the complete dataset is processed to eliminate random fluctuations or irrelevant interference. This is achieved by smoothing random fluctuations using a sliding window mean filtering method, thus generating a normalized dataset.

[0030] The normalized dataset is converted into a unified time-series format through timestamp synchronization and semantic mapping to obtain a time-aligned data stream.

[0031] In practice, the normalized dataset is synchronized through timestamps and the clock reference of all data sources is calibrated using the Network Time Protocol (NTP) to control the time deviation of different acquisition devices within milliseconds and generate a dataset with a unified time reference. The dataset with a unified time reference calculates the cumulative distance of all possible alignment paths between sequences using a dynamic time warping algorithm to measure the similarity between two time series. The one with the highest similarity is taken as the optimal matching path. The optimal matching path between the two sequences is found, and the sum of the cumulative distances between all point pairs along the optimal matching path is calculated. The alignment of non-uniformly sampled data sequences is achieved by minimizing the cumulative distance. The new values ​​between existing data points are calculated using a linear interpolation algorithm on the aligned non-uniformly sampled data sequences, so that the data points are arranged at fixed time intervals (e.g., 1 second), generating a primary data stream with time alignment. The initial data stream with temporal alignment is processed through semantic mapping transformation, which converts the multi-dimensional heterogeneous data feature labels in the data stream into standardized semantic identifiers, generating a data stream with preliminary semantic uniformity. The data stream with preliminary semantic uniformity is then subjected to deep semantic encoding through word embedding, which maps text descriptions, numerical indicators, and classification labels to a unified vector space, generating a data stream with deep semantic uniformity. The data stream with deep semantic uniformity is then restructured according to a unified temporal format and encapsulated into a temporally aligned data stream containing timestamp sequences, standardized semantic vectors, and multimodal feature identifiers.

[0032] The temporal feature extractor, frequency domain feature extractor, and semantic feature extractor are used to perform multi-dimensional feature mining on the time-aligned data stream, forming a unified temporal feature vector set.

[0033] In practice, the time-aligned data stream is input to the time-domain feature extractor, which calculates statistical features such as mean, variance, peak value, and skewness to generate a time-domain feature vector. The time-domain feature vector is then input to the frequency-domain feature extractor, which extracts frequency-domain features such as the main frequency, spectral energy, and spectral entropy by decomposing the signal into sine and cosine components of different frequencies to generate a frequency-domain feature vector. Finally, the frequency-domain feature vector is input to the semantic feature extractor, which uses word embeddings to extract word vectors and contextual semantic features from the text data to generate a semantic feature vector. It should be noted that time-domain feature extractors include mean (reflecting the average level of data), variance (measuring the degree of data fluctuation), peak value (identifying the maximum value), skewness (describing the asymmetry of distribution), etc.

[0034] Temporal feature vectors, frequency domain feature vectors, and semantic feature vectors are input into the feature fusion process. By concatenating the temporal feature vectors, frequency domain feature vectors, and semantic feature vectors in the row or column direction and scaling the feature vectors to a uniform range, multi-dimensional feature fusion is performed to form a unified temporal feature vector set.

[0035] It should be noted that the uniform range refers to scaling the feature vector to a range with a mean of 0 and a standard deviation of 1.

[0036] The analysis module inputs a unified time-series feature vector set into the large model's intelligent hub, and generates a system health status assessment matrix and anomaly detection report through cross-modal correlation analysis.

[0037] Specifically, the steps include the following: A unified set of time-series feature vectors is input into the large-scale intelligent hub, which uses a fusion architecture of a pre-trained language model and a time-series prediction model to process the input data.

[0038] In practice, the large-scale intelligent hub receives a unified temporal feature vector set and distributes it to a pre-trained language model and a time series prediction model. The pre-trained language model uses natural language processing methods to capture meaning-related information from the unified temporal feature vector set and applies a self-attention mechanism to encode the dependencies between elements in the sequence (such as long-distance contextual associations) by calculating the attention weights of the query vector, key vector, and value vector, generating a context-aware feature representation. The time series prediction model applies linear regression and exponential smoothing to the unified temporal feature vector set to analyze the overall trend of data points in the unified temporal features and detects periodic fluctuations in the unified temporal feature vector set through seasonal decomposition. The two models execute processing tasks in parallel, generating semantically enhanced feature vectors and time series prediction feature vectors, respectively. The semantically enhanced feature vectors and time series prediction feature vectors are input to the feature fusion layer and weightedly fused through an attention mechanism to generate a comprehensive feature representation, which serves as the output of the large-scale intelligent hub.

[0039] Initialize the parameters of the pre-trained language model to generate a stable initial parameter set. Input the parameter set into the position encoding module, process the sequence order through sine curve encoding and learned encoding to generate position-enhanced sequence representations, input the position-enhanced sequence representations into the configuration module, add linear projection layers according to task requirements (such as classification or regression), generate an adapted output layer structure, and input it into the model architecture integration module. The integration module combines the components to complete the construction of the pre-trained language model.

[0040] The specific steps for training the pre-trained language model are as follows: A unified temporal feature vector set is tokenized to generate a tokenized input dataset; the tokenized input dataset is then input into the self-supervised learning task application stage, where 15% of the tokens are randomly masked using masked language modeling, and the masked content is predicted to generate labeled training batch data; the labeled training batch data is then input into the model training and optimization module for gradient descent and backpropagation, outputting an updated pre-trained language model parameter set. right The updated pre-trained language model parameter set is validated and evaluated. The perplexity is calculated through forward propagation, and the loss and accuracy are monitored. The trained language model is then output.

[0041] The original time series data is input and cleaned and normalized using data preprocessing methods to handle missing and outlier values, generating a regular time series dataset. The time series dataset is then input into the feature engineering stage, where time series feature extraction methods are applied to generate a feature vector set containing trend, seasonality, and residual components. The feature vector set is used to select and initialize the pre-trained language model structure according to the prediction target, thus completing the construction of the time series prediction model.

[0042] The training steps for the time series prediction model are as follows: A unified time series feature vector set is processed through a sliding window to generate a time series sample dataset; the time series sample dataset is input into the supervised learning task application stage, generating labeled training batch data through a time step prediction task (e.g., predicting the future m steps using n historical steps); the labeled training batch data is input into the time series prediction model training and optimization module, calculating the mean squared error loss through gradient descent and backpropagation, and outputting the updated time series prediction model parameter set; the updated time series prediction model parameter set is validated and evaluated, calculating the mean absolute error through forward propagation and monitoring the prediction accuracy, and outputting the trained time series prediction model.

[0043] The large model intelligent hub applies a self-attention mechanism to perform cross-modal semantic alignment processing on a unified temporal feature vector set, generating an intermodal correlation weight matrix.

[0044] In practice, the large model intelligent hub performs a linear transformation on the comprehensive feature representation output by the unified temporal feature vector set to generate a query vector matrix, a key vector matrix, and a value vector matrix. It then performs a dot product calculation on the query vector matrix and the key vector matrix, adjusts the numerical range of the dot product calculation result by a scaling factor, and generates an initial attention score matrix. The initial attention score matrix is ​​then converted into a probability distribution by the Softmax function to generate an attention weight probability distribution matrix. Finally, the attention weight probability distribution matrix and the value vector matrix are weighted and summed to generate an intermodal correlation weight matrix.

[0045] It should be noted that the dot product is used to measure the similarity or correlation between two vectors, and its formula is as follows:

[0046] in, For query vector, For key vectors, For vector A, the first... The component represents a specific value for a certain feature dimension (e.g., the first component in a text vector). (semantic strength value of dimension) For vector B, the first The component represents the specific value of another feature dimension (e.g., the first component in the time series vector). CPU utilization values ​​at specific points in time. To unify the total number of dimensions of the time series feature vector set.

[0047] The intermodal correlation weight matrix is ​​processed through feature fusion and context modeling, and multimodal information is integrated by applying a deep neural network to obtain a cross-modal joint representation vector.

[0048] In practice, the intermodal correlation weight matrix is ​​used as input. A weighted summation algorithm is applied to combine the intermodal correlation weight matrix with the multimodal feature vectors in the unified temporal feature vector set to generate a preliminary fused feature representation. The preliminary fused feature representation is input to the context modeling process. A long short-term memory network is used to capture the long-term dependencies in the unified temporal feature vector set through gating mechanisms (such as input gate, forget gate, and output gate). Combined with the self-attention mechanism of the Transformer architecture, the global relevance weights of the unified temporal feature vector set are captured to generate a context-enhanced feature representation. The context-enhanced feature representation is input to a deep neural network. Through multilayer perceptron and convolutional neural network, nonlinear transformation and dimensionality adjustment are performed to generate a deep integrated feature representation. The deep integrated feature representation is processed by a normalization layer to form a cross-modal joint representation vector.

[0049] It should be noted that, for each element in the input sequence, the Transformer architecture employs a self-attention mechanism that calculates the association weights between the element and all other elements in the sequence (including itself), thereby capturing global contextual information.

[0050] A multilayer perceptron consists of an input layer, one or more hidden layers, and an output layer. It performs nonlinear transformations and feature abstraction after feature fusion or before the final decision.

[0051] Normalization layer processing ensures faster and more stable training by adding normalization layers between layers of a deep neural network, preventing gradient explosion or vanishing.

[0052] The cross-modal joint representation vector performs multi-dimensional evaluation and abnormal pattern detection through machine learning classifiers and anomaly detection algorithms, generating a system health status evaluation matrix and anomaly detection report.

[0053] In practice, the cross-modal joint representation vector is input into a multi-class support vector machine classifier. The decision boundary in the feature space is calculated using radial basis functions to evaluate the state of the cross-modal joint representation vector across multiple dimensions, including performance, resource utilization, and stability, generating a state score vector containing quantified values ​​for each dimension. This state score vector is then input into an isolated forest anomaly detection algorithm. An isolated tree is constructed using a random forest, and the path length of the state score vector is calculated to quantify its deviation from the normal distribution, generating an anomaly score list (numerical values ​​representing the degree of anomaly). An adaptive anomaly detection mechanism automatically identifies anomalies based on the distribution characteristics of the anomaly scores (e.g., using kernel density estimation or percentile analysis), generating anomaly label sequences (e.g., 'normal' or 'abnormal'). High anomalies (e.g., scores in the upper 5 percentile of the distribution) are classified as 'abnormal', while low anomalies are classified as 'normal'. The anomaly score list and anomaly label sequence are integrated with the state score vector, and a system health status assessment matrix is ​​generated through matrix construction. This system health status assessment matrix is ​​then input into a report generation center for data parsing, extracting key anomaly events and trend indicators, and generating a structured anomaly detection report.

[0054] It should be noted that the status score vector includes quantitative scores for dimensions such as performance, resource utilization, and stability; the structured anomaly detection report includes anomaly summary, root cause analysis, severity level, and recommended actions.

[0055] The system health status assessment matrix is ​​organized in the form of a two-dimensional table. The rows represent time points or components, and the columns represent health dimensions (such as CPU health, memory health, and transaction health). The cells are filled with normalized scores and anomaly flags.

[0056] The decision-making module generates an optimization strategy instruction set through an autonomous decision-making mechanism based on the system health status assessment matrix and anomaly detection reports.

[0057] Specifically, the steps include the following: The multi-strategy collaborative generation mechanism performs in-depth analysis and decision reasoning on the system health status assessment matrix and anomaly detection report input data, generating a preliminary set of optimization strategies including index optimization schemes, resource adjustment strategies, and fault handling plans.

[0058] In practice, the multi-strategy collaborative generation mechanism coordinates multiple algorithms to parse the system health status assessment matrix and anomaly detection report input data, generating parsed multi-dimensional features. The parallel strategy generation center receives the parsed multi-dimensional features and uses rule-based reasoning algorithms to analyze them through index selection rules and query optimization rules. It matches condition-action pairs (e.g., IF index fragmentation rate > 30%, THEN suggests rebuilding the index) to generate a candidate set of index optimization schemes. It applies time series analysis methods and uses an LSTM network to perform long-term trend analysis on the parsed multi-dimensional features to predict future resource demands and generate a candidate set of resource adjustment strategies. It applies a case matching algorithm to generate a candidate set of fault handling plans by retrieving the most similar records in historical operation and maintenance cases to the current scenario. The three candidate sets are input into the strategy integration process, and a multi-objective optimization algorithm is used to prioritize them, generating a preliminary set of optimization strategies.

[0059] The initial set of optimization strategies is input into a database that is continuously built and updated using historical operation and maintenance data. The strategies are then matched and verified against historical operation and maintenance cases stored in the database. Invalid strategies are eliminated through successful case screening and risk assessment to obtain the verified strategy solutions.

[0060] In practice, the initial optimization strategy set uses a case matching algorithm to calculate the similarity of each strategy in the set, generating a strategy-case matching result list. This list is then input into a successful case screening process, where a success rate threshold filtering mechanism selects a subset of strategies that match historical successful cases, generating an initial verification strategy set. This set is then input into a risk assessment process, where a weighted summation algorithm is used to calculate the risk score for each strategy based on risk indicators (such as failure frequency and impact scope) from historical operation and maintenance cases. Based on these risk scores, a strategy risk assessment report is generated using a risk level classification mechanism. The strategy risk assessment report and the initial verification strategy set are then input into a strategy filtering process, where invalid strategies with risk scores exceeding a preset limit are eliminated through risk threshold comparison, resulting in verified strategy solutions.

[0061] It should be noted that the preset limits are calculated using ROC curve analysis to determine the true positive rate (TPR) and false positive rate (FPR) of the risk score threshold. The balance point is found by maximizing the Youden index J (J=TPR-FPR). A risk score threshold of 0.6 corresponds to a higher true positive rate (TPR=90%) and a lower false positive rate (e.g., FPR=5%), effectively reducing false alarms. A risk score threshold of 0.8 ensures that the false negative rate is controlled within 10%, avoiding missing high-risk events. Therefore, the value range is determined to be 0.6 to 0.8 (risk score standardized to [0-1]), which can effectively distinguish between low, medium and high-risk events, balance false alarm and false negative rates, and ensure the accuracy and reliability of system decision-making.

[0062] The validated strategy is then fed into the multi-objective particle swarm optimization algorithm to perform a Pareto front search of resource consumption and performance gains, generating an optimization strategy instruction set.

[0063] In specific operations, After verification, the strategy scheme is input into the multi-objective particle swarm optimization algorithm processing flow. After initializing the particle swarm, the multi-objective particle swarm optimization algorithm performs iterative optimization loop. In each iteration, the resource consumption objective function value and performance gain objective function value of the strategy scheme corresponding to each particle are calculated. The resource consumption objective function value and performance gain objective function value of all particles are sorted in a non-dominated manner. By comparing the dominance relationship between particles (i.e., one particle is not inferior to another particle in all objective function values ​​and is strictly better in at least one objective function value), the non-dominated solution set is identified and assigned to the highest level (Pareto optimal solution). The non-dominated sorting process is iteratively performed on the remaining solutions to generate the Pareto level sequence. The Pareto rank sequence is input into the particle velocity update formula. The particle velocity vector is updated by using the optimal position, global optimal position, and current position of the Pareto rank sequence in the velocity update formula. The updated particle velocity vector is input into the position update formula to generate a new generation of particle swarm position vectors. The new generation of particle swarm position vectors is then modified for feasibility to generate the final particle swarm position vector.

[0064] It should be noted that the objective function value for resource consumption includes CPU utilization and memory usage, while the objective function value for performance gains includes query latency reduction rate and transaction rollback probability.

[0065] Speed ​​update formula:

[0066] in, For particles; For particles in iteration The new velocity vector at time t; For particles In iteration The current velocity vector at any given moment; The inertial weight is dynamically adjusted based on historical convergence data (e.g., initially 0.9, then linearly reduced to 0.4 with iterations). To control the learning rate of particles towards the optimal level for each individual; To control the learning rate of particles toward the global optimal direction; For particles The individual's historical best position, The globally optimal position; For particles In iteration The current position vector at any given moment; , It is a random number in the range [0,1].

[0067] Position update formula:

[0068] in For particles In iteration The new position vector at time t; For particles In iteration The current position vector at any given moment; The new velocity vector derived from the velocity update formula.

[0069] The particle swarm position vector is input into the Pareto solution set extraction process, which filters non-dominated solutions to form the Pareto optimal front. The Pareto optimal front selects the final strategy configuration through decision preference weights, which are generated based on multi-objective priority analysis in historical operation and maintenance data (such as the trade-off weight between performance gains and resource consumption). The final strategy configuration is input into the strategy instruction conversion center, which parses the instruction structure through a syntax validator to check whether it conforms to predefined syntax rules. If there are no syntax rule errors, an optimized strategy instruction set is generated.

[0070] The execution module sends the policy instruction set to the database kernel layer, automatically performs index reconstruction, resource scheduling and transaction rollback operations, and generates policy execution results.

[0071] Specifically, the steps include the following: The strategy instruction set is sent to the database kernel layer. By parsing and optimizing the strategy instruction set, the index rebuild instructions are extracted. The index structure optimization operation is performed through the database kernel interface, and the index rebuild execution result, which includes the index rebuild time, storage space changes and performance improvement indicators, is generated.

[0072] In practice, after the strategy instruction set is sent to the database kernel layer, the database kernel layer receives the strategy instruction set and performs instruction parsing. By translating and decomposing the optimization strategy instructions into operation commands that the database kernel can understand and execute, the index rebuilding instructions in the optimization strategy instruction set are extracted. The index rebuilding instructions are input to the instruction decoder, which converts the index rebuilding instructions into specific database operation commands, generating an executable index optimization operation sequence. The executable index optimization operation sequence is used to perform index structure optimization operations. During the execution of the index structure optimization operation, the performance monitor collects time-consuming data, storage change data and performance indicator data in real time, and the result formatter integrates the time-consuming data, storage change data and performance indicator data into a structured index reconstruction execution result.

[0073] It should be noted that index structure optimization operations include index creation, index rebuilding, and index deletion.

[0074] The index reconstruction execution result triggers the resource scheduler to start dynamic resource allocation and load balancing adjustment, generating a resource scheduling execution report that records CPU core allocation, memory buffer adjustment and thread pool configuration changes.

[0075] In practice, the index reconstruction execution result is input into the resource demand analyzer. The resource demand analyzer calculates the target resource quota based on the performance improvement indicators and generates resource demand parameters including the target number of CPU cores, the target memory buffer size, and the target thread pool size. The resource demand parameters are input into the resource allocator. The resource allocator generates specific resource allocation instructions (including CPU core allocation instructions, memory buffer adjustment instructions, and thread pool configuration instructions) based on the difference between the current system resource status and the resource demand parameters. CPU core allocation instructions allocate a specified number of CPU cores to the database process via the CPU affinity setting interface, generating a CPU core allocation record. Memory buffer adjustment instructions adjust the database shared buffer size and cache pool configuration via the memory management interface, generating a memory buffer adjustment record. Thread pool configuration instructions modify the maximum number of worker threads and the task queue length via the connection pool management interface, generating a thread pool configuration record. The CPU core allocation record, memory buffer adjustment record, and thread pool configuration record are input into a report generator. The report generator integrates these records, adds timestamps and performance metrics, and generates a resource scheduling execution report.

[0076] It should be noted that resource allocation instructions include CPU core allocation instructions, memory buffer adjustment instructions, and thread pool configuration instructions.

[0077] Input the resource scheduling execution report into the transaction monitoring process, identify abnormal transactions in the resource scheduling execution report (including deadlock transactions, timeout uncommitted transactions, and data consistency abnormal transactions), detect and roll back these abnormal transactions, and generate a transaction rollback operation log containing the rollback transaction ID, rollback timestamp, and data recovery status.

[0078] In practice, the resource scheduling execution report is input into the transaction monitoring process. The transaction monitoring process extracts transaction status data from the report through the report parser, generates a transaction status list, and inputs the transaction status list into the exception identifier. Deadlocked transactions are identified by recognizing the deadlock state (i.e., deadlock) between multiple transactions or processes due to circular waiting for resources. Timed-out uncommitted transactions are identified by monitoring the execution time of transactions or operations. Data consistency anomalies are identified by ensuring that data meets the predefined integrity constraints and business rules of the database schema definition (such as foreign key constraints and unique indexes) and historical operation and maintenance knowledge base (such as verification rules in business logic rules and case library) after transaction execution, generating an anomaly transaction list. The anomaly transaction list is input into the rollback processor, which calls the corresponding rollback strategy (such as deadlock transaction rollback strategy, timeout transaction rollback strategy, and consistency anomaly transaction rollback strategy) according to the transaction type, executes the transaction rollback operation, generates the rollback execution result, and inputs the rollback execution result into the log generator to record the rollback transaction ID, rollback timestamp, and data recovery status, generating a transaction rollback operation log.

[0079] It should be noted that the rollback operation is as follows: when an error or system failure occurs during the execution of a transaction, all executed operations are undone, restoring the database state to the consistent state before the transaction began.

[0080] The index reconstruction execution results, resource scheduling execution reports, and transaction rollback operation logs are integrated into a complete strategy execution result by time series.

[0081] In the specific operation, the strategy execution result is input into the timestamp extractor, the index reconstruction start timestamp and end timestamp are extracted from the index reconstruction execution result, the resource adjustment operation timestamp is extracted from the resource scheduling execution report, and the rollback event timestamp is extracted from the transaction rollback operation log to generate a list of events with timestamps; The time series sorter inputs a list of timestamped events into the time series sorter. The time series sorter uses the quicksort algorithm to sort all timestamps in ascending order, generating a time series event sequence. The time series event sequence is then input into the result integrator. The result integrator merges the performance metrics from the index reconstruction execution results, the resource configuration change records from the resource scheduling execution report, and the rollback details from the transaction rollback operation log into a unified structured data format according to time order, generating a complete strategy execution result.

[0082] The update module continuously monitors the strategy execution results, collects system performance data and multimodal operation and maintenance feedback, generates a reinforcement learning training sample set, inputs the reinforcement learning training sample set into the large model intelligent hub for reinforcement learning training, and updates the knowledge base and weight parameters.

[0083] Specifically, the steps include the following: The strategy execution results are received through a multimodal output interface. The multimodal output interface extracts key performance indicators and operation log information from the strategy execution results through data parsing and generates structured output data.

[0084] In practice, the multimodal output interface receives the strategy execution results, scans text logs using regular expression matching algorithms to extract key performance indicators (such as CPU utilization and memory usage), and simultaneously uses natural language processing to process log information (such as error codes and transaction IDs) to generate a preliminary extracted data set. This preliminary extracted data set is then serialized and encoded according to a predefined JSON Schema structured pattern based on historical operational data analysis and system requirements, generating standardized structured output data. The predefined JSON Schema structured pattern is a pre-designed rule file written in JSON format that transforms the parsed, messy raw data into highly standardized structured output data.

[0085] It should be noted that the strategy execution results include multi-format data streams such as text logs, numerical metrics, and binary event records.

[0086] The structured output data is converted into performance metrics into visual charts through text-to-image conversion methods, and a topology diagram is generated through topology analysis algorithms. Together, they form a visual operation and maintenance report. The visual operation and maintenance report, along with voice broadcast warnings and dynamic demonstration videos, are merged into a multimodal operation and maintenance data set through a data integration engine.

[0087] In practice, the structured output data is split into performance metric data streams and topology information data streams by a data distributor. The performance metric data stream uses a chart generation algorithm to convert numerical performance metrics into visual charts such as line charts and bar charts. Simultaneously, the topology information data stream uses a topology analysis algorithm to parse node connections, path dependencies, and network hierarchy to generate a network topology diagram. The visual charts and network topology diagrams are then input into a report synthesizer, which uses a page layout algorithm to integrate the charts and diagrams into a unified format visual operations and maintenance report.

[0088] The multimodal operation and maintenance data set is input into the real-time analysis processor, and evaluation data on the effectiveness of policy execution is generated through time series analysis and pattern recognition algorithms.

[0089] In practice, the multimodal operation and maintenance data set is input into the real-time analysis processor. The real-time analysis processor extracts continuous time segments through the sliding window mechanism to generate time series data blocks. The time series data blocks are input into the time series analysis algorithm, which applies the autoregressive integral moving average model. By integrating parameter estimation and modeling the time series, trend indicators, periodic components and residual sequences are calculated to generate time series feature vectors. The temporal feature vector is input into the pattern recognition algorithm, which calculates the class probability distribution of the temporal feature vector through a classification model (such as a convolutional neural network or support vector machine). Based on the class probability distribution, it distinguishes between abnormal patterns and normal operation patterns, generating a pattern classification result. The pattern classification result and the temporal feature vector are integrated through a weighted fusion algorithm to generate a comprehensive feature representation. The comprehensive feature representation is input into the evaluation generator, which uses a linear regression model to calculate a performance quantification score (such as predicting system performance indicators based on feature weights) and a logistic regression model to calculate the anomaly detection probability (such as outputting the probability value of anomaly occurrence). Together, they constitute the evaluation data of the strategy execution effect.

[0090] It should be noted that the sliding window mechanism divides a continuous data stream into windows of fixed or dynamic size and performs aggregation calculations or pattern detection within the windows. For CPU utilization stream data, a 5-minute sliding window is applied to calculate the mean / peak value within the window, smoothing out instantaneous fluctuations and capturing long-term trends.

[0091] In summary, this invention achieves deep fusion and dynamic optimization of multimodal data through a large-scale intelligent hub, resulting in three significant benefits: First, cross-modal correlation analysis maps text logs, visual charts, and voice data to a unified feature space, enabling the system to identify hidden fault modes that traditional methods cannot detect. Second, a reinforcement learning-based autonomous decision-making mechanism utilizes multimodal feedback to continuously optimize strategies, improving the accuracy of index reconstruction and resource scheduling. Finally, the closed-loop feedback system transforms complex operational results into intuitive visual reports through multimodal outputs such as text-generated graphs and text-generated videos, reducing the need for manual intervention. This multimodal collaboration and dynamic evolution capability fundamentally improves the self-awareness accuracy and self-optimization efficiency of the database system, achieving truly intelligent autonomous operation and maintenance.

[0092] It should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention and are not intended to limit it. Although the present invention has been described in detail with reference to preferred embodiments, those skilled in the art should understand that modifications or equivalent substitutions can be made to the technical solutions of the present invention without departing from the spirit and scope of the technical solutions of the present invention, and all such modifications or substitutions should be covered within the scope of the claims of the present invention.

Claims

1. A large model driven DataAI Plus system, characterized in that: include, The data acquisition module collects structured operation and maintenance data, unstructured log data, and multimodal external data in real time, performs data cleaning, format alignment, and feature extraction, and generates a unified time-series feature vector set; the data cleaning, format alignment, and feature extraction are described above. Includes the following steps, The collected multimodal raw data is processed by outlier removal, missing value imputation, and noise filtering to generate a normalized dataset; The normalized dataset is converted into a unified time-series format through timestamp synchronization and semantic mapping to obtain a time-series aligned data stream. Using time-domain feature extractors, frequency-domain feature extractors, and semantic feature extractors, multi-dimensional feature mining is performed on time-aligned data streams to form a unified time-series feature vector set. The analysis module inputs a unified time-series feature vector set into the large-scale intelligent hub and generates a system health status assessment matrix and anomaly detection report through cross-modal correlation analysis. The large-scale intelligent hub adopts a fusion architecture of a pre-trained language model and a time-series prediction model. The decision-making module generates an optimization strategy instruction set based on the system health status assessment matrix and anomaly detection reports through an autonomous decision-making mechanism. The execution module sends the strategy instruction set to the database kernel layer, automatically performs index rebuilding, resource scheduling and transaction rollback operations, and generates strategy execution results. The update module continuously monitors the strategy execution results, collects system performance data and multimodal operation and maintenance feedback, generates a reinforcement learning training sample set, inputs the reinforcement learning training sample set into the large model intelligent hub for reinforcement learning training, and updates the knowledge base and weight parameters. The process of generating a system health status assessment matrix and anomaly detection report through cross-modal correlation analysis includes the following steps: After receiving a unified temporal feature vector set, the large model intelligent hub performs cross-modal semantic alignment through a self-attention mechanism to generate an inter-modal correlation weight matrix. Feature fusion and context modeling are performed on the intermodal correlation weight matrix to obtain a cross-modal joint representation vector, including: The intermodal correlation weight matrix is ​​combined with the multimodal feature vectors in the unified temporal feature vector set by a weighted summation algorithm to obtain a preliminary fused feature representation; The preliminary fusion feature representation uses a long short-term memory network to capture long-term dependencies in the unified temporal feature vector set through a gating mechanism, and combines the self-attention mechanism of the Transformer architecture to capture the global relevance weights of the unified temporal feature vector set, generating context-enhanced feature representations; The context-enhanced feature representation is transformed and its dimensions are adjusted by a multilayer perceptron and a convolutional neural network to generate a deep integrated feature representation. The deep integrated feature representation is then processed by a normalization layer to obtain the cross-modal joint representation vector. The database system for large-scale intelligent central management utilizes cross-modal joint representation vectors to perform multi-dimensional evaluation of system status and anomaly detection, thereby obtaining a system health status evaluation matrix and anomaly detection report.

2. The DataAI Plus system driven by a large model as described in claim 1, characterized in that: The structured operation and maintenance data includes CPU utilization, memory utilization, disk I / O throughput, and network traffic metrics; the unstructured log data includes database slow query logs, transaction logs, and error logs; and the multimodal external data includes operation and maintenance documents, operation and maintenance screenshots, and operation and maintenance voice recordings.

3. The DataAI Plus system driven by a large model as described in claim 1, characterized in that: The process of generating an optimization strategy instruction set through an autonomous decision-making mechanism includes the following steps. A multi-strategy collaborative generation mechanism performs in-depth analysis and decision reasoning on the system health status assessment matrix and anomaly detection report to obtain a preliminary set of optimization strategies. The initial set of optimization strategies is verified and optimized by using historical operation and maintenance cases stored in the pre-set knowledge base to obtain the verified strategy solution. The validated strategy scheme is evaluated using a multi-objective particle swarm optimization algorithm, which balances resource consumption with performance gains, and an optimized strategy instruction set is generated.

4. The DataAI Plus system driven by a large model as described in claim 1, characterized in that: The automatic execution of index reconstruction, resource scheduling, and transaction rollback operations to generate strategy execution results includes the following steps: The optimization strategy instruction set is parsed to obtain the index rebuilding instruction, and the index structure optimization operation is executed by calling the database kernel interface through the execution module, generating the index rebuilding execution result. Based on the index reconstruction execution result, the resource scheduler is triggered to perform dynamic resource allocation and load balancing adjustment, and a resource scheduling execution report is generated. Initiate transaction monitoring based on the resource scheduling execution report, identify abnormal transactions in the resource scheduling execution report, detect and roll back abnormal transactions, and generate transaction rollback operation logs; The index reconstruction execution results, resource scheduling execution reports, and transaction rollback operation logs are integrated into the policy execution results.

5. The DataAI Plus system driven by a large model as described in claim 1, characterized in that: The execution result of the continuous detection strategy includes the following steps. After receiving the strategy execution results, the multimodal output interface extracts key performance indicators and operation log information through data parsing to generate structured output data; Structured output data is transformed into performance metrics and topology diagrams through multimodal transformation to generate visual operation and maintenance reports; Visualized operation and maintenance reports, voice broadcast warnings, and dynamic demonstration videos are integrated into a multimodal operation and maintenance data set. Through real-time collection and analysis of the multimodal operation and maintenance data set, evaluation data on the effectiveness of policy execution is generated.

6. The DataAI Plus system driven by a large model as described in claim 1, characterized in that: The process of collecting system performance data and multimodal operation and maintenance feedback to generate a reinforcement learning training sample set includes the following steps. The system receives performance data and multimodal operation and maintenance feedback in real time through a multi-source data acquisition interface. The system performance data and multimodal operation and maintenance output data are verified for integrity and noise filtered through a data quality assessment mechanism to generate a standardized feedback dataset. The standardized feedback dataset is processed by feature standardization and sample labeling to generate a reinforcement learning training sample set.

7. The DataAI Plus system driven by a large model as described in claim 1, characterized in that: The process of inputting the reinforcement learning training sample set into the large model intelligent center for reinforcement learning training includes the following steps: The reinforcement learning training sample set is input into the policy network and value network of the large model's intelligent hub. The policy gradient and value function parameters are calculated through the proximal policy optimization algorithm to generate updated policy network parameters and value function parameters. The updated policy network parameters and value function parameters are optimized through multi-objective fusion to obtain the advantage function. The advantage function parameters are then calculated using the generalized advantage estimation algorithm to generate the final weight parameters. The final weight parameters are deployed to the online inference environment of the large model's intelligent hub for reinforcement learning training.

Images