Method and system for predicting residual useful life of bearing based on vector space retrieval

Abstract

The application relates to the technical field of bearing life prediction, in particular to a bearing residual service life prediction method and system based on vector space retrieval. The method comprises the following steps: receiving a bearing operation data sequence and converting the bearing operation data sequence into an index key vector; encapsulating the vector and a life label into a key-value pair storage object and writing the key-value pair storage object into a persistent storage area. A space division index tree is initialized based on the persistent storage area, the data object is mounted to a data leaf node, a routing jump pointer is established between the leaf nodes to form a vector graph index topology, and a traversal depth constraint value is set according to the topology density. When inquiring, a request key vector is generated, a greedy priority search is triggered in the vector graph topology, and a candidate index node set is locked. Finally, weighted aggregation based on the inverse of the Euclidean distance is performed, and a prediction value is output. The application optimizes the index structure and retrieval mechanism, solves the problems of fast addressing and real-time retrieval efficiency of a large amount of feature data, and improves the system reliability and query response speed.

Description

Technical Field

[0001] This invention relates to the field of bearing life prediction, specifically to a method and system for predicting the remaining service life of bearings based on vector space retrieval. Background Technology

[0002] As a core component of rotating machinery, the health of rolling bearings directly affects the operational safety of the entire mechanical system. With the development of Industry 4.0 intelligent manufacturing, accurate prediction of the remaining service life of bearings has become a key technology for reducing unplanned downtime and lowering maintenance costs. Currently, data-driven prediction methods are gradually becoming mainstream, the core idea of ​​which is to use historical monitoring data to extrapolate the current degradation state.

[0003] In existing technical solutions, a simple prediction is typically made by combining a stream processing framework with statistical indicators. For example, Spark Streaming can be used to calculate the "average of the sum of squares" of the horizontal and vertical accelerations of a bearing during operation, and this average can be compared with the key values ​​in a historical map. The time corresponding to the key with the smallest absolute difference is selected as the prediction result.

[0004] However, this method has significant limitations: it compresses complex time-series vibration signals into a single scalar value (i.e., the average energy) for matching. In actual operating conditions, different fault stages or different fault types of bearings (such as outer ring spalling and roller wear) may exhibit similar vibration energy amplitudes, but they differ significantly in high-dimensional features such as frequency distribution and waveform texture. Relying solely on one-dimensional numerical matching can easily lead to misjudgments of "different diseases appearing as the same," resulting in low prediction accuracy.

[0005] On the other hand, the management and application of bearing data establishes multiple mapping relationships by associating bearing attributes, customer information, and production data through MEMS sensor IDs. However, this existing technology mainly addresses the issues of static data association and storage, as well as full lifecycle information traceability. Its database architecture is based on precise queries in relational databases (based on ID matching), and it cannot achieve "similarity retrieval" of massive amounts of unstructured vibration waveform data. In other words, the system cannot answer the crucial prediction question: "Which bearing's failure precursor is most similar to the current operating state of the bearing in the historical database?"

[0006] With the increasing frequency of sensor acquisition, bearing monitoring data is becoming increasingly massive and dimensional. Traditional methods based on single threshold comparison or shallow neural networks either suffer from low feature utilization or have long model training cycles and poor interpretability. How to transform complex bearing vibration signals into a data structure that can be efficiently processed by computers, and how to quickly and accurately retrieve similar degradation trajectories from massive historical data to extrapolate future lifespan using historical examples, is a pressing technical challenge in the field of predictive maintenance for bearings.

[0007] To address this, the present invention proposes a method and system for predicting the remaining service life of bearings based on vector space retrieval. This method can retain multi-dimensional feature information of signals and utilize vector space retrieval technology to achieve accurate and low-latency matching prediction of the remaining service life of bearings in a massive historical database. Summary of the Invention

[0008] The purpose of this invention is to provide a method and system for predicting the remaining service life of bearings based on vector space retrieval. By encapsulating bearing time-series operation data, constructing a vector graph index topology with spatial quantization mapping and routing jump pointers in a vector database, and utilizing a greedy priority graph search process constrained by traversal depth, the mapping between historical state retrieval and remaining service life based on vector space distance is realized.

[0009] To achieve the above objectives, the present invention provides the following technical solution:

[0010] A method for predicting the remaining service life of bearings based on vector space retrieval includes:

[0011] Receive bearing operation data sequence, use encoding protocol to convert operation data sequence into index key vector, use index key vector as key value, encapsulate associated historical life data as attribute metadata, generate key value pair storage object, and write key value pair storage object into persistent storage area of ​​vector database;

[0012] The persistent storage area of ​​the vector database is initialized with a spatial partitioning index tree. The key-value pair storage objects are mounted to the data leaf nodes at the bottom of the spatial partitioning index tree using spatial vector clustering rules. Routing jump pointers are established between the data leaf nodes to form a vector graph index topology. The traversal depth constraint value is set according to the connection density of the vector graph index topology.

[0013] The system receives the target data to be predicted and generates a query request key vector. It triggers a greedy search process in the vector graph index topology, uses the route jump pointer to perform node jump access, controls the extension range of the search path based on the traversal depth constraint value, locks the candidate index node set whose spatial distance from the query request key vector meets the preset conditions, extracts attribute metadata from the candidate index node set, performs weighted aggregation operation, and outputs the remaining lifetime prediction value.

[0014] Preferably, the specific process of converting the running data sequence into an index key vector using the encoding protocol includes: receiving a bearing running data sequence, the running data sequence including bearing vibration acceleration data; calling a variational mode decomposition algorithm, setting a convergence threshold parameter, and converting the running data sequence into an orthogonal component sequence; performing a dimension mapping transformation on the orthogonal component sequence to generate a two-dimensional feature distribution matrix; inputting the two-dimensional feature distribution matrix into a preset convolutional encoder, performing texture mapping using convolutional layers, performing data dimensionality reduction using pooling layers, and flattening the dimensionality-reduced data into the index key vector through a fully connected layer.

[0015] Preferably, the specific process of generating key-value pair storage objects and writing them into the persistent storage area of ​​the vector database includes: initializing a compact data serialization protocol and constructing a binary storage frame structure containing a metadata header field and a payload field; filling the metadata header field with the historical lifetime data, filling the payload field with the index key vector, performing serialization encoding to generate a fixed-length binary data block, and using the fixed-length binary data block as the key-value pair storage object; allocating a heap file storage page in the persistent storage area of ​​the vector database and locking the current write offset pointer of the heap file storage page; locating the physical address according to the current write offset pointer and appending the fixed-length binary data block to the heap file storage page; and registering the physical address as the address handle of the key-value pair storage object.

[0016] Preferably, the specific process of initializing the spatial partitioning index tree in the persistent storage area based on the vector database includes: reading the index key vector from the persistent storage area to construct a calibration dataset, pre-setting the number of feature clusters and setting an initial reference vector; calling an iterative clustering algorithm to compare the Euclidean distance values ​​of the vectors in the calibration dataset to the initial reference vector, and assigning the vectors to the corresponding reference groups according to the Euclidean distance values; performing mean aggregation processing on the vectors in the reference groups, updating the coordinates of the initial reference vector using the aggregation results, until the coordinate values ​​of the reference vectors are stable, and generating a quantized codebook vector; defining the boundary of the subspace region according to the quantized codebook vector, instantiating data leaf nodes for the subspace region, and writing the quantized codebook vector into the navigation attribute field of the data leaf node to complete the coarse-grained partitioning of the spatial partitioning index tree.

[0017] Preferably, the specific process of establishing routing jump pointers between data leaf nodes to form a vector graph index topology includes: setting a neighbor connection quota parameter and an in-degree connection constraint threshold for the small-world nearest neighbor graph; selecting a target data leaf node to be connected to the vector graph index topology, and obtaining the index key vector of an existing node from the spatial partitioning index tree as a traversal search entry point; performing a greedy traversal operation based on the traversal entry point to obtain a set of candidate neighbor nodes whose Euclidean distance values ​​to the index key vector of the target data leaf node are arranged in ascending order within a preset number range; performing heuristic pruning based on distance weight and connection angle distribution on the candidate neighbor node set to filter out the neighbor node set and extract the address handle of each node; writing the address handle into the adjacency routing table of the target data leaf node to generate a routing jump pointer; simultaneously, checking the number of in-degree connections of the neighbor node set, and when the number of in-degree connections is lower than the in-degree connection constraint threshold, writing the address handle of the target data leaf node in reverse to the adjacency routing table of the neighbor node set to establish a bidirectional graph interconnection structure.

[0018] Preferably, the specific process of setting the traversal depth constraint value based on the connection density of the vector graph index topology includes: counting the number of routing jump pointer entries maintained by the data leaf nodes in the vector graph index topology, performing average processing on the number of entries to obtain an average connectivity value; calling a preset search breadth coefficient, performing a multiplication operation between the average connectivity value and the search breadth coefficient to obtain a search range reference value; writing the search range reference value into the running parameter register of the retrieval engine, and defining the length limit of the candidate neighbor queue dynamically maintained in the graph traversal addressing operation as the traversal depth constraint value.

[0019] Preferably, the specific process of locking the candidate index node set whose spatial distance from the query request key vector meets the preset conditions includes: initializing the candidate neighbor queue according to the traversal depth constraint value; obtaining the query request key vector generated based on the target data to be predicted, writing the entry node of the vector graph index topology into the candidate neighbor queue, and sorting it in ascending order according to the Euclidean distance value with the query request key vector; starting the iterative retrieval logic, reading the first node of the candidate neighbor queue as the current anchor point, and traversing the associated neighbor nodes through the route jump pointer; comparing the Euclidean distance value between the associated neighbor node and the query request key vector, and comparing it with the distance value of the last node in the candidate neighbor queue; when the Euclidean distance value is less than the distance value of the last node, inserting the associated neighbor node into the corresponding sorting position in the candidate neighbor queue, and removing nodes that overflow the list length; iterating in a loop until the retrieval logic is completed, and locking the nodes remaining in the candidate neighbor queue as the candidate index node set.

[0020] Preferably, the specific process of extracting attribute metadata from the candidate index node set, performing weighted aggregation operation, and outputting the remaining useful life prediction value includes: traversing the candidate index node set, reading the attribute metadata stored in each node as historical reference values, and obtaining the vector space Euclidean distance value between each node and the query request key vector; performing a reciprocal operation on the vector space Euclidean distance value to generate an original weight factor, and performing an accumulation operation on the original weight factor to obtain a weight normalization base; performing a division operation on the original weight factor using the weight normalization base to obtain a normalized weight coefficient; performing a multiplication operation on the normalized weight coefficient and the historical reference value to generate a weighted component value, performing a summation operation on all the weighted component values, and outputting the summation result as the remaining useful life prediction value.

[0021] A bearing remaining service life prediction system based on vector space retrieval includes:

[0022] The data encapsulation and persistence module is configured to receive bearing operation data sequences, convert the operation data sequences into index key vectors using an encoding protocol, use the index key vectors as key values, encapsulate the associated historical life data as attribute metadata, generate key-value pair storage objects, and write the key-value pair storage objects into the persistent storage area of ​​the vector database.

[0023] The spatial index topology construction module is configured to initialize a spatial partitioning index tree based on the persistent storage area of ​​the vector database, use spatial vector clustering rules to mount the key-value pair storage objects to the data leaf nodes at the bottom layer of the spatial partitioning index tree, establish routing jump pointers between the data leaf nodes to form a vector graph index topology, and set traversal depth constraint values ​​according to the connection density of the vector graph index topology.

[0024] The vector graph addressing module is configured to receive target data to be predicted and generate a query request key vector, trigger a greedy first search process in the vector graph index topology, perform node jump access using the routing jump pointer, control the extension range of the search path according to the traversal depth constraint value, lock the candidate index node set whose spatial distance from the query request key vector meets the preset conditions, extract the attribute metadata from the candidate index node set, perform a weighted aggregation operation to output the remaining lifetime prediction value.

[0025] Compared with the prior art, the beneficial effects of the present invention are as follows:

[0026] 1. This invention converts bearing operation data into index key vectors using an encoding protocol, and constructs a vector graph index topology by combining a spatial partitioning index tree with routing jump pointers. During the retrieval phase, a greedy priority search process is triggered, which transforms full database traversal matching into local graph traversal. This reduces the number of distance calculations during the query process, lowers the retrieval computation overhead under large-scale historical data, and shortens the data processing response time.

[0027] 2. This invention encapsulates the index key vector and historical lifetime attribute metadata into key-value pair storage objects, and persistently stores them by locating the physical address based on the current write offset pointer. This achieves compact association storage of data features and business tags. When performing weighted aggregation operations, attribute metadata can be read directly through the address handle, reducing unnecessary disk seek operations and improving data read and write efficiency.

[0028] 3. This invention defines subspace regions through spatial quantization mapping rules, forms interconnected vector graph index topology using routing jump pointers, and locks multiple candidate index node sets for weighted aggregation based on traversal depth constraints, thereby achieving consensus prediction based on multi-sample similarity. The invention also reduces the impact of single historical sample bias on prediction results through a distance inverse weighting mechanism, thus improving the stability of prediction results under different data distributions.

[0029] 4. This invention generates a two-dimensional feature distribution matrix by calling a multi-scale data decomposition protocol and a convolutional encoder and maps it to an index key vector. At the same time, it dynamically sets the traversal depth constraint value according to the connection density of the vector graph index topology, realizing the effective mapping of physical state features to vector space distance. Furthermore, it adaptively adjusts the extension range of the search path according to the data distribution density, ensuring that the historical cases retrieved in the vector space have structural similarity to the target to be tested. Attached Figure Description

[0030] Figure 1 This is a flowchart illustrating the bearing remaining service life prediction method based on vector space retrieval of the present invention.

[0031] Figure 2 This is a logical diagram illustrating the greedy search and metadata extraction steps of the vector graph in an embodiment of the present invention;

[0032] Figure 3 This is a schematic diagram of the bearing remaining service life prediction system based on vector space retrieval according to the present invention. Detailed Implementation

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

[0034] Please see Figures 1 to 3 This invention provides a method and system for predicting the remaining service life of bearings based on vector space retrieval. The technical solution is as follows:

[0035] Example 1

[0036] Reference Figure 1 This is a schematic diagram of the bearing remaining service life prediction method based on vector space retrieval according to the present invention. This embodiment provides an application scenario for the bearing remaining service life prediction method based on vector space retrieval, and the specific steps include:

[0037] Receive bearing operation data sequence, use encoding protocol to convert operation data sequence into index key vector, use index key vector as key value, encapsulate associated historical life data as attribute metadata, generate key value pair storage object, and write key value pair storage object into persistent storage area of ​​vector database;

[0038] The persistent storage area of ​​the vector database is initialized with a spatial partitioning index tree. The key-value pair storage objects are mounted to the data leaf nodes at the bottom of the spatial partitioning index tree using spatial vector clustering rules. Routing jump pointers are established between the data leaf nodes to form a vector graph index topology. The traversal depth constraint value is set according to the connection density of the vector graph index topology.

[0039] The system receives the target data to be predicted and generates a query request key vector. It triggers a greedy search process in the vector graph index topology, uses the route jump pointer to perform node jump access, controls the extension range of the search path based on the traversal depth constraint value, locks the candidate index node set whose spatial distance from the query request key vector meets the preset conditions, extracts attribute metadata from the candidate index node set, performs weighted aggregation operation, and outputs the remaining lifetime prediction value.

[0040] Furthermore, the specific process of converting the running data sequence into an index key vector using the encoding protocol includes: receiving a bearing running data sequence, the running data sequence including bearing vibration acceleration data; calling a variational mode decomposition algorithm, setting a convergence threshold parameter, and converting the running data sequence into an orthogonal component sequence; performing a dimension mapping transformation on the orthogonal component sequence to generate a two-dimensional feature distribution matrix; inputting the two-dimensional feature distribution matrix into a preset convolutional encoder, performing texture mapping using convolutional layers, performing data dimensionality reduction using pooling layers, and flattening the dimensionality-reduced data into the index key vector through a fully connected layer.

[0041] Specifically, bearing vibration acceleration data with a sampling frequency of 12kHz and a data length of 2048 points are received as the running data sequence. A variational mode decomposition algorithm, an iterative optimization method, is invoked. A convergence threshold parameter is set to control the mode decomposition. (e.g., 1e-6), controlling the accuracy and stability of the iteration. The modal decomposition layer number K is set to 4, and the quadratic penalty factor is set to 2000. The protocol executes iterative calculations until the change in the modal center frequency or the mode itself between two consecutive iterations is lower than the convergence threshold parameter. The process stops at a certain point, outputting four sets of orthogonal component sequences (called Intrinsic Mode Functions, IMFs) with non-overlapping frequency bands. A Hilbert transform is then performed on each of these four sets of orthogonal component sequences to extract their instantaneous frequencies. With instantaneous amplitude The data completes the dimensional mapping transformation of the signal from a one-dimensional time domain to a two-dimensional time-frequency space. Instantaneous vibration snapshots serve as the severity and key physical characteristics of the current fault mode; similar instantaneous vibration feature vectors correspond to similar current damage states and remaining lifetimes. Then, the two-dimensional feature matrix construction process is initiated: Frequency quantization: The frequency range is set to 0 to 6 kHz and uniformly quantized into 224 discrete frequency layers (vertical axis). Time quantization: The 2048 sampling points are linearly interpolated and mapped to 224 time points (horizontal axis). Instantaneous energy spectrum construction: At each time point... Above, for all The IMF component is used to obtain its instantaneous amplitude. This energy contribution is then accumulated into the corresponding instantaneous frequencies of the 224 frequency layers. At the corresponding frequency level. The amplitude is used as the color depth of the heatmap (the instantaneous amplitude is normalized and then used as the pixel value). Resampling and generation: Through image processing techniques such as bilinear interpolation, the accumulated discrete instantaneous energy spectrum is resampled and mapped to generate a resolution of [resolution missing]. Two-dimensional feature distribution matrix of pixels.

[0042] The matrix is ​​input into a preset convolutional encoder, which contains two convolutional layers, 32 convolutional kernels, and a kernel size of [missing value]. A first max pooling layer with a stride of 1, same padding, and ReLU activation function; two first max pooling layers with a stride of 2; 64 convolutional kernels, kernel size [missing information]. The convolutional layers consist of two max-pooling layers with a stride of 1, same padding, and ReLU activation function, and a second max-pooling layer with a stride of 2. The texture mapping process performed by the convolutional layers includes: using the sliding operation of the convolutional kernel to extract and transform features from the two-dimensional feature distribution matrix to capture the dynamic texture features of signal energy in the time-frequency plane. The pooling layers perform data dimensionality reduction using the max operation, shrinking the feature map size to [a smaller value]. The input matrix has a size of 1. After two convolutional layers and two pooling layers, the feature map size is finally reduced to [size missing]. Finally, a fully connected layer with 128 nodes flattens the multidimensional feature map and maps it into a 128-dimensional floating-point array, which is the index key vector.

[0043] This invention transforms non-stationary physical vibration signals into orthogonal component spectra containing time-frequency texture information, and uses convolutional networks for feature extraction and dimensionality reduction encoding. This enables the transformation of high-dimensional and complex time-series waveform data into fixed-length feature vectors that can be stored and measured in a database, thus providing a standardized data foundation for subsequent vector retrieval operations.

[0044] Furthermore, the specific process of generating key-value pair storage objects and writing them into the persistent storage area of ​​the vector database includes: initializing a compact data serialization protocol and constructing a binary storage frame structure containing a metadata header field and a payload field; filling the metadata header field with the historical lifetime data, filling the payload field with the index key vector, performing serialization encoding to generate a fixed-length binary data block, and using the fixed-length binary data block as the key-value pair storage object; allocating a heap file storage page in the persistent storage area of ​​the vector database and locking the current write offset pointer of the heap file storage page; locating the physical address based on the current write offset pointer and appending the fixed-length binary data block to the heap file storage page; and registering the physical address as the address handle of the key-value pair storage object.

[0045] Specifically, a compact data serialization protocol is initialized. This protocol is a fixed-length binary encoding rule that constructs a 520-byte binary storage frame structure. This frame structure includes an 8-byte metadata header field (used to fill historical lifetime data, e.g., 4 bytes for lifetime value and 4 bytes for timestamp) and a 512-byte payload field (used to fill a 128-dimensional floating-point index key vector). Data from memory is filled into the corresponding fields. Serialization encoding is performed, specifically: first, following little-endian byte order, the 8-byte metadata header field (historical lifetime data) is read from memory and written to the beginning of the 520-byte frame; then, following the same little-endian byte order, a 512-byte data block of the 128-dimensional floating-point index key vector is appended to the metadata header field. This process ensures that the byte order of data types remains consistent during inter-data transfer, ultimately generating a 520-byte fixed-length binary data block, which is the key-value pair storage object. In the persistent storage area of ​​the vector database, an 8KB heap file storage page (the smallest unit of a file) is allocated. The current write offset pointer of the heap file storage page is locked, indicating the starting position of the data block within the current storage page. Based on this current write offset pointer and the global file ID of the storage page, the physical address of the data block on the physical storage medium (SSD) is located. The fixed-length binary data block is appended to a free location in the heap file storage page. Finally, the file ID, page number, and page offset are encoded into a 64-bit value and registered as the address handle of the key-value pair storage object. This handle will serve as the target address for the routing jump pointer of the vector graph index in memory.

[0046] This invention achieves standardized management of data storage space by adopting a fixed-length binary frame structure and a compact serialization protocol, eliminating the fragmentation problem caused by variable-length records; by using an offset-based append writing method and a physical address direct addressing mechanism, it reduces disk seek time and metadata parsing overhead, thereby improving the throughput of the database in large-scale write scenarios.

[0047] Furthermore, the specific process of initializing the spatial partitioning index tree in the persistent storage area based on the vector database includes: reading the index key vector from the persistent storage area to construct a calibration dataset, pre-setting the number of feature clusters and setting an initial reference vector; calling an iterative clustering algorithm to compare the Euclidean distance values ​​of the vectors in the calibration dataset to the initial reference vector, and assigning the vectors to the corresponding reference groups according to the Euclidean distance values; performing mean aggregation processing on the vectors in the reference groups, updating the coordinates of the initial reference vector using the aggregation results, until the coordinate values ​​of the reference vectors are stable, and generating a quantized codebook vector; defining the boundary of the subspace region according to the quantized codebook vector, instantiating data leaf nodes for the subspace region, and writing the quantized codebook vector into the navigation attribute field of the data leaf node to complete the coarse-grained partitioning of the spatial partitioning index tree.

[0048] Specifically, 100,000 index key vectors are randomly sampled and read from the persistent storage area of ​​the vector database to form a calibration dataset in memory. The number of feature clusters is set to 1024, and 1024 vectors are randomly selected from the calibration dataset as initial reference vectors. An iterative clustering algorithm, specifically the K-means iterative clustering algorithm, is executed to calculate the Euclidean distance from each vector in the calibration dataset to the 1024 initial reference vectors. Each vector is then labeled and assigned to the reference group with the smallest distance value. Subsequently, an arithmetic mean is calculated for all vectors within each reference group (mean aggregation processing), and the calculated average coordinates are assigned to the corresponding reference vector as the coordinates for the next iteration. This process is repeated until the coordinate changes of all 1024 reference vectors (defined as the sum of squared Euclidean distances across all corresponding coordinate dimensions) between two consecutive iterations are less than a preset stability threshold (e.g., 1e-4). The 1024 center vectors generated at this point are the quantized codebook vectors. Based on these 1024 quantized codebook vectors, 1024 Voronoi subspace regions are defined in the vector space. 1024 corresponding data leaf node data structures (such as inverted linked list head nodes) are instantiated in memory, and the corresponding quantized codebook vectors are filled into the navigation attribute fields of each data leaf node. After the instantiation of the data leaf nodes is completed, a data mounting operation is performed: for each index key vector in the persistent storage area, its Euclidean distance to all quantized codebook vectors is calculated, and the index key vector is assigned to the data leaf node corresponding to the quantized codebook vector with the smallest distance. The address handle of this data leaf node is appended to the corresponding inverted linked list head node, establishing a spatial partitioning index tree for fast subspace location.

[0049] This invention discretizes a continuous high-dimensional vector space into a finite number of subspace regions through an iterative clustering algorithm and constructs a coarse-grained index structure based on a quantized codebook, thereby realizing spatial partitioning management of massive vector data. During retrieval, the search range can be quickly narrowed by comparing the codebook, avoiding brute-force scanning of the entire database and significantly reducing the computational complexity and memory consumption of retrieval on large-scale datasets.

[0050] Further, the specific process of establishing routing jump pointers between data leaf nodes to form a vector graph index topology includes: setting a neighbor connection quota parameter and an in-degree connection constraint threshold for the small-world nearest neighbor graph; selecting a target data leaf node to be connected to the vector graph index topology, and obtaining the index key vector of existing nodes from the spatial partitioning index tree as a traversal search entry point; performing a greedy traversal operation based on the traversal entry point to obtain a set of candidate neighbor nodes whose Euclidean distance values ​​to the index key vector of the target data leaf node are arranged in ascending order within a preset number range; performing heuristic pruning based on distance weight and connection angle distribution on the candidate neighbor node set to filter out the neighbor node set and extract the address handle of each node; writing the address handle into the adjacency routing table of the target data leaf node to generate a routing jump pointer; simultaneously, checking the number of in-degree connections of the neighbor node set, and when the number of in-degree connections is lower than the in-degree connection constraint threshold, writing the address handle of the target data leaf node in reverse to the adjacency routing table of the neighbor node set to establish a bidirectional graph interconnection structure. (Refer to...) Figure 2 This is a logical schematic diagram of the vector graph greedy priority search and metadata extraction steps of the present invention.

[0051] Specifically, after completing the coarse-grained partitioning of the spatial partitioning index tree, the data processing flow continues to build the vector graph index topology. First, the connection constraint parameters of the graph topology need to be set: the neighbor connection quota parameter M for the small-world nearest neighbor graph is set to 32, meaning each node can have a maximum of 32 out-degree connections; simultaneously, the in-degree connection constraint threshold M is set. max The value is set to 48 to prevent overly densely connected supernodes. The target data leaf node (i.e., each key-value pair storage object) to be integrated into the vector graph index topology is selected, and its own index key vector serves as the starting point for subsequent traversal searches. The data processing flow obtains the index key vectors of existing nodes from the spatial partitioning index tree as the traversal search entry point. Based on this traversal entry point, a greedy traversal operation is performed, extending the search process along the closer directions to obtain a set of candidate neighbor nodes whose Euclidean distance values ​​to the target data leaf node's index key vector are arranged in ascending order within a preset number range. Here, the preset number range (search efficiency parameter) is set to 128.

[0052] Subsequently, a heuristic pruning based on distance weight and connection angle distribution is performed on the candidate neighbor node set. This pruning operation first selects the M nearest nodes based on distance weight, and then eliminates redundant connections with too small an angle between them by evaluating the connection angle distribution of these nodes, ensuring that the 32 finally selected neighbor nodes are evenly distributed in the vector space. The address handles of the final neighbor nodes are extracted and written into the adjacency routing table of the target data leaf node to generate a route jump pointer. At the same time, the number of in-degree connections of the neighbor node set is checked. When the number of in-degree connections is lower than the in-degree connection number constraint threshold (48), the address handle of the target data leaf node is written in reverse to the adjacency routing table of the neighbor node set to establish a bidirectional graph interconnection structure.

[0053] The specific process of establishing routing jump pointers between data leaf nodes to form a vector graph index topology includes: assigning connection levels to the target data leaf nodes according to a random level allocation probability function; checking the number of in-degree connections in the preferred neighbor node set at each level and calculating the Lorenz balance index of the number of in-degree connections; and dynamically adjusting the in-degree connection number constraint threshold based on the Lorenz balance index to achieve load balancing optimization of the vector graph index topology.

[0054] After the bidirectional connections are constructed, the distribution of the number of in-degree connections of the preferred neighbor nodes at each level is checked, and the Lorenz equilibrium index G of these in-degree connections is calculated. The G index quantifies the uniformity of the distribution of the number of in-degree connections. Its calculation is based on the area difference between the actual cumulative distribution and the theoretically perfectly uniform distribution after sorting the in-degree connections of all neighbor nodes. If the G value is too high (indicating uneven connection distribution and the existence of hotspot nodes), the in-degree connection constraint threshold will be dynamically reduced (e.g., from 32 to 28). This dynamic adjustment process, based on the Lorenz equilibrium index, aims to prevent high-in-degree nodes that have become "hotspots" from continuing to receive new reverse connections, forcing new nodes to establish connections with sparse nodes with lower in-degree connections, thus achieving load balancing optimization of the vector graph index topology. This scheme, by introducing a multi-level structure and a dynamic constraint threshold adjustment mechanism based on the Lorenz equilibrium index, achieves load balancing optimization of the graph index topology, significantly improving the stability and throughput of retrieval in high-concurrency scenarios.

[0055] This invention constructs a vector graph index topology with small-world characteristics, and optimizes the spatial distribution diversity of connections while ensuring connectivity between nodes using greedy traversal and heuristic pruning strategies. It enables fast navigation in high-dimensional data space, reducing the time complexity of the retrieval process from linear to logarithmic, and greatly improving the efficiency of dynamic insertion and nearest neighbor query of massive vector data.

[0056] Furthermore, the specific process of setting the traversal depth constraint value based on the connection density of the vector graph index topology includes: counting the number of routing jump pointer entries maintained by the data leaf nodes in the vector graph index topology, performing average processing on the number of entries to obtain an average connectivity value; calling a preset search breadth coefficient, performing a multiplication operation between the average connectivity value and the search breadth coefficient to obtain a search range reference value; writing the search range reference value into the running parameter register of the retrieval engine, and defining the length limit of the candidate neighbor queue dynamically maintained in the graph traversal addressing operation as the traversal depth constraint value.

[0057] Specifically, the background monitoring process of the search engine periodically scans the vector graph index topology in memory. Assuming the current graph contains 1,000,000 data leaf nodes, the total number of actively established route jump pointers (i.e., total out-degree) in the adjacency routing tables of all nodes is accumulated, assuming a cumulative value of 16,000,000. An arithmetic mean is calculated, yielding an average connectivity value of 16 (i.e., each node actively connects to an average of 16 neighbors). The pre-defined search breadth coefficient in the configuration file is called, for example, set to 8 (this coefficient defines the ratio of the search field of view to the graph density). The processor performs a multiplication operation: 16 multiplied by 8, resulting in the value 128 as a reference value for the search range. The value 128 is written to the search engine's runtime parameter register (corresponding to the efSearch parameter in the graph algorithm). In subsequent graph traversal and addressing operations, this value 128 is forcibly defined as the length limit of the dynamically maintained candidate neighbor queue (priority queue). When the queue is filled with 128 nodes and the distance of a newly explored node is less than the last node in the queue, the queue is updated and exploration continues; only when the distance of a newly explored node is greater than the last node in the queue, the search path stops extending, thus establishing 128 as the current traversal depth constraint value.

[0058] The specific process of calling the preset search breadth coefficient includes: collecting query latency data of the retrieval engine and recall data of the vector database in real time, and constructing a latency-recall curve model; determining the search breadth coefficient corresponding to the minimum query latency that meets the current recall target based on the latency-recall curve model; and injecting the determined search breadth coefficient into the configuration parameters of the retrieval engine.

[0059] The search engine's online monitoring module periodically records the P95 latency (95th percentile latency) of actual query requests and the query recall rate based on a preset standard dataset. A non-linear latency-recall curve is constructed using these real-time data points. Assuming the current business requirement is a recall target of 98%, the minimum search breadth coefficient (e.g., 8.5) corresponding to achieving 98% recall is determined through a reverse lookup using the curve model. Subsequently, this dynamically calculated coefficient of 8.5 overwrites the static coefficient in the configuration file and becomes the currently running search breadth coefficient. This solution achieves intelligent and adaptive calibration of the search breadth coefficient, ensuring that the optimal balance between the recall target and query latency performance is always found, improving the responsiveness to business needs.

[0060] This technical solution establishes a dynamic mapping relationship between traversal depth constraint values ​​and vector graph topology connection density, thereby enabling adaptive adjustment of the retrieval strategy. It avoids the problems of insufficient recall due to searching too shallowly in sparse graphs or wasting computational resources due to searching too deeply in dense graphs, thus optimizing query response latency while ensuring retrieval recall accuracy.

[0061] Further, the specific process of locking the candidate index node set whose spatial distance from the query request key vector meets the preset conditions includes: initializing the candidate neighbor queue according to the traversal depth constraint value; obtaining the query request key vector generated based on the target data to be predicted, writing the entry node of the vector graph index topology into the candidate neighbor queue, and sorting it in ascending order according to the Euclidean distance value with the query request key vector; starting the iterative retrieval logic, reading the first node of the candidate neighbor queue as the current anchor point, and traversing the associated neighbor nodes through the route jump pointer; comparing the Euclidean distance value between the associated neighbor node and the query request key vector, and comparing it with the distance value of the last node in the candidate neighbor queue; when the Euclidean distance value is less than the distance value of the last node, inserting the associated neighbor node into the corresponding sorting position in the candidate neighbor queue, and removing nodes that overflow the list length; iterating in a loop until the retrieval logic is completed, and locking the nodes remaining in the candidate neighbor queue as the candidate index node set.

[0062] Specifically, the data processing flow first sets the traversal depth constraint value to 64 and initializes the candidate neighbor queue (priority queue) based on this value, with a maximum capacity of 64. The process obtains the query request key vector (128-dimensional floating-point array) generated based on the target data to be predicted, and writes the entry node (highest level) of the vector graph index topology into the candidate neighbor queue, and sorts them in ascending order according to the Euclidean distance value with the query request key vector. The iterative retrieval logic is started: the first node of the candidate neighbor queue is read as the current anchor point, and all its associated neighbor nodes are traversed through the route jump pointer. The Euclidean distance value between the associated neighbor node and the query request key vector is compared with the distance value of the last node in the candidate neighbor queue. When the Euclidean distance value is less than the distance value of the last node, the associated neighbor node is inserted into the corresponding sorting position in the candidate neighbor queue, and nodes that overflow the list length (64) are removed. The loop iterates until the retrieval logic is completed, that is, the distance of the best neighbor around the current anchor point is no longer better than the distance of the last node in the candidate neighbor queue. Finally, the 64 nodes remaining in the candidate neighbor queue are locked as the candidate index node set.

[0063] This invention achieves graph traversal based on greedy best-first search by maintaining a priority queue of fixed capacity and implementing a dynamic distance pruning strategy. While ensuring that the retrieval result approximates the global optimum, it strictly limits memory usage and computation times, avoids the infinite divergence of search paths in massive graphs, and ensures that the time complexity of the retrieval algorithm is controllable.

[0064] Further, the specific process of extracting attribute metadata from the candidate index node set and performing weighted aggregation to output the remaining useful life prediction value includes: traversing the candidate index node set, reading the attribute metadata stored in each node as historical reference values, and obtaining the vector space Euclidean distance value between each node and the query request key vector; performing a reciprocal operation on the vector space Euclidean distance value to generate an original weight factor, and performing an accumulation operation on the original weight factor to obtain a weight normalization base; performing a division operation on the original weight factor using the weight normalization base to obtain a normalized weight coefficient; performing a multiplication operation on the normalized weight coefficient and the historical reference value to generate a weighted component value, performing a summation operation on all the weighted component values, and outputting the summation result as the remaining useful life prediction value.

[0065] Specifically, the search engine identifies a set of candidate index nodes containing three nodes. It iterates through this set: the first node stores historical lifetime data (attribute metadata, i.e., remaining lifetime RUL) of 100 hours, with a Euclidean distance of 0.5 to the query request key vector; the second node has 120 hours, with a distance of 1.0; and the third node has 80 hours, with a distance of 2.0. The reciprocal operation is then performed to generate the original weight factors. To avoid the weight explosion problem caused by the distance approaching zero, the reciprocal operation is performed... Before that, the Euclidean distance values ​​need to be calculated. Apply a very small smoothing constant (e.g., 1e-6) is regularized. This represents the original weight factor for the i-th candidate neighbor. Assuming the smoothing constant's influence is negligible at this distance, the first node has a weight of 2.0 (i.e., 1 divided by 0.5), the second node has a weight of 1.0, and the third node has a weight of 0.5. Summing these three values ​​yields a weight normalization base of 3.5. Next, the normalized weight coefficients are calculated: approximately 0.571 for the first node (2.0 divided by 3.5), approximately 0.286 for the second node, and approximately 0.143 for the third node. These coefficients are multiplied by their corresponding historical lifetimes to generate weighted component values: 57.1 hours, 34.3 hours, and 11.4 hours, respectively. Finally, these three components are summed to obtain a result of 102.8 hours. This summation is then used as the predicted remaining lifetime and output to the user terminal.

[0066] The specific process of generating the original weight factor by performing the reciprocal operation on the Euclidean distance value of the vector space includes: obtaining the connection level of the candidate index node set in the vector graph index topology; performing a multiplication operation based on the level decay coefficient on the original weight factor to generate the level-adjusted original weight factor, and performing a normalization operation.

[0067] Specifically, after obtaining the original weight factors (2.0, 1.0, 0.5), the connection levels of the three candidate nodes in the vector graph topology are examined. Assume the first node (weight 2.0) is connected to level 2, the second node (weight 1.0) is connected to level 1, and the third node (weight 0.5) is connected to level 0. A preset level decay coefficient is used. Decrease as the level L increases (e.g.) =0.8， =0.9， =1.0 The original weighting factors after the new hierarchical adjustment are: the first node. The second node The third node The three adjusted values ​​are summed to obtain a new weighted normalization base of 3.0. All subsequent prediction calculations are based on this adjusted weight. This scheme incorporates the hierarchical structure information of the graph index topology into the distance-weighted prediction mechanism. By assigning decay weights to high-level connections, the influence of global, imprecise neighbors is reduced, thereby improving the prediction accuracy and reliability of local nearest neighbor queries.

[0068] This invention breaks through the limitations of simple averaging in the traditional K-nearest neighbor algorithm by introducing an inverse distance weighted aggregation mechanism, giving greater decision weight to historical samples with low distances; effectively suppressing the interference of edge nodes or noisy samples in the candidate set on the prediction results, and significantly improving the accuracy and robustness of the remaining lifetime prediction.

[0069] Example 2

[0070] Reference Figure 3 This is a schematic diagram of the bearing remaining service life prediction system based on vector space retrieval according to the present invention. This embodiment provides a bearing remaining service life prediction system based on vector space retrieval. The system is deployed in an industrial edge computing server and is used for real-time status monitoring and lifespan early warning of the main shaft bearing of a wind turbine generator. The specific operation steps include:

[0071] The data encapsulation and persistence module is configured to receive bearing operation data sequences, convert the operation data sequences into index key vectors using an encoding protocol, use the index key vectors as key values, encapsulate the associated historical life data as attribute metadata, generate key-value pair storage objects, and write the key-value pair storage objects into the persistent storage area of ​​the vector database.

[0072] The spatial index topology construction module is configured to initialize a spatial partitioning index tree based on the persistent storage area of ​​the vector database, use spatial vector clustering rules to mount the key-value pair storage objects to the data leaf nodes at the bottom layer of the spatial partitioning index tree, establish routing jump pointers between the data leaf nodes to form a vector graph index topology, and set traversal depth constraint values ​​according to the connection density of the vector graph index topology.

[0073] The vector graph addressing module is configured to receive target data to be predicted and generate a query request key vector, trigger a greedy first search process in the vector graph index topology, perform node jump access using the routing jump pointer, control the extension range of the search path according to the traversal depth constraint value, lock the candidate index node set whose spatial distance from the query request key vector meets the preset conditions, extract the attribute metadata from the candidate index node set, perform a weighted aggregation operation to output the remaining lifetime prediction value.

[0074] Specifically, the data encapsulation and persistence module serves as the system's write interface, receiving bearing vibration waveform data with a sampling rate of 20kHz via an industrial fieldbus. This module integrates a deep learning inference engine, mapping each waveform data segment to a 128-dimensional floating-point index key vector. The module encapsulates the corresponding historical lifetime tags (e.g., "2000 hours remaining") as attribute metadata, along with the index key vector, into a custom binary object format (Blob). This format is defined as a fixed-length binary frame of 520 bytes, containing an 8-byte lifetime metadata header field and a 512-byte index key vector payload field. Subsequently, the module calls the underlying file system's I / O interface to append this binary object to a persistent storage file on a solid-state drive (SSD), recording its physical storage offset.

[0075] The spatial index topology construction module runs as a background service process. It periodically scans the persistent storage area, using the K-means iterative algorithm as the spatial vector clustering rule to divide the massive number of key-value pair storage objects into 2048 feature clusters, and attaches each object to the inverted list (data leaf node) of the corresponding cluster. This inverted list stores the 64-bit address handles of all key-value pair storage objects belonging to that cluster in the persistent storage area. Based on this, the module calculates the 32 nearest neighbor nodes for each object node and uses a maximum-minimum distance heuristic pruning strategy to create memory address pointers (routing jump pointers) pointing to these neighbors in memory, constructing a small-world navigation graph (vector graph index topology). The module calculates the average number of connections in the entire graph (e.g., 32) and sets the search multiplier to 2, thus fixing the traversal depth constraint value to 64.

[0076] The vector graph addressing module serves as the system's query response interface. When real-time monitoring data arrives, the module converts it into a query request key vector and initiates a greedy search starting from the graph's entry node. The search process rapidly jumps along the route pointers within the graph, approaching nodes closer to the query vector with each jump. The system maintains a priority queue with a capacity of 64 (the traversal depth constraint value). The search is truncated when the distance to a node on the search path is no longer better than the worst node in the queue. The module locks the 64 candidate index nodes in the queue, reads their historical lifetime metadata, and performs a weighted summation using the inverse of the Euclidean distance. Before performing the reciprocal calculation, a very small smoothing constant (e.g., 1e-6) is applied to the Euclidean distance for regularization, outputting the final prediction result (e.g., "estimated remaining lifetime 450 hours").

[0077] This technical solution achieves decoupled operation of data storage, index construction, and retrieval reasoning through a modular system architecture design. It utilizes persistent storage to carry massive historical data and combines it with in-memory vector graph index topology for fast addressing, effectively solving the contradiction between the storage pressure of large-scale bearing feature data and real-time retrieval response in industrial scenarios, and constructing a high-concurrency, low-latency intelligent prediction system.

[0078] Although embodiments of the invention have been shown and described, it will be understood by those skilled in the art that various changes, modifications, substitutions and alterations can be made to these embodiments without departing from the principles and spirit of the invention, the scope of which is defined by the appended claims and their equivalents.

Claims

1. A method for predicting the remaining service life of bearings based on vector space retrieval, characterized in that, include: The process of receiving bearing operation data sequences and converting them into index key vectors using an encoding protocol includes: receiving bearing operation data sequences, which include bearing vibration acceleration data; calling a variational mode decomposition algorithm, setting a convergence threshold parameter, and converting the operation data sequences into orthogonal component sequences; performing a dimension mapping transformation on the orthogonal component sequences to generate a two-dimensional feature distribution matrix; inputting the two-dimensional feature distribution matrix into a preset convolutional encoder, performing texture mapping using convolutional layers, performing data dimensionality reduction using pooling layers, and flattening the dimensionality-reduced data using fully connected layers. The index key vector is used as the key value, and the associated historical lifetime data is encapsulated as attribute metadata to generate key-value pair storage objects, which are then written to the persistent storage area of ​​the vector database. The spatial partitioning index tree is initialized based on the persistent storage area of ​​the vector database. Key-value pair storage objects are mounted to the data leaf nodes at the bottom layer of the spatial partitioning index tree using spatial vector clustering rules. Routing pointers are established between the data leaf nodes to form a vector graph index topology. This includes: checking the number of in-degree connections in the neighbor node set; calculating the Lorenz equilibrium index of the number of in-degree connections; dynamically adjusting the in-degree connection constraint threshold based on the Lorenz equilibrium index; and when the number of in-degree connections is lower than the in-degree connection constraint threshold, writing the address handle of the target data leaf node in reverse to the adjacency routing table of the neighbor node set. The traversal depth constraint value is set based on the connection density of the vector graph index topology. The specific process includes: counting the number of routing jump pointer entries maintained by the data leaf nodes in the vector graph index topology; performing an average value calculation on the number of entries to obtain an average connectivity value; calling a preset search breadth coefficient; multiplying the average connectivity value with the search breadth coefficient to obtain a search range reference value; writing the search range reference value into the retrieval engine's running parameter register; and defining the length limit of the dynamically maintained candidate neighbor queue in the graph traversal addressing operation as the traversal depth constraint value. The system receives the target data to be predicted and generates a query request key vector. It triggers a greedy search process in the vector graph index topology, uses the route jump pointer to perform node jump access, controls the extension range of the search path based on the traversal depth constraint value, locks the candidate index node set whose spatial distance from the query request key vector meets the preset conditions, extracts attribute metadata from the candidate index node set, performs weighted aggregation operation, and outputs the remaining lifetime prediction value.

2. The bearing remaining service life prediction method based on vector space retrieval according to claim 1, characterized in that, The specific process of generating key-value pair storage objects and writing them into the persistent storage area of ​​the vector database includes: initializing a compact data serialization protocol and constructing a binary storage frame structure containing a metadata header field and a payload field; filling the metadata header field with the historical lifetime data and the payload field with the index key vector; performing serialization encoding to generate a fixed-length binary data block and using the fixed-length binary data block as the key-value pair storage object; allocating a heap file storage page in the persistent storage area of ​​the vector database and locking the current write offset pointer of the heap file storage page; locating the physical address based on the current write offset pointer and appending the fixed-length binary data block to the heap file storage page; and registering the physical address as the address handle of the key-value pair storage object.

3. The bearing remaining service life prediction method based on vector space retrieval according to claim 1, characterized in that, The specific process of initializing the spatial partitioning index tree in the persistent storage area based on the vector database includes: reading the index key vector from the persistent storage area to construct a calibration dataset, pre-setting the number of feature clusters and setting an initial reference vector; calling an iterative clustering algorithm to compare the Euclidean distance values ​​of the vectors in the calibration dataset to the initial reference vector, and assigning the vectors to the corresponding reference groups according to the Euclidean distance values; performing mean aggregation on the vectors in the reference groups, updating the coordinates of the initial reference vector using the aggregation results until the coordinate values ​​of the reference vectors are stable, and generating a quantized codebook vector; defining the boundaries of the subspace region according to the quantized codebook vector, instantiating data leaf nodes for the subspace region, and writing the quantized codebook vector into the navigation attribute field of the data leaf node to complete the coarse-grained partitioning of the spatial partitioning index tree.

4. The bearing remaining service life prediction method based on vector space retrieval according to claim 1, characterized in that, The specific process of establishing routing jump pointers between data leaf nodes to form a vector graph index topology includes: setting the neighbor connection quota parameter and in-degree connection constraint threshold of the small-world nearest neighbor graph; selecting the target data leaf node to be accessed in the vector graph index topology, and obtaining the index key vector of the existing node from the spatial partitioning index tree as the traversal search entry; performing a greedy traversal operation based on the traversal search entry to obtain a set of candidate neighbor nodes whose Euclidean distance values ​​with the index key vector of the target data leaf node are arranged in ascending order within a preset number range; performing heuristic pruning based on distance weight and connection angle distribution on the candidate neighbor node set to filter out the neighbor node set and extract the address handle of each node; writing the address handle into the adjacency routing table of the target data leaf node to generate a routing jump pointer.

5. The bearing remaining service life prediction method based on vector space retrieval according to claim 1, characterized in that, The specific process of locking the candidate index node set whose spatial distance from the query request key vector meets the preset conditions includes: initializing the candidate neighbor queue according to the traversal depth constraint value; obtaining the query request key vector generated based on the target data to be predicted, writing the entry node of the vector graph index topology into the candidate neighbor queue, and sorting it in ascending order according to the Euclidean distance value with the query request key vector; starting the iterative retrieval logic, reading the first node of the candidate neighbor queue as the current anchor point, and traversing the associated neighbor nodes through the route jump pointer; comparing the Euclidean distance value between the associated neighbor node and the query request key vector, and comparing it with the distance value of the last node in the candidate neighbor queue; when the Euclidean distance value is less than the distance value of the last node, inserting the associated neighbor node into the corresponding sorting position in the candidate neighbor queue, and removing nodes that overflow the list length; iterating in a loop until the retrieval logic is completed, and locking the nodes remaining in the candidate neighbor queue as the candidate index node set.

6. The bearing remaining service life prediction method based on vector space retrieval according to claim 1, characterized in that, The specific process of extracting attribute metadata from the candidate index node set and performing weighted aggregation to output the remaining useful life prediction value includes: traversing the candidate index node set, reading the attribute metadata stored in each node as historical reference values, and obtaining the vector space Euclidean distance value between each node and the query request key vector; performing a reciprocal operation on the vector space Euclidean distance value to generate an original weight factor, and performing an accumulation operation on the original weight factor to obtain a weight normalization base; performing a division operation on the original weight factor using the weight normalization base to obtain a normalized weight coefficient; performing a multiplication operation on the normalized weight coefficient and the historical reference value to generate a weighted component value, performing a summation operation on all the weighted component values, and outputting the summation result as the remaining useful life prediction value.

7. A bearing remaining service life prediction system based on vector space retrieval, characterized in that, include: The data encapsulation and persistence module is configured to receive bearing operation data sequences and convert the operation data sequences into index key vectors using an encoding protocol. The specific process includes: receiving the bearing operation data sequence, which includes bearing vibration acceleration data; calling a variational mode decomposition algorithm, setting a convergence threshold parameter, and converting the operation data sequence into an orthogonal component sequence; performing a dimension mapping transformation on the orthogonal component sequence to generate a two-dimensional feature distribution matrix; inputting the two-dimensional feature distribution matrix into a preset convolutional encoder, performing texture mapping using convolutional layers, performing data dimensionality reduction using pooling layers, and flattening the dimensionality-reduced data using fully connected layers; encapsulating the index key vector as a key and the associated historical lifespan data as attribute metadata to generate key-value pair storage objects, and writing the key-value pair storage objects into the persistent storage area of ​​the vector database. The spatial index topology construction module is configured to initialize a spatial partitioning index tree based on the persistent storage area of ​​the vector database, mount the key-value pair storage objects to the data leaf nodes at the bottom layer of the spatial partitioning index tree using spatial vector clustering rules, and establish routing jump pointers between the data leaf nodes to form a vector graph index topology. This includes: checking the number of in-degree connections in the neighbor node set; calculating the Lorenz balance index of the number of in-degree connections; dynamically adjusting the in-degree connection constraint threshold based on the Lorenz balance index; and writing the address handle of the target data leaf node in reverse to the specified location when the number of in-degree connections is lower than the in-degree connection constraint threshold. The adjacency routing table of the neighbor node set; setting the traversal depth constraint value according to the connection density of the vector graph index topology; the specific process includes: counting the number of entries of the route jump pointer maintained by the data leaf nodes in the vector graph index topology, performing average processing on the number of entries to obtain the average connectivity value; calling the preset search breadth coefficient, performing a multiplication operation between the average connectivity value and the search breadth coefficient to obtain the search range reference value; writing the search range reference value into the running parameter register of the retrieval engine, and defining the length limit of the candidate neighbor queue dynamically maintained in the graph traversal addressing operation as the traversal depth constraint value; The vector graph addressing module is configured to receive target data to be predicted and generate a query request key vector, trigger a greedy first search process in the vector graph index topology, perform node jump access using the routing jump pointer, control the extension range of the search path according to the traversal depth constraint value, lock the candidate index node set whose spatial distance from the query request key vector meets the preset conditions, extract the attribute metadata from the candidate index node set, perform a weighted aggregation operation to output the remaining lifetime prediction value.

Images