Search optimization for RAG: MMR balances relevance and diversity
Explore the latest optimization technology in the field of information retrieval and master the practical application of MMR algorithm in improving user experience.
Core content:
1. Analysis of the impact of information redundancy on user experience
2. Mathematical principles and core mechanisms of MMR algorithm
3. Application examples and code implementation of MMR algorithm in different fields
Search optimization for RAG: MMR balances relevance and diversity
Article Objective
This article is aimed at engineers in the fields of information retrieval, recommendation systems, and natural language processing, as well as practitioners interested in RAG (Retrieval-Augmented Generation) technology . It aims to help readers:
Have a deep understanding of information redundancy and its impact on information acquisition efficiency and user experience. Master the mathematical principles, core mechanisms and operational procedures of the Maximum Marginal Relevance (MMR) algorithm . Understand the application examples and code implementation considerations of the MMR algorithm in different scenarios . Inspire how to apply diversity optimization strategies in specific businesses .
Tip: MMR is not only an algorithm, but also reflects a strategic thinking of balancing multiple goals in information sorting. Mastering it will help build smarter information systems with better user experience.
The code for this article: https://github.com/li-xiu-qi/XiaokeAILabs/blob/main/datas/test_mmr_search/test_mmr_search.py
? theme
The theme of this session : Systematically analyze the Maximum Marginal Relevance (MMR) algorithm and explore its core principles, implementation details and application value in suppressing information redundancy and enhancing result diversity.
? Summary
Challenges : Traditional sorting methods focus on maximizing relevance, which can easily lead to highly homogeneous content in the result list and reduce the marginal utility of information acquisition. MMR scheme : MMR introduces the concept of marginal relevance , which explicitly balances the relevance of candidate items to the query and the difference between the candidate items and the set of selected items during the iterative selection process . Core mechanism : By adjusting parameters (Lambda), flexibly controls the relative weights of relevance and diversity in sorting decisions. Application areas : MMR has been verified and applied in many fields such as search engine ranking, recommendation system, automatic text summarization, computational advertising, etc.
? Table of contents
? Article Objective ? theme ? Summary ? Preface ? 1. What is the maximum marginal correlation algorithm? ? 1.1 Definition and core concept ? 1.2 The composition of “marginal” value ? 2. Why do we need the maximum marginal correlation algorithm? ? 3. Methodology for balancing relevance and diversity ? 4. Detailed explanation of MMR algorithm ? 4.1 Core Mathematical Expression ? 4.2 Iterative Selection Process 5. MMR algorithm code implementation (Python example) Results Analysis ? 6. Application scenarios of MMR algorithm ? Summary and Outlook ? Previous selections
? Preface
Let's consider a common information retrieval scenario: When a user enters a query word, such as "apple", into a search engine, what kind of results do they expect to get? If the top results returned are all pointing to Apple's official website, the user may not be satisfied despite the high relevance. Similarly, in a recommendation system, if the system repeatedly recommends content with extremely similar styles and themes based on a user's click, it will also limit the user's discovery space.
These examples reveal a core challenge in information services: information redundancy . A ranking strategy that simply pursues relevance can find results that match the query, but when the content of these results overlaps with each other, the incremental information that users can obtain from them is very limited. An effective strategy should not only provide relevant results, but also ensure that the results are diverse , covering multiple aspects of users' potential needs and optimizing the information exploration process.
To address this challenge, the Maximal Marginal Relevance (MMR) algorithm was proposed. It provides a structured and effective way to optimize both relevance and diversity, and constitutes an important part of modern information retrieval and recommendation technology. Next, we will explore the working principle of MMR in depth.
? 1. What is the maximum marginal correlation algorithm?
? 1.1 Definition and core concept
Maximum Marginal Relevance (MMR) is an algorithm for sorting or selecting a collection of items. Its fundamental goal is to maximize the content differences between these items while ensuring that the selected items are highly relevant to the user's query, thereby reducing the redundancy of the output results.
We can understand MMR from a first principles perspective: when selecting a series of items (such as documents, products, news summaries) from a larger candidate pool to build the final list, ideally, each new item added at each step should not only meet the relevance requirements to the original query, but also provide new perspectives or information that are different from the set of selected items .
The key word here is " marginal ". It focuses on adding Add a new project to The incremental value brought by With query The relevance and and It is a comprehensive reflection of the differences among existing projects.
? 1.2 The composition of “marginal” value
In the MMR framework, “marginal relevance” specifically measures the Being considered for inclusion in the selected collection The "net value" that can be contributed when the company is in a financial crisis. This value consists of two interacting parts:
Relevance Contribution : Project Self and user query This is usually represented by a relevance scoring function To quantify. Diversity Contribution : Project With Collection The degree of dissimilarity of the items in . This is usually achieved by penalizing and It is reflected by the similarity of the most similar items in the , that is, reducing redundancy.
The design idea of the MMR algorithm is to accurately select the candidate project that can maximize this "marginal comprehensive value" in each iterative selection.
? 2. Why do we need the maximum marginal correlation algorithm?
The demand for MMR is rooted in the real logic of information interaction and the information processing characteristics of users:
Optimize cognitive load and information acquisition efficiency : Faced with information flow, humans have limited processing bandwidth. Large amounts of repeated or highly similar information will increase cognitive load and reduce information absorption efficiency. Diversified results can enable users to access broader and more multi-dimensional information within a limited number of interactions, especially when dealing with exploratory or multi-faceted queries (such as "the impact of climate change"), where users may expect to understand information at different levels, such as the environment, economy, and society. Improve user satisfaction and exploration experience : Over-personalization or single-dimensional relevance ranking may lead to the "Filter Bubble" effect, limiting the user's vision. Introducing diversity can not only meet the needs clearly expressed by users, but also bring about unexpected discoveries (Serendipity), increase the fun of exploration, and thus improve users' long-term satisfaction and stickiness to the system. Support better business decisions : In scenarios such as e-commerce recommendations or online advertising, displaying a variety of products or advertising ideas can help reach a wider range of users' potential interests, which may promote the sales of long-tail products or improve the overall conversion effect of advertising campaigns, and avoid excessive concentration of traffic on a few head projects. Dealing with uncertainty in query intent : User queries are often ambiguous. For example, when searching for "Python", users may mean programming language or python. By introducing diversity through MMR, representative content related to different potential intents can be appropriately included in the results, thereby increasing the probability of covering the user's true intent.
Therefore, MMR is not only an improvement in sorting technology, but also an answer to the question of "how to design information presentation to more effectively serve complex user needs and cognitive patterns." It recognizes and attempts to address the multidimensionality of information needs and users' inherent preference for information efficiency.
? 3. Methodology for balancing relevance and diversity
While this article is centered around MMR, it is instructive to understand its place in the broader spectrum of diversity optimization techniques. Methods for balancing relevance and diversity can be roughly divided into several categories:
Re-ranking based strategy :
MMR is a classic representative of this type of method : first, an initial sorted list based on relevance is obtained, and then the MMR criterion is applied for iterative selection and re-ranking to integrate diversity factors. Other heuristic or classification-based techniques : For example, one can first perform clustering or topic modeling on the initial results and then select high-quality, representative items from each cluster/topic to form the final list. Directly optimize the objective function that includes diversity :
Some more complex models, such as Determinantal Point Processes (DPP), attempt to directly optimize a global objective function that includes both relevance and diversity measures during model training or inference. DPP uses the properties of determinants to elegantly characterize the "capacity" or "diversity" of a collection and is another important diversity modeling tool. Intent-aware Diversification :
For queries with multiple interpretations, the system first identifies several possible subtopics, then retrieves relevant results for each subtopic and combines these results based on the probability or importance of the intent to ensure that the main query aspects are covered. : Candidate projects currently being evaluated. : The user's query or context information. : The collection of items that have been selected into the final result list. : The set of remaining candidate items. : Relevance scoring function . Used to calculate candidate items With query Similarity or match between two pairs. This can be implemented as cosine similarity, BM25 score, or any other measure of relevance. Larger values indicate greater relevance. : Redundancy (or similarity) metric function . Calculate candidate items With selected items The similarity between The same or compatible metrics (for example, both use the cosine similarity of the vector space model). The larger the value, the and The closer the content is, the more The higher the redundancy possible. : This expression evaluates the candidate items With all selected items (collection ) and take the maximum value . This represents Relative to the currently selected collection The maximum potential redundancy . (Lambda): Balance parameter , the value range is . It controls the trade-off between relevance and diversity: when When terms, MMR degenerates into a pure correlation ranking. when When , the formula becomes to minimize the maximum similarity with the selected item set (i.e. ), in extreme cases, projects with low correlation but great differences may be preferred (however, the initial candidate set A certain relevance is usually guaranteed). when , the algorithm makes a trade-off between the relevance score and the diversity penalty (reflected by the maximum redundancy). The higher the value, the more the results are biased towards relevance; the lower the value, the more the results are biased towards diversity. It means that both are equally important. initialization : Get the initial list of candidate projects This is usually the result of recall and preliminary ranking by a search engine or recommender system, such as Top-K relevant documents. Initialize an empty result list . Setting balance parameters and the total number of items expected to be selected . Select the first project : Because the initial is empty, the formula Items are usually treated as 0 or a very small value (which does not affect comparisons). At this time, the MMR score is mainly composed of Decide. Therefore, choose middle Most relevant items , add it to .renew . Iteratively select subsequent items (execute Second-rate) : Calculate and query The relevance score . Calculate its difference with the currently selected set Each project Similarity . Find the maximum of these similarities:. calculate MMR score:. For the current candidate set Each project in : from Select the project with the highest MMR score . Will from Move to .renew . Termination : When The number of items in When, or candidate set When it is empty, the algorithm stops. The items in the list, in the order in which they were selected, form the final list of results that balances relevance and diversity.
MMR has been widely used in the industry due to its intuitive concept, relatively simple implementation, and controllable computational overhead . It provides a clear and actionable framework to quantify and balance the two core indicators of relevance and diversity.
? 4. Detailed explanation of MMR algorithm
? 4.1 Core Mathematical Expression
The MMR algorithm constructs the final result list through an iterative process. Assume that we have an initial candidate item set (usually pre-sorted by relevance), and an initially empty target set , used to store the final selected item. The algorithm repeats the following steps until Reach the predetermined size :
In each iteration, the algorithm starts with The candidate project set , choose the project that maximizes the following MMR scores , and add it to :
The selection rule is expressed as:
The symbols here represent:
? 4.2 Iterative Selection Process
The execution process of the MMR algorithm can be summarized as the following steps:
5. MMR algorithm code implementation (Python example)
Design idea : We will implement a function mmr_selection, which receives the query representation, the candidate item representation, the initial ranking, Parameters and number of targets The function simulates the iterative selection process of MMR: first, the most relevant items are selected, and then in subsequent steps, the MMR score is calculated for each remaining candidate (combining its relevance to the query and its maximum similarity to the selected items), and the items with the highest scores are selected to join the result set until the number is reached. .
Example code : We use FlagEmbedding Library loading bge-large-zh-v1.5 model to obtain sentence vectors and use cosine similarity as and The measurement of.
import numpy as np
from FlagEmbedding import FlagModel # Import FlagModel
def cosine_similarity (vec1, vec2) :
"""Compute the cosine similarity of two NumPy vectors"""
vec1 = np.asarray(vec1)
vec2 = np.asarray(vec2)
dot_product = np.dot(vec1, vec2)
norm_vec1 = np.linalg.norm(vec1)
norm_vec2 = np.linalg.norm(vec2)
if norm_vec1 == 0 or norm_vec2 == 0 :
return 0.0
similarity = dot_product / (norm_vec1 * norm_vec2)
# If needed, you can consider the similarity range, such as mapping to [0, 1]
# return max(0.0, similarity) # If non-negative similarity is required
return similarity # Use the original cosine similarity [-1, 1]
def mmr_selection (query_embedding, item_embeddings, item_ids, lambda_param, num_results) :
"""
Item selection using the MMR algorithm
Args:
query_embedding (np.array): vector representation of the query.
item_embeddings (dict): Dictionary of candidate item vector representations {item_id: np.array}.
item_ids (list): List of initial candidate item IDs (usually string IDs).
lambda_param (float): MMR tradeoff parameter lambda (0 <= lambda <= 1).
num_results (int): The number of results N to select.
Returns:
list: The final selected project ID list (string ID).
"""
if not item_ids or not item_embeddings or num_results <= 0 :
return []
# Filter out valid candidate IDs (existing in the embeddings dictionary)
valid_candidate_ids = [id for id in item_ids if id in item_embeddings]
if not valid_candidate_ids:
return []
candidate_pool = set(valid_candidate_ids)
selected_item_ids = []
# Precompute the relevance of all valid candidate items to the query (Sim_1)
candidate_relevance = {
id: cosine_similarity(query_embedding, item_embeddings[id])
for id in valid_candidate_ids
}
# Make sure N does not exceed the number of valid candidates
num_results = min(num_results, len(valid_candidate_ids))
# Step 1: Select the most relevant project
if valid_candidate_ids:
first_selection_id = max(candidate_relevance, key=candidate_relevance.get)
selected_item_ids.append(first_selection_id)
candidate_pool.remove(first_selection_id)
# Subsequent iteration selection
while len(selected_item_ids) < num_results and candidate_pool:
mmr_scores = {}
selected_embeddings_list = [item_embeddings[id] for id in selected_item_ids] # Get the vector of the selected item
for candidate_id in candidate_pool:
candidate_emb = item_embeddings[candidate_id]
# Sim_1: Get precomputed correlations
relevance_score = candidate_relevance.get(candidate_id, -1.0 ) # Use precomputed relevance, -1.0 as default value
# Sim_2: Calculate the maximum similarity with the selected items
max_similarity_with_selected = -1.0 # Initialize to the lowest possible cosine similarity
if selected_item_ids: # Calculated only if S is not empty
similarities_to_selected = [cosine_similarity(candidate_emb, sel_emb) for sel_emb in selected_embeddings_list]
if similarities_to_selected:
max_similarity_with_selected = max(similarities_to_selected)
# Calculate MMR score
# MMR Score = λ * Sim1(Di, Q) - (1 - λ) * max(Sim2(Di, Dj)) for Dj in S
# Note: If Sim1 and Sim2 may be negative, you need to ensure that the formula logic is correct
mmr_score = lambda_param * relevance_score - ( 1 - lambda_param) * max_similarity_with_selected
mmr_scores[candidate_id] = mmr_score
if not mmr_scores: # If there are no more candidates to calculate scores
break
# Select the project with the highest MMR score in the current iteration
best_next_id = max(mmr_scores, key=mmr_scores.get)
selected_item_ids.append(best_next_id)
candidate_pool.remove(best_next_id) # Remove from the candidate pool
return selected_item_ids
# --- Get vector using FlagEmbedding and run MMR ---
# 1. Load the model (make sure the model path is correct)
model_path = r"C:\Users\k\Desktop\BaiduSyncdisk\baidu_sync_documents\hf_models\bge-large-zh-v1.5"
try :
model = FlagModel(model_path, use_fp16= True ) # Try to use FP16 acceleration
print( "Model loaded successfully." )
except Exception as e:
print( f"Model loading failed: {e} " )
# You can add exit or use backup logic here
exit() # or return, raise e, etc.
# 2. Define query and candidate sentences
query_sentence = "What are the applications of large language models?"
candidate_sentences = [
# Directly related to the query - Application class
"Large language models can be used for text generation, such as writing poetry or code." , # id=s1
"Machine translation is one of the common application scenarios of large language models." , # id=s2
"Chatbots and intelligent customer service are often built on large language models." , # id=s3
"Large-scale models capable of text summarization and information extraction." , # id=s4
# Related to queries - principle/definition class (different from application class)
"Large language models usually refer to deep learning models with huge number of parameters." , # id=s5
"The Transformer architecture is the foundation of modern large language models." , # id=s6
"Training large language models requires massive amounts of text data and computing resources." , # id=s7
# Not very relevant or off topic
"It's a nice day today." , # id=s8
"The research on artificial intelligence has a long history." , # id=s9
]
# Assign IDs to sentences
candidate_ids = [ f"s {i+ 1 } " for i in range(len(candidate_sentences))]
# Create a mapping dictionary from ID to sentence
id_to_sentence = {candidate_ids[i]: candidate_sentences[i] for i in range(len(candidate_sentences))}
# 3. Get the embedding vectors of all sentences
all_sentences = [query_sentence] + candidate_sentences
print( "Start calculating embedding vector..." )
embeddings = model.encode(all_sentences)
print( f"Embedding vector calculation completed, shape: {embeddings.shape} " ) # Should be (1 + len(candidate_sentences), 1024)
query_embedding = embeddings[ 0 ]
item_embeddings_dict = {candidate_ids[i]: embeddings[i+ 1 ] for i in range(len(candidate_sentences))}
# 4. Set parameters and run MMR
# Assume that the initial list is obtained based on some rough sorting (here simplified to the original order)
initial_ranked_ids = candidate_ids
num_select = 5 # Expect to select 5 results
# Scenario 1: More focus on relevance
lambda_high = 0.7
selected_high_lambda = mmr_selection(query_embedding, item_embeddings_dict, initial_ranked_ids, lambda_high, num_select)
print( f"\n--- MMR selection result (lambda= {lambda_high} , N= {num_select} ) ---" )
print( "Selected sentence ID: " , selected_high_lambda)
print( "Selected sentence content:" )
for i, item_id in enumerate(selected_high_lambda):
print( f" {i+ 1 } . ID= {item_id} : {id_to_sentence[item_id]} " )
# Scenario 2: More focus on diversity
lambda_low = 0.3
selected_low_lambda = mmr_selection(query_embedding, item_embeddings_dict, initial_ranked_ids, lambda_low, num_select)
print( f"\n--- MMR selection result (lambda= {lambda_low} , N= {num_select} ) ---" )
print( "Selected sentence ID: " , selected_low_lambda)
print( "Selected sentence content:" )
for i, item_id in enumerate(selected_low_lambda):
print( f" {i+ 1 } . ID= {item_id} : {id_to_sentence[item_id]} " )
Code description and analysis : The above code first loads bge-large-zh-v1.5 Then, a query sentence and a set of candidate sentences containing different categories (application, principle, irrelevant) are defined. model.encode() Calculate the embedding vectors of all sentences. Finally, call mmr_selection function twice, using high (0.7) and low (0.3) to select the top 5 sentences.
Output:
Embedding vector calculation completed, shape: (10, 1024)
--- MMR selection results (lambda=0.7, N=5) ---
Selected sentence IDs: ['s5', 's1', 's2', 's3', 's7']
Select sentence content:
1. ID=s5: Large language models usually refer to deep learning models with huge number of parameters.
2. ID=s1: Large language models can be used for text generation, such as writing poetry or code.
3. ID=s2: Machine translation is one of the common application scenarios of large language models.
4. ID=s3: Chatbots and intelligent customer service are often built based on large language models.
5. ID=s7: Training large language models requires massive amounts of text data and computing resources.
--- MMR selection results (lambda=0.3, N=5) ---
Selected sentence IDs: ['s5', 's8', 's9', 's1', 's6']
Select sentence content:
1. ID=s5: Large language models usually refer to deep learning models with huge number of parameters.
2. ID=s8: The weather is really nice today.
3. ID=s9: Artificial intelligence research has a long history.
4. ID=s1: Large language models can be used for text generation, such as writing poetry or code.
5. ID=s6: Transformer architecture is the basis of modern large language models.
Results Analysis
By comparing the MMR selection results of λ=0.7 and λ=0.3, we can clearly observe how the algorithm balances relevance and diversity:
1. High lambda value (0.7): biased towards correlation
Features : All 5 selected results are highly relevant to the query "What are the applications of large language models?" Content distribution : Including application scenarios such as "Large language models can be used for text generation, such as writing poetry or code", "Machine translation is one of the common application scenarios of large language models", "Chatbots and intelligent customer service are often built based on large language models", as well as principle descriptions such as "Large language models usually refer to deep learning models with huge parameters" and "Training large language models requires massive text data and computing resources". Effect : The results focus on the query topic, provide practical and complementary information, and are suitable for scenarios that require deep and relevant content.
2. Low λ value (0.3): biased towards diversity
Features : The results include sentences related to the query as well as completely irrelevant content. However, it is obvious that the irrelevant content is ranked second, which shows that the parameters here are too diverse. Content distribution : "Large language models usually refer to deep learning models with huge parameters" is selected as the most relevant item, followed by irrelevant sentences such as "The weather is really nice today" and "Artificial intelligence research has a long history", and finally "Large language models can be used for text generation, such as writing poetry or code" and "Transformer architecture is the basis of modern large language models" and other related but thematically scattered content. Effect : Sacrifices some relevance in exchange for higher diversity, which is suitable for exploratory scenarios or covering multiple aspects of information when the query is ambiguous.
3. Commonalities and mechanisms
Preferred consistency : For both λ values, the first choice is "Large language models usually refer to deep learning models with huge parameters" because the initial step only considers correlation (Sim_1). Iteration logic : In subsequent selections, λ controls the weights of relevance (λ _ Sim_1) and diversity ((1-λ) _ max(Sim_2)): λ=0.7: relevance weight 0.7, diversity 0.3, tends to select sentences that are closely related to the query. λ=0.3: Diversity weight 0.7, relevance 0.3, tends to select sentences that are very different from the selected content.
It should be noted that different models require appropriate adjustment of diversity weights.
4. Core advantages
MMR flexibly adjusts the balance between relevance and diversity through the λ parameter:
High λ is suitable for precise information retrieval, such as focusing on specific applications of large language models. Low λ is suitable for diverse recommendations, such as exploring different topics or background knowledge. In practical applications, the choice of λ should be dynamically adjusted based on business requirements (such as depth vs. breadth) and the intentions of most users.
? 6. Application scenarios of MMR algorithm
The core idea of MMR - balancing relevance and diversity - makes it widely applicable in many information service scenarios:
Search Engine Results Page (SERP) Optimization :
When user query terms have multiple meanings or refer to multiple subtopics (for example, "Jaguar" can refer to a car brand or an animal), MMR can help ensure that search results are not only relevant, but also cover these different aspects and provide a more comprehensive view of the information.
Product recommendations : Avoid showing users a list of very similar products. For example, when recommending clothing, use MMR to recommend different styles, colors, or brands of clothing instead of multiple T-shirts of the same style in different colors. Content (news/video/music) recommendation : For the same event or topic, push content from different perspectives, sources or styles to avoid information cocoons and enhance users’ experience of discovering new content.
In the extractive summarization task, it is necessary to select several sentences from the original text to form a summary. MMR can be used to select those sentences that can reflect the core points of the original text (highly related to the original text or the theme). ), and there is less information overlap between them (sentences Lower) key sentences.
Ad creative rotation and diversification : For the same ad campaign, the system can use MMR to select the ad creative combination to display to a specific user, ensuring that there is a certain degree of difference between the creatives (such as different visual elements, copywriting, or promotional points) to reduce user fatigue and explore the effectiveness of different creatives.
In the RAG architecture, if the document fragments (Chunks) obtained by the retrieval module are highly similar, they will provide redundant contextual information for the subsequent large language model (LLM). Applying MMR to reorder the retrieved Chunks can select a set of Chunks that are both relevant to the original query and contain complementary information, thereby improving the quality and comprehensiveness of the answers generated by the LLM.
? Summary and Outlook
? Technology Panorama
MMR is one of the key technologies to correct and optimize the traditional relevance-first sorting paradigm in the context of information overload . Its core lies in the introduction and quantification of the diversity dimension. It is closely related to research fields such as diversity measurement methods , reranking algorithm frameworks , and user intent recognition , and is an important tool for building intelligent information systems. In modern multi-stage ranking architectures (such as recall-coarse-fine ranking), MMR is often used in the fine ranking or re-ranking stage to make final optimization adjustments to the candidate results. Despite the existence of more complex probabilistic models such as DPP to model diversity, MMR still maintains its wide application and continued influence in industry due to its intuitiveness, computational efficiency and ease of deployment .
? Learning summary
Core trade-off : Balancing relevance and diversity in information sorting to avoid uniform results and information redundancy. MMR mechanism : through parameters , the relevance contribution to the candidate items in each iteration selection () and redundancy penalty (based on ) perform linear combinations and select the project with the highest marginal value. Key Components : Query , candidate set , selected , the correlation function , similarity (redundancy) function , balance parameter . Practical value : Applied to search, recommendation, summary and other scenarios, it can significantly improve the information coverage of results, user satisfaction and the efficiency of exploration and discovery .
? Hands-on Challenge
Hands-on Implementation and Parameter Exploration : Using the provided Python code framework, try to implement MMR on a specific dataset with actual text or item embeddings (e.g., vectors generated using TF-IDF , Word2Vec , or Sentence-BERT (SBERT)). value, observe and analyze the changing rules of the final sorted list content. Effect evaluation and comparison : Design experiments to compare the MMR ranking results with baseline methods (such as pure Consider using an evaluation metric that includes diversity considerations (e.g. -NDCG or the user-perceived diversity version of Precision/Recall@K) to quantify the improvement brought by MMR. Scenario Migration and Application : Reflect on your current work. Is there any link that can introduce MMR or similar diversity optimization ideas? How to define appropriate (correlation) and (Similarity/redundancy) measure?
♻️Interaction issues
Question 1 : What is the core problem that the MMR algorithm aims to solve? What mechanism does it use to achieve this goal? Question 2 : In the mathematical expression of MMR, the balance parameter What role did you play? What are the behavioral characteristics of the algorithm when the values of are set to 1 and 0 respectively? Question 3 : Please list an example of MMR application other than search engine result ranking, and explain in detail the scenario: and How can it be defined?
