JP2013004093A - Search method and system by multi-instance learning - Google Patents

Abstract

PROBLEM TO BE SOLVED: To disclose a search method and system by multi-instance learning.SOLUTION: Disclosed is a search method including: acquiring a training package including a positive training package and a training instance in the training packages; generating a weight in each training instance in the positive training package; acquiring, as for all instances in the training package and a test package, a sort score in each test instance by using the weight of each training instance in the positive training package; specifying the sort scores of each test package on the basis of the sort score of each test instance in the test package; and specifying a search result on the basis of the sort scores of the test package, and the absolute size of the weight indicates an extent to which the lookup word meaning of a user can be expressed by the corresponding training instance. Thus, it is possible to much more sufficiently use information provided by the instance in the positive training package, and to improve search performance.

Description

  The present invention relates generally to the field of image processing technology, and more particularly to a search method and system using multi-instance learning.

  With the rapid increase in the number of digital images, there is a need for fast and effective image retrieval techniques. The technology can be applied in many ways to human daily life, such as digital photo management, online shopping, remote education and the like.

  The image search technology mainly includes an image search technology by text and an image search technology by contents. Unlike image search technology using text, content-based image search technology automatically extracts visual content features such as hue, texture, and shape for each image without generating an index based on the drawing of characters on the image. And generating an index based on such visual content features. In performing a search, the user can select one or more representative sample images to construct a lookup, and then cause the search system to search for images that are similar to the visual content features of the sample images.

  Image retrieval based on region features is one of the important methods of image retrieval based on contents because region features are well matched to human visual perception and a search technique based on region features generally provides better search performance. Search based on region features is a method of extracting meaningful regions in an image using image segmentation technology, then drawing using local features for each region, and integrating each region feature to obtain a feature drawing of the image. The search is performed by designing a search algorithm based on the features. Multi-instance learning is an efficient algorithm that has been successfully applied to image retrieval by region.

  In image search by multi-instance learning, each image is used as a package, and each region in the image is used as an instance. The data set is composed of packages with type indicators, each package containing a few instances without type indicators. As a basic starting point for multi-instances, if a package contains at least one positive instance (described below), the package is labeled as a positive training package. On the other hand, if all instances in a package are negative, the package is labeled as a negative training package.

  A negative training package always contains negative instances. A positive training package may include both positive and negative instances therein. Furthermore, the system does not know which instances are positive and which are negative. Thus, in multi-instance learning, the most important issue is how to perform a search using information provided by instances in a positive training package.

  Algorithms in the prior art are generally intended to select positive instances included in positive training packages using a suitable method. This method has the disadvantage that at least the number of instances to be selected needs to be determined in advance. For example, if there is a restriction that only one positive instance can be selected from each positive training package, only one instance will be involved in the final search, but is actually included in the positive training package Often there is not just one positive instance. If a search is performed using only one instance among them, the information provided by the instances in the positive training package cannot be fully utilized, and the search performance is limited.

  In view of the above circumstances, an embodiment of the present invention provides a search method and system by multi-instance learning in which information provided by an instance in a positive training package is more fully utilized and search performance is improved.

  According to one aspect of an embodiment of the present invention, there is provided a search method using multi-instance learning, including a training package including a positive training package and a training instance in the training package, and each training instance in the positive training package. For each of the instances in the training package and the test package, obtain the respective sort score of the test instance using the weight of each of the training instances in the positive training package, and each of the test instances in the test package Identifying a respective sort score for the test package based on a sort score for the test package, and identifying a search result based on the sort score for the test package, wherein the absolute magnitude of the weight includes a corresponding lesson Instance representing a degree representable lookup semantics of user, a method is provided.

  According to another aspect of an embodiment of the present invention, a search system with multi-instance learning, an acquisition means configured to acquire a training package including a positive training package and a training instance in the training package; A training instance weight generating means configured to generate a weight for each training instance in the positive training package, and for each of the instances in the training package and the test package, each weight of the training instance in the positive training package is used. A test instance sort score obtaining means configured to obtain each sort score of the test instance, and each of the test packages based on each sort score of the test instance in the test package A search result specifying means configured to specify a sort score and to specify a search result based on the sort score of the test package, wherein the absolute magnitude of the weight is determined by the user corresponding to the training instance. A system is provided that represents the degree to which lookup semantics can be expressed.

  According to another aspect of the present invention, a storage medium is further provided. The storage medium includes machine readable program code. When the program code is executed by an information processing apparatus, it causes the information processing apparatus to execute the search method based on the multi-instance learning according to the present invention.

  According to another aspect of the present invention, a program is further provided. The program includes machine readable commands. When the command is executed by the information processing apparatus, it causes the information processing apparatus to execute the search method by multi-instance learning according to the present invention.

  According to the method of the embodiment of the present invention, a weight can be generated for each training instance in the positive training package in the process of performing an image search. The absolute magnitude of the weight represents the degree to which the corresponding training instance can represent the user's lookup semantics. As a result, when calculating the sort score of each test instance in the test package at the end, for each training instance in the positive training package, each weight is set as the initial label, and finally the sort score of each test instance is set. Based on this, the sort score of the test package can be obtained and a search result can be given. Therefore, in an embodiment of the present invention, it is not intended to select a limited number of positive instances from the positive training package, but for each instance in the positive training package, each weight is calculated and The degree of agreement between each instance and the user's lookup semantics is expressed in absolute size. Thereby, the sort score of each test instance in the test package is acquired based on the weight of each instance in each positive training package. This fully utilizes the information provided by each of the training instances in the positive training package and contributes to improved search performance.

  Other aspects of embodiments of the invention are provided in the following specification. Here, the detailed description is for the purpose of fully disclosing preferred embodiments of the embodiments of the present invention and is not intended to be limiting.

The above and other objects and advantages of the embodiments of the present invention will be further described below using specific embodiments with reference to the drawings. In the drawings, the same or corresponding technical features or parts are denoted by the same or corresponding reference numerals.
4 is a flowchart illustrating a method provided by an embodiment according to the present invention. 6 is a flowchart illustrating another method provided by an embodiment according to the present invention. 1 is a schematic diagram showing a first apparatus provided by an embodiment according to the present invention. FIG. 3 is a schematic diagram showing a second apparatus provided by an embodiment according to the present invention. FIG. 6 is a schematic diagram showing a third device provided by an embodiment according to the present invention. FIG. 6 is a schematic diagram showing a fourth apparatus provided by an embodiment according to the present invention. It is a block diagram which shows the typical structure of the personal computer of the information processing apparatus employ | adopted by the Example by this invention.

  Embodiments of the present invention will be described below with reference to the drawings.

  For ease of understanding, here are first some concepts according to embodiments of the present invention: training package, training instance, positive training package, negative training package, positive instance, negative instance, test package. , Including test instances).

  First, in the multi-instance learning framework, each image is regarded as one package, and each region in the image is regarded as one instance. Note that after the sample image that is the search seed is divided into a plurality of regions, each of the regions is called a training instance, and all the training instances in one sample image constitute one training package. In other words, one sample image corresponds to one training package, and one training package includes a plurality of training instances.

  The training instance includes a positive instance and a negative instance. The positive instance can express the user's lookup meaning (search intention / search target), and the negative instance cannot express the user's lookup meaning. Training packages can be divided into positive training packages and negative training packages. A positive training package contains at least one positive instance. All instances included in the negative training package are negative instances. For example, if the user tries to search for an image with a tiger, the sample image provided may be an image with a tiger, but the image may contain some background, such as trees, lawn, etc. There is also sex. That is, in the sample image, tigers are actually displayed only in some areas, and trees, lawns, and the like are displayed in other areas. In this way, when performing segmentation on the sample image, tiger patterns are displayed in some areas, while only trees, lawns, etc. are displayed in some areas. is there. Since the user's lookup semantics [search intention / search target] should search for images with tigers, for the sample image, the instance corresponding to the region with the pattern of tigers is a positive instance, An instance corresponding to a certain area such as lawn is a negative instance. Since the training package corresponding to the sample image includes both positive and negative instances, the training package is a positive training package. The sample image may be referred to as a positive sample image. If the user wants to search is an image with a tiger, but all the sample images provided are patterns such as trees, lawns, etc. The lookup meaning [search intention / search target] cannot be expressed, and corresponds to a negative instance. On the other hand, the training package corresponding to the sample image is also a negative training package, and the sample image may be referred to as a negative sample image.

  The sample image may be provided by the user when starting the search, or may be selected by the user by presenting the search system during the search. There may be a plurality of sample images. Furthermore, not only positive sample images but also negative sample images may be provided. Along with that, the user should inform the system which are positive sample images and which are negative sample images. In contrast, after the search system has performed region segmentation on the sample image, it can also understand which training packages are positive and which training packages are negative. However, immediately after obtaining an instance in the positive training package, the system does not know which is a positive instance or which is a negative instance in the positive training package, You have to get the level information. Therefore, the sample image is called a training image. That is, in order to perform an image search, first, it is necessary to perform training based on an instance in a sample image and acquire usable information. Thereby, further subsequent search processing can be completed.

  The search system selects an image corresponding to the user's lookup semantics from the image database. Note that the image database includes various images. These images are test images. In multi-instance image retrieval, it is also necessary to divide the test image into regions. The divided area is called a test instance. In contrast, a test instance in one test image constitutes one test package.

  The image search method provided in the embodiment according to the present invention will be described in detail below.

  Referring to FIG. 1, a search method using multi-instance learning provided by an embodiment according to the present invention includes the following steps.

  S101: A training package and a training instance in the training package are acquired. The training package includes a positive training package.

  As explained above, the training package may be provided by the user. For example, when starting an image search, the user can select one or a plurality of images as sample images. The search system performs region segmentation on these sample images, so that each region corresponds to one training instance, and one sample image corresponds to one training package. In an embodiment of the invention, the training package includes at least a positive training package. Of course, training packages may include not only positive training packages but also negative training packages in order to obtain better search results. That is, when providing a sample image, the user can provide not only a positive sample image but also a negative sample image.

  S102: A weight is generated for each training instance in the positive training package. The absolute magnitude of the weight represents the degree to which the corresponding training instance can represent the user's lookup semantics.

  In an embodiment of the present invention, a weight is generated for each training instance in the positive training package without selecting a limited number of positive instances from the positive training package. The weight represents the degree to which the corresponding training instance can represent the user's lookup semantics. Here, in the embodiment of the present invention, the absolute magnitude of the weight can represent the degree that the user's lookup meaning can be expressed. That is, if an instance in a positive training package is indeed a positive instance, the weight generated for that package is greater than the weight of the negative instance, and the weight itself is a positive value.

  S103: For all instances in the training package and the test package, a sort score (score used for ranking) of each test instance is acquired using the weight of each training instance in the positive training package.

  After obtaining the respective weights for the training instances in the positive training package, for all instances in the training package and the test package, the similarity between all instances and for each training instance in the positive training package A sort score for each test instance can be obtained based on the weight. That is, the weight of each instance in the positive training package is applied to the process of calculating the sort score for the test instance in the test package.

  In other words, in a general search method, after acquiring some information from a positive training package, a package that expresses the user's lookup semantics (search intention / search target) from the test package using the information is used. Search. These pieces of information are, for example, sort scores of instances. In the conventional method, the sort score is a relative value, and the degree to which the instance matches the user's lookup semantics cannot be expressed directly. In an embodiment of the present invention, instead of the sort score, the weight of each instance in the positive training package can be used to directly express the degree to which the instance matches the user's lookup semantics.

  S104: The sort score of each test package is specified based on the sort score of each test instance in the test package, and the search result is specified based on the sort score of the test package.

  After the sort score for each test instance is obtained, the sort score for the test package can be identified based on the sort score for the test instance. For example, for a test package, a value obtained by averaging the sort scores of the test instances in the test package can be used as the sort score of the test package. Of course, in general, only one or a small number of instances may be positive instances in one test package, so if the test package sort score is obtained using the above average method, Test package sort score may be low. In order to improve the appropriateness of the sort score of the test package, the maximum value of the sort score of each test instance in the test package may be used as the sort score of the test package.

  After obtaining the sort score for each test package, search results can be provided to the user based thereon. For example, images corresponding to a predetermined number of test packages with higher ranks in the sort score may be returned to the user, or after each test package is sorted according to the sort score, it corresponds to the test package according to the order. The images to be performed may be sequentially provided to the user.

  In short, in the process of performing the image search, a weight can be generated for each training instance in the positive training package. The absolute magnitude of the weight represents the degree to which the corresponding training instance can represent the user's lookup semantics. Thus, when the sort score of each test instance in the test package is finally calculated, the weight of each training instance in the positive training package is set as the initial label, and finally the sorting score of each test instance is calculated. Based on the test package, you can get the sort score of the test package and give the search result. As described above, in the embodiment of the present invention, each weight is calculated for each instance in the positive training package without intending to select a limited number of positive instances from the positive training package. Obtain the sort score of each test instance in the test package based on the weight of each instance in each positive training package by representing the consistency between each instance and the user's lookup semantics with the absolute magnitude of the weight To do. In this way, the search performance is improved by fully utilizing the information provided by each training instance in the positive training package.

  In concrete implementation, there are various methods for generating the weight for each training instance in the positive training package. One implementation means will be described in detail below. Referring to FIG. 2, the following steps may be included.

  S201: Obtain an initial weight of a training instance in a positive training package.

  The initial weight of the training instance in the positive training package can be set in the profile in advance. Thereby, the system can acquire the initial weight by means of reading the profile. For example, it may be installed uniformly at 10 (of course other values may be used, but generally a positive value).

  S202: Acquire a training package and a training instance in the training package, and learn using a graph algorithm (described later) based on the similarity between the training instances to acquire a sort score for each training instance.

  After the training package and the training instance are acquired, learning can be performed by employing a graph algorithm to acquire the sort score of each training instance. During learning, learning by a graph is performed mainly based on the similarity between training instances.

  Here, the process of acquiring the sort score of each training instance by performing learning based on an algorithm based on a graph is a conventional technique and is not the main point of the present invention. Therefore, only a brief description will be given here.

  Learning by graphs can be performed by the following method. That is, a weighted graph is first constructed. The nodes in the graph correspond to all training instances in the training package. That is, assuming that there are two training packages and each training package has five training instances, there are 10 nodes in the constructed graph. The weight of an edge in the graph represents the similarity between two nodes connected to the edge. Next, learning is performed using an algorithm based on a graph. At the end of the algorithm, each training instance can correspond to one sort score.

  Note that when calculating the similarity between nodes, the visual feature (generally in the form of a vector) is extracted from each training instance, and then the distance between the two is calculated using the vector calculation method. Can do. Here, the smaller the distance, the higher the similarity. Conversely, the greater the distance, the lower the similarity. Of course, in the actual application, in addition to extracting the visual features, it is also possible to separately acquire features relating to each training instance, such as drawing information. In addition, these pieces of information can be added to the calculation of the similarity between training instances.

As described above, constructing a weighted graph is an explanation method based on a figure. For the computer system, the data corresponding to the weighted graph is an n × n matrix S. Note that n is the total number of training instances. That is, in the above example, if there are 10 training instances, the matrix has 10 rows and 10 columns, and the element S _ij of the i-th row and the j-th column is the i-th training instance and the j-th row. Corresponds to the similarity between training instances. Furthermore, normalization processing by rows can be performed on the matrix.

There are many specific implementation methods for graph algorithms. For example, in one embodiment, the following method can be used. That is, first, initial labels are set for all training instances. For example, if all training packages are positive training packages, the initial label for all training instances can be 1. If a training package has both a positive training package and a negative training package, the initial label of all training instances in the positive training package is 1, and the initial label of all training instances in the negative training package is -1. It can be. The initial label is then transmitted on the previously constructed weighted graph until it has global stability. Finally, the sort score of each training instance can be obtained. For a computer system, the process of transmitting the labels on the weighted graph as described above can be achieved according to the following iterative formula.
f (t + 1) = αSf (t) + (1−α) y (1)
Where S is a normalization matrix corresponding to the constructed graph. y is a label vector composed of initial labels for each training instance. For example, if there is one positive training package and one negative training package, each of which has five instances, y is (1,1,1,1,1, −1, −1 , -1, -1, -1) ^T. α (0 <α <1) is a linear combination coefficient. f (t) is also a vector, the number of elements in it is the same as the number of training instances, and each element corresponds to the value of the label corresponding to each training instance after the tth iteration. For example, f (1) represents a vector consisting of labels for each training instance after the first iteration. In the initial state, f (0) may take any value, and in one specific embodiment f (0) may be equal to y.

  That is, iterative steps can be performed a plurality of times using equation (1). The convergence of the iterative process corresponds to the state having global stability when transmitting on the weighted graph, and then obtains the corresponding f (t), A sort score for each training instance can be obtained based on the value of the element. In a specific implementation, it can be determined whether the iterative process has converged by the following method. That is, it is determined whether or not f (t) and f (t−1) are very close (the distance between the two can be calculated and compared with a certain threshold value). If the result of this determination is affirmative, it is determined that the process has converged, and the iterative process may be terminated. Of course, it may be realized by a method in which the number of repetitions is provided in advance, and detailed description thereof is omitted here.

The reason why the iterative process is performed by using the formula (1) is because it is necessary to minimize the following function to be minimized.

は重み付きグラフにより得られた平滑性拘束条件（smoothness constraint）である。f_i、f_jはfの中のi項目及びj項目である。即ち、類似した訓練インスタンスに対応するソートスコアの差異は大きくないことが期待される。二つ目の拘束関係

は、初期ラベルによるフィッテング〔適合〕拘束条件（fitting constraint）である。即ち、最終的なソートスコアと初期ラベルとの差異が大きくないことが期待される。ただし、μは2つの項目の重要性のバランスを取るための重みである。(１)式におけるαはμで算出することができる。即ちα＝1／(1＋μ)。このように、上記の関数を最適化することにより、(１)式における反復的な式を得ることができる。言い換えれば、(１)式を用いて反復を行うことにより、最終的なソートスコアに(２)式における拘束条件を満足させることができる。そして、このように算出されたソートスコアの高さは、対応する訓練インスタンスがユーザのルックアップ語義〔検索意図、検索対象〕を表現可能な度合いを表すことができる。即ち、訓練インスタンスのソートスコアが高いほど、ユーザのルックアップ語義を表すことができる。 The function to be minimized consists of two constraint relationships. First restraint relationship

Is the smoothness constraint obtained by the weighted graph. f _i and f _j are i and j items in f. That is, it is expected that the difference in the sort scores corresponding to similar training instances is not large. Second constraint relationship

Is the fitting constraint with the initial label. That is, it is expected that the difference between the final sort score and the initial label is not large. However, μ is a weight for balancing the importance of the two items. Α in the equation (1) can be calculated by μ. That is, α = 1 / (1 + μ). Thus, by optimizing the above function, an iterative formula in the formula (1) can be obtained. In other words, by performing the iteration using the equation (1), the final sort score can satisfy the constraint condition in the equation (2). The height of the sort score calculated in this way can represent the degree to which the corresponding training instance can express the user's lookup semantics (search intention, search target). That is, the higher the sort score of the training instance, the more the user's lookup meaning can be expressed.

Here, since the number of training instances is generally not large when specifically realized, the final result may be obtained by directly using the analytical solution of equation (1).
f * = (1−α) (I−αS) ⁻¹ y (3)
Here, I is a unit matrix.

  Step S203: Identify a positive neighboring instance set (discussed below) for each training instance in the training package, and for each training instance, a positive neighboring instance based on the sort score of each training instance in the positive neighboring instance set Change the weight of the training instance in the set, thereby obtaining the final weight of each training instance in the positive training package. In addition, the positive neighboring instance set of the training instance is configured by a training instance in a positive training package having a similar relationship provided in advance with the training instance.

  In step S202, the sort score of each training instance is calculated to indicate the degree to which each training instance can express the user's lookup semantics. However, in realizing the present invention, the present inventors have found that the sort score calculated by the method is generally relativistic, that is, the relative magnitude of the sort score of each training instance is significant. It was done. For example, in the sort score obtained by the above method, the sort score of each training instance in a certain positive training package may be negative. Note that if an instance is indeed a positive instance, it may be certainly higher than the sort score of a negative instance when that instance is represented in the sort score. However, if it is negative, its absolute size has lost its significance. However, since it is actually a positive training package, at least one training instance in it will be a positive instance, and the sort score of the positive instance will be a positive value. This can contribute to subsequent searches. Therefore, if the negative search value is directly used to perform a subsequent search process, the validity of the search results may be impaired. (The subsequent search process is the need to assign an initial label to a training instance. If a value is assigned by directly using the sort score obtained in step S202, a negative value may be assigned to the initial label of the positive instance in the positive training package). Thus, in an embodiment of the present invention, further processing is required after the sort score for the training instance is obtained.

  Various methods can be employed to perform the further processing. For example, simply, after the sort score of each training instance is calculated, an offset in each sort score is added so that the sort score of at least one training instance in the positive training package has a positive value. As a result, it is possible to avoid that the sort scores of all the training instances in one positive training package are all negative values.

  Alternatively, in the embodiment of the present invention, the above process may be realized by employing the following method. That is, first, each training instance is searched for a positive neighboring instance set of each training instance. For a training instance L, a positive neighboring instance set of a training instance L is an adjacency / similarity in which the set consists of training instances in a positive training package and each instance in the set is with the training instance L It has a relationship. In a concrete realization, what kind of adjacency / similarity needs to be satisfied may be set in advance, for example, whether the similarity between two training instances is greater than a certain threshold Can be set easily. Or in the Example of this invention, you may calculate based on the transition relationship in the weighted graph constructed | assembled by step S202.

  In addition, when calculating based on the transition relationship in the weighted graph, the similarity relationship between the nodes can be specified based on the primary or higher order transmission relationship between the nodes. Here, the primary transmission relationship indicates the similarity between two training instances. A secondary transfer relationship has a very high similarity between instance 1 and instance 2 and a relatively high similarity between instance 2 and instance 3, and instance 1 and instance 3 When the degree of similarity is directly calculated, the instance 1 and the instance 3 are considered to satisfy a certain similarity even if the score is low. Others can be inferred from this.

  Here, a positive neighboring instance set is not found for each training instance. That is, for a training instance, its positive neighbor instance set may be empty.

  In an embodiment of the present invention, the initial weight of each training instance in the positive training package is known in advance. Thus, after the positive neighboring instance set for each training instance is obtained, the weights of the instances in the set can be adjusted. There are a variety of adjustment policies when specifically adjusting for each instance in the same positive neighboring instance set. For example, in one policy, the adjustment range of each training instance is specified according to the height of the sort score of each training instance. For example, the weight of the training instance having the highest sort score is increased by 1, and is the second highest. Things may increase by 0.8, the third highest may increase by 0.5, and so on. Of course, in other adjustment policies, the adjustment may be performed on one training instance having the highest sort score, which is not listed here.

  Here, when there is both a positive training package and a negative training package in the training package, when specifically adjusting the weight of the training instance, for the training instance in the positive training package, its positive neighbor Adjustments can be made to increase the weight of the instances in the instance set, and for training instances in the negative training package, adjustments can be made to decrease the weight in the positive neighboring instance set. That is, a training instance in a negative training package is never a positive instance, so if an instance in a positive training package has a similar relationship to it, the instance in that positive training package may not be a positive instance Therefore, it is reasonable to reduce the weight.

  For a training instance in a positive training package (for ease of explanation, let's take a training instance A in a positive training package as an example), it is unknown whether A is a positive instance or a negative instance. There is a possibility that it is a positive instance. Thus, if other instances in the positive training package have a similar relationship to it, i.e., if these other instances constitute a set of positive neighboring instances of training instance A, then training instance A will have its positive neighbors. The instance weight in the instance set can be increased. As a result, there are two possibilities. One possibility is that if the training instance A is indeed a positive instance, it is likely that an instance in the positive neighboring instance set is a positive instance, so it is reasonable to increase its weight. Is. Another possibility is that if training instance A is located in a positive training package, but is a negative instance, it is unlikely that an instance in its positive neighboring instance set is a positive instance, so that At first glance, it is unreasonable to increase the weight. However, here each positive training instance has its own set of positive neighboring instances (of course the set may be empty), and the same training instance in the positive training package has different May be located in a positive neighboring instance set. Thus, in the second case above, instances in training instance A's positive neighboring instance set are located in training instance B or other instance's positive neighboring instance set, and training instance B or other instance is May be an instance in a negative training package. Therefore, an operation of further reducing the weight of the instance in the positive neighboring instance set is performed. Thereby, the weight increased before that can be reduced. This means that training instances in a positive training package may be subject to multiple weight adjustment operations, some are consistently larger, some are consistently smaller, and some are partially It is increased and partially reduced, and finally each training instance in the positive training package has its own weight.

  Further, when all of the components constituting the training package are positive training packages, when adjusting the weight of the training instance, the specific adjustment operation may be an operation for increasing the weight. Here, in this case, only the operation of increasing can be performed, but the sort score of each training instance is different, and the case where each of the training instances is located in the positive neighboring instance set is also different, so that the positive training package still remains. Each training instance in can also have a different final weight. Here, even if there is only a positive training package, the final weight obtained can still represent the degree of matching between each training instance in the positive training package and the user's lookup semantics. This is determined by the previously described feature of “positive instances are generally similar” and will not be described in detail here.

  With the above method, a weight can be generated for each training instance in the positive training package. Next, when performing a search using the weight, the following steps may be included.

  S204: For all instances in the training package and the test package, learning is performed using an algorithm based on a graph based on the similarity between all instances to obtain a sort score for each test instance. Note that the initial label of each training instance in the positive training package is specified by the final weight.

  After the weight of each instance in the positive training package is obtained, learning can be performed based on a graph algorithm to specify the sort score of each test instance for all instances in the training package and test package. it can. When learning is performed based on a graph algorithm, a weighted graph is first constructed as in step 202. In the graph, the node corresponds to all instances in the training package and the test package, and the edge weight represents the similarity between two nodes connected to the edge. Here, when learning is performed based on the algorithm according to the figure, it is necessary to set an initial label for each instance (for example, in step S202, the initial labels of all instances in the positive training package are set to 1, The initial label for all instances in the negative training package can be set to −1). In the embodiment of the present invention, when it is necessary to calculate the sort score for each instance in the test package, the positive training package in the training package is determined based on the final weight obtained in step S203. You can specify the initial label of the instance.

  That is, the weight for each instance in the positive training package is calculated in step S203, and calculated in step S204 when it is necessary to learn the algorithm based on the graph based on all the instances in the training package and the test package. An initial label for each training instance in the positive training package can be identified based on the weights. For example, after performing the normalization process directly on the weight of each training instance in the positive training package calculated in step S203, the normalized value is used as the initial label of each training instance in the positive training package. can do.

If the training package has a negative training package, the initial label of each training instance in the negative training package may still be set to -1. Similar to step S202, the initial label of each instance can be transmitted on the previously constructed weighted graph until it has global stability, and finally the sort score of each test instance can be obtained. . For a computer system, the process of transmitting labels on a weighted graph as described above can be completed by the following iterative formula.
f (t + 1) ＝ Sf (t) (4)
Here, S is a normalization matrix corresponding to a graph constructed based on all instances in the training package and the test package. f (t) is a vector, the number of elements in it is the total number of training instances and test instances, and each element corresponds to the value of the corresponding label in each instance after the tth iteration. . For example, f (1) represents a vector composed of labels of each instance after the first iteration process. In the initial state, f (0) may be a vector composed of initial labels corresponding to each instance. When the iterative process ends, the value of each element in f (t) can be used as the sort score for each instance.
Here, when the iterative process is performed using the equation (4), a new initial value is assigned to the label of each training instance in f (t) every time an iterative process is completed. That is, in the iteration process, the training instance label is retained as it is, in other words, always equal to the initial label (but the training instance label in the positive training package is always the previously calculated weight or normalization. While equal to the processed weight, the label of the training instance in the negative training package is always equal to the given initial value, eg −1). Of course, each time an iterative process is completed, the label of the test instance will change. However, the initial label of each test instance in the test package can be arbitrarily set. This is because the final calculation result is not related to the initial label value of the test instance.

  Also, as described above, without obtaining the final sort score by the iterative method, the final result is obtained by directly using the analytical solution of equation (4). May be. The result is the same as with iteration. Of course, when the number of test instances generally increases, the analytical solution involves an operation for obtaining the inverse of the matrix, so that the operation complexity becomes higher than the iterative method. In addition, regarding the learning by the graph in step S204, the previous description can be referred to for portions not described in detail, and will not be described in detail here.

  S205: The sort score of each test package is specified based on the sort score of each test instance in the test package, and the search result is specified based on the sort score of the test package.

  The embodiment of the present invention provides a search system using multi-instance learning corresponding to the provided search method using multi-instance learning. Referring to FIG. 3, the system includes:

  The acquisition means 301 is configured to acquire a training package and a training instance in the training package. The training package includes a positive training package.

  It comprises training instance weight generation means 302 configured to generate a weight for each training instance in the positive training package. The absolute magnitude of the weight represents the degree to which the corresponding training instance can represent the user's lookup semantics.

  Test instance sort score acquisition means 303 configured to acquire the sort score of each test instance using the weight of each training instance in the positive training package for all instances in the training package and the test package.

  Search result specifying means 304 configured to specify the sort score of each test package based on the sort score of each test instance in the test package and to specify the search result based on the sort score of the test package is provided.

  Referring to FIG. 4, in generating weights specifically for the training instances in the positive training package, the training instance weight generating unit 302 may include the following.

  An initial weight learning sub-means 3021 configured to know the initial weight of the training instance in the positive training package is provided.

  A training instance sort score acquisition sub-unit 3022 configured to acquire a sort score of each training instance by employing a graph algorithm based on the similarity between the training instances is provided.

  Identify the positive neighboring instance set for each training instance in the training package and for each training instance, for each training instance in the positive training package, based on the sort score of each training instance in the positive neighboring instance set A weight correction sub- means 3023 is provided that is configured to change the weight of the training instance in the positive neighboring instance set to obtain the final weight. In addition, the positive neighboring instance set of the training instance is configured by a training instance having a similar relationship provided in advance with the training instance in the positive training package.

  When specifically realized, the training package may include a negative training package. On the other hand, the weight correction sub means 3023 may include the following.

  For each training instance in the positive training package, a weight increasing sub-means configured to increase the weight of the training instance in the positive neighboring instance set based on the training instance sort score in the positive neighboring instance set Prepare.

  For each training instance in the negative training package, a weight reduction sub-means configured to reduce the weight of the training instance in the positive neighboring instance set based on the training instance sort score in the positive neighboring instance set Prepare.

  Specifically, when correcting the sort score of the training instance in the positive neighboring instance set, a correction to increase or decrease only the sort score of the training instance having the largest sort score in the positive neighboring instance set. You can go. At this time, the weight correction sub means 3023 can be specifically configured to change the weight of the training instance having the highest sort score in the positive neighboring instance set.

  Specifically, various methods may be employed when determining a positive neighboring instance set. One way to do this is based on the first-order or higher-order transfer relationship of each node in the weighted graph built in the course of learning based on a graph-based algorithm. Instance set can be specified. That is, referring to FIG. 5, the weight correction sub means 3023 may include the following.

  To identify the positive neighboring instance set of each training instance in the training package based on the first-order or higher-order transmission relation of each node in the weighted graph constructed in the course of learning based on the algorithm by the graph It comprises a configured positive neighboring instance set identification sub-means 30231. In the weighted graph, a node corresponds to all training instances in the training package, and an edge weight corresponds to the similarity between two nodes connected to that edge.

  For each training instance, based on the sort score of each training instance in the positive neighboring instance set, the training instance in the positive neighboring instance set is obtained to obtain the final weight of each training instance in the positive training package. Compensation sub-means 30232 configured to change the weights.

  Specifically, the test instance sort score acquisition unit 303 adopts a graph algorithm based on the similarity between all instances for all instances in the training package and the test package. Learning to obtain a sort score for each test instance. Note that the initial label of each training instance in the positive training package is determined by its weight.

  Various methods can be employed to specify the test package sort score based on the test instance sort score. In one method, referring to FIG. 6, the search result specifying means 304 may include the following.

  A test package sort score specifying sub means 3041 is provided which is configured so that the maximum value of the sort score corresponding to each test instance in the test package is used as the sort score of the test package.

  Specific sub means 3042 configured to specify search results based on the sort score of the test package is provided.

  According to the system provided by the embodiment according to the present invention, a weight can be generated for each training instance in the positive training package in the course of performing the image search. The absolute magnitude of the weight represents the degree to which the corresponding training instance can represent the user's lookup semantics. As a result, when the sort score of each test instance in the test package is finally calculated, for each training instance in the positive training package, each weight is set as its initial label, and finally, based on the sort score of each test instance. You can get the sort score of the test package and give the search result. Thus, in an embodiment of the present invention, it is not intended to select a finite quantity of positive instances from the positive training package, but calculates the respective weight for each instance in the positive training package and the absolute value of the weight The degree of coincidence between each instance and the user's lookup semantics is expressed with a large size. Thereby, the sort score of each test instance in the test package is further acquired based on the weight of each instance in each positive training package. Thereby, the information provided by each training instance in the positive training package is fully utilized, which contributes to the improvement of search performance.

  Here, the embodiment of the system has been described based on the embodiment of the method. For those parts that do not have a detailed description, reference may be made to the description of the method part, which is not described in detail here.

  The series of processes and devices can be realized by software and / or firmware. When implemented by software and / or firmware, a program constituting the software is installed from a storage medium or a network to a computer having a dedicated hardware configuration, for example, the general-purpose personal computer 700 shown in FIG. . The computer can execute functions and the like when various programs are installed.

  In FIG. 7, a central processing unit (CPU) 701 executes various processes based on a program stored in a read-only memory (ROM) 702 or a program loaded from a storage unit 708 into a random access memory (RAM) 703. To do. The RAM 703 also stores data necessary for the CPU 701 to execute various processes as necessary.

  The CPU 701, ROM 702, and RAM 703 are connected to each other via a bus 704. An input / output interface 705 is also connected to the bus 704.

  An input unit 706 including a keyboard and a mouse, an output unit 707 including a display such as a cathode ray tube (CRT), a liquid crystal display (LCD) and a speaker, a storage unit 708 including a hard disk, and a network interface card such as a LAN A communication unit 709 including a card, a modem, and the like is connected to an input / output interface 705. A communication unit 709 executes communication processing via a network, for example, the Internet.

  A drive 710 is also connected to the input / output interface 705 as necessary. A removable medium 711 such as a magnetic disk, an optical disk, a magneto-optical disk, a semiconductor memory, or the like can be mounted on the drive 710 as necessary. Thus, the read computer program is installed in the storage unit 708 as necessary.

  When the series of processing is realized by software, a program constituting the software is installed from a network such as the Internet or a storage medium such as a removable medium 711.

  Those skilled in the art will recognize that such storage media is not limited to the removable media 711 shown in FIG. 7 in which the program is stored and delivered remotely from the device to provide the program to the user. Should be understood. Examples of the removable medium 711 include a magnetic disk (including a floppy disk (registered trademark)), an optical disk (including a compact disk read-only memory (CD-ROM) and a digital versatile disk (DVD)), and a magneto-optical disk ( Including mini disk (MD) (registered trademark) and semiconductor memory. Alternatively, the storage medium may be a hard disk included in the ROM 702 and the storage unit 708, which stores the program and is delivered to the user together with a device including them.

  Further, when executing the series of processing steps, they may be executed in time order according to the order described as it is, but they are not limited to time order. Some steps may be performed in parallel or separately from each other.

  Although the invention and its advantages have been described in detail, various modifications, substitutions and transformations are possible without departing from the spirit and scope of the invention which is limited to the appended claims. And the terms “comprising”, “having”, or any other equivalent expression of an embodiment of the present invention are intended for non-exclusive inclusion, and a process, method, article or device comprising a series of elements In addition to including those elements, it is also permitted to include other elements not explicitly listed, or specific elements of such a process, method, article or device. In the absence of further limitation, an element defined by the phrase “comprising one” does not exclude the presence of other identical elements in a process, method, article or device that includes the element.

The following additional notes are further disclosed for the embodiment including the above examples.
(Appendix 1) A search method by multi-instance learning,
Obtain a training package including a positive training package and a training instance in the training package;
Generating a weight for each training instance in the positive training package;
For each of the instances in the training package and the test package, obtain the respective sort score of the test instance using the respective weight of the training instance in the positive training package, and based on the respective sort score of the test instance in the test package Identifying a respective sort score for the test package and identifying a search result based on the sort score for the test package;
The absolute magnitude of the weight represents the degree to which the corresponding training instance can represent the user's lookup semantics.
(Supplementary Note 2) Generating a weight for each training instance in the positive training package is as follows.
Know the initial weight of the training instance in the positive training package,
Based on the similarity between training instances, a graph-based algorithm is used to learn to obtain each sort score for the training instances, and to identify each positive neighboring instance set for each training instance in the training package. For each training instance, in the positive neighboring instance set to obtain the final weight of each training instance in the positive training package based on the respective sorting score of the training instance in the positive neighboring instance set Changing the weight of the training instance,
The method according to claim 1, wherein the set of positive neighboring instances of the training instance is constituted by training instances having a pre-established similar relationship with the training instance in the positive training package.
(Supplementary note 3) The training package further includes a negative training package, and for each training instance, the training instance in the positive neighboring instance set is based on the training score of the training instance in the positive neighboring instance set. Changing the weight is
For each training instance in the positive training package, increase the weight of the training instance in the positive neighboring instance set based on the training instance sort score in the positive neighboring instance set, and for each training instance in the negative training package The method of claim 2, further comprising reducing the weight of the training instance in the positive neighboring instance set based on the sort score of the training instance in the positive neighboring instance set.
(Supplementary Note 4) Based on the sort score of the training instance in the positive neighboring instance set described above, changing the weight of the training instance in the positive neighboring instance set is:
4. The method of claim 2 or 3, comprising changing the weight of the training instance with the highest sort score in the positive neighboring instance set.
(Supplementary note 5) Identifying each positive neighboring instance set of training instances in the training package described above is
Identify each positive neighboring instance set of training instances in the training package based on the primary or multi-order transmission relationships of each of the nodes in the weighted graph constructed in the course of learning based on a graph algorithm Including
The method of claim 2, wherein, in the weighted gram, nodes correspond to all training instances in a training package, and edge weights correspond to the similarity between two nodes connected to it.
(Supplementary Note 6) For all of the instances in the training package and the test package, obtain a test instance sort score based on the similarity between all instances and the weight of each training instance in the positive training package. Is
For all of the instances in the training package and the test package, based on the similarity between all instances, adopting a graphing algorithm to learn and obtaining each sort score of the test instance,
The method of claim 1, wherein each initial label of the training instance in the positive training package is determined by a respective weight.
(Appendix 7) Specifying the sort score of each test package based on the sort score of each test instance in the test package is as follows.
The method according to appendix 1, comprising: setting a maximum score of the sort score corresponding to each test instance in the test package as the sort score of the test package.
(Appendix 8) A search system using multi-instance learning,
An acquisition means configured to acquire a training package including a positive training package and a training instance in the training package;
Training instance weight generating means configured to generate a weight for each training instance in the positive training package;
Test instance sort score obtaining means configured to obtain a respective sort score of the test instance using a weight of each of the training instances in the positive training package for all of the instances in the training package and the test package;
A search result identifying means configured to identify each sort score of the test package based on a sort score of each test instance in the test package, and to identify a search result based on the sort score of the test package; Prepared,
The absolute magnitude of the weight represents the degree to which the corresponding training instance can represent the user's lookup semantics.
(Supplementary note 9) The training instance weight generation means includes:
An initial weight learning sub-means configured to know the initial weight of the training instance in the positive training package;
A training instance sort score acquisition sub-unit configured to acquire a respective sort score of the training instance by employing a graph algorithm based on the similarity between the training instances; and
Identify each positive neighboring instance set for each training instance in the training package, and for each training instance, each of the training instances in the positive training package based on the respective sorting score of the training instance in the positive neighboring instance set Weight correction sub-means configured to change the weight of the training instance in the positive neighboring instance set to obtain the final weight of
9. The system according to claim 8, wherein the set of positive neighboring instances of the training instance is configured by a training instance having a similar relationship provided in advance with the training instance in the positive training package.
(Supplementary Note 10) The training package further includes a negative training package, and the weight correction sub-unit includes:
For each training instance in the positive training package, a weight increasing sub-means configured to increase the weight of the training instance in the positive neighboring instance set based on the sort score of the training instance in the positive neighboring instance set ,
A weight reduction sub-means configured to reduce the training instance weight in the positive neighboring instance set based on the training instance sort score in the positive neighboring instance set for each training instance in the negative training package; The system according to appendix 9, characterized by comprising:
(Supplementary note 11) The system according to Supplementary note 9 or 10, wherein the weight correction sub-unit is configured to change the weight of the training instance having the largest sort score in the positive neighboring instance set.
(Supplementary Note 12) The weight correction sub means includes:
Identify each positive neighboring instance set of training instances in the training package based on the primary or multi-order transmission relationships of each of the nodes in the weighted graph constructed in the course of learning based on a graph algorithm A positive neighboring instance set specific sub-means configured such that
For each training instance, in the positive neighboring instance set to obtain the final weight of each training instance in the positive training package based on the respective sorting score of the training instance in the positive neighboring instance set. Correction sub-means configured to change the weight of the training instance;
The system of claim 9, wherein, in the weighted gram, nodes correspond to all training instances in the training package, and edge weights correspond to the similarity between two nodes connected to it. .
(Additional remark 13) The said test instance sort score acquisition means specifically employ | adopts the algorithm by a graph and learns about all the instances in a training package and a test package based on the similarity of all the instances. Configured to get the sort score for each of the test instances,
The system of claim 8 wherein each initial label of training instances in a positive training package is determined by a respective weight.
(Supplementary Note 14) The search result specifying means includes:
A test package sort score identifying sub-means configured to use the maximum value of the sort score corresponding to each of the test instances in the test package as the sort score of the test package;
The system according to claim 8, further comprising: specifying sub means configured to specify a search result based on a sort score of the test package.

(Supplementary Note 1 ′) A search method using multi-instance learning, in which one or a plurality of test packages are searched based on one or a plurality of training packages from a storage device storing a plurality of test packages, and each training The package includes a training instance, each test package includes a test instance, and the method includes:
Obtain one or more training packages, including positive training packages, via the input interface;
Generating a weight for each training instance in the positive training package;
For all of the instances in the training package and the test package, use the similarity between instances and the weight of each training instance in the positive training package to obtain a sort score for each test instance;
Calculate the sort score for each test package based on the sort score of each test instance contained in each test package,
Identifying one or more test packages as search results based on the sort score of each test package stored in the storage device,
The absolute magnitude of the weight for the training instance represents the degree to which the corresponding training instance can express the user's search intent.
A method characterized by that.
(Appendix 2 ') Generating a weight for each training instance in the positive training package is
Obtaining an initial weight of a training instance in the positive training package from a storage device;
Based on the similarity between training instances, we use a graph algorithm to learn and get the sort score for each training instance,
A positive neighboring instance set is identified for each training instance in the training package, and the training instance weights in the positive neighboring instance set are determined based on the respective sorting scores of the training instances in the positive neighboring instance set. Modifying to obtain a final weight of each training instance in the positive training package;
The positive neighboring instance set of the training instances is a set of training instances having a pre-established similar relationship with the training instances in the positive training package. Method.
(Supplementary Note 3 ′) The one or more training packages further include a negative training package, and the positive neighborhood is based on a training instance sort score in the positive neighborhood instance set for each training instance. Changing the weight of the training instance in the instance set to
For each training instance in the positive training package, based on the training instance sort score in the positive neighboring instance set, increase the weight of the training instance in the positive neighboring instance set;
Reducing the weight of the training instance in the positive neighboring instance set for each training instance in the negative training package based on the training instance sort score in the positive neighboring instance set.
The method according to appendix 2 ', characterized in that
(Supplementary Note 4 ′) Changing the weight of the training instance in the positive neighboring instance set based on the training score of the training instance in the positive neighboring instance set described above,
Changing the weight of the training instance having the largest training instance sort score in the positive neighboring instance set,
The method according to appendix 2 'or 3', characterized in that
(Supplementary Note 5 ') Identifying a positive neighboring instance set for each training instance in the training package
For each training instance in the training package based on the similarity based on the primary or higher order transmission relationship between the training instances corresponding to the nodes in the weighted graph constructed in the course of learning based on the algorithm by the graph. Identifying a set of neighboring instances of
In the weighted graph, a node corresponds to all training instances in a training package, and an edge weight corresponds to the similarity between two nodes connected to the edge.
The method according to appendix 2 ', characterized in that
(Supplementary Note 6 ′) For all the instances in the training package and the test package, the sort score of each test instance is obtained using the similarity between all instances and the weight of each training instance in the positive training package. That is
For all of the instances in the training package and the test package, based on the similarity between all instances, employing a graph algorithm to learn and obtain a sort score for each test instance,
The initial label of each training instance in the positive training package is determined by its weight.
The method according to appendix 1 ′, characterized in that
(Appendix 7 ') Calculate the sort score of each test package based on the sort score of each test instance included in each test package.
Including the maximum sort score corresponding to each test instance in the test package as the sort score of the test package,
The method according to appendix 1 ′, characterized in that
(Supplementary Note 8 ′) A search system using multi-instance learning that searches one or a plurality of test packages based on one or a plurality of training packages from a storage device storing a plurality of test packages, and each training A package contains training instances, each test package contains test instances, and the system
An acquisition means configured to acquire one or more training packages including a positive training package via an input interface;
Training instance weight generating means configured to generate a weight for each training instance in the positive training package;
A test configured to obtain a sort score for each test instance for all instances in the training package and the test package using similarity between instances and the weight of each training instance in the positive training package An instance sort score acquisition means;
A calculation means for calculating a sort score of each test package based on a sort score of each test instance included in each test package;
Search result specifying means configured to specify one or a plurality of test packages as search results based on the sort score of each test package stored in the storage device,
The absolute magnitude of the weight for the training instance represents the degree to which the corresponding training instance can express the user's search intention.
(Supplementary Note 9 ′) The training instance weight generation means includes:
Sub means for obtaining an initial weight of a training instance in the positive training package from a storage device;
A sub-means for obtaining each sort score of the training instances based on the similarity between the training instances;
A positive neighboring instance set is identified for each training instance in the training package, and the training instance weights in the positive neighboring instance set are determined based on the respective sorting scores of the training instances in the positive neighboring instance set. A weight correction sub-means for modifying to obtain the final weight of each training instance in the positive training package;
The positive neighboring instance set of the training instance is a set of training instances having a pre-established similar relationship with the training instance in the positive training package.
The system according to appendix 8 ′, characterized in that
(Additional remark 10 ') The said test instance sort score acquisition means is comprised so that the sort score of each test instance may be acquired based on the similarity between all instances about all the instances in the said training package and the said test package. And
The initial label of each training instance in the positive training package is determined by its weight.
The system according to appendix 8 ′, characterized in that

Claims (10)

A search method by multi-instance learning, wherein one or a plurality of test packages are searched from a storage device storing a plurality of test packages based on one or a plurality of training packages. Each test package includes a test instance, and the method includes:
Obtain one or more training packages, including positive training packages, via the input interface;
Generating a weight for each training instance in the positive training package;
For all of the instances in the training package and the test package, use the similarity between instances and the weight of each training instance in the positive training package to obtain a sort score for each test instance;
Calculate the sort score for each test package based on the sort score of each test instance contained in each test package,
Identifying one or more test packages as search results based on the sort score of each test package stored in the storage device,
The absolute magnitude of the weight for the training instance represents the degree to which the corresponding training instance can express the user's search intent.
A method characterized by that. Generating a weight for each training instance in the positive training package described above,
Obtaining an initial weight of a training instance in the positive training package from a storage device;
Based on the similarity between training instances, we use a graph algorithm to learn and get the sort score for each training instance,
A positive neighboring instance set is identified for each training instance in the training package, and the training instance weights in the positive neighboring instance set are determined based on the respective sorting scores of the training instances in the positive neighboring instance set. Modifying to obtain a final weight of each training instance in the positive training package;
The positive neighboring instance set of the training instances is a set of training instances having a similar relationship provided in advance with the training instances in the positive training package. Method. The one or more training packages further include a negative training package, wherein the training in the positive neighboring instance set is based on the training instance sort score in the positive neighboring instance set for each training instance. Changing the weight of an instance
For each training instance in the positive training package, based on the training instance sort score in the positive neighboring instance set, increase the weight of the training instance in the positive neighboring instance set;
Reducing the weight of the training instance in the positive neighboring instance set for each training instance in the negative training package based on the training instance sort score in the positive neighboring instance set.
The method according to claim 2. Changing the weight of training instances in the positive neighboring instance set based on the sort score of training instances in the positive neighboring instance set,
Changing the weight of the training instance having the largest training instance sort score in the positive neighboring instance set,
The method according to claim 2 or 3, characterized in that Identifying a positive neighboring instance set for each training instance in the training package is
For each training instance in the training package based on the similarity based on the primary or higher order transmission relationship between the training instances corresponding to the nodes in the weighted graph constructed in the course of learning based on the algorithm by the graph. Identifying a set of neighboring instances of
In the weighted graph, a node corresponds to all training instances in a training package, and an edge weight corresponds to the similarity between two nodes connected to the edge.
The method according to claim 2. For all instances in the training package and the test package, using the similarity between all instances and the weight of each training instance in the positive training package, obtaining a sort score for each test instance;
For all of the instances in the training package and the test package, based on the similarity between all instances, employing a graph algorithm to learn and obtain a sort score for each test instance,
The initial label of each training instance in the positive training package is determined by its weight.
The method according to claim 1. Calculating the sort score for each test package based on the sort score for each test instance contained in each test package
Including the maximum sort score corresponding to each test instance in the test package as the sort score of the test package,
The method according to claim 1. A search system using multi-instance learning that searches one or a plurality of test packages based on one or a plurality of training packages from a storage device storing a plurality of test packages. Each test package contains a test instance, and the system
An acquisition means configured to acquire one or more training packages including a positive training package via an input interface;
Training instance weight generating means configured to generate a weight for each training instance in the positive training package;
A test configured to obtain a sort score for each test instance for all instances in the training package and the test package using similarity between instances and the weight of each training instance in the positive training package An instance sort score acquisition means;
A calculation means for calculating a sort score of each test package based on a sort score of each test instance included in each test package;
Search result specifying means configured to specify one or a plurality of test packages as search results based on the sort score of each test package stored in the storage device,
The absolute magnitude of the weight for the training instance represents the degree to which the corresponding training instance can express the user's search intention. The training instance weight generation means includes:
Sub means for obtaining an initial weight of a training instance in the positive training package from a storage device;
A sub-means for obtaining each sort score of the training instances based on the similarity between the training instances;
A positive neighboring instance set is identified for each training instance in the training package, and the training instance weights in the positive neighboring instance set are determined based on the respective sorting scores of the training instances in the positive neighboring instance set. A weight correction sub-means for modifying to obtain the final weight of each training instance in the positive training package;
The positive neighboring instance set of the training instance is a set of training instances having a pre-established similar relationship with the training instance in the positive training package.
The system according to claim 8. The test instance sort score acquisition means is configured to acquire the sort score of each test instance based on the similarity between all instances for all instances in the training package and the test package,
The initial label of each training instance in the positive training package is determined by its weight.
The system according to claim 8.

Images