Submodulare Optimierung für diverse Abfragegenerierung in DeepResearch

Bei der Implementierung von DeepResearch gibt es mindestens zwei Stellen, an denen Sie unterschiedliche Suchanfragen generieren müssen. Erstens müssen Sie Web-Suchanfragen basierend auf der Benutzereingabe generieren (die direkte Eingabe der Benutzereingabe in die Suchmaschine ist keine gute Idee). Zweitens enthalten viele DeepResearch-Systeme einen "Forschungsplaner", der das ursprüngliche Problem in Teilprobleme zerlegt, Agenten gleichzeitig aufruft, um diese unabhängig voneinander zu lösen, und dann deren Ergebnisse zusammenführt. Ob es sich um Suchanfragen oder Teilprobleme handelt, unsere Erwartungen bleiben gleich: Sie müssen für die ursprüngliche Eingabe relevant und vielfältig genug sein, um einzigartige Perspektiven darauf zu bieten. Oft müssen wir die Anzahl der Suchanfragen begrenzen, um keine unnötigen Kosten für Suchmaschinenanfragen oder die Verwendung von Agenten-Tokens zu verursachen.

Obwohl das Verständnis der Bedeutung der Suchanfragenerstellung gegeben ist, nehmen die meisten Open-Source-DeepResearch-Implementierungen diese Optimierung nicht ernst. Sie geben diese Einschränkungen einfach direkt per Prompt vor. Einige fordern das LLM möglicherweise zu einer zusätzlichen Runde auf, um die Suchanfragen zu bewerten und zu diversifizieren. Hier ist ein Beispiel dafür, wie die meisten Implementierungen im Grunde vorgehen:

In diesem Artikel möchte ich einen rigoroseren Ansatz zur Lösung der optimalen Suchanfragenerstellung mithilfe von Satz-Vektor Modellen und submodularer Optimierung demonstrieren. Zu meiner Promotionszeit war die submodulare Optimierung neben L-BFGS eine meiner Lieblingstechniken. Ich werde zeigen, wie man sie zur Generierung einer Reihe von vielfältigen Suchanfragen unter einer Kardinalitätsbeschränkung anwendet, was die Gesamtqualität von DeepResearch-Systemen erheblich verbessern kann.

tagSuchanfragenerstellung per Prompt

Zuerst möchten wir prüfen, ob die Eingabe per Prompt ein effektiver Ansatz zur Generierung vielfältiger Suchanfragen ist. Wir wollen auch verstehen, ob ein ausgefeilter Prompt effektiver ist als ein einfacher Prompt. Führen wir ein Experiment durch, in dem wir die beiden folgenden Prompts vergleichen, um dies herauszufinden:

You are an expert at generating diverse search queries. Given any input topic, generate {num_queries} different search queries that explore various angles and aspects of the topic.
Kopieren

You are an expert research strategist. Generate an optimal set of diverse search queries that maximizes information coverage while minimizing redundancy.

Task: Create exactly {num_queries} search queries from any given input that satisfy:
- Relevance: Each query must be semantically related to the original input
- Diversity: Each query should explore a unique facet with minimal overlap
- Coverage: Together, the queries should comprehensively address the topic

Process:
1. Decomposition: Break down the input into core concepts and dimensions
2. Perspective Mapping: Identify distinct angles (theoretical, practical, historical, comparative, etc.)
3. Query Formulation: Craft specific, searchable queries for each perspective
4. Diversity Check: Ensure minimal semantic overlap between queries
Kopieren

Wir verwenden gemini-2.5-flash als LLM mit der ursprünglichen Suchanfrage "embeddings and rerankers" und testen sowohl den einfachen als auch den strukturierten Prompt, um iterativ von einer bis 20 Suchanfragen zu generieren. Anschließend verwenden wir jina-embeddings-v3 mit der Aufgabe text-matching, um die Satzähnlichkeit zwischen der ursprünglichen Suchanfrage und den generierten Suchanfragen sowie die Ähnlichkeit innerhalb der generierten Suchanfragen selbst zu messen. Hier sind die Visualisierungen.

Betrachtet man die beiden Diagramme auf der rechten Seite, so sieht man, dass sowohl der einfache als auch der strukturierte Prompt eine große Varianz in den Kosinusähnlichkeitswerten aufweisen, wobei viele eine Ähnlichkeit von 0,7-0,8 erreichen, was darauf hindeutet, dass einige generierte Suchanfragen nahezu identisch sind. Außerdem haben beide Methoden Schwierigkeiten, die Vielfalt aufrechtzuerhalten, wenn mehr Suchanfragen generiert werden. Anstatt einen deutlichen Abwärtstrend der Ähnlichkeit mit zunehmender Anzahl von Suchanfragen zu beobachten, beobachten wir relativ stabile (und hohe) Ähnlichkeitswerte, was darauf hindeutet, dass zusätzliche Suchanfragen oft vorhandene Perspektiven duplizieren.

Eine Erklärung ist, dass Wang et al. (2025) festgestellt haben, dass LLMs oft Meinungen dominanter Gruppen unverhältnismäßig widerspiegeln, selbst bei Prompt-Steuerung, was auf eine Tendenz zu gängigen Perspektiven hindeutet. Dies liegt daran, dass die Trainingsdaten des LLM bestimmte Standpunkte überrepräsentieren können, wodurch das Modell Variationen erzeugt, die mit diesen vorherrschenden Perspektiven übereinstimmen. Abe et al. (2025) fanden auch heraus, dass die LLM-basierte Suchanfragenerweiterung populäre Interpretationen bevorzugt, während andere übersehen werden. Zum Beispiel könnte "Was sind die Vorteile von KI?" gängige Vorteile wie Automatisierung, Effizienz und Ethischkeit liefern, aber weniger offensichtliche wie die Entdeckung von Medikamenten verfehlen.

Multilingual Prompting for Improving LLM Generation Diversity

Large Language Models (LLMs) are known to lack cultural representation and overall diversity in their generations, from expressing opinions to answering factual questions. To mitigate this problem, we propose multilingual prompting: a prompting method which generates several variations of a base prompt with added cultural and linguistic cues from several cultures, generates responses, and then combines the results. Building on evidence that LLMs have language-specific knowledge, multilingual prompting seeks to increase diversity by activating a broader range of cultural knowledge embedded in model training data. Through experiments across multiple models (GPT-4o, GPT-4o-mini, LLaMA 70B, and LLaMA 8B), we show that multilingual prompting consistently outperforms existing diversity-enhancing techniques such as high-temperature sampling, step-by-step recall, and personas prompting. Further analyses show that the benefits of multilingual prompting vary with language resource level and model size, and that aligning the prompting language with the cultural cues reduces hallucination about culturally-specific information.

arXiv.orgQihan Wang

Wisdom from Diversity: Bias Mitigation Through Hybrid Human-LLM Crowds

Despite their performance, large language models (LLMs) can inadvertently perpetuate biases found in the data they are trained on. By analyzing LLM responses to bias-eliciting headlines, we find that these models often mirror human biases. To address this, we explore crowd-based strategies for mitigating bias through response aggregation. We first demonstrate that simply averaging responses from multiple LLMs, intended to leverage the “wisdom of the crowd”, can exacerbate existing biases due to the limited diversity within LLM crowds. In contrast, we show that locally weighted aggregation methods more effectively leverage the wisdom of the LLM crowd, achieving both bias mitigation and improved accuracy. Finally, recognizing the complementary strengths of LLMs (accuracy) and humans (diversity), we demonstrate that hybrid crowds containing both significantly enhance performance and further reduce biases across ethnic and gender-related contexts.

arXiv.orgAxel Abels

tagProblemformulierung

Man könnte meinen, unser vorheriges Experiment sei nicht schlüssig und wir sollten den Prompt verbessern und es erneut versuchen. Während das Prompting die Ergebnisse sicherlich bis zu einem gewissen Grad verändern kann, ist es wichtiger, dass wir etwas gelernt haben: Allein die Erhöhung der Anzahl der generierten Suchanfragen macht es wahrscheinlicher, dass wir vielfältige Suchanfragen erhalten. Die schlechte Nachricht ist, dass wir als Nebenprodukt auch eine Reihe von doppelten Suchanfragen erhalten.

Da es jedoch kostengünstig ist, eine große Anzahl von Suchanfragen zu generieren, was schließlich einige gute Suchanfragen ergibt, warum behandeln wir dies nicht als ein Subset-Auswahlproblem?

In der Mathematik können wir dieses Problem wie folgt formulieren: Gegeben sei eine ursprüngliche Eingabe $q_0$, eine Menge von Kandidatenabfragen $V=\{q_1, q_2, \cdots, q_n\}$, die von einem LLM mithilfe von Prompt-Engineering generiert wurden. Wähle eine Teilmenge $X\subseteq V$ von $k$ Abfragen aus, die die Abdeckung maximiert und gleichzeitig die Redundanz minimiert.

Leider erfordert das Finden der optimalen Teilmenge von $k$ Abfragen aus $n$ Kandidaten die Überprüfung von $\binom{n}{k}$ Kombinationen - exponentielle Komplexität. Allein für 20 Kandidaten und $k=5$ sind das 15.504 Kombinationen.

tagSubmodulare Funktion

Bevor wir versuchen, das Problem der Teilmengenauswahl brutal zu lösen, möchte ich den Lesern den Begriff Submodularität und submodulare Funktion vorstellen. Sie mögen vielen unbekannt vorkommen, aber Sie haben vielleicht schon von der Idee des "abnehmenden Grenzertrags" gehört - nun, Submodularität ist die mathematische Darstellung davon.

Stellen Sie sich vor, Sie platzieren Wi-Fi-Router, um die Internetabdeckung in einem großen Gebäude zu gewährleisten. Der erste Router, den Sie installieren, bietet einen enormen Wert - er deckt einen bedeutenden Bereich ab, der zuvor keine Abdeckung hatte. Der zweite Router bietet ebenfalls einen erheblichen Mehrwert, aber ein Teil seines Abdeckungsbereichs überschneidet sich mit dem ersten Router, sodass der Grenznutzen geringer ist als beim ersten. Wenn Sie weiterhin Router hinzufügen, deckt jeder zusätzliche Router immer weniger neue Bereiche ab, da die meisten Bereiche bereits von bestehenden Routern abgedeckt sind. Schließlich bietet der 10. Router möglicherweise nur noch sehr wenig zusätzliche Abdeckung, da das Gebäude bereits gut abgedeckt ist.

Diese Intuition erfasst das Wesen der Submodularität. Mathematisch ist eine Mengenfunktion $f: 2^V \rightarrow \mathbb{R}$ submodular, wenn für alle $A \subseteq B \subseteq V$ und jedes Element $v \notin B$ gilt:

$$f(A \cup {v}) - f(A) \geq f(B \cup {v}) - f(B)$$

Im Klartext: Das Hinzufügen eines Elements zu einer kleineren Menge bringt mindestens so viel Nutzen wie das Hinzufügen desselben Elements zu einer größeren Menge, die die kleinere Menge enthält.

Wenden wir dieses Konzept nun auf unser Problem der Abfragegenerierung an. Man erkennt sofort, dass die Abfrageauswahl einen natürlichen abnehmenden Grenzertrag aufweist:

• Die erste Abfrage, die wir auswählen, deckt einen völlig neuen semantischen Raum ab.
• Die zweite Abfrage sollte andere Aspekte abdecken, aber eine gewisse Überschneidung ist unvermeidlich.
• Wenn wir weitere Abfragen hinzufügen, deckt jede zusätzliche Abfrage immer weniger neues Terrain ab.

tagEmbedding-basierter Submodular-Funktionsentwurf

Sei $\mathbf{e}_i \in \mathbb{R}^d$ der Vektor für die Vektormodellierung der Abfrage $q_i$, der mit einem Satz-Vektormodellierungsmodell (z. B. jina-embeddings-v3) ermittelt wurde. Es gibt zwei Hauptansätze für den Entwurf unserer Zielfunktion:

tagAnsatz 1: Facility Location (Abdeckungsbasiert)

$$f_{\text{coverage}}(X) = \sum_{j=1}^{n} \max\left(\alpha \cdot \text{sim}(\mathbf{e}_0, \mathbf{e}_j), \max_{q_i \in X} \text{sim}(\mathbf{e}_j, \mathbf{e}_i)\right)$$

Diese Funktion misst, wie gut die ausgewählte Menge $X$ alle Kandidatenabfragen "abdeckt", wobei:

• $\text{sim}(\mathbf{u}, \mathbf{v}) = \frac{\mathbf{u} \cdot \mathbf{v}}{|\mathbf{u}| |\mathbf{v}|}$ die Kosinusähnlichkeit ist
• $\alpha \cdot \text{sim}(\mathbf{e}_0, \mathbf{e}_j)$ die Relevanz für die ursprüngliche Abfrage sicherstellt
• $\max_{q_i \in X} \text{sim}(\mathbf{e}_j, \mathbf{e}_i)$ die Abdeckung des Kandidaten $j$ durch die ausgewählte Menge $X$ misst

Ein Vorbehalt ist, dass diese Funktion die Diversität nur implizit fördert. Sie bestraft die Ähnlichkeit innerhalb der ausgewählten Menge $X$ nicht explizit. Diversität entsteht, weil die Auswahl ähnlicher Abfragen zu abnehmenden Abdeckungsergebnissen führt.

tagAnsatz 2: Explizite Abdeckung + Diversität

Für eine direktere Kontrolle über die Diversität können wir die Abdeckung mit einem expliziten Diversitätsbegriff kombinieren:

$$f(X) = \lambda \cdot f_{\text{coverage}}(X) + (1-\lambda) \cdot f_{\text{diversity}}(X)$$

wobei die Diversitätskomponente wie folgt formuliert werden kann:

$$f_{\text{diversity}}(X) = \sum_{q_i \in X} \sum_{q_j \in V \setminus X} \text{sim}(\mathbf{e}_i, \mathbf{e}_j)$$

Dieser Diversitätsbegriff misst die gesamte Ähnlichkeit zwischen ausgewählten und nicht ausgewählten Abfragen - er wird maximiert, wenn wir Abfragen auswählen, die sich von den verbleibenden Kandidaten unterscheiden (eine Form der Graph Cut-Funktion).

tagUnterschied zwischen den beiden Ansätzen

Beide Formulierungen behalten die Submodularität bei.

Die Facility-Location-Funktion ist eine bekannte submodulare Funktion. Sie weist Submodularität aufgrund der Max-Operation auf: Wenn wir unserer ausgewählten Menge eine neue Abfrage $q$ hinzufügen, wird jede Kandidatenabfrage $j$ von der "besten" Abfrage in unserer Menge abgedeckt (derjenigen mit der höchsten Ähnlichkeit). Das Hinzufügen von $q$ zu einer kleineren Menge $A$ verbessert eher die Abdeckung verschiedener Kandidaten als das Hinzufügen zu einer größeren Menge $B \supseteq A$, in der viele Kandidaten bereits gut abgedeckt sind.

In der Graph Cut-Diversitätsfunktion ist der Diversitätsbegriff $\sum_{q_i \in X} \sum_{q_j \in V \setminus X} \text{sim}(\mathbf{e}_i, \mathbf{e}_j)$ submodular, da er den "Schnitt" zwischen ausgewählten und nicht ausgewählten Mengen misst. Das Hinzufügen einer neuen Abfrage zu einer kleineren ausgewählten Menge erzeugt mehr neue Verbindungen zu nicht ausgewählten Abfragen als das Hinzufügen zu einer größeren ausgewählten Menge.

Der Facility-Location-Ansatz beruht auf impliziter Diversität durch Abdeckungswettbewerb, während der explizite Ansatz die Diversität direkt misst und optimiert. Beide sind also gültig, aber der explizite Ansatz gibt Ihnen eine direktere Kontrolle über den Kompromiss zwischen Relevanz und Diversität.

tagImplementierungen

GitHub - jina-ai/submodular-optimization

Contribute to jina-ai/submodular-optimization development by creating an account on GitHub.

GitHubjina-ai

Da unsere Funktion submodular ist, können wir den Greedy-Algorithmus verwenden, der eine $(1-1/e) \approx 0.63$ Approximationsgarantie bietet:

$$\max_{X \subseteq V} f(X) \quad \text{subject to} \quad |X| \leq k$$

Hier ist der Code zur Optimierung von Facility Location (abdeckungsbasiert) - derjenige mit impliziter Diversität.

def greedy_query_selection(candidates, embeddings, original_embedding, k, alpha=0.3):
    """
    Greedy algorithm for submodular query selection
    
    Args:
        candidates: List of candidate query strings
        embeddings: Matrix of query embeddings (n x d)
        original_embedding: Embedding of original query (d,)
        k: Number of queries to select
        alpha: Relevance weight parameter
    """
    n = len(candidates)
    selected = []
    remaining = set(range(n))
    
    # Precompute relevance scores
    relevance_scores = cosine_similarity(original_embedding, embeddings)
    
    for _ in range(k):
        best_gain = -float('inf')
        best_query = None
        
        for i in remaining:
            # Calculate marginal gain of adding query i
            gain = compute_marginal_gain(i, selected, embeddings, 
                                       relevance_scores, alpha)
            if gain > best_gain:
                best_gain = gain
                best_query = i
        
        if best_query is not None:
            selected.append(best_query)
            remaining.remove(best_query)
    
    return [candidates[i] for i in selected]

def compute_marginal_gain(new_idx, selected, embeddings, relevance_scores, alpha):
    """Compute marginal gain of adding new_idx to selected set"""
    if not selected:
        # First query: gain is sum of all relevance scores
        return sum(max(alpha * relevance_scores[j], 
                      cosine_similarity(embeddings[new_idx], embeddings[j]))
                  for j in range(len(embeddings)))
    
    # Compute current coverage
    current_coverage = [
        max([alpha * relevance_scores[j]] + 
            [cosine_similarity(embeddings[s], embeddings[j]) for s in selected])
        for j in range(len(embeddings))
    ]
    
    # Compute new coverage with additional query
    new_coverage = [
        max(current_coverage[j], 
            cosine_similarity(embeddings[new_idx], embeddings[j]))
        for j in range(len(embeddings))
    ]
    
    return sum(new_coverage) - sum(current_coverage)
Kopieren

Der Balanceparameter $\alpha$ steuert den Kompromiss zwischen Relevanz und Diversität:

• Hohes $\alpha$ (z. B. 0,8): Priorisiert die Relevanz für die ursprüngliche Abfrage, kann die Diversität beeinträchtigen
• Niedriges $\alpha$ (z. B. 0,2): Priorisiert die Diversität zwischen ausgewählten Abfragen, kann vom ursprünglichen Zweck abweichen
• Moderates $\alpha$ (z. B. 0,4-0,6): Ausgewogener Ansatz, funktioniert in der Praxis oft gut

tagLazy Greedy Algorithmus

Man kann im obigen Code feststellen:

for i in remaining:
    # Calculate marginal gain of adding query i
    gain = compute_marginal_gain(i, selected, embeddings, 
                               relevance_scores, alpha)
Kopieren

Wir berechnen den Grenzertrag für alle verbleibenden Kandidaten in jeder Iteration. Das können wir besser machen.

Der Lazy Greedy Algorithmus ist eine clevere Optimierung, die die Submodularität ausnutzt, um unnötige Berechnungen zu vermeiden. Die wichtigste Erkenntnis ist: Wenn Element A in Iteration $t$ einen höheren Grenzertrag hatte als Element B, dann wird A auch in Iteration $t+1$ einen höheren Grenzertrag haben als B (aufgrund der Submodularitätseigenschaft).

import heapq

def lazy_greedy_query_selection(candidates, embeddings, original_embedding, k, alpha=0.3):
    """
    Lazy greedy algorithm for submodular query selection
    More efficient than standard greedy by avoiding unnecessary marginal gain computations
    """
    n = len(candidates)
    selected = []
    
    # Precompute relevance scores
    relevance_scores = cosine_similarity(original_embedding, embeddings)
    
    # Initialize priority queue: (-marginal_gain, last_updated, query_index)
    # Use negative gain because heapq is a min-heap
    pq = []
    for i in range(n):
        gain = compute_marginal_gain(i, [], embeddings, relevance_scores, alpha)
        heapq.heappush(pq, (-gain, 0, i))
    
    for iteration in range(k):
        while True:
            neg_gain, last_updated, best_idx = heapq.heappop(pq)
            
            # If this gain was computed in current iteration, it's definitely the best
            if last_updated == iteration:
                selected.append(best_idx)
                break
            
            # Otherwise, recompute the marginal gain
            current_gain = compute_marginal_gain(best_idx, selected, embeddings, 
                                               relevance_scores, alpha)
            heapq.heappush(pq, (-current_gain, iteration, best_idx))
    
    return [candidates[i] for i in selected]
Kopieren

Lazy Greedy funktioniert wie folgt:

1. Führen Sie eine Priority Queue von Elementen, sortiert nach ihren Grenzerträgen.
2. Berechnen Sie nur den Grenzertrag des obersten Elements neu.
3. Wenn es nach der Neuberechnung immer noch das höchste ist, wählen Sie es aus.
4. Andernfalls fügen Sie es an der richtigen Position wieder ein und überprüfen Sie das nächste oberste Element.

Dies kann zu erheblichen Geschwindigkeitssteigerungen führen, da wir die Neuberechnung von Grenzerträgen für Elemente vermeiden, die eindeutig nicht ausgewählt werden.

tagErgebnisse

Führen wir das Experiment noch einmal durch. Wir verwenden denselben einfachen Prompt, um ein bis 20 verschiedene Abfragen zu generieren, und führen die gleichen Kosinusähnlichkeitsmessungen wie zuvor durch. Für die submodulare Optimierung wählen wir Abfragen aus den 20 generierten Kandidaten mit unterschiedlichen Werten von k aus und messen die Ähnlichkeit wie zuvor. Die Ergebnisse zeigen, dass die durch submodulare Optimierung ausgewählten Abfragen vielfältiger sind und eine geringere In-Set-Ähnlichkeit aufweisen.

tagAbschließende Frage: Warum die submodulare Formulierung wichtig ist

Sie fragen sich vielleicht: Warum die Mühe machen, dies als submodulares Optimierungsproblem zu formulieren? Warum nicht einfach Heuristiken oder andere Optimierungsansätze verwenden?

Kurz gesagt, die submodulare Formulierung verwandelt eine Ad-hoc-Heuristik "diverse Abfragen auswählen" in ein rigoroses Optimierungsproblem mit nachweisbaren Garantien, effizienten Algorithmen und messbaren Zielen.

tagGarantierte Effizienz

Sobald wir bewiesen haben, dass unsere Zielfunktion submodular ist, erhalten wir leistungsstarke theoretische Garantien und einen effizienten Algorithmus. Der Greedy-Algorithmus, der in $O(nk)$ Zeit im Vergleich zur Überprüfung von $\binom{n}{k}$ Kombinationen läuft, erreicht eine $(1-1/e) \approx 0.63$ Approximation der optimalen Lösung. Dies bedeutet, dass unsere Greedy-Lösung immer mindestens 63 % so gut ist wie die bestmögliche Lösung. Keine Heuristik kann dies versprechen.

Darüber hinaus ist der Lazy-Greedy-Algorithmus in der Praxis aufgrund der mathematischen Struktur submodularer Funktionen dramatisch schneller. Die Beschleunigung ergibt sich aus dem abnehmenden Ertrag: Elemente, die in früheren Iterationen eine schlechte Wahl waren, werden später wahrscheinlich keine gute Wahl mehr. Anstatt also alle $n$ Kandidaten zu überprüfen, muss Lazy Greedy typischerweise nur die Gewinne für die obersten Kandidaten neu berechnen.

tagKeine Notwendigkeit für handgefertigte Heuristiken

Ohne einen prinzipiellen Rahmen könnten Sie auf Ad-hoc-Regeln wie "sicherstellen, dass Abfragen eine Kosinusähnlichkeit < 0,7 haben" oder "verschiedene Schlüsselwortkategorien ausgleichen" zurückgreifen. Diese Regeln sind schwer abzustimmen und nicht verallgemeinerbar. Die submodulare Optimierung bietet Ihnen einen prinzipiellen, mathematisch fundierten Ansatz. Sie können Hyperparameter systematisch mithilfe von Validierungssätzen abstimmen und die Lösungsqualität in Produktionssystemen überwachen. Wenn das System schlechte Ergebnisse liefert, haben Sie klare Metriken, um zu debuggen, was schiefgelaufen ist.

Schließlich ist die submodulare Optimierung ein gut untersuchtes Feld mit jahrzehntelanger Forschung, das es Ihnen ermöglicht, fortschrittliche Algorithmen über Greedy hinaus zu nutzen (wie beschleunigtes Greedy oder lokale Suche), theoretische Erkenntnisse darüber, wann bestimmte Formulierungen am besten funktionieren, und Erweiterungen zur Behandlung zusätzlicher Einschränkungen wie Budgetbeschränkungen oder Fairnessanforderungen.

submodularity.org: Tutorials, References, Activities and Tools for Submodular Optimization