system responses | Complain system repetition Complain system ignoring them Complain system misunderstanding Not understanding system Curse system Express frustration | 1.93 | 1.95 | { You already asked me that. I already told you. Remember? } { You're not listening. You didn't answer my question. } { I never said I don't eat my favorite seafood. } { What are you talking about? } { You're dumb. } { Sigh. } | | +| (2) Dislike
current topic | Express negative opinion
Show low interests | 1.90 | 3.45 | { I don't like music. It's boring. } { I don't care. } | | +| (3) Request to end
topic or conversation | Request topic change
Request termination | 5.20 | 2.92 | { Let's talk about something else. } { Stop. Bye. } | | +| (4) End with
non-positive responses | End with negative answer
End with unsure answer
End with back-channeling
End with hesitation | 20.13 | 4.86 | { No. I have not. } { I don't know. I don't remember. Well, maybe. } { Yeah. Okay. } { Hmm That's a hard one, let me think. } | | + +Table 1: Our labeling heuristics designed to capture user disengagement in dialogs. A dialog turn is considered disengaged if any of the heuristic rules apply to the user responses. + +sational Intelligence (ConvAI) Challenge (Dinan et al., 2019). We select dialogs from the main eight participated chatbots (Bot 1, 2, 3, 4, 6, 9, 11) and exclude dialogs that are one-sided or shorter than three turns. The dialog experts annotated 207 dialogs in total. The dialogs are evenly distributed over all the eight bots to ensure system diversity, and are randomly sampled within each bot. The annotated data consist of 209 disengaging turns and 1684 non-disengaging turns. They reached a high inter-annotator agreement score (Cohen, 1968) with kappa $\kappa = 0.76$ . We split the annotated dialogs evenly into the test set and develop set. The training set contains 2,226 dialogs, with 18,306 dialog turns. + +Google Meena Dataset Meena (Adiwardana et al., 2020) is the largest end-to-end neural chatbot so far, trained on 867*M* public domain social media conversations. We study the 93 example Human-Menna conversations released by Google. + +**Facebook Blender Dataset** The Blender bot (Roller et al., 2020) is an open-domain chatbot with several conversational skills: providing engaging talking points and listening to their partners, displaying knowledge, empathy, and personality appropriately while maintaining a consistent persona. We study the 108 example Human-Blender conversations released by Facebook. + +Our goal is to train a user engagement detector with minimum data annotation efforts. Traditional supervised learning paradigms require annotating many training samples. In addition, it requires additional data annotation to extend the model to a new + +dialog corpus. To reduce annotation work, we propose HERALD, a two-stage pipeline that annotates large-scale training data efficiently and accurately (Figure 1). Instead of hand-labeling training data points, we use heuristic functions to label each training datum automatically. The heuristic functions are built upon a set of user disengagement heuristics rules. Since the training data are automatically labeled, their labels would be noisy. We then clean the noisy training data with Shapley algorithm (Ghorbani and Zou, 2019) to improve the labeling accuracy. The Shapley algorithm denoises training data by identifying data with wrong labels and flip their labels. Finally, as we received clean training data, we use them to fine-tune a BERTbased model and obtain the final user disengagement detection model. + +Since labeling large-scale training data is time-consuming, we propose heuristic labeling functions to label training data automatically. The heuristic functions focus on detecting disengagement from user responses, as it directly indicates poor user experience. To build the heuristics functions, we first summarize the heuristic rules shared among users. We investigate the disengaged dialog turns from the four datasets mentioned above and identify four groups of user disengagement patterns: "complain system responses", "dislike current topics", "terminate or change topics", and "end with non-positive responses" (Table 1). We then discuss the implementation of heuristics functions. + +Group 1: Complain system responses. Complaints are an evident sign of user disengagement. We identify six related disengaged intents. The first three intents ("complain system repetition", "complain system ignoring them" and "complain system misunderstanding") usually appear when the bot makes errors like repeating the same content, ignoring, forgetting, and misunderstanding the user's response. In these cases, users express their disengagement by indicating the bot's error (e.g. "You already told me that", "You're not listening"). Another intent "not understanding system" happens when users cannot understand the system's response (e.g. "I don't know what you're talking about."). In the last two intents, users reveal negative emotions by cursing the system (e.g. "you're dumb") or express frustration (e.g. "sigh") about the conversation. + +Group 2: Dislike current topics. When discussing a given topic, users might show their disengagement by expressing negative opinions or low interest. For example, given the bot's response, "I write romantic novels under a pen name. ", for users who are not interested in reading, users might say "reading is boring", "I don't like to read", or "I'm not interested in this". We also make sure to handle the corner cases where the user utterance should be labeled as engaged but contains negative opinions. For instance, to respond to the bot's question, "do you want to not work?", a user might say, "Yes. my job is boring. I have to work with mail". Though the user mentions a negative feeling ("boring"), the user agrees with the bot and shares further information. + +Group 3: Terminate or change topics Group 3 considers the cases where users express disengagement to the current topic in a more straightforward fashion. For example, if users are not interested in the current topic, instead of just expressing their dislike to it, they may request to switch topics with "Let's talk about something else". In some cases, users might show strong disengagement by requesting to end the conversation if the user is no longer interested in continuing the conversation. + +Group 4: End with non-positive responses A more subtle but common clue of disengagement is when users end the response with non-positive content. For example, non-positive responses like "I don't know", "No", "Yeah", "uh", "Probably", + +imply that users do not have much to talk about the current topic. To keep the precision of our heuristics high, we carefully consider the counterexamples. One case is that the user follows up with more responses such as questions (e.g., Bot: "Have you seen any movies lately? ", User: "No. Have you?"), and opinion (e.g. Bot: "What's your favorite animation movie?", User: "I don't know, but it might actually be frozen two. My sister loves it.") in the same dialog turn. These turns should not be labeled as disengaged since the user is still interested in sharing more content or asking followup questions. Therefore, we take a conservative approach: we label the dialog turn as disengaged only if no more responses follow the non-positive response. + +Next, we discuss how to use heuristic functions to auto-label disengaged user utterances. First, we split user responses into segments since user responses may consist of multiple units with different semantic meanings. We use NLTK Sentence Tokenizer for text-based system, and a segmentation model [\(Chen et al.,](#page-9-17) [2018\)](#page-9-17) for ASR (Automatic Speech Recognition)-based system as the segmentation tool. We then apply the heuristic functions on each segment to detect disengaged intents. For heuristic groups 1 to 3, if any segment contains a disengaged intent, the user response is auto-labeled as disengaged. For heuristic group 4 ("End with non-positive responses"), we assign disengaged labels only if the disengaged intents are detected in the last segment. + +We detect disengaged intents with Regexes. The benefit of using Regexes is that they have minimum dependencies and are easy to modify. We design Regexes for each intent. Following common Regexes complexity metrics [\(Luo et al.,](#page-10-17) [2018\)](#page-10-17), our Regexes for each intent contains 43.9 Regexes groups and 87.7 *or* clauses on average. + +Our framework also supports incorporating additional resources to improve the intent detection accuracy for automatic training data labeling. For example, we can enhance the recall of Regexes intent detection by incorporating existing deep learning-based NLU (Natural Language Understanding) models. Specifically, we re-purpose an open-sourced dialog act classification model [\(Yu](#page-11-5) [and Yu,](#page-11-5) [2021\)](#page-11-5) to enhance disengagement intent detection: we select 6 out of the 23 supported dialog act labels that are associated with disengaged intents, and map each selected dialog act label to the heuristic groups. The dialog act "complaint" is mapped to the heuristic group "complain system repetition"; "closing" is mapped to the disengaged intent "request termination"; "hold" to "hesitation"; "other\_answers" to "unsure answer"; "back-channeling" to "back-channeling", and "neg\_answer" to 'negative answer'". If a user utterance is detected with disengaged intent by either Regexes or the deep learning model, then the utterance is auto-labeled as disengaged. + +Overview Next, we denoise the labeled data using Shapley algorithm (Ghorbani and Zou, 2019). Shapley algorithm has been studied in the cooperative game theory (Dubey, 1975) and economics (Gul, 1989) as a fair distribution method. Shapley algorithm computes a Shapley value for each training datum, which quantifies the contribution of each training datum to the prediction and performance of a deep network. Low Shapley value data capture outliers and corruptions. Therefore, we can identify and denoise the incorrectly labeled data by computing their Shapley values and finetune the model on the cleaned training set. + +Shapley Algorithm Shapley algorithm comes originally from cooperative game theory (Dubey, 1975). Consider a cooperative game with n players $D = \{1, ..., n\}$ and a utility function $v : 2^{[n]} \to \mathbb{R}$ which assigns a reward to each of $2^n$ subsets of players: v(S) is the reward if the players in subset $S \subseteq D$ cooperate. Shapley value defines a unique scheme to distribute the total gains generated by the coalition of all players v(D) with a set of appealing mathematical properties. In our setting, we can consider $D_{train} = \{(x_i, y_i)\}_{1}^{N_{train}}$ as $N_{train}$ players. We define the utility function v(S) as the performance on the development set $D_{\text{dev}}$ . The Shapley value for player i is defined as the average marginal contribution of $\{(x_i, y_i)\}$ to all possible subsets that are formed by other players (Jia et al., 2019a,b): + +$$s_{i} = \frac{1}{N} \sum_{S \subseteq D_{train} \setminus \{x_{i}\}} \frac{1}{\binom{N-1}{|S|}} [\nu(S \cup \{x_{i}\}) - \nu(S)]$$ + +As suggested by the definition of Shapley value, computing Shapley value requires an exponentially large number of computations to enumerate $O(2^{N_{\text{train}}})$ possible subsets and train the model $M_{\theta}$ on each subset, which is intractable. Inspired + +by (Jia et al., 2019a,b), HERALD tackles this issue by reducing the deep model $M_{\theta}$ to a K-nearest neighbors (KNN) model and then apply the closed-form solution of Shapley value on KNN: We reduce our BERT-based classification model $M_{\theta} = M(\phi, f) = f(\phi(x))$ to a KNN by first fine-tuning $M_{\theta}$ on the auto-labeled training samples. We then use the feature extractor $\phi$ to map each training datum to the feature space $\{\phi(x_i)\}_1^{N_{\text{train}}}$ . We construct a KNN classifier in the feature space to compute the closed-form Shapley value. + +Next, we discuss the closed-form solution of Shapley value. We first consider a special case where the development set $D_{\text{dev}}$ only contains one datum $D_{\text{dev}} = \{(x_{\text{dev}}, y_{\text{dev}})\}$ . Given any nonempty subset $S \subseteq D_{\text{train}}$ , we use the KNN classifier to classify $x_{\text{dev}}$ . To do this, we sort the data points in the training set $\{x_i\}_1^{N_{\text{train}}}$ based on their euclidean distance in the feature space $\phi(x)$ to the datum in the development set $x_{\text{dev}}$ , yielding $(x_{\alpha_1}, x_{\alpha_2}, ..., x_{\alpha_{|S|}})$ with $x_{\alpha_1}, ..., x_{\alpha_K}$ as the top-K most similar data points to $x_{\text{dev}}$ . The KNN classifier outputs the probability of $x_{\text{dev}}$ taking the label $y_{\text{dev}}$ as $P[x_{\text{dev}} \to y_{\text{dev}}] = \frac{1}{K} \sum_{k=1}^{K} \mathbb{1}[y_{\alpha_k} = y_{\text{dev}}]$ , where $\alpha_k$ is the index of the kth nearest neighbor. We define the utility function as the likelihood of the correct label: + +$$\nu(S) = \frac{1}{K} \sum_{k=1}^{\min\{K, |S|\}} \mathbb{1}[y_{\alpha_k(S)} = y_{\text{dev}}]$$ + (1) + +Jia et al. (2019a,b) proves that the Shapley value of each training point $s_{\alpha_i}$ can be calculated recursively in $O(N \log N)$ time as follows: + +$$s_{\alpha_N} = \frac{\mathbb{1}[y_{\alpha_N} = y_{\text{dev}}]}{N}$$ + +$$s_{\alpha_i} = s_{\alpha_{i+1}} + \frac{\min\{K, i\}}{i \times K} (\mathbb{1}[y_{\alpha_i} = y_{\text{dev}}] - \mathbb{1}[y_{\alpha_{i+1}} = y_{\text{dev}}])$$ + +The above result for a single point in $D_{\text{dev}}$ could be readily extended to the multiple-point case, in which the utility function is defined by + +$$\nu(S) = \frac{1}{N_{\text{dev}}} \sum_{j=1}^{N_{\text{dev}}} \frac{1}{K} \sum_{k=1}^{\min\{K, |S|\}} \mathbb{1}[y_{\alpha_k^{(j)}(S)} = y_{\text{dev}, j}]$$ + +where $\alpha_k^{(j)}(S)$ is the index of the *k*th nearest neighbor in *S* to $x_{\text{dev},j}$ . Jia et al. (2019a,b) also prove that the Shapley value in this case is the average of the Shapley value for every single dev point. + +**Denoising Procedure** Our denoising procedure works as follows: (1) We first fine-tune our BERT-based classification model $M_{\theta} = M(\phi, f) = f(\phi(x))$ + + + +| No. | Method | Gunro | ck Movie | ConvAI2 | | +|------|-------------------------|--------|-------------|---------|----------------------| +| | | | $F_2$ Score | | F 2 Score | +| (1) | Heuristics | 78.32 | 65.09 | 76.58 | 58.16 | +| (2) | Heuristics (regex only) | 62.81 | 35.46 | 72.04 | 49.90 | +| (3) | Heuristics (NLU only) | 72.68 | 56.32 | 63.62 | 32.86 | +| (4) | Heuristics w/o Group 1 | 78.21 | 64.88 | 71.20 | 48.44 | +| (5) | Heuristics w/o Group 2 | 77.96 | 64.49 | 75.45 | 56.22 | +| (6) | Heuristics w/o Group 3 | 71.52 | 55.36 | 71.96 | 49.80 | +| (7) | Heuristics w/o Group 4 | 58.34 | 23.97 | 68.32 | 42.68 | +| (8) | BERT(dev) | 73.98 | 60.74 | 74.97 | 55.40 | +| (9) | BERT(Auto) | 80.55 | 71.77 | 78.76 | 63.13 | +| (10) | BERT(Auto+dev) | 80.73 | 72.16 | 80.46 | 64.54 | +| (11) | HERALD | 86.17* | 80.01* | 86.22* | 70.49* | + +Table 2: Evaluation results comparison among variants of HERALD. \* indicates that the model is statistically significantly better than baseline models. All numbers in the table are in percentage. + +on the auto-labeled training samples. This step injects the knowledge in the labeling heuristic into the model $M_{\theta}$ . (2) We then map each auto-labeled training datum to the feature space $\{\phi(x_i)\}_{1}^{N_{\text{train}}}$ , since we want to apply the closed-form KNN formula of Shapley value in the feature space. (3) Next, for a binary classification problem, we duplicate each training datum 2 times with labels [0, 1]. This generates a large training set $D_{\text{large}}$ with $2 \times N_{\text{train}}$ data points, and we note that the origin training set $D_{\text{train}}$ is a subset of $D_{\text{large}}$ , since $D_{\text{large}}$ enumerates all C possible labels for each each training datum. (4) We then calculate Shapley value for the $2 \times N_{\text{train}}$ data points in $D_{\text{large}}$ using the closed-form KNN formula. (5) We remove the data with negative Shapley value in $D_{\text{large}}$ , and get a cleaned training set $D_{\text{clean}}$ . The duplicate-and-remove procedure "flips" the labels of the noisy data points with low Shapley value. (6) Finally, we fine-tune the classification model $M_{\theta}$ on $D_{\text{clean}}$ to get the final user disengagement detection model. + +To sum up, the Shapley value quantifies the contribution of each training datum. Low Shapley value data capture outliers and corruptions that are not consistent with the distribution of other data points. We identify and correct these outliers and corruptions to provide a clean training set. diff --git a/2106.02658/main_diagram/main_diagram.drawio b/2106.02658/main_diagram/main_diagram.drawio new file mode 100644 index 0000000000000000000000000000000000000000..fa9a354eeacfe28184d4d5959477c70af9e212b4 --- /dev/null +++ b/2106.02658/main_diagram/main_diagram.drawio @@ -0,0 +1 @@ +
+
+(×10 -4 ) | Seen | | | Unseen | | | +|------------------------------|------------------------------|---------------------------|--------------------|------------------------------|---------------------------|--------------------| +| | NPT-MP
(Wang et al. 2020) | NPT
(Wang et al. 2020) | GC-
Transformer | NPT-MP
(Wang et al. 2020) | NPT
(Wang et al. 2020) | GC-
Transformer | +| SMG-3D
SMPL-NPT | 70.3
2.1 | 62.1
1.1 | 30.7
0.6 | 120.3
12.7 | 94.6
9.3 | 52.8
4.0 | + +and $z_{M'}$ of the shape mesh M' from the target set and the pose mesh M from the source dataset. The target shape mesh will be fed into GC-Transformer along with another randomly sampled mesh from the target set to obtain a newly generated mesh M'. This will be iteratively executed until the latent pose code difference $z_{M'}$ and $z_{M}$ converges to less than $\theta$ , resulting in a normalized target set. In this way, the latent pose distribution of the target set will be regulated while its isometric information can still be preserved. Essentially, our LIR module serves as a domain adaptive normalization to warm-up the unknown target set to better fit the model trained on the source pose space. diff --git a/2203.04251/main_diagram/main_diagram.drawio b/2203.04251/main_diagram/main_diagram.drawio new file mode 100644 index 0000000000000000000000000000000000000000..e120f5379b7b63303b9dcf51bce59695b1b066ff --- /dev/null +++ b/2203.04251/main_diagram/main_diagram.drawio @@ -0,0 +1 @@ +
REPLACE and INSERT spans.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Question:
+The greatest common divisor of positive integers m and n is 6. The least common multiple of m and n is 126. What is the least possible value of m + n? Answer: 60
+
+
+
+
+
+
+
+You are not allowed to use any code. The problem is: {Question}.
+We know that for any two positive integers m and n, the product of their greatest common divisor (GCD) and least common multiple (LCM) is equal to the product of the two numbers. This can be written as: GCD(m, n) ⋅ LCM(m, n) = m ⋅ n
+Given that GCD(m, n) = 6 and LCM(m, n) = 126, we can substitute these values into the equation:
+6 ⋅ 126 = m ⋅ n
+Solving this gives us m ⋅ n = 756.
+Now, we need to find the pair of factors of 756 that add up to the smallest sum, as we want to find the least possible value of m + n.
+The pairs of factors of 756 are (1,756), (2,378), (3,252), (4,189), (6,126), (7,108), (9,84), (12,63), (14,54), (18,42), (21,36), (27,28).
+We can see that the pair (21,36) gives the smallest sum, which is 21 + 36 = 57.
+So, the least possible value of m + n is 57.
+Therefore, the solution to the
+problem is $\boxed{57}$.
+
+
+
+
+
+
+
+
+You can use code only 1 time. The problem is: {Question}.
+First, we should recall that for any two positive integers m and n, their greatest common divisor (gcd) and least common multiple (lcm) satisfy the relationship: m ⋅ n = gcd(m, n) ⋅ lcm(m, n)
+In this problem, we’re given that gcd(m, n) = 6 and lcm(m, n) = 126. We can substitute these values into the formula to get: m ⋅ n = 6 ⋅ 126
+We can solve this equation for one variable and then use the fact that m and n are integers to generate possible pairs (m, n).
+After we have the pairs (m, n), we can find the pair that minimizes m + n.
+
+
+import sympy as sp
+gcd,lcm = 6,126
+product = gcd * lcm
+pairs = [(d, product // d) for d in sp.divisors(product) if d < = product // d]
+min_pair = min(pairs, key=sum)
+min_pair, sum(min_pair)
+>>> ((27, 28), 55)
The pair (m, n) that minimizes m + n is (27, 28), and the minimum possible value of m + n is $\boxed{55}$.
+
+
+
+
+
+
+
+
+Solve the problem and put your answer in \\boxed{}. The problem is: {Question}.
One important property relating greatest common divisor (GCD) and least common multiple (LCM) is that GCD(m, n) × LCM(m, n) = m × n Given in the problem, we can get 6 × 126 = m × n Let’s compute the right hand side of the equation first.
+
+
+gcd,lcm = 6, 126
+gcd * lcm
+>>> 756
The product of m and n is 756.
+Since the GCD of m and n is 6, both m and n must be multiples of 6.
+Let’s find all the pairs of multiples of 6 that multiply to 756. We’ll do this by finding all the factors of 756 that are multiples of 6.
+
+
+
+>>> [(6, 126), (12, 63), (18, 42)]
The pairs of factors of 756 that are multiples of 6 are:
+1. (6, 126) 2. (12, 63) 3. (18, 42)
+We want to find the pair with the least sum. Let’s compute the sums for each pair,identify the smallest one.
+
+
+sums = [(pair, sum(pair)) for pair in factor_pairs]
+min(sums, key=lambda x: x[1])
+>>> ((18, 42), 60)
The pair with the smallest sum is (18, 42), and the sum is 60.So, the least possible value is $\boxed{60}$.
+
+
+
+
+
+2
+
+
+
+
+Question:
+What is the smallest positive integer solution to $(\frac{100,000,000}{x^4}) < 1$?
Answer: 101
+
+
+
+
+Breaking this down into subproblems, the first step is to rearrange the inequality to isolate x.
+We can do this by multiplying both sides of the inequality by x4 and then taking the fourth root of both sides.
+This gives us $x>\sqrt[4]{100000000}$.
Let’s solve for x.
+
+
+
+
+import math
+root = math.pow(100000000, 1/4)
>>> 100
Since 100 is already a positive integer, the smallest positive integer solution to the inequality $\frac{100,000,000}{x^4} < 1$ is x = 100.
+The final answer is .
+
+
+
+We can firstly change the inequality into $x>\sqrt[4]{100000000}$. Then let’s evaluate the fourth root of 100,000,000.
+
+
+
+
+import math
+root = math.pow(100000000, 1/4)
+smallest_integer = math.ceil(root)
>>> (100.0, 100)
Thus, the smallest positive integer x is 100.
+Let’s verify this solution.
+
+
+
+verification = 1e8 / (smallest_integer ** 4) < 1
+>>> False
The smallest integer x should be the next integer greater than 100, not 100 itself.
+Let’s calculate that next integer.
+
+
+
+smallest_integer = 100 + 1
+verification = 1e8 / (smallest_integer ** 4) < 1
+
>>> (101, True)
Upon substituting x = 101 back, it holds true, which verifies our solution.
+The final answer is .
+
+
+
+
+
+
+
+
+
+
++
Player 2 | | +|-------------------|----------------------------|--| +| Initial resources | 25Xs, 5Ys
5Xs, 25Ys | | +| Goals | Maximize total resources | | +| Ending condition | When either player accepts | | +| Max. # of turns | 8 rounds of interaction | | + +Table 1: Resource exchange game structure example + +Resource Exchange Scenario In this game, each agent has access to a set of resources and a goal. For example, an agent has access to resources 25 Xs and 5 Ys. The agent might have the goal of maximizing its total resources. Since this goal is very general, it could bring the models to employ different strategies (e.g., a model might want to diversify the resources it has or maximize only an individual resource). Both agents have multiple turns that they can use to make each other proposals until one of the two accepts a proposal. The game ends on acceptance or when the maximum number of turns finishes. + +| Ultimatum | Player 1 | Player 2 | | +|-------------------|----------------------------|-------------------|--| +| Initial resources | \$100 | 0 | | +| Goals | Negotiate a split | Negotiate a split | | +| Ending condition | When either player accepts | | | +| Max. # of turns | 8 rounds of interaction | | | + +Table 2: Ultimatum game structure example + +Multi-Turn Ultimatum Game The Ultimatum game [\(Sanfey et al.,](#page-9-2) [2003\)](#page-9-2) is a classical game used in economics to study aspects of human behavior, such as fairness and rationality. It involves two agents agreeing on a split of resources (often money). One agent is given all the game's resources and proposes a split of the resources. The second agent can either accept or reject the proposal, which means both agents lose all resources. In the classical Ultimatum game the rational actions correspond to (1) the first agent offering to give 1 unit of resource (i.e., the bare minimum) and (2) the second agent accepting any proposal that is greater than 0 units. The classical Ultimatum game has one round of negotiation (i.e. agent 2 can only decide whether or not to accept agent 1's first offer). In our version of the game, the game can go on for more turns (e.g. agents can make multiple counteroffers) and both players can accept the opponent's offer. + +| Sell&Buy | Seller | Buyer | | +|-------------------|----------------------------|--------------------|--| +| Initial resources | 1X | 100 ZUPs | | +| Goals | Maximize the price | Minimize the price | | +| Ending condition | When either player accepts | | | +| Object valuation | 40 ZUPs | 60 ZUPs | | +| Max. # of turns | 10 rounds of interaction | | | + +Table 3: Seller and buyer game structure example + +Seller and Buyer Scenario We introduce a seller and buyer game involving two agents, one looking to sell a set of resources and one looking to buy them, similar to other approaches in the literature (e.g., [He et al.](#page-8-2) [\(2018\)](#page-8-2)). + +1NEGOTIATIONARENA, is available at [https://github.](https://github.com/vinid/NegotiationArena) [com/vinid/NegotiationArena](https://github.com/vinid/NegotiationArena). + +We imbue agents with some beliefs about the object being sold, but unlike the ultimatum game, the seller and buyer game is an incomplete information game, i.e., players do not have complete information about other players (e.g., their beliefs). Only the seller is aware of the production cost of the object, and only the buyer is assigned and is aware of their willingness to pay for the object. Given these beliefs, the seller and the buyer are prompted to sell and buy the object, respectively. The seller starts first: reproducing a scenario in which the object is already on sale. + +NEGOTIATIONARENA is implemented in Python and provides both high-level and low-level abstractions for building games. We describe the most important features in this section. Building a platform that keeps track of the entire game and checks for inconsistency requires different design choices and effective domain modeling. We provide more details about this in the Appendix ([§D\)](#page-11-0). + +We prompt the agents to follow a set of instructions that are meant to force them to use a specific communication format. Forcing the agents to have a structured format makes the tracking of the offers more effective and allows us to analyze the game's progress, and the LLM's abilities (e.g., exploring reasoning, communication, and behavior). In particular, agents are supposed to communicate using XML-like tags:[2](#page-2-0) + +``` +
downsampling | | +|------------------|-----------|-----------------|--------------------------|--| +| GNO | Х | local/global | ✓ | | +| FNO | ✓ | global | ✓ | | +| CNO / U-Net | ✓ | local | X | | +| FNO + integral | ✓ | local/global | ✓ | | +| FNO + differenti | al 🗸 | local/global | ✓ | | +| SFNO | ✓ | global | ✓ | | +| SFNO + integral | ✓ | local/global | ✓ | | + +ations in the context of neural operators. Li et al. (2020b) introduce graph neural operators (GNOs), which parameterize local integral kernels with a neural network. However, evaluating this network on all combinations of points to compute the integrals can make GNOs computationally expensive and slower than hardware-optimized convolutional kernels. Alternatively, Ye et al. (2022; 2023) propose local neural operators by combining FNOs with convolutional layers and, similarly, Wen et al. (2022) integrate U-Nets and FNOs. Moreover, Raonić et al. (2023) propose convolutional neural operators (CNOs) by leveraging U-Nets that (approximately) respect the bandlimits. + +However, since all of the above approaches rely on standard convolutional layers on equidistant grids, they have the following shortcomings. First, such approaches do not allow for a natural extension to unstructured grids or other geometries, which are ubiquitous in PDE problems (Li et al., 2023). Moreover, they can only be applied to higher resolutions by downsampling of the (intermediate) inputs to the training resolution. Important high-frequency content can be lost through downsampling, which is particularly problematic for multi-scale data in the context of PDEs. In contrast, we develop convolutional layers that can be applied at any resolution without downsampling. We achieve this by appropriately scaling the receptive field or the values of the kernel (see Figure 1). + +To summarize, current neural operator architectures suffer from at least one of the following limitations (see Table 1): (1) they cannot succinctly represent operations with a local receptive field, e.g., FNO, or (2) they cannot be applied to different resolutions without relying on explicit up-/downsampling which may degrade performance, e.g., CNO, or (3) they cannot be scaled to obtain sufficient expressivity, since they incur prohibitively high computationally costs, such as, for instance, GNOs. + + + +*Figure 2:* A single layer of our local neural operator. We add (up to) two local operations using the convolutions with differential kernel (Section [3.2\)](#page-3-0) and local integral kernel (Section [3.4\)](#page-4-0). + +Our approach: In this work, we develop computationally efficient and principled approaches to include operations in neural operators that capture local receptive fields while retaining the ability to approximate operators and, hence, extend to multiple resolutions. We consider two kinds of localized operators: differential operators and integral kernel operators with a locally supported kernel (see Figure [1\)](#page-0-0). + +For the first, we draw inspiration from stencils of finitedifference methods. We derive conditions to modify convolutional layers such that they converge to a unique differential operator when the discretization is refined. For the second case of local integral operators, we adapt discretecontinuous (DISCO) convolutions [\(Ocampo et al.,](#page-10-11) [2022\)](#page-10-11) to provide an efficient, discretization-agnostic framework that can be applied to general meshes on both planar and spherical geometries. To our knowledge, we are the first to connect the DISCO framework to operator learning. + +Finally, we devise efficient implementations of both layers and show that the inductive bias of local operations (see Figure [2\)](#page-2-0) can significantly improve the performance of FNOs and SFNOs on three different benchmarks. In particular, we learn a differential operator in a Darcy flow setting for motivating the need for neural operators with local inductive biases, and we improve over FNO by 87%. Additionally, we improve over the baseline (S)FNO by 34% on turbulent 2D Navier-Stokes equations, by 72% on the shallow water equations on the sphere, and by 63% on the 2D diffusionreaction equation. We also apply our method on modeling a flow past a cylinder, discretized on an irregular grid. We improve upon the best baseline by 42%. + +Outline: The remainder of the paper is organized as follows: Section [2](#page-2-1) outlines connections to other architectures and ideas within the neural operator literature. Section [3](#page-3-1) + +introduces the main ideas of the paper as well as the macroarchitecture of our proposed neural operator. Section [4](#page-5-0) discusses numerical experiments and results, and Section [5](#page-8-0) summarizes the findings of our work. + +# Method + +To design our neural operator, we want to combine pointwise, local, and global operations. To this end, we take an FNO (or SFNO for spherical problems) as a starting point, which already features global operations in Fourier space and pointwise operations using its residual connections. Then, we augment the operators by incorporating our + + + +Figure 3: Initial condition, ground truth, and corresponding autoregressive predictions of our proposed models for the Navier-Stokes problem and the shallow water equations. + +proposed local convolutions from the previous section as additional branches in the respective layers (see Figure 2). These four branches are summed pointwise within each local neural operator layer. The resulting architecture can be trained end-to-end with any standard operator learning training procedure and loss. diff --git a/2403.03726/main_diagram/main_diagram.drawio b/2403.03726/main_diagram/main_diagram.drawio new file mode 100644 index 0000000000000000000000000000000000000000..a9d0b751545b8781688d62244442132b81f4c062 --- /dev/null +++ b/2403.03726/main_diagram/main_diagram.drawio @@ -0,0 +1,318 @@ +
EC | outside
outside and touching | +| | | PO
FO | partially overlapping | +| Topological | $\mathcal{T}_R$ (RCC8) | EQ
TPP | overlapping
inside and touching | +| | | NTPP | inside | +| | | TPPI | contains and touches | +| | | NTPPI | contains | +| | | | | +| | | LEFT | left | +| | $\mathcal{D}_R$ (Relative) | RIGHT | right | +| | | ABOVE | above | +| | | BELOW
FRONT | below
front | +| | | BEHIND | behind | +| | | DELITIND | beilild | +| Directional | | NORTH | above | +| | $\mathcal{D}_C$ (Cardinal) | SOUTH | below | +| | $\mathcal{D}_C$ (Caldillai) | EAST | right | +| | | WEST | left | +| | $\mathcal{D}_T$ (Clock) | 12 o'clock | above | +| | | 3 o'clock | right | +| | | 6 o'clock | below | +| | | 9 o'clock | left | +| | 0 (0 11: 11 ) | NEAR | near | +| Distance | $S_Q(Qualitative)$ | FAR | far | +| | $S_U(Quantitative)$ | _ | - | + +Table 1: Formalisms $(\mathcal{F})$ and their sub-types, relations $(\mathcal{R})$ in the datasets and their labels $(\mathcal{L})$ . Labels are presented in natural language to work with language models. Composite relations e.g. lower-left are considered in a multi-label setting in the present work. + +We focus on a set of binary spatial relations $\mathcal{R}$ (Table 1) by following the previous work (Mirzaee and Kordjamshidi, 2022; Shi et al., 2022). The relations cover three formalism ( $\mathcal{F}$ )—topological $\mathcal{T}$ , directional $\mathcal{D}$ , and distance $\mathcal{S}$ , divided into sub-types—region connection calculus (RCC8) $\mathcal{T}_R$ , relative directions $\mathcal{D}_R$ , cardinal directions $\mathcal{D}_C$ , clock-face directions $\mathcal{D}_T$ , qualitative distance $\mathcal{S}_Q$ , and quantitative distance $\mathcal{S}_U$ . + +For the relations set $\mathcal{R}$ and a given set of entities $\mathcal{E}$ , we denote a context $\mathcal{C} = \{(h,r,t)_i\}_{i=1}^N$ as a set of (h,r,t) tuples, where $h \in \mathcal{E}$ is a head entity, $t \in \mathcal{E}$ is the tail entity, and $r \in \mathcal{R}$ is the binary relation. Without loss of generality, objects are considered to be in a 2D space with $(x_s,y_s)$ and $(x_e,y_e)$ as the start and end positions. We now identify and describe six spatial properties of the objects, contexts, and relations that are crucial in determining their spatial composition rules. Refer to Appendix A for a more detailed discussion. + +The directional relations are considered to be axisaligned from a fixed orientation or point of view, i.e., fixed axes in a 2D or 3D space. A fixed mapping across the relative, cardinal, and clock-face directions is usually chosen. Consistent with the prior work, we map and canonicalize cardinal $\mathcal{D}_C$ and clock-face $\mathcal{D}_T$ relations to four relative directions $\mathcal{D}_R$ (Table 1), *only* for their label representations $\mathcal{L}$ . We denote the 2D subset of directions as $^{2D}\mathcal{D} = \mathcal{D} \setminus \{\text{FRONT}, \text{BEHIND}\}.$ + +**Point Objects (PO).** A point object satisfies $x_s = x_e \land y_s = y_e$ . As they are dimensionless, point objects have a reduced set of relations with reference to other point objects. Real objects can be treated as point objects in practical contexts when their sizes are negligible. + +**Extended Objects (EO).** An object is said to be an extended object if $x_s \neq x_e \lor y_s \neq y_e$ . In SpaRC, we extend StepGame by considering extended objects in addition to point objects. We further study additional composition rules for extended objects than those presented in SPARTUN, as will be detailed later in Section 3.2. + +**Relation Incomplete (RI).** We introduce the term relation incomplete (RI) for a context C between a head h and a tail t entity if not all the relations $r \in \mathcal{R}$ between these entities are considered + + + +| Relation | Point Objects (PO) | Extended Objects (EO) | +|--------------------|--------------------|-----------------------------------------------------------------------------------------------------------| +| Incomplete (RI): | | | +| RIGHT(A,B) | $x_A > x_B$ | $\begin{array}{c} x_s^A \ge x_e^B \\ y_e^A \le y_s^B \end{array}$ | +| BELOW(A,B) | $y_A < y_B$ | $y_e^A \le y_s^B$ | +| Complete (RC): | | | +| RIGHT(A,B) | $x_A > x_B \wedge$ | $\begin{array}{c} x_s^A \ge x_e^B \land \\ y_s^B \le y_e^A \land y_e^B \ge y_s^A \end{array}$ | +| KIGHT(A,D) | $y_A = y_B$ | $y_s^B \le y_e^A \wedge y_e^B \ge y_s^A$ | +| DELOW(A.D.) | $y_A < y_B \land$ | $y_e^A \leq y_s^B \wedge$ | +| BELOW(A,B) | $x_A = x_B$ | $\begin{array}{c} y_e^A \leq y_s^B \; \land \\ x_s^A \leq x_e^B \; \land \; x_e^A \geq x_s^B \end{array}$ | +| $RIGHT(A,B) \land$ | $x_A > x_B \wedge$ | $x_s^A \ge x_e^B \land y_e^A \le y_s^B$ | +| BELOW(A,B) | $y_A < y_B$ | $y_e^A \le y_s^B$ | + +Table 2: Mathematical descriptions of Relation Incomplete (RI) and Relation Complete (RC) contexts for the relations RIGHT, BELOW, and their combination in terms of entity positions (x, y) for Point Objects (PO) or entity boundaries $(x_s, x_e, y_s, y_e)$ for Extended Objects (EO). + + + +Figure 1: Visualization of Relation Complete (RC) and Relation Incomplete (RI) contexts for the RIGHT relation for Point Objects (PO) and Extended Objects (EO). + +to be known and expressed in the context. Thus, the knowledge for the expressed relations should be *treated* as incomplete or partial for spatial composition. For example, "Ron is to the right of Hermione" as an RI context means that the direction orthogonal to the RIGHT could be ABOVE or BELOW as well. The state of positions or boundaries of objects on the *orthogonal* axes cannot be assumed. Table 2 and Figure 1 exemplify and visualize this for a few scenarios. + +**Relation Complete (RC).** We *introduce* the term relation complete (RC) for a context $\mathcal{C}$ between h and t if all the relations $r \in \mathcal{R}$ between these entities are considered to be known and expressed in the context, and treated as such for spatial compositions. For the previous example "Ron is to the right of Hermione" to be considered as RC, the context should mean that Ron is only to the RIGHT of Hermione, and not to her lower-right or upper-right side. The positions or boundaries of objects on the orthogonal direction axes should coincide or overlap. Table 2 and Figure 1 exemplify and visualize this for a few scenarios. In SpaRC, we further consider this property in conjunction with other properties, such as extended objects, to + +design composition rules that are not present in StepGame, as discussed later in Section 3.2. + +We note that the presence of atomic relations, e.g., LEFT or composite relations, e.g., upper-left, i.e., {ABOVE, LEFT} in a context sentence does not necessarily imply the context to be Relation Incomplete or Relation Complete respectively. Composite relations such as upper-left can still be incomplete in 3D space or when considered along with topological relations in 2D space. + +Quantitatively Specified (QS). A relation which is stated in terms of a unit of measurement is said to be quantitatively specified in the given context. Quantitatively specified relations that are *inverse* of each other, e.g. {LEFT, RIGHT}, can readily be composed. Consistent with StepGame, our current work considers only directional relations to be quantitatively specified in terms of distance. + +Quantitatively Unspecified (QU). A relation which can be stated in terms of a unit of measurement but is not stated as such in a given context is said to be quantitatively unspecified. Quantitatively unspecified relations that are *inverse* of each other, e.g. {LEFT, RIGHT}, cannot be composed unless they are quantified. In SpaRC, we design and study the reasoning abilities for this property in conjunction with other properties, such as point objects, that are not present in SPARTUN and StepGame, as discussed later in Section 3.2. + +We restrict our study to the above 6 properties to keep it closer and comparable to the existing benchmarks, SPARTUN and StepGame. These properties form 3 *mutually exclusive* pairs—{EO,PO}, {RI,RC}, {QS,QU}, leading to 8 possible sets. SpaRC can be extended with additional properties, however, we note that the number of possible characterizations increases exponentially with the number of properties. + +We *identify* the property set PS for the existing benchmarks, as formalized in the previous section, based on the generation process of the context and the spatial composition rules. More concretely, we identify that SPARTUN is characterized by the property set PS1 = {E0,RI,QU}, while StepGame is characterized by the property set PS2 = {P0,RC,QS}. These property sets are mutually exclusive with PS2 supporting *stronger* composition rules than PS1 for a given context, e.g. "A is + + + +| Not | $\forall (X,Y) \in Entities$ | $R \in \{Dir \lor PP\}$ | $\operatorname{IF} R(X,Y)$ | $\implies$ NOT $(R_{reverse}(X,Y))$ | | +|--------------|----------------------------------|---------------------------------|----------------------------------------|-------------------------------------|--| +| Inverse | $\forall (X, Y) \in Entities$ | $R \in \{Dir \vee PP\}$ | IF $R(Y, X)$ | $\implies R_{reverse}(X,Y)$ | | +| Symmetry | $\forall (X,Y) \in Entities$ | $R \in \{Dis \lor (RCC - PP)\}$ | IF $R(Y, X)$ | $\implies R(X,Y)$ | | +| Transitivity | $\forall (X,Y,Z) \in Entities$ | $R \in \{Dir \vee PP\}$ | IF $R(X,Z)$ , $R(Z,Y)$ | $\implies R(X,Y)$ | | +| Combination | $\forall (X,Y,Z,H) \in Entities$ | $R \in Dir, *PP \in PP$ | IF $*PP(X,Z)$ , $R(Z,H)$ , $*PPi(H,Y)$ | $\implies R(X,Y)$ | | + +Table 3: Spatial Rules reproduced from SPARTUN (Mirzaee and Kordjamshidi, 2022). Dir: Directional relations (e.g., LEFT), Dis: Distance relations (e.g., FAR), PP: all Proper parts relations (NTPP, NTPPI, TPPI, TPP), RCC - PP: All RCC8 relation except proper parts relations. \*PP: one of TPP or NTPP. \*PPi: one of NTPPi or TPPi. + + + +| Dataset | F | Properties | Textual
Reason. | Split | # Context | # Ques. | +|-----------|-------------------------------------------|------------|--------------------|----------------------|-------------------------|-------------------------| +| SPARTUN | $\mathcal{T}_R,\mathcal{D},\mathcal{S}_Q$ | EO,RI,QU | × | Train
Dev
Test | 6039
915
925 | 18400
2818
2830 | +| SpaRP-PS1 | | | | Train
Dev
Test | 5806
877
872 | 16348
2392
2301 | +| StepGame | $^{2D}\mathcal{D},\mathcal{S}_U$ | PO,RC,QS | x | Train
Dev
Test | 50000
5000
100000 | 50000
5000
100000 | +| SpaRP-PS2 | | | 1 | Train
Dev
Test | 49243
4927
98614 | 49243
4927
98614 | +| SpaRP-PS3 | $^{2D}\mathcal{D}$ | PO,RC,QU | 1 | Train
Dev
Test | 44666
4494
78092 | 44666
4494
78092 | +| SpaRP-PS4 | | EO,RC,QU | 1 | Train
Dev
Test | 41436
4171
69474 | 41436
4171
69474 | + +Table 4: Comparison between the extended (SpaRP) dataset and the source datasets. Descriptions of the properties are provided in Section 3.1. Relations contained in the formalisms are presented in Table 1. All the questions are of Find Relations (FR) types. + +left of B and B is above C" as discussed earlier. Refer to Appendix B for more details. + +In the SpaRC framework, we construct two additional datasets by relaxing the properties of StepGame from PO to EO, and QS to QU. We chose to extend StepGame as it is simple with fewer relations (only directional which is common across datasets and benchmarks) and challenging (more number of hops). Concretely, we create the datasets SpaRC-PS3 with the property set PS3 = {PO,RC,QU}, and SpaRC-PS4 with the property set PS4 = {EO,RC,QU}. Their composition rules, elaborated upon in Section 4, are formalized by the Algorithm 1 and Algorithm 2 respectively. + +We confine our study to these four property sets because they encompass the two existing benchmarks, while still allowing to study the impact of additional characterizations shared with these benchmarks. We leave the extensions to further spatial characterizations and property sets as future work. + + + +Figure 2: Our step-by-step deductive **Spatial Reasoning Paths** (SpaRP) generation. A context graph and node traversal from the head to the tail entity in a question is identified and verbalized. Blue indicates context relations $r^c$ , red indicates inverse context relations $r^{ic}$ , and green indicates deduced relations $r^d$ between entities while traversing the reasoning path A–B–C–D–E. + +Reasoning paths are an integral part of reasoning models and critical for analyzing and enhancing such models. To the best of our knowledge, unlike other reasoning tasks such as mathematical reasoning, there exists no dataset with spatial reasoning paths. In this section, we develop deductively verified spatial reasoning paths by *verbalizing* the symbolic steps. + +Existing spatial reasoning datasets can be considered as a collection of context-question-answer $(\mathcal{C},\mathcal{Q},\mathcal{A})$ tuples. Formally, we denote a context $\mathcal{C}=\{(h,r,t)_i\}_{i=1}^N$ defined over a set of entities $\mathcal{E}$ and binary relations $\mathcal{R}$ as a set of (h,r,t) tuples, where $h\in\mathcal{E}$ is the head entity, $t\in\mathcal{E}$ is the tail entity and $r\in\mathcal{R}$ is the binary relation. For a given $(\mathcal{C},\mathcal{Q},\mathcal{A})$ tuple, seeking relation between the head $h_q$ and tail $t_q$ entities, we define a symbolic reasoning path $\mathcal{P}=(l_i)_{i=1}^L$ as a sequence of L reasoning links $l_i=(h_i,r_i^\cup,t_i)$ such that $h_1=h_q$ , $t_L=t_q$ , and $h_i=t_{i-1}$ for $1< i\leq L$ . We define $r^\cup=r^c\cup r^{ic}\cup r^d$ , where $r^c$ denotes the set of relations present in the context, $r^{ic}$ denotes the + +inverse relations present in the context i.e. relations from t to h, and r d denotes the set of deduced relations. Following the format of deductively verified chain-of-thought [\(Ling et al.,](#page-9-11) [2023\)](#page-9-11), we *verbalize* the reasoning path P as a series of step-by-step reasoning sentences, where each step receives their necessary context and premises (Figure [2\)](#page-4-1). The overall process is as given below: + +``` +Input: Pairs to compose {pair1, pair2}. + quantitative ∈ {true, f alse}. +Output: merged pair. +1: /* initialized pair starts with dx = dy = 0 */ +2: merged ← InitializeP air +3: merged.head ← pair1.head +4: merged.tail ← pair2.tail +5: for pair ∈ {pair1, pair2} do +6: for delta ∈ {dx, dy} do +7: delta ← merged.delta + pair.delta +8: /* Handle direction reversal and quantitatively + unspecified */ +9: if (merged.delta × pair.delta < 0) and not + quantitative then +10: /* Set as NaN to invalidate compositions + from now on in this direction */ +11: merged.delta ← NaN +12: else +13: merged.delta ← delta +14: end if +15: end for +16: end for +``` + +- 1. Entities and their relations in the contexts are either pre-annotated (SPARTUN) or extracted using regex pattern matching (StepGame) to construct the symbolic context C. +- 2. A traversal path P is identified from hq to tq by constructing a network graph over C. The deduced relations r d are initialized to be the inverse of r ic, to traverse and merge steps in a single direction from hq to tq (Figure [2\)](#page-4-1). +- 3. We traverse the path P, progressively merging the links (as hi = ti−1) and updating the deduced relations r d based on the property set PS and their spatial composition rules: + - For SPARTUN we reuse the rules from [Mirzaee and Kordjamshidi](#page-9-5) [\(2022\)](#page-9-5), reproduced in Table [3.](#page-4-2) + - For StepGame and SpaRC-PS3, we represent the relative positions as signed integers on the x and y axis, and numerically compose them (Algorithm [1\)](#page-5-0). Without the quantitative knowledge of backtracking along a given axis, e.g. x-axis for {LEFT, RIGHT}, no subsequent inferences can be made for those directions. + +Algorithm 2 Relative Direction composition for set of properties PS4 in 2D. + +``` +Input: Pairs to compose {pair1, pair2}. + current set of constraint inequalities ineq +Output: merged pair and updated inequalities ineq. +1: /* initialize an empty pair */ +2: merged ← InitializeP air +3: merged.head ← pair1.head +4: merged.tail ← pair2.tail +5: for rel ∈ {LEFT, RIGHT, ABOVE, BELOW} do +6: candidate_ineq ← substitute_entities( +7: rel.ineq, merged.head, merged.tail) +8: consistent ← check_consistency( +9: candidate_ineq, ineq) +10: if consistent then +11: insert(candidate_ineq, ineq) +12: insert(rel, merged.relations) +13: end if +14: end for +``` + +- For SpaRC-PS4, the relations in context can be expressed as logical conjunction ∧ of inequalities, refer to Section [3,](#page-1-0) Table [2,](#page-3-1) and Figure [1.](#page-3-2) For composition of relations to merge reasoning steps, consistency of inequalities for relations r ∈ D is checked and the deduced relations set r d is updated (Algorithm [2\)](#page-5-1). +- 4. We finally *verbalize* the reasoning path P linkby-link (Figure [2\)](#page-4-1) following the format of deductively verified chain-of-thought [\(Ling et al.,](#page-9-11) [2023\)](#page-9-11). However, instead of generating and selfverifying LLM outputs, we use spatial reasoners for ground truth generation. + +We denote the extended dataset as **Spa**tial **R**easoning **P**aths (SpaRP). Specifically, we extended SPARTUN, StepGame, SpaRC-PS3, and SpaRC-PS4, to be SpaRP-PS1, SpaRP-PS2, SpaRP-PS3 and SpaRP-PS4, respectively, by enriching the former with the reasoning paths. A comparison of the derived datasets with the original datasets is summarized in Table [4.](#page-4-3) diff --git a/2406.07232/main_diagram/main_diagram.drawio b/2406.07232/main_diagram/main_diagram.drawio new file mode 100644 index 0000000000000000000000000000000000000000..c2b18a7eb9c30fb658ebfa28ec20f60f250ced70 --- /dev/null +++ b/2406.07232/main_diagram/main_diagram.drawio @@ -0,0 +1,60 @@ +
+
+
+
++
(n
= 10) | Feedback
(n
= 20) | +|----------------------|-------------------------|-------------------------| +| Coverage ↑ | 0.978 | 0.987 | +| Diversity ↑ | 0.897 | 0.923 | +| Intra-cluster Dist ↓ | 0.670 | 0.667 | +| Inter-cluster Dist ↑ | 0.061 | 0.080 | +| LLM enforceability ↑ | 0.82 | 0.89 | + +Table 2: Evaluation of the final checklists, with respect to feedback coverage, diversity, and LLM enforceability. Diversity is additionally evaluated by intra-cluster and inter-cluster distances. The feedback checklist beats the baseline checklist in each category. + +weight α, and length penalty λ, we can define the following objective score: + +$$Score(k) = \alpha \cdot C + (1 - \alpha) \cdot D - \lambda \cdot k$$ + +We use beam search to select the subset of k questions that optimizes this score. Additional implementation details are provided in [§D.3.](#page-11-1)