alessandrobenedetti opened a new pull request, #2489:
URL: https://github.com/apache/solr/pull/2489

   https://issues.apache.org/jira/browse/SOLR-17319
   
   # Description
   
   Reciprocal Rank Fusion (RRF) is an algorithm that takes in input multiple 
ranked lists to produce a unified result set.
   Examples of use cases where RRF can be used include hybrid search and 
multiple Knn vector queries executed concurrently.
   RRF is based on the concept of reciprocal rank, which is the inverse of the 
rank of a document in a ranked list of search results.
   The combination of search results happens taking into account the position of
   the items in the original rankings, and giving higher score to items that 
are ranked higher in multiple lists. RRF was introduced the first time by 
Cormack et al. in [1].
   The syntax proposed:
   JSON Request
   ```
   {
       "queries": {
           "lexical1": {
               "lucene": {
                   "query": "id:(10^=2 OR 2^=1 OR 4^=0.5)"
               }
           },
           "lexical2": {
               "lucene": {
                   "query": "id:(2^=2 OR 4^=1 OR 3^=0.5)"
               }
           }
       },
       "limit": 10,
       "fields": "[id,score]",
       "params": {
           "combiner": true,
           "combiner.upTo": 5,
           "facet": true,
           "facet.field": "id",
           "facet.mincount": 1
       }
   }
   ```
   
   [1] Cormack, Gordon V. et al. “Reciprocal rank fusion outperforms condorcet 
and individual rank learning methods.” Proceedings of the 32nd international 
ACM SIGIR conference on Research and development in information retrieval (2009)
   # Solution
   
   The support has been introduced leveraging the "queries" support in the JSON 
request syntax.
   The combination of results happen at QueryComponent, processing level.
   The debug component has the responsibility of managing the explainability 
part.
   
   
   
   Limitations: 
   
   - grouping/field collapsing won't be supported in a first version
   -  the distributed support is present but not super advanced: query 
combination happens at node level and then results are combined at shard level.
   
   # Tests
   
   Tests have been added to cover the main use cases
   
   # Checklist
   
   Please review the following and check all that apply:
   
   - [ ] I have reviewed the guidelines for [How to 
Contribute](https://github.com/apache/solr/blob/main/CONTRIBUTING.md) and my 
code conforms to the standards described there to the best of my ability.
   - [ ] I have created a Jira issue and added the issue ID to my pull request 
title.
   - [ ] I have given Solr maintainers 
[access](https://help.github.com/en/articles/allowing-changes-to-a-pull-request-branch-created-from-a-fork)
 to contribute to my PR branch. (optional but recommended)
   - [ ] I have developed this patch against the `main` branch.
   - [ ] I have run `./gradlew check`.
   - [ ] I have added tests for my changes.
   - [ ] I have added documentation for the [Reference 
Guide](https://github.com/apache/solr/tree/main/solr/solr-ref-guide)
   


-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: issues-unsubscr...@solr.apache.org

For queries about this service, please contact Infrastructure at:
us...@infra.apache.org


---------------------------------------------------------------------
To unsubscribe, e-mail: issues-unsubscr...@solr.apache.org
For additional commands, e-mail: issues-h...@solr.apache.org

Reply via email to