CN116501828B - Server-less vector query method and system based on unstructured data sets - Google Patents

Abstract

The invention provides a server non-perception vector query method and a system based on unstructured data sets, wherein the method is applied to the technical field of vector query, and comprises the following steps: acquiring a batch query request, wherein the batch query request comprises a plurality of vector query requests; searching a plurality of vector clusters corresponding to the batch query requests to generate a query plan; wherein each vector cluster is divided into a plurality of balanced vector clusters; optimizing the query plan, eliminating redundant transmission in the query plan, and obtaining the optimized query plan; acquiring transmission time information and calculation time information, and reordering the optimized query plan by taking the balance vector cluster as granularity to obtain an optimal execution sequence; grouping the optimal execution sequence by using a dynamic programming algorithm to obtain a grouping plan; and pushing each group into a global grouping queue for transmission and calculation according to a grouping plan, and obtaining a vector query result.

Description

Server-aware vector query method and system based on unstructured data sets

Technical Field

The present invention relates to the technical field of vector query, and in particular to a server-unaware vector query method and system based on unstructured data sets.

Background Art

Vector retrieval refers to the technology of converting unstructured data into high-dimensional feature vectors for query, calculation and storage. At present, vector retrieval technology is widely used in artificial intelligence fields such as face recognition, information retrieval and recommendation systems. In the existing technology, the graphics processing unit (GPU), as a highly parallelized coprocessor, is a natural choice for processing vector operations and performing vector query tasks. Since the GPU video memory capacity is much smaller than the host memory, in order to better utilize the GPU's computing resources and overcome its insufficient video memory, in actual vector retrieval applications, the host memory is often used as an extended storage of the GPU video memory.

However, in actual vector query applications, the above-mentioned technical solution of combining GPU with host memory greatly increases the data transmission overhead from host memory to GPU video memory, and cannot fully utilize the computing resources on the GPU, resulting in low vector query efficiency and excessively long time required, causing a certain amount of waste of transmission resources and computing resources.

Therefore, it is necessary to develop a server-insensitive vector query method and system based on unstructured data sets to improve the efficiency of vector query and achieve higher computing performance and cost-effectiveness.

Summary of the invention

In view of the above problems, an embodiment of the present invention provides a server-unaware vector query method and system based on an unstructured data set, so as to overcome the above problems or at least partially solve the above problems.

A first aspect of an embodiment of the present invention provides a server-unaware vector query method based on an unstructured data set, the method comprising:

Obtaining a batch query request, where the batch query request includes multiple vector query requests;

Using an IVF index constructed offline based on an unstructured data set, multiple vector clusters corresponding to the batch query request are searched and a query plan is generated, wherein the query plan represents: a transmission order of the multiple vector clusters from the main memory to the video memory of the GPU, and a calculation order of calculating the vector query request in the vector clusters; wherein each of the vector clusters is divided into multiple balanced vector clusters;

Optimizing the query plan, eliminating redundant transmissions in the query plan, and obtaining an optimized query plan;

Acquire transmission time information and calculation time information, and reorder the optimized query plan with the balance vector cluster as the granularity to obtain the optimal execution order;

Using a dynamic programming algorithm, grouping the optimal execution sequence to obtain a grouping plan;

According to the grouping plan, each group is pushed into the global grouping queue for transmission and calculation to obtain a vector query result.

The second aspect of the embodiment of the present application further provides a server-unaware vector query system based on an unstructured data set, the system comprising:

A declarative application programming interface, used to obtain a batch query request, wherein the batch query request includes a plurality of vector query requests;

A vector database, used for searching for multiple vector clusters corresponding to the batch query request by using an IVF index constructed offline based on an unstructured data set, and generating a query plan, wherein the query plan represents: a transmission order of the multiple vector clusters from the main memory to the display memory of the GPU, and a calculation order of calculating the vector query request in the vector clusters; wherein each of the vector clusters is divided into multiple balanced vector clusters;

A query plan optimization module, used to optimize the query plan, eliminate redundant transmissions in the query plan, and obtain an optimized query plan;

A pipeline scheduler, used for obtaining transmission time information and calculation time information, and reordering the optimized query plan with the balance vector cluster as the granularity to obtain the optimal execution order;

The pipeline scheduler is further used to group the optimal execution order using a dynamic programming algorithm to obtain a grouping plan;

The GPU processor is used to push each group into the global grouping queue for transmission and calculation according to the grouping plan to obtain the vector query result.

The embodiment of the present invention provides a server-unaware vector query method and system based on an unstructured data set, the method comprising: obtaining a batch query request, the batch query request comprising multiple vector query requests; using an IVF index constructed offline based on an unstructured data set, finding multiple vector clusters corresponding to the batch query request, and generating a query plan, the query plan representing: the transmission order of the multiple vector clusters from the main memory to the GPU's video memory, and the calculation order of the vector query request in the vector cluster; wherein each of the vector clusters is divided into multiple balanced vector clusters; optimizing the query plan, eliminating redundant transmissions in the query plan, and obtaining an optimized query plan; obtaining transmission time information and calculation time information, reordering the optimized query plan with the balanced vector cluster as the granularity, and obtaining an optimal execution order; using a dynamic programming algorithm to group the optimal execution order to obtain a grouping plan; according to the grouping plan, pushing each group into a global grouping queue for transmission and calculation to obtain a vector query result. On the one hand, the embodiment of the present application optimizes the query plan, eliminates redundant transmissions in the query plan, improves transmission efficiency, and saves transmission resources. On the other hand, the embodiment of the present application reorders the query plan to obtain the optimal execution order, uses a dynamic programming algorithm to group, and then transmits and calculates according to the determined optimal execution order and optimal grouping scheme, thereby further improving the efficiency of vector query.

BRIEF DESCRIPTION OF THE DRAWINGS

In order to more clearly illustrate the technical solutions of the embodiments of the present invention, the accompanying drawings required for use in the description of the embodiments of the present invention will be briefly introduced below. Obviously, the accompanying drawings in the following description are only some embodiments of the present invention. For ordinary technicians in this field, other accompanying drawings can be obtained based on these accompanying drawings without paying creative labor.

FIG1 is a flowchart of a method for server-unaware vector query based on an unstructured data set provided by an embodiment of the present invention;

FIG2 is a schematic diagram of an initial query plan provided by an embodiment of the present invention;

3 is a schematic diagram of the computing time and space utilization of a stream processor in a GPU provided by an embodiment of the present invention;

FIG4 is a schematic diagram of a query plan optimization result within a batch process provided by an embodiment of the present invention;

5 is a schematic diagram of a query plan optimization result between batch processing provided by an embodiment of the present invention;

FIG6 is a schematic diagram of reordering of a pipeline scheduler provided by an embodiment of the present invention;

FIG7 is a schematic diagram of a calculation process of dynamic kernel expansion provided by an embodiment of the present invention;

FIG8 is a schematic diagram of a query process of a vector query method provided by an embodiment of the present invention;

9 is a schematic diagram of the structure of a server-unaware vector query system based on an unstructured data set provided by an embodiment of the present invention;

FIG. 10 is a schematic diagram of the structure of an electronic device provided by an embodiment of the present invention.

DETAILED DESCRIPTION

The exemplary embodiments of the present invention will be described in more detail below in conjunction with the accompanying drawings in the embodiments of the present invention. Although the exemplary embodiments of the present invention are shown in the accompanying drawings, it should be understood that the present invention can be implemented in various forms and should not be limited by the embodiments set forth herein. On the contrary, these embodiments are provided in order to enable a more thorough understanding of the present invention and to enable the scope of the present invention to be fully communicated to those skilled in the art.

Breakthroughs in deep learning technology have enabled unstructured data to be converted into high-dimensional feature vectors, and vector retrieval has therefore been used to serve a wide range of artificial intelligence applications, such as face recognition, information retrieval, and recommendation systems. With the rapid growth of user data, the size of many vector retrieval data sets has reached billions or even hundreds of billions. In addition, as a highly parallel coprocessor, GPU is a natural choice for processing vector operations and performing vector retrieval tasks. However, GPUs are not only more expensive than CPUs, but their video memory capacity is also much smaller than host memory. Therefore, when processing large-scale vector data sets, it is often necessary to use a number of GPUs that far exceeds the required GPU computing resources to place such a large-scale data set, resulting in a waste of GPU computing resources. In order to better utilize the computing resources of GPUs and overcome the defect of insufficient video memory, so that it still has better performance and cost-effectiveness than CPUs under large-scale data sets, the most natural approach is to use host memory as an extended storage of video memory.

However, according to the above-mentioned technical solution of combining GPU with host memory, there are the following problems: On the one hand, there is serious redundant transmission in the data transmission from host memory to GPU video memory. When processing a batch of query requests, different query requests may be calculated on the same data. If the calculation and data transmission are performed according to the original calculation mode, it will lead to multiple transmissions of the same data in a batch of queries, greatly increasing the data transmission overhead. On the other hand, the existing vector computing engine cannot fully utilize the computing resources of the GPU when processing the calculation of each query request on the data, resulting in low utilization of GPU computing resources.

In view of the above problems, the embodiments of the present invention propose a server-unaware vector query method and system based on unstructured data sets to solve the above redundant transmission problems and the problem of low computing resource utilization, so as to achieve higher computing performance and cost performance. The vector query method provided by the embodiments of the present application is described in detail below through some embodiments and their application scenarios in conjunction with the accompanying drawings.

This embodiment proposes a server-unaware vector query method based on an unstructured data set. Referring to FIG. 1 , FIG. 1 shows a flow chart of the steps of a server-unaware vector query method based on an unstructured data set. As shown in FIG. 1 , the method includes:

Step S101: obtaining a batch query request, where the batch query request includes a plurality of vector query requests.

In specific implementation, a batch query request includes multiple vector query requests. In the actual query process, calculations need to be performed based on each vector query request in the batch query request. Different vector query requests involve different vectors, or in other words, different vectors need to be queried.

In an optional implementation, the step S101, obtaining a batch query request, includes:

Step S1011, receiving query request information input by a user, wherein the query request information includes at least: vectors of a batch query request, search accuracy requirements, expected query processing time, and the number of nearest neighbor vectors to be returned.

Step S1012: convert the query request information into search configuration and resource configuration through a declarative application programming interface.

Step S1013: execute the search configuration and the resource configuration to generate the batch query request.

In the actual application process, the user submits the corresponding job (inputs the query request information of this query). Through the declarative application programming interface of this embodiment, the user's query request information can be automatically converted into specific search configuration and resource configuration, thereby executing the search configuration and resource configuration, and generating batch query requests. Therefore, there is no need for the user to manually configure the corresponding resources for this query. The system can automatically generate schematic search configuration and resource configuration, and then generate batch query requests. This embodiment proposes a set of "server-unaware" declarative application programming interfaces (APIs), which shield a large number of resource configuration details (such as GPU quantity, type, communication method, etc.). Developers only need to make simple declarations on their model training tasks (such as data sets, accuracy, expected completion time) in this set of interfaces, and the system can automatically allocate and schedule resources for them, thereby greatly reducing the development complexity of model training tasks.

Step S102, using the IVF index constructed offline based on the unstructured data set, to find multiple vector clusters corresponding to the batch query request, and generate a query plan, the query plan represents: the transmission order of the multiple vector clusters from the main memory to the GPU memory, and, the calculation order of the vector query request in the vector clusters; wherein each of the vector clusters is divided into a plurality of balanced vector clusters.

In this embodiment, an inverted file system (IVF) is pre-constructed in a vector database, which refers to a technique of performing k-means clustering on all vectors in the vector database to divide the vectors into multiple vector clusters. Specifically, the unstructured data in deep learning is converted into high-dimensional feature vectors, and a large number of unstructured data sets are stored in the form of vectors to obtain a vector database. By querying the vectors in the vector database, query retrieval of the unstructured data is realized. Based on the pre-constructed IVF index, a query is performed according to the batch query request obtained in step S101, and each vector query request in the batch query request includes a query vector, so that multiple vector clusters closest to the query vector can be determined. Since this embodiment pre-divided the large-scale vector data set provided into multiple vector clusters by k-means clustering, only the multiple vector clusters closest to the query vector will be searched during online query, and all vectors do not need to be traversed one by one, thereby improving query performance and reducing latency.

This embodiment uses the IVF index constructed offline to find the vector clusters corresponding to all vector query requests, and constructs a query vector-search vector cluster matrix as a query plan, where each query vector corresponds to a vector query request. The query plan represents: the transmission order of the multiple vector clusters from the main memory to the GPU memory, and the calculation order of the vector query requests in the vector clusters.

Referring to FIG. 2 , FIG. 2 shows a schematic diagram of an initial query plan. As shown in FIG. ₂ , G ₁ , G ₂ and G ₃ on the horizontal axis represent the transmission order of the query plan, C 1 , C ₂ , C ₃ , C ₄ , C ₅ , C ₆ represent different vector clusters, and Query-1 (Q ₁ ), Query-2 (Q ₂ ), Query-3 (Q ₃ ) on the vertical axis represent different vector query requests. Exemplarily, assuming that the GPU memory capacity is three vector clusters, that is, the GPU can only store three vector clusters. According to the query plan shown in FIG2 , it can be seen that the first transmission _G1 is to transfer the three vector clusters _C1 , _C2 , and _C3 from the host memory to the GPU memory, calculate the vector query request _Q1 in _C1 , calculate _Q2 in _C2 , and calculate _Q3 in _C3 . After the calculation is completed, the three vector clusters are driven out to the host memory; then the second transmission _G2 is executed to transfer the three vector clusters _C4 , _C5 , and _C6 from the host memory to the GPU memory, calculate _Q1 in _C4 , calculate _Q2 in _C5 , and calculate _Q3 in _C6 . After the calculation is completed, the three vector clusters are driven out to the host memory; the third transmission _G3 is to transfer the three vector clusters _C1 , _C2 , and _C3 from the host memory to the GPU memory again, calculate _Q1 in _C3 , and calculate Q3 in C6. ₁ , calculate Q ₂ , calculate Q ₃ in C ₂ , and after the calculation is completed, the three vector clusters are evicted to the host memory. As can be seen from Figure 2, the initial query plan includes the transfer order of multiple vector clusters from the main memory to the GPU's video memory (for example, first transfer C ₁ , C ₂ , C ₃ , then transfer C ₄ , C ₅ , C ₆ , and finally transfer C ₃ , C ₁ , C ₂ ), and, the calculation order of the vector query request in the vector cluster (for example, the calculation order in G ₃ is: calculate Q ₁ in C ₃ , calculate Q ₂ in C ₁ , and calculate Q ₃ in C ₂ ).

In an optional implementation, the vector cluster is divided into a plurality of balanced vector clusters by the following steps, the steps comprising:

Step S1021, according to the size of the minimum vector cluster, each vector cluster is divided to obtain multiple candidate vector clusters; specifically, IVF index is constructed according to the k-means clustering method to obtain n vector clusters, the sizes of the n vector clusters are not the same, and the smallest vector cluster is determined. Each vector cluster is divided according to the size of the minimum vector cluster to obtain multiple candidate vector clusters.

Step S1022, determining whether the variance of the candidate vector cluster size is less than a preset variance value.

Step S1023, when the variance of the candidate vector cluster size is less than the preset variance value, the candidate vector cluster is determined as the balanced vector cluster. Specifically, when the variance of the candidate vector cluster is less than the preset variance value, it means that the candidate vector clusters are similar in size and have little difference, and can be used as a balanced vector cluster.

Step S1024, when the variance of the candidate vector cluster size is greater than or equal to the preset variance value, recursively halve the size of the minimum vector cluster, divide it according to the halved vector cluster size, and generate a new candidate vector cluster until the variance of the candidate vector cluster size is less than the preset variance value. Specifically, when the variance of the candidate vector cluster is greater than or equal to the preset variance value, it means that the size difference between the candidate vector clusters is still too large and has not converged to the expected range. The vector cluster can be re-divided according to half the size of the minimum vector cluster in step S1021 as a new division unit to generate a new candidate vector cluster, and then the variance of the candidate vector cluster is detected again. If the variance exceeds the preset variance value, the division unit is further halved to regenerate the candidate vector cluster until the variance of the candidate vector cluster is less than the preset variance value.

In the specific implementation, after pre-building the IVF index offline, each generated vector cluster is divided into several balanced vector clusters. By calculating the variance value of the vector cluster, the vector cluster with a variance value less than the preset variance value is determined as the balanced vector cluster, thereby achieving that the size of each balanced vector cluster is almost the same.

In the process of vector query, some long tail computing blocks will block the entire computing kernel, so that only some GPU stream processors (streaming multiprocessors) are used at the same time. Referring to FIG3, FIG3 shows a schematic diagram of the computing time and space utilization of a stream processor in a GPU. As shown in FIG3, in the actual vector query process, the GPU includes multiple stream processors (streaming multiprocessors, SM) (SM ₁ , SM ₂ , SM ₃ , SM ₄ as shown in FIG3), and each stream processor performs the calculation of the vector query request on the vector cluster respectively. As shown in FIG3, SM ₁ performs the calculation of the vector query request Q ₁ on the vector cluster C ₁ , SM ₂ performs the calculation of the vector query request Q ₂ on the vector cluster C ₂ , and SM ₃ performs the calculation of the vector query request Q ₃ on the vector cluster C _3. It should be noted that due to the imbalance of the k-means clustering algorithm, the size of each vector cluster is different. The different sizes of vector clusters lead to different calculation times for each stream processor. The larger the vector cluster, the longer the calculation time. As shown in Figure 3, the direction of the horizontal arrow represents the direction of the time axis. The vector cluster _C1 is much larger than _C2 and _C3 , which causes the calculation time of the stream processor _SM1 to be longer than that of _{SM2 and} SM3. This causes the execution time of the query request _Q1 on the vector cluster _C1 to slow down the entire GPU kernel calculation, resulting in idle time for the stream processors _SM2 and _SM3 , reducing the time utilization of the stream processors in the GPU.

In order to solve the above problems, an embodiment of the present application proposes a vector cluster balancing technology, which pre-divides the vector cluster into multiple balanced vector clusters of similar size, and uses the balanced vector cluster as the granularity for transmission and calculation, thereby avoiding the situation where the query request slows down the entire kernel calculation due to the execution time on individual vector clusters, thereby solving the problem of insufficient time utilization of the GPU stream processor.

Step S103, optimizing the query plan, eliminating redundant transmissions in the query plan, and obtaining an optimized query plan.

According to the original query plan, redundant transmission is easy to occur. As shown in FIG2 , the first transmission _G1 is to transfer the three vector clusters _C1 , _C2 , and _C3 from the host memory to the GPU memory, the second transmission _G2 is to transfer the three vector clusters _C4 , _C5 , and _C6 from the host memory to the GPU memory, and the third transmission _G3 is to transfer the three vector clusters _C1 , _C2 , and _C3 from the host memory to the GPU memory again. It can be concluded that the vector clusters are cumulatively transmitted 9 times in the above process, but only 6 vector clusters will be transmitted after the order of _G2 and _G3 is exchanged. The initial query plan generates 3 redundant transmissions, resulting in the _C1 , _C2 , and _C3 vector clusters being repeatedly transmitted from the main memory to the GPU memory, wasting transmission resources and affecting the overall vector query efficiency. The embodiment of the present application proposes to optimize the query plan, eliminate the redundant transmission therein, and obtain the optimized query plan, so that the optimized query plan avoids repeated transmission of the same vector cluster and improves the transmission and calculation efficiency of the vector cluster.

In an optional implementation, the step S103, optimizing the query plan to eliminate redundant transmission in the query plan, includes:

Step S1031, adjusting the number of transmissions of each of the vector clusters to at most once.

Step S1032: Adjust the calculation order of the vector clusters that already exist in the video memory of the GPU forward.

In vector query processing, the processing of each subset (i.e., each time a vector query request is calculated on a vector cluster) is independent, based on which the query plan of each query request can be improved without changing the correctness of its query result. This embodiment improves the query plan from two aspects: within the batch processing and between batch processing, so as to completely eliminate the redundant transmission of the batch query request.

On the one hand, optimization is performed inside the batch processing, corresponding to step S1031. Referring to FIG4 , FIG4 shows a schematic diagram of query plan optimization results inside the batch processing. In the example shown in FIG4 , the vector query in the example involves a total of 6 vector clusters: C ₁ , C ₂ , C ₃ , C ₄ , C ₅ , and C ₆ , and the batch query request includes 3 vector query requests: Q ₁ , Q ₂ , and Q ₃ . Let the matrix in FIG4 be M, and each element [i, j] in the matrix M represents the calculation result of the corresponding vector query request _Qi in the corresponding vector cluster C _j . 0 indicates that the vector cluster C _j is not involved by the vector query request _Qi , that is, the vector cluster C _j is not the vector required by the vector query request _Qi ; 1 indicates that the vector cluster C _j is involved by the vector query request _Qi , that is, the vector cluster C _j is the vector required by the vector query request _Qi .

Based on the following observation: the optimal number of query transmissions is always no less than the number of vector clusters involved, the optimization goal is to improve the original query plan so that the total number of transmissions of the improved query plan is the number of vector clusters and the correctness of the results is guaranteed. After a vector cluster is transmitted into the GPU memory, the improved query plan will immediately process the query request involving the current vector cluster. In this way, the optimized query plan will only transmit each vector cluster at most once, thereby eliminating redundant data transmission and realizing the query plan optimization within the batch processing.

On the other hand, optimization is performed between batch processing requests, corresponding to step S1032. Referring to FIG5 , FIG5 shows a schematic diagram of query plan optimization results between batch processing. As shown in FIG5 , assuming that the GPU video memory capacity is 3, it initially accommodates two vector clusters: C ₅ and C ₆ , that is, when the previous batch is processed, C ₅ and C ₆ are transferred to the GPU video memory, and when the next batch is processed, C ₅ and C ₆ also need to be processed. In this case, the optimization between batch processing requests can adjust the calculation order of the vector clusters that already exist in the GPU video memory forward, specifically, it can be adjusted to the first place in the processing order, that is, the processing order of C ₅ and C ₆ is moved to the front of the entire query request processing order. In this way, the vector clusters that have been transferred to the GPU video memory in the previous batch can be fully reused, further reducing the overhead required for transmission.

Step S104, acquiring transmission time information and calculation time information, and reordering the optimized query plan with the balance vector cluster as the granularity to obtain the optimal execution order;

In this embodiment, in order to obtain the transmission time information and the computing time information, an analyzer component is constructed offline in advance by querying the history or preprocessing some queries. The analyzer can predict the data transmission time or computing time of each query online, that is, according to the optimized query plan, the analyzer can calculate and estimate the time required for the batch query request to transmit data and the time required for GPU computing. According to the obtained time information, the optimized query plan can be further reordered to obtain the optimal execution order.

In an optional implementation manner, the acquiring the transmission time information and the calculation time information includes:

The transmission time information of each vector cluster is calculated according to the following formula:

Transfer time = ,in, is the size of the equilibrium vector cluster within the vector cluster, a and b are transmission time parameters pre-fitted by the least square method, and m represents the number of the equilibrium vector clusters within the vector cluster;

The calculation time information of each vector cluster is calculated according to the following formula:

Compute time = , where A and B are the calculation time parameters obtained in advance by least squares fitting;

The transmission time information represents the time information required for each of the vector clusters to be transmitted from the main memory to the video memory of the GPU, and the calculation time information represents the time information required for calculating the corresponding query request in each of the vector clusters.

In this embodiment, the analyzer is mainly used to predict the time of data transmission from main memory to GPU memory through PCIe, which is generally implemented by calling cudaMemcpyAsync, the interface of cuda. The entire transmission time can be divided into two parts: the actual propagation time on PCIe and the interface call overhead. Specifically, assuming that the current group contains m balanced vector clusters, the transmission time can be roughly calculated by the following formula: ,in is the size of the equilibrium vector cluster, a and b can be fitted offline by the least squares method, that is, the calculation time parameters set by historical data or experience. The analyzer predicts the calculation time as above, calculated according to the following formula: , where A and B are the calculation time parameters obtained in advance by least squares fitting, and the calculation time is in a linear function relationship with the calculation amount.

This embodiment uses an analyzer to predict the time of transmission and calculation of each group, that is, to predict the time of transmission and calculation of each vector cluster (including multiple balanced vector clusters). The predicted time information (transmission time information and calculation time information) will be used by the pipeline scheduler to assist in calculating the optimal pipeline plan. Specifically, after receiving the optimized query plan, the pipeline scheduler will further reorder and group the plan to achieve the maximum transmission calculation overlap and the minimum pipeline overhead. The simplest method is to enumerate all pipeline scheduling schemes and find the one with the smallest running time, but the enumeration of the algorithm during operation will bring great algorithm overhead. Therefore, the embodiment of the present application splits the entire search problem into two sub-problems. First, step S104 is executed to reorder the optimized query plan with the balanced vector cluster as the granularity to obtain the optimal execution order. After determining the optimal execution order at the granularity of the balanced vector cluster, step S105 is executed to search for the optimal grouping plan in this order.

In an optional implementation, the step S104, obtaining the transmission time information and the calculation time information, and reordering the optimized query plan with the balance vector cluster as the granularity, includes:

Step S1041, according to the transmission time information, the execution order of the balance vector cluster with a transmission time of zero is moved to the first place;

Step S1042: According to the calculation time information, the execution order of the balance vector cluster requiring a larger calculation time is adjusted forward.

In the specific implementation, refer to FIG6 , which shows a reordering schematic diagram of a pipeline scheduler. Assume that all balance vector clusters are {B ₁ , B ₂ , B ₃ , ... B _m }, representing a specific execution order. As shown in FIG6 , there are four balance vector clusters B ₁ , B ₂ , B ₃ , and B _{4 . PCIe represents transmission data, and GPU represents the corresponding kernel calculation. The horizontal bar is the time axis. The longer the horizontal bar, the longer the transmission time or calculation time of the balance vector cluster. As shown in part (a) of FIG6 , B 4 is} already in the GPU and does not need to be transmitted. The execution order is B ₁ →B ₂ →B ₃ →B ₄ . Each balance vector cluster needs to be transmitted before it can start calculation.

According to step S1041, according to the transmission time information, the execution order of the balance vector cluster with zero transmission time is moved to the first place, so that the overlap and parallelism of transmission and calculation can be increased. As shown in part (b) of Figure 6, the processing order of the balance vector cluster with zero transmission time ( _B4 ) is moved to the first place, so that the calculation time of _B4 can be completely covered by the transmission time of _B1 .

According to step S1042, according to the calculation time information, the execution order of the balance vector cluster with a larger calculation time is adjusted forward, and the balance vector cluster with a larger calculation time is moved to the first position of the transmission order and the front of the execution order. As shown in part (c) of Figure 6, since in this group, the calculation time of B ₃ is longer, B ₃ is moved to the first position of the transmission order and first transmitted to the GPU memory, so that its execution order is also moved forward. Optionally, it can be placed after the execution order of the balance vector cluster with a zero transmission time adjusted in step S1041 (for example, after B ₄ in Figure 6), so that the calculation time of the balance vector cluster (B ₃ ) with a larger calculation time can be covered more by the transmission time of other balance vector clusters. The above steps S1041 and S1042 can be implemented by a corresponding sorting algorithm to solve and obtain the optimal execution order.

The existing parallel mode of transmission and calculation will cause bubbles in the pipeline, so that the calculation and transmission cannot be fully overlapped. For example, in part (a) of Figure 6, the stream processor in the GPU needs to wait for _B1 to be transmitted through PCIe before it can start calculation. The waiting time generated is the bubble. In order to solve this problem, this embodiment adjusts the execution order (transmission order and calculation order) of the balanced vector clusters in each vector cluster, calculates the optimal execution order, so that the calculation time of the balanced vector cluster can be covered by the transmission time of other balanced vector clusters as much as possible, reducing bubbles and improving vector query efficiency.

Step S105: Use a dynamic programming algorithm to group the optimal execution sequence to obtain a grouping plan.

After determining the optimal execution order at the granularity of the balanced vector cluster, the pipeline scheduler searches for the optimal grouping plan based on this order using a dynamic programming algorithm. In the related art, the basic pipeline strategy is to perform pipeline processing one by one according to the vector clusters, that is, to transmit and calculate cluster by cluster. However, this fine-grained pipeline processing introduces two types of pipeline overhead. The first is the overhead of frequently calling the transmission interface. Since the amount of data transmitted is fixed, the vector cluster granularity leads to the maximum number of interface calls, and therefore has the largest call overhead. Another overhead is the synchronization overhead between each packet transmission and calculation. At the cluster granularity, each vector cluster needs to be synchronized, which has the largest synchronization overhead. In order to reduce the overhead in the above two aspects, this embodiment proposes to use a dynamic programming algorithm to find the optimal grouping scheme among possible scheme combinations.

In an optional implementation, the step S105, using a dynamic programming algorithm to group the optimal execution order to obtain a grouping plan, includes:

Step S1051, using a dynamic programming algorithm, traverse the nodes of the search tree, each of the nodes represents a grouping scheme, and the child nodes of each node represent the sub-schemes of the grouping scheme.

In the specific implementation, a global variable, optimal time, is maintained using a dynamic programming algorithm to record the optimal time of the pipeline solution in the current search space. Each pipeline solution is taken as a node in the search tree. For example, "Move B ₃ to the first position in the transmission order" is taken as a node in the search tree, and then "Move B ₃ to the first position in the transmission order and set B ₂ to the next position in the transmission order of B ₃ " is taken as a child node of the node.

Step S1052, by completely overlapping the remaining transmission and calculation, ignoring the pipeline processing overhead, calculate the time interval expected to be required to execute the grouping solution of the current node.

Specifically, when traversing the nodes in the search tree, the time interval required for executing the corresponding grouping scheme is estimated for each node, and the time interval represents the maximum time and the shortest time expected to execute the grouping scheme. In this embodiment, the time interval corresponding to the scheme in the current subtree can be calculated by completely overlapping the remaining transmission and calculation and ignoring the pipeline processing overhead.

Step S1053, when the minimum value of the time interval is greater than the minimum value of the time interval of other nodes, prune the current node and its child nodes.

In this embodiment, a heuristic pruning method is combined with the dynamic programming algorithm. If the minimum value of the time interval of the node is greater than the optimal maintenance time (i.e., the minimum value of the time interval of other nodes), the node and all child nodes (subtrees) corresponding to the node are pruned, and there is no need to continue calculating all child nodes of the node, further reducing the search space of dynamic programming and saving computing resources.

Step S1054, the grouping scheme corresponding to the nodes finally remaining in the search tree after pruning is determined as the grouping plan. The time complexity of the dynamic programming algorithm is at the polynomial level. The algorithm with pruning heuristic can quickly find the optimal grouping scheme at runtime and minimize the additional system overhead caused by the pipeline.

Step S106: according to the grouping plan, each group is pushed into a global grouping queue for transmission and calculation to obtain a vector query result.

In an optional implementation, the step S106, according to the grouping plan, pushes each group into a global grouping queue for transmission and calculation to obtain a vector query result, including:

Step S1061, extracting transmission tasks from the global packet queue through the storage manager, and maintaining a local packet transmission queue;

Step S1062, according to the local packet transmission queue, after completing the transmission task of the current packet, the storage manager notifies the kernel controller to execute the corresponding computing task and starts to execute the transmission task of the next packet;

Step S1063, extracting computing tasks from the global grouping queue through the kernel controller, and maintaining a local grouping computing queue;

Step S1064: the core controller executes the calculation task of the current group according to the local group calculation queue, and after completing the execution of all groups, the core controller generates a vector query result.

In a possible implementation, in step S1064, the kernel controller executes the computing task of the current group, including:

According to the characteristics of the balance vector cluster address, each of the balance vector clusters in the current group is divided into a plurality of sub-vector clusters;

The calculation of the vector query request on each of the sub-vector clusters is regarded as a block calculation task, and the block calculation tasks are evenly distributed to multiple stream processors on the GPU;

Each of the stream processors executes the assigned block computing task.

When performing vector queries, there is not only the problem of low time utilization, but also the problem of low space utilization. Specifically, there are multiple stream processors in the GPU, and it is easy for the number of computing blocks of the entire computing kernel to be small and unable to fully occupy all the stream processors of the GPU, that is, the kernel calculation corresponding to the query request of the current batch cannot fully utilize all the stream processors, as shown in SM ₄ in Figure 3, and some stream processors (SM ₄ ) will be idle, resulting in low space utilization.

In order to solve the problem of low space utilization mentioned above, this embodiment proposes a method for dynamic kernel expansion: utilizing the feature of the continuous vector cluster address after balancing, that is, the address of the vector in the balanced vector cluster is continuous, and dynamically dividing a balanced vector cluster into several sub-vector clusters at runtime. The original block calculation (block), that is, the calculation of a vector query request on a balanced vector cluster, will also be divided into several smaller block calculations (blocks), each block calculation will be run in a stream processor, and each stream processor can accommodate multiple block calculations. Referring to Figure 7, Figure 7 shows a schematic diagram of the calculation process of dynamic kernel expansion. As shown in Figure 7, the horizontal axis is the direction of the time axis development, and each block represents the calculation of a sub-vector cluster. The divided sub-vector clusters are evenly distributed to the stream processors in the GPU, thereby ensuring that the task volume of each stream processor is similar, and realizing dynamic kernel expansion.

In the embodiment of the present application, before the kernel controller executes the calculation task of the current group according to the local group calculation queue, the balance vector cluster in the current group is divided into a plurality of sub-vector clusters, and according to the busyness of the current stream processor, the plurality of sub-vector clusters are evenly distributed to a plurality of stream processors in the GPU, so that the stream processors perform calculations, thereby ensuring that there are no idle stream processors and improving the GPU occupancy rate.

Example 1:

Referring to FIG. 8 , FIG. 8 shows a schematic diagram of a query process of a vector query method. As shown in FIG. 8 , the vector query method is mainly divided into two parts: online and offline.

For the offline part, it is necessary to build an IVF (inverted index) index for the dataset in advance. IVF uses k-means clustering to divide the vectors of the dataset into multiple vector clusters. In addition, for the generated multiple vector clusters, the vector cluster balancing module expands the index and divides each vector cluster into multiple balanced vector clusters of similar size. The dataset is then loaded into the host memory and transferred to the GPU memory online through PCIe under the control of the storage management system.

In addition, the present embodiment now also pre-designs an analyzer component, which is constructed offline by querying history or pre-processing some queries, and can be used to predict the data transmission time or calculation time of each query online.

For the online part, according to the vector query method, the specific steps are as follows:

Step 1: Receive online batch query requests from users. Specifically, the query request information input by the user can be converted into corresponding search configuration and resource configuration through the declarative application programming interface to generate batch query requests.

Step 2: Use the IVF index built offline to select the nearest n vector clusters as query data and generate a query plan.

Step 3: Optimize the entire query plan based on vector clusters to eliminate redundant transmissions in the query plan and obtain an optimized query plan.

Step 4: During runtime, the pipeline scheduler receives the improved query plan, as well as the transmission time information and computation time information provided by the analyzer. Based on the above information, the pipeline scheduler uses a greedy algorithm to reorder the query plan to obtain the optimal execution order. In addition, the pipeline scheduler can also use a dynamic programming algorithm to group the optimal execution order to obtain a grouped plan. The pipeline scheduler will find the best trade-off between pipeline efficiency and pipeline overhead.

Step 5: Push each group in the grouping plan into the global grouping queue for transmission and calculation.

Step 6: The kernel controller and storage manager each extract tasks from the global group queue and maintain the corresponding local group queue. As long as its local group queue is not empty, the storage manager will start transmission immediately. After completing the transmission of the current group, the storage manager will notify the kernel controller to perform the corresponding calculation and pop up the next group to start transmission. If the kernel calculation engine is empty at this time, the kernel controller will calculate the current group and use dynamic kernel expansion to divide the balanced vector cluster into multiple sub-vector clusters to make full use of each GPU stream processor.

Step 7: After completing the calculation of all groups in batch processing, the final vector query result is generated, and the kernel controller returns the vector query result to the user.

The embodiments of the present application propose query plan optimization based on data and vector clusters to solve the problem of redundant data transmission, and solve the problem of underutilization of the GPU's stream processor in space and time by balancing the dynamic computing kernel expansion additional data clusters. It also proposes to use a pipeline scheduler to reorder and group at runtime to maximize the parallelism of transmission and calculation, so that the embodiments of the present application can surpass the existing related vector query technology and achieve higher computing performance and cost-effectiveness.

A second aspect of an embodiment of the present application provides a server-unaware vector query system based on an unstructured data set. Referring to FIG. 9 , FIG. 9 shows a schematic structural diagram of a server-unaware vector query system based on an unstructured data set. As shown in FIG. 9 , the system includes:

A declarative application programming interface, used to obtain a batch query request, wherein the batch query request includes a plurality of vector query requests;

A vector database, used for searching for multiple vector clusters corresponding to the batch query request by using an IVF index constructed offline based on an unstructured data set, and generating a query plan, wherein the query plan represents: a transmission order of transferring the multiple vector clusters from a main memory to a display memory of a GPU, and a calculation order of calculating the vector query request in the vector clusters; wherein each of the vector clusters is divided into multiple balanced vector clusters;

A query plan optimization module, used to optimize the query plan, eliminate redundant transmissions in the query plan, and obtain an optimized query plan;

A pipeline scheduler, used for obtaining transmission time information and calculation time information, and reordering the optimized query plan with the balance vector cluster as the granularity to obtain the optimal execution order;

The pipeline scheduler is further used to group the optimal execution order using a dynamic programming algorithm to obtain a grouping plan;

The GPU processor is used to push each group into the global grouping queue for transmission and calculation according to the grouping plan to obtain the vector query result.

In an optional implementation, the query plan optimization module includes:

A batch processing internal optimization submodule, used for adjusting the number of transmissions of each vector cluster to at most once;

The batch processing external optimization submodule is used to adjust the calculation order of the vector clusters that already exist in the video memory of the GPU forward.

In an optional embodiment, the device further comprises an analyzer:

The analyzer is used to calculate the transmission time information of each vector cluster according to the following formula:

Transfer time = ,in, is the size of the equilibrium vector cluster within the vector cluster, a and b are transmission time parameters pre-fitted by the least square method, and m represents the number of the equilibrium vector clusters within the vector cluster;

The analyzer is further configured to calculate the calculation time information of each vector cluster according to the following formula:

Compute time = , where A and B are the calculation time parameters obtained in advance by least squares fitting;

The transmission time information indicates the time information required for each of the vector clusters to be transmitted from the main memory to the video memory of the GPU, and the calculation time information indicates the time information required for calculating the corresponding query request in each of the vector clusters;

The analyzer is further configured to send the calculated transmission time information and the calculation time information to the pipeline scheduler.

In an optional implementation, the system further includes: a vector cluster balancing module, the vector cluster balancing module is used to divide the vector cluster into a plurality of balanced vector clusters of similar size through the following steps, the steps including:

Dividing each of the vector clusters according to the size of the minimum vector cluster to obtain a plurality of candidate vector clusters;

Determining whether the variance of the candidate vector cluster size is less than a preset variance value;

In a case where the variance of the size of the candidate vector cluster is less than the preset variance value, determining the candidate vector cluster as the balanced vector cluster;

When the variance of the candidate vector cluster size is greater than or equal to the preset variance value, the size of the minimum vector cluster is recursively halved, and the cluster is divided according to the halved vector cluster size to generate a new candidate vector cluster until the variance of the candidate vector cluster size is less than the preset variance value.

In an optional implementation, the pipeline scheduler includes:

A first reordering submodule, configured to move the execution order of the balance vector cluster with a transmission time of zero to the first place according to the transmission time information;

The second reordering submodule is used to adjust the execution order of the balance vector cluster requiring a larger calculation time forward according to the calculation time information.

In an optional implementation, the pipeline scheduler further includes:

A node traversal submodule, used to traverse the nodes of the search tree using a dynamic programming algorithm, each of the nodes represents a grouping scheme, and the child nodes of each node represent the sub-schemes of the grouping scheme;

A time interval calculation submodule is used to calculate the estimated time interval required to execute the grouping scheme of the current node by completely overlapping the remaining transmission and calculation and ignoring the pipeline processing overhead;

A pruning submodule, used for pruning the current node and its child nodes when the minimum value of the time interval is greater than the minimum value of the time interval of other nodes;

The determination submodule is used to determine the grouping scheme corresponding to the nodes finally remaining in the search tree after pruning as the grouping plan.

In an optional implementation, the declarative application programming interface includes:

A query request information receiving submodule, configured to receive query request information input by a user, wherein the query request information includes at least: vectors of a batch query request, search accuracy requirements, expected query processing time, and the number of nearest neighbor vectors returned;

A conversion submodule, used to convert the query request information into search configuration and resource configuration;

The request generation submodule is used to execute the search configuration and the resource configuration to generate the batch query request.

In an optional implementation, the GPU processor includes:

A storage manager, configured to extract transmission tasks from the global packet queue and maintain a local packet transmission queue;

The storage manager is further used to notify the kernel controller to execute the corresponding computing task and start to execute the transmission task of the next packet according to the local packet transmission queue after completing the transmission task of the current packet;

A kernel controller, used for extracting computing tasks from the global packet queue and maintaining a local packet computing queue;

The kernel controller is further used to execute the calculation task of the current group according to the local group calculation queue, and generate the vector query result after completing the execution of all groups.

In an optional implementation, the kernel controller includes a dynamic kernel expansion module and a plurality of stream processors;

The dynamic kernel expansion module is used to divide each of the balance vector clusters in the current group into a plurality of sub-vector clusters according to the characteristics of the balance vector cluster address;

The dynamic kernel expansion module is further used to treat the calculation of the vector query request on each of the sub-vector clusters as a block calculation task, and evenly distribute the block calculation tasks to the multiple stream processors;

The stream processor is used to execute the block computing task assigned by the dynamic kernel extension module.

The embodiment of the present invention further provides an electronic device, referring to FIG10, which is a schematic diagram of the structure of the electronic device proposed in the embodiment of the present invention. As shown in FIG10, the electronic device 100 includes: a memory 110 and a processor 120, the memory 110 and the processor 120 are connected via a bus communication, the memory 110 stores a computer program, and the computer program can be run on the processor 120, thereby implementing the steps in a server-unaware vector query method based on an unstructured data set disclosed in the embodiment of the present invention.

An embodiment of the present invention further provides a computer-readable storage medium having a computer program/instruction stored thereon. When the computer program/instruction is executed by a processor, the steps of a server-unaware vector query method based on an unstructured data set disclosed in an embodiment of the present invention are implemented.

An embodiment of the present invention further provides a computer program product, including a computer program/instruction, which, when executed by a processor, implements the steps in a server-unaware vector query method based on an unstructured data set disclosed in an embodiment of the present invention.

The various embodiments in this specification are described in a progressive manner, and each embodiment focuses on the differences from other embodiments. The same or similar parts between the various embodiments can be referenced to each other.

The embodiments of the present invention are described with reference to the flowcharts and/or block diagrams of the methods, devices, electronic devices, and computer program products according to the embodiments of the present invention. It should be understood that each process and/or box in the flowchart and/or block diagram, as well as the combination of the processes and/or boxes in the flowchart and/or block diagram, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, a special-purpose computer, an embedded processor, or other programmable data processing terminal device to generate a machine, so that the instructions executed by the processor of the computer or other programmable data processing terminal device generate a device for implementing the functions specified in one process or multiple processes in the flowchart and/or one box or multiple boxes in the block diagram.

Although the preferred embodiments of the present invention have been described, those skilled in the art may make additional changes and modifications to these embodiments once they have learned the basic creative concept. Therefore, the appended claims are intended to be interpreted as including the preferred embodiments and all changes and modifications that fall within the scope of the embodiments of the present invention.

Finally, it should be noted that, in this article, relational terms such as first and second, etc. are only used to distinguish one entity or operation from another entity or operation, and do not necessarily require or imply any such actual relationship or order between these entities or operations. Moreover, the terms "include", "comprise" or any other variants thereof are intended to cover non-exclusive inclusion, so that a process, method, article or terminal device including a series of elements includes not only those elements, but also other elements not explicitly listed, or also includes elements inherent to such process, method, article or terminal device. In the absence of further restrictions, the elements defined by the sentence "including one..." do not exclude the existence of other identical elements in the process, method, article or terminal device including the elements.

The above is a detailed introduction to a server-aware vector query method and system based on an unstructured data set provided by the present invention. This article uses specific examples to illustrate the principles and implementation methods of the present invention. The description of the above embodiments is only used to help understand the method of the present invention and its core idea; at the same time, for general technical personnel in this field, according to the idea of the present invention, there will be changes in the specific implementation method and application scope. In summary, the content of this specification should not be understood as a limitation on the present invention.

Claims (10)

1. A server-unaware vector query method based on an unstructured data set, characterized in that the method comprises: Obtaining a batch query request by using a server-unaware declarative application programming interface, where the batch query request includes a plurality of vector query requests; Using an IVF index constructed offline based on an unstructured data set, multiple vector clusters corresponding to the batch query request are searched and obtained, and a query plan is generated, wherein the query plan represents: a transmission order of the multiple vector clusters from the main memory to the video memory of the GPU, and a calculation order of the vector query request in the vector cluster; wherein each of the vector clusters is divided into multiple balanced vector clusters; the balanced vector cluster represents a vector cluster whose variance value obtained by dividing the vector cluster is less than a preset variance value; Optimizing the query plan, eliminating redundant transmissions in the query plan, and obtaining an optimized query plan; Acquire transmission time information and calculation time information, and reorder the optimized query plan with the balance vector cluster as the granularity to obtain the optimal execution order; Using a dynamic programming algorithm, grouping the optimal execution sequence to obtain a grouping plan; According to the grouping plan, each group is pushed into the global grouping queue for transmission and calculation to obtain a vector query result. 2. The server-unaware vector query method based on unstructured data sets according to claim 1, characterized in that said optimizing the query plan and eliminating redundant transmission in the query plan comprises: Adjusting the number of transmissions of each of the vector clusters to at most once; The calculation order of the vector clusters already existing in the video memory of the GPU is adjusted forward. 3. The server-unaware vector query method based on unstructured data sets according to claim 1, wherein the step of obtaining transmission time information and calculation time information comprises: The transmission time information of each vector cluster is calculated according to the following formula: Transfer time = ,in, is the size of the equilibrium vector cluster within the vector cluster, a and b are transmission time parameters pre-fitted by the least square method, and m represents the number of the equilibrium vector clusters within the vector cluster; The calculation time information of each vector cluster is calculated according to the following formula: Compute time = , where A and B are the calculation time parameters obtained in advance by least squares fitting; The transmission time information represents the time information required for each of the vector clusters to be transmitted from the main memory to the video memory of the GPU, and the calculation time information represents the time information required for calculating the corresponding query request in each of the vector clusters. 4. The server-unaware vector query method based on unstructured data sets according to claim 1, characterized in that the vector cluster is divided into a plurality of balanced vector clusters by the following steps, the steps comprising: Dividing each of the vector clusters according to the size of the minimum vector cluster to obtain a plurality of candidate vector clusters; Determining whether the variance of the candidate vector cluster size is less than the preset variance value; In a case where the variance of the size of the candidate vector cluster is less than the preset variance value, determining the candidate vector cluster as the balanced vector cluster; When the variance of the candidate vector cluster size is greater than or equal to the preset variance value, the size of the minimum vector cluster is recursively halved, and the cluster is divided according to the halved vector cluster size to generate a new candidate vector cluster until the variance of the candidate vector cluster size is less than the preset variance value. 5. The server-unaware vector query method based on unstructured data sets according to claim 1, characterized in that the obtaining of transmission time information and calculation time information, taking the balance vector cluster as the granularity, and reordering the optimized query plan comprises: According to the transmission time information, the execution order of the balance vector cluster with zero transmission time is moved to the first place; According to the calculation time information, the execution order of the balance vector cluster requiring a larger calculation time is adjusted forward. 6. The server-unaware vector query method based on unstructured data sets according to claim 1, characterized in that the use of a dynamic programming algorithm to group the optimal execution order to obtain a grouping plan comprises: Using a dynamic programming algorithm, traverse the nodes of the search tree, each of the nodes represents a grouping scheme, and the child nodes of each node represent the sub-schemes of the grouping scheme; By completely overlapping the remaining transmission and calculation, ignoring the pipeline processing overhead, the estimated time interval required to execute the grouping scheme of the current node is calculated; When the minimum value of the time interval is greater than the minimum value of the time interval of other nodes, pruning the current node and its child nodes; The grouping scheme corresponding to the nodes finally remaining in the search tree after pruning is determined as the grouping plan. 7. The server-unaware vector query method based on unstructured data sets according to claim 1, wherein the step of obtaining batch query requests by using a server-unaware declarative application programming interface comprises: Receive query request information input by a user, wherein the query request information includes at least: vectors of a batch query request, search accuracy requirements, expected query processing time, and the number of nearest neighbor vectors returned; The query request information is converted into search configuration and resource configuration through the server-unaware declarative application programming interface; The search configuration and the resource configuration are executed to generate the batch query request. 8. The server-unaware vector query method based on unstructured data sets according to claim 1, characterized in that the step of pushing each group into a global group queue for transmission and calculation according to the grouping plan to obtain a vector query result comprises: Extracting transmission tasks from the global packet queue through a storage manager and maintaining a local packet transmission queue; According to the local packet transmission queue, after completing the transmission task of the current packet, the storage manager notifies the kernel controller to execute the corresponding computing task and starts to execute the transmission task of the next packet; Extracting computing tasks from the global packet queue through the kernel controller and maintaining a local packet computing queue; According to the local group calculation queue, the kernel controller executes the calculation task of the current group, and after completing the execution of all groups, the kernel controller generates a vector query result. 9. The server-unaware vector query method based on unstructured data sets according to claim 8, wherein the kernel controller executes the calculation task of the current group, including: According to the characteristics of the balance vector cluster address, each of the balance vector clusters in the current group is divided into a plurality of sub-vector clusters; The calculation of the vector query request on each of the sub-vector clusters is regarded as a block calculation task, and the block calculation tasks are evenly distributed to multiple stream processors on the GPU; Each of the stream processors executes the assigned block computing task. 10. A server-unaware vector query system based on unstructured data sets, characterized in that the system comprises: A declarative application programming interface, used to obtain a batch query request using a server-unaware declarative application programming interface, wherein the batch query request includes multiple vector query requests; A vector database, used to use an IVF index built offline based on an unstructured data set to search for multiple vector clusters corresponding to the batch query request and generate a query plan, wherein the query plan represents: a transmission order of the multiple vector clusters from the main memory to the display memory of the GPU, and a calculation order of the vector query request in the vector cluster; wherein each of the vector clusters is divided into multiple balanced vector clusters; the balanced vector cluster represents a vector cluster whose variance value obtained by dividing the vector cluster is less than a preset variance value; A query plan optimization module, used to optimize the query plan, eliminate redundant transmissions in the query plan, and obtain an optimized query plan; A pipeline scheduler, used for obtaining transmission time information and calculation time information, and reordering the optimized query plan with the balance vector cluster as the granularity to obtain the optimal execution order; The pipeline scheduler is further used to group the optimal execution order using a dynamic programming algorithm to obtain a grouping plan; The GPU processor is used to push each group into the global grouping queue for transmission and calculation according to the grouping plan to obtain the vector query result.