Original: TalkToModel: Explaining Machine Learning Models with Interactive Natural Language Conversations
Revised: TalkToModel: Explaining Machine Learning Models with Interactive Natural Language Conversations

Original: Abstract
Revised: Abstract

Original: Machine Learning (ML) models are increasingly used to make critical decisions in real-world applications, yet they have become more complex, making them harder to understand.
Revised: Machine Learning (ML) models are increasingly used to make critical decisions in real-world applications, yet they have become more complex, making them harder to understand.

Original: To this end, researchers have proposed several techniques to explain model predictions.
Revised: To this end, researchers have proposed several techniques to explain model predictions.

Original: However, practitioners struggle to use these explainability techniques because they often do not know which one to choose and how to interpret the results of the explanations.
Revised: However, practitioners struggle to use these explainability techniques because they often do not know which one to choose and how to interpret the results of the explanations.

Original: In this work, we address these challenges by introducing TalkToModel: an interactive dialogue system for explaining machine learning models through conversations.
Revised: In this work, we address these challenges by introducing TalkToModel: an interactive dialogue system for explaining machine learning models through conversations.

Original: TalkToModel comprises 1) a dialogue engine that adapts to any tabular model and dataset, understands language, and generates responses, and 2) an execution component that constructs the explanations.
Revised: TalkToModel comprises 1) a dialogue engine that adapts to any tabular model and dataset, understands language, and generates responses, and 2) an execution component that constructs the explanations.

Original: In real-world evaluations with humans, 73% of healthcare workers (e.g., doctors and nurses) agreed they would use TalkToModel over baseline point-and-click systems for explainability in a disease prediction task, and 85% of ML professionals agreed TalkToModel was easier to use for computing explanations.
Revised: In real-world evaluations with humans, 73% of healthcare workers (e.g., doctors and nurses) agreed they would use TalkToModel over baseline point-and-click systems for explainability in a disease prediction task, and 85% of ML professionals agreed TalkToModel was easier to use for computing explanations.

Original: Our ﬁndings demonstrate that TalkToModel is more effective for model explainability than existing systems, introducing a new category of explainability tools for practitioners.
Revised: Our ﬁndings demonstrate that TalkToModel is more effective for model explainability than existing systems, introducing a new category of explainability tools for practitioners.

Original: We release code a demo for the TalkToModel system at: https://github.com/dylan-slack/TalkToModel .  
Revised: We release code a demo for the TalkToModel system at: https://github.com/dylan-slack/TalkToModel .  Introduction

Original: Machine learning (ML) models are being deployed to make consequential decisions in several critical domains such as healthcare, ﬁnance, and law, due to their strong predictive performance.
Revised: Machine learning (ML) models are being deployed to make consequential decisions in several critical domains such as healthcare, ﬁnance, and law, due to their strong predictive performance.

Original: However, state-of-the-art ML models, such as deep neural networks, have also become more complex and, therefore, hard to understand.
Revised: However, state-of-the-art ML models, such as deep neural networks, have also become more complex and, therefore, hard to understand.

Original: This dynamic poses challenges in real-world applications for the model stakeholders who need to understand why models make predictions and whether to trust the predictions.
Revised: This dynamic poses challenges in real-world applications for the model stakeholders who need to understand why models make predictions and whether to trust the predictions.

Original: Consequently, there are an increasing number of techniques that explain the predictions of ML models.
Revised: Consequently, there are an increasing number of techniques that explain the predictions of ML models.

Original: However, recent work suggests practitioners often have difﬁculty interpreting the results of the explanations and determining which ones to run [17, 14].
Revised: However, recent work suggests practitioners often have difﬁculty interpreting the results of the explanations and determining which ones to run [17, 14].

Original: Being able to understand
Revised: Being able to understand

Original: ML models through simple and intuitive interactions is a key bottleneck in adoption across many applications—particularly in settings where experts use models to aid decision making.
Revised: ML models through simple and intuitive interactions is a key bottleneck in adoption across many applications—particularly in settings where experts use models to aid decision making.

Original: Natural language dialogues are a promising solution for supporting accessible interactions with
Revised: Natural language dialogues are a promising solution for supporting accessible interactions with

Original: ML models.
Revised: ML models.

Original: However, designing a dialogue system that supports a satisfying model understandingexperience introduces several challenges.
Revised: However, designing a dialogue system that supports a satisfying model understanding

Original: First, the system must handle many conversation topics about the model and data [38].

Original: Further, the system should handle conversations across different application areas [5].

Original: For example, participants will use different terminology in conversations about loan prediction compared to disease diagnosis.

Original: Last, the dialogue system should generate accurate responses that address the core questions presented by the user [27, 42].

Original: “Applicant #358 wants to know why they were denied a loan.
Revised: “Applicant #358 wants to know why they were denied a loan.

Original: Could you tell me?”
Revised: Could you tell me?”

Original: TalkToModel “What could they do to change this?”
Revised: TalkToModel “What could they do to change this?”

Original: Users Provide Input
Revised: Users Provide Input

Original: With Interface
Revised: With Interface

Original: TalkToModel parses inputs to executable form filter applicant 358 feature importance previous filter counterfactual explanation
Revised: TalkToModel parses inputs to executable form filter applicant 358 feature importance previous filter counterfactual explanation

Original: TalkToModel Executes
Revised: TalkToModel Executes

Original: Operations and Returns
Revised: Operations and Returns

Original: Results  “They were denied because of their income and credit score” “Increase credit score by 30 and income by $1,000” 
Revised: Results  “They were denied because of their income and credit score” “Increase credit score by 30 and income by $1,000” experience introduces several challenges.

Revised: First, the system must handle many conversation topics about the model and data [38].

Revised: Further, the system should handle conversations across different application areas [5].

Revised: For example, participants will use different terminology in conversations about loan prediction compared to disease diagnosis.

Revised: Last, the dialogue system should generate accurate responses that address the core questions presented by the user [27, 42].

Original: In this work, we address these challenges by introducing TalkToModel: a system that enables openended natural language dialogues for understanding ML models for any tabular dataset and classiﬁer.
Revised: In this work, we address these challenges by introducing TalkToModel: a system that enables openended natural language dialogues for understanding ML models for any tabular dataset and classiﬁer.

Original: Users can have discussions with TalkToModel about why predictions occur, how the predictions would change if the data changes, and how to ﬂip predictions, among many other operations.
Revised: Users can have discussions with TalkToModel about why predictions occur, how the predictions would change if the data changes, and how to ﬂip predictions, among many other operations.

Original: For example, on a disease prediction task, users can ask “how important is BMI for the predictions?”
Revised: For example, on a disease prediction task, users can ask “how important is BMI for the predictions?”

Original: or “so how would decreasing the glucose levels by ten change the likelihood of men older than twenty having the disease?”
Revised: or “so how would decreasing the glucose levels by ten change the likelihood of men older than twenty having the disease?”

Original: TalkToModel will respond by describing how, for instance, BMI is the most important feature for predictions, and decreasing glucose will decrease the chance by 20% .
Revised: TalkToModel will respond by describing how, for instance, BMI is the most important feature for predictions, and decreasing glucose will decrease the chance by 20% .

Original: To support such rich conversations with TalkToModel, we introduce techniques for both language understanding and model explainability.
Revised: To support such rich conversations with TalkToModel, we introduce techniques for both language understanding and model explainability.

Original: We implement a dialogue engine that parses user text inputs (referred to as user utterances ) into an SQL-like programming language designed for model understanding.
Revised: We implement a dialogue engine that parses user text inputs (referred to as user utterances ) into an SQL-like programming language designed for model understanding.

Original: To support the system adapting to any dataset and model, we introduce lightweight adaption techniques that train large language models (LLMs) to perform the parsing.
Revised: To support the system adapting to any dataset and model, we introduce lightweight adaption techniques that train large language models (LLMs) to perform the parsing.

Original: Last, we introduce an execution engine that runs the parses.
Revised: Last, we introduce an execution engine that runs the parses.

Original: To reduce the burden of users deciding which explanations to run, we introduce methods to automatically select explanations for the user, by runniung many explanations and comparing their ﬁdelities.
Revised: To reduce the burden of users deciding which explanations to run, we introduce methods to automatically select explanations for the user, by runniung many explanations and comparing their ﬁdelities.

Original: We conduct extensive quantitative and human subject experiments to determine the efﬁcacy of
Revised: We conduct extensive quantitative and human subject experiments to determine the efﬁcacy of

Original: TalkToModel.
Revised: TalkToModel.

Original: We assess TalkToModel’s language understanding generalization capabilities across diabetes prediction, rearrest prediction, and loan default prediction tasks and ﬁnd TalkToModel is quite effective at generalizing to new situations.
Revised: We assess TalkToModel’s language understanding generalization capabilities across diabetes prediction, rearrest prediction, and loan default prediction tasks and ﬁnd TalkToModel is quite effective at generalizing to new situations.

Original: Next, we compare TalkToModel with the most popular open source explainability dashboard in a series of user studies with two groups (1) healthcare professionals with minimal or no ML experience and (2) ML professionals with intermediate or more
Revised: Next, we compare TalkToModel with the most popular open source explainability dashboard in a series of user studies with two groups (1) healthcare professionals with minimal or no ML experience and (2) ML professionals with intermediate or more

Original: ML experience.
Revised: ML experience.

Original: In both cases, over 80% of participants agreed TalkToModel was easier to use than the baseline dashboard, and 77 .
Revised: In both cases, over 80% of participants agreed TalkToModel was easier to use than the baseline dashboard, and 77 .

Original: 7% of healthcare workers and 69 .
Revised: 7% of healthcare workers and 69 .

Original: 2% of ML professionals agreed they were more conﬁdent using TalkToModel.
Revised: 2% of ML professionals agreed they were more conﬁdent using TalkToModel.

Original: Overall, these results indicate that TalkToModel is effective at facilitating model understanding using open ended natural language dialogues.
Revised: Overall, these results indicate that TalkToModel is effective at facilitating model understanding using open ended natural language dialogues.

Original:  TalkToModel
Revised:  TalkToModel

Original: In this section, we introduce TalkToModel.
Revised: In this section, we introduce TalkToModel.

Original: First, we describe the dialogue engine and discuss how it understands user inputs, maps them to operations, and generates text responses based on the results of running the operations.
Revised: First, we describe the dialogue engine and discuss how it understands user inputs, maps them to operations, and generates text responses based on the results of running the operations.

Original: Second, we describe the execution engine, which runs the operations.
Revised: Second, we describe the execution engine, which runs the operations.

Revised: [Table]

Original: 1.1 Text Understanding
Revised: 2.1 Parsing User Utterances

Original: To understand the intent behind user utterances, the system learns to translate or parse them into logical forms.
Revised: To understand the intent behind user utterances [Table] the system learns to translate or parse them into logical forms.

Original: TalkToModel performs the following steps to accomplish this: 1) the system constructs a grammar for the user-provided dataset and model, which deﬁnes the set of acceptable parses, 2)
Revised: TalkToModel performs the following steps to accomplish this: 1) the system constructs a grammar for the user-provided dataset and model, which deﬁnes the set of acceptable parses, 2)

Original: TalkToModel generates (utterance, parse) pairs for the dataset and model, 3) the system ﬁnetunes[Table] a large language model (LLM) to translate user utterances into parses
Revised: TalkToModel generates (utterance, parse) pairs for the dataset and model, 3) the system ﬁnetunes a large language model (LLM) to translate user utterances into parses

Original: [Table]
Revised: [Table]

Original: and 4) the system responds conversationally to users by composing the results of the executed parse into a response.
Revised: and 4) the system responds conversationally to users by composing the results of the executed parse into a response.

Original: Grammar To represent the intentions behind the user utterances in a structured form, TalkToModel relies on a grammar, which expresses user utterances in a structured form.
Revised: Grammar To represent the intentions behind the user utterances in a structured form, TalkToModel relies on a grammar, which expresses user utterances in a structured form.

Original: Compared with approaches that treat determining user intentions in conversations as a classiﬁcation problem [19, 4], our approach expresses compositions of operations and arguments that are combinatorially challenging in a prediction setting.
Revised: Compared with approaches that treat determining user intentions in conversations as a classiﬁcation problem [19, 4], our approach expresses compositions of operations and arguments that are combinatorially challenging in a prediction setting.

Original: This grammar consists of production rules that include the operations the system can run (an overview is provided in Table 1), the acceptable arguments for each operation, and the relations between operations.
Revised: This grammar consists of production rules that include the operations the system can run (an overview is provided in Table 1), the acceptable arguments for each operation, and the relations between operations.

Original: Supporting Context In Dialogues User conversations naturally make references back to events earlier in the conversation (e.g., “what do you predict for them ?”).
Revised: Supporting Context In Dialogues User conversations naturally make references back to events earlier in the conversation (e.g., “what do you predict for them ?”).

Original: However, current models only parse a single input, making hard to apply them in settings where the context is important.
Revised: However, current models only parse a single input, making hard to apply them in settings where the context is important.

Original: We introduce two operations: previous filter and previous operation , which look back in the conversation to ﬁnd the last ﬁlter and last operation, respectively.
Revised: We introduce two operations: previous filter and previous operation , which look back in the conversation to ﬁnd the last ﬁlter and last operation, respectively.

Original: In contrast with approaches that maintain the conversation state using neural representations [6], grammar operations allow for much more trustworthy and dependable behavior while still fostering rich interactions, which is critical for high-stakes settings.
Revised: In contrast with approaches that maintain the conversation state using neural representations [6], grammar operations allow for much more trustworthy and dependable behavior while still fostering rich interactions, which is critical for high-stakes settings.

Original: These operations also act recursively, enabling users to build complex parses in multiple steps, supporting natural conversations for users.
Revised: These operations also act recursively, enabling users to build complex parses in multiple steps, supporting natural conversations for users.

Original: Parsing Dataset Generation We ﬁnetune an LLM to translate utterances into the grammar in a seq2seq fashion.
Revised: Parsing Dataset Generation We ﬁnetune an LLM to translate utterances into the grammar in a seq2seq fashion.

Original: We automate the ﬁnetuning of an LLM to parse user utterances into the grammar by generating a training dataset of (utterance, parse) pairs.
Revised: We automate the ﬁnetuning of an LLM to parse user utterances into the grammar by generating a training dataset of (utterance, parse) pairs.

Original: Compared to dataset generation methods that use human annotators to generate and label datasets for training conversation models [10, 31], this approach is much less costly, while still being highly effective.
Revised: Compared to dataset generation methods that use human annotators to generate and label datasets for training conversation models [10, 31], this approach is much less costly, while still being highly effective.

Original: We write an initial set of user utterances and parses, where parts of the utterances and parses are wildcard terms.
Revised: We write an initial set of user utterances and parses, where parts of the utterances and parses are wildcard terms.

Original: TalkToModel enumerates the wildcards with aspects of a user-provided dataset, such as the feature names or values, to generate a training dataset.
Revised: TalkToModel enumerates the wildcards with aspects of a user-provided dataset, such as the feature names or values, to generate a training dataset.

Original: For instance, the utterance “How many people have {NUMERIC_FEATURE} above {NUMERIC_VALUE} ” would have the numeric features and numeric values in the data enumerated to generate further training utterances.
Revised: For instance, the utterance “How many people have {NUMERIC_FEATURE} above {NUMERIC_VALUE} ” would have the numeric features and numeric values in the data enumerated to generate further training utterances.

Original: We have already written the initial set of utterances and parses, so users only need to provide their dataset to setup the conversation.
Revised: We have already written the initial set of utterances and parses, so users only need to provide their dataset to setup the conversation.

Original: Semantic Parsing We compare two strategies for using pre-trained LLMs to parse user utterances into the grammar 1.)
Revised: Semantic Parsing We compare two strategies for using pre-trained LLMs to parse user utterances into the grammar 1.)

Original: few-shot GPT-J [37] and 2.) ﬁnetuned T5 [29].
Revised: few-shot GPT-J [37] and 2.) ﬁnetuned T5 [29].

Original: The few-shot approach does not require ﬁnetuning the LLM and is quicker to setup, which makes it easier for users to get started with the system.
Revised: The few-shot approach does not require ﬁnetuning the LLM and is quicker to setup, which makes it easier for users to get started with the system.

Original: However, the ﬁnetuned T5 leads to improved performance and a better user experience overall.
Revised: However, the ﬁnetuned T5 leads to improved performance and a better user experience overall.

Original: For the few-shot approach, we prompt the LLM using (utterance, parse) pairs, ordering the closest pairs according to cosine distance of embedding immediately before the user utterance because LLMs exhibit recency biases and consider the GPT-J 6B model [43, 37].
Revised: For the few-shot approach, we prompt the LLM using (utterance, parse) pairs, ordering the closest pairs according to cosine distance of embedding immediately before the user utterance because LLMs exhibit recency biases and consider the GPT-J 6B model [43, 37].

Original: We also ﬁne-tune pre-trained T5 models in a seq2seq fashion on our datasets.
Revised: We also ﬁne-tune pre-trained T5 models in a seq2seq fashion on our datasets.

Original: and consider T5 Small, Base, and Large.
Revised: and consider T5 Small, Base, and Large.

Original: Generating Responses TalkToModel composes the results of the operations into a natural language response it returns to the user.
Revised: Generating Responses TalkToModel composes the results of the operations into a natural language response it returns to the user.

Original: The system generates these responses by ﬁlling in templates associated with each operation based on the results.
Revised: The system generates these responses by ﬁlling in templates associated with each operation based on the results.

Original: Compared to approaches that generate responses using neural methods [32], this approach ensures the responses are trustworthy and do not contain useless information hallucinated by the system, which could be a very poor user experience.
Revised: Compared to approaches that generate responses using neural methods [32], this approach ensures the responses are trustworthy and do not contain useless information hallucinated by the system, which could be a very poor user experience.

Original: 1.2 Executing Parses
Revised: 2.2 Executing Parses

Original: In this subsection, we provide an overview of the execution engine, which runs the operations necessary to respond to user utterances in the conversation.
Revised: In this subsection, we provide an overview of the execution engine, which runs the operations necessary to respond to user utterances in the conversation.

Original: Feature Importance Explanations TalkToModel explains why the model makes predictions to users with feature importance explanations.
Revised: Feature Importance Explanations TalkToModel explains why the model makes predictions to users with feature importance explanations.

Original: We implement the feature importance explanations using post-hoc feature importance explanations.
Revised: We implement the feature importance explanations using post-hoc feature importance explanations.

Original: Post-hoc feature importance explanations do not rely on internal details of the model f
Revised: Post-hoc feature importance explanations do not rely on internal details of the model f

Original: (e.g., internal weights or gradients) and only on the input data x and predictions y to compute explanations, so users are not limited to only certain types of models [30, 22, 16, 28, 18].
Revised: (e.g., internal weights or gradients) and only on the input data x and predictions y to compute explanations, so users are not limited to only certain types of models [30, 22, 16, 28, 18].

Original: While there exists several post hoc explanation methods, each one adopts a different deﬁnition of what constitutes an explanation (e.g., LIME returns coefﬁcients of a local linear model, while SHAP computes Shapley values)
Revised: While there exists several post hoc explanation methods, each one adopts a different deﬁnition of what constitutes an explanation (e.g., LIME returns coefﬁcients of a local linear model, while SHAP computes Shapley values)

Original: Consequently, we automatically select the most faithful explanation for users, unless a user speciﬁcally requests a certain technique.
Revised: Consequently, we automatically select the most faithful explanation for users, unless a user speciﬁcally requests a certain technique.

Original: This metric is the mean absolute difference between the model’s prediction on the original input and a fudged version on m ∈ { 0 , 1 } d features,
Revised: This metric is the mean absolute difference between the model’s prediction on the original input and a fudged version on m ∈ { 0 , 1 } d features,

Original: [Equation]
Revised: [Equation]

Original: where (cid:12) is the tensor product and (cid:15) ∼ N (0 , Iσ ) is N × d dimensional Gaussian noise.
Revised: where (cid:12) is the tensor product and (cid:15) ∼ N (0 , Iσ ) is N × d dimensional Gaussian noise.

Original: To evaluate faithfulness for a particular explanation method, we compute area under the curve on the top-k most important features, thereby summarizing the results into a single metric.
Revised: To evaluate faithfulness for a particular explanation method, we compute area under the curve on the top-k most important features, thereby summarizing the results into a single metric.

Original: We compute faithfulness for multiple different explanations and select the one with the highest value.
Revised: We compute faithfulness for multiple different explanations and select the one with the highest value.

Original: Practically, we consider
Revised: Practically, we consider

Original: KernelSHAP [21] and LIME [30] when choosing explanation methods, because they tend to be able to explain models predictions well.
Revised: KernelSHAP [21] and LIME [30] when choosing explanation methods, because they tend to be able to explain models predictions well.

Original: Additional Explanation Types Since users have explainability questions that cannot be answered solely with feature importance explanations, we also support counterfactual explanations and feature interaction effects.
Revised: Additional Explanation Types Since users have explainability questions that cannot be answered solely with feature importance explanations, we also support counterfactual explanations and feature interaction effects.

Original: These methods support topics around how to get different outcomes and if features interact with each other during predictions, supporting a broad set of user queries.
Revised: These methods support topics around how to get different outcomes and if features interact with each other during predictions, supporting a broad set of user queries.

Original: We implement counterfactual explanations using DiCE, which generates a diverse set of counterfactuals [23], and feature interaction effects using the partial dependence based approach from Greenwell et al.
Revised: We implement counterfactual explanations using DiCE, which generates a diverse set of counterfactuals [23], and feature interaction effects using the partial dependence based approach from Greenwell et al.

Original: Exploring Data and Predictions Because understanding models often requires inspection of model predictions, errors, and the data itself, TalkToModel supports a wide variety of data and model exploration tools.
Revised: Exploring Data and Predictions Because understanding models often requires inspection of model predictions, errors, and the data itself, TalkToModel supports a wide variety of data and model exploration tools.

Original: For example, TalkToModel provides options for ﬁltering data and performing what-if analyses, supporting user queries that concern subsets of data or what would happen if data points change.
Revised: For example, TalkToModel provides options for ﬁltering data and performing what-if analyses, supporting user queries that concern subsets of data or what would happen if data points change.

Original: Users can also inspect model errors, predictions, prediction probabilities, compute summary statistics, and evaluation metrics for individuals and groups of instances.
Revised: Users can also inspect model errors, predictions, prediction probabilities, compute summary statistics, and evaluation metrics for individuals and groups of instances.

Original: [Table]
Revised: [Table]

Original:  Evaluation
Revised:  Evaluation

Original: We demonstrate the accuracy of the system’s language understanding capabilities and show it effectively understands users in dialogues.
Revised: We demonstrate the accuracy of the system’s language understanding capabilities and show it effectively understands users in dialogues.

Original: Next, we perform a human study and verify users both prefer and are more effective using TalkToModel than traditional point-and-click systems.
Revised: Next, we perform a human study and verify users both prefer and are more effective using TalkToModel than traditional point-and-click systems [Table]

Original: Language Understanding
Revised: Language Understanding

Original: We collect gold parsing datasets and evaluate the  accuracy of TalkToModel.
Revised: Here, we quantitatively assess the language understanding capabilities of TalkToModel by creating gold parse datasets and evaluating the system’s accuracy at parsing this data.

Original: Gold Parse Collection While we synthetically generate training data, we construct gold datasets to evaluate the parsing performance of our models across diabetes prediction, loan prediction [Table] and recidivism prediction tasks to ensure we evaluate TalkToModel in diverse settings.
Revised: Gold Parse Collection While we synthetically generate training data, we construct gold datasets to evaluate the parsing performance of our models across diabetes prediction, loan prediction, and recidivism prediction tasks to ensure we evaluate TalkToModel in diverse settings.

Original: We adopt an approach inspired by Yu et al.
Revised: We adopt an approach inspired by Yu et al.

Original: [41] to construct the datasets.
Revised: [41] to construct the datasets.

Original: First, we write 50 (utterance, parse) pairs for the particular task (i.e., loan or diabetes prediction).
Revised: First, we write 50 (utterance, parse) pairs for the particular task (i.e., loan or diabetes prediction).

Original: From there, we ask Mechanical Turk workers to rewrite the utterances while preserving their semantic meaning.
Revised: From there, we ask Mechanical Turk workers to rewrite the utterances while preserving their semantic meaning.

Original: Revising in this way ensures that the ground truth parse for the revised utterance will stay the same, but the system will have a new evaluation utterance.
Revised: Revising in this way ensures that the ground truth parse for the revised utterance will stay the same, but the system will have a new evaluation utterance.

Original: We ask workers to rewrite each pair 8 times for a total of 400 (utterance, parse) pairs per task.
Revised: We ask workers to rewrite each pair 8 times for a total of 400 (utterance, parse) pairs per task.

Original: Next, we ﬁlter out low-quality mturk revisions.
Revised: Next, we ﬁlter out low-quality mturk revisions.

Original: We ask the crowd sourced workers to rate the similarity between the original utterance and revised utterance on a scale of ( 1 - 4 ), whereindicates the utterances have the same meaning and 1 that they do not have the same meaning.
Revised: We ask the crowd sourced workers to rate the similarity between the original utterance and revised utterance on a scale of ( 1 - 4 ), whereindicates the utterances have the same meaning and 1 that they do not have the same meaning.

Original: We collect 5 ratings per revision and remove (utterance, parse) pairs that score below 3 . 0 on average.
Revised: We collect 5 ratings per revision and remove (utterance, parse) pairs that score below 3 . 0 on average.

Original: Results We present the results in Table 2.
Revised: Results We present the results in Table 2.

Original: To evaluate performance on the datasets, we use the exact match parsing accuracy and provide results on the IID and compositional split of the data [36, 41, 13].
Revised: To evaluate performance on the datasets, we use the exact match parsing accuracy and provide results on the IID and compositional split of the data [36, 41, 13].

Original: The IID split contains (utterance, parse) pairs where the parse’s operations and their structure (but not necessarily the arguments) are in the training data.
Revised: The IID split contains (utterance, parse) pairs where the parse’s operations and their structure (but not necessarily the arguments) are in the training data.

Original: The compositional split consists of the remaining parses that are not in the training data.
Revised: The compositional split consists of the remaining parses that are not in the training data.

Original: Because LM’s struggle compositionally, this split is generally much harder for LM’s to parse [24, 40].
Revised: Because LM’s struggle compositionally, this split is generally much harder for LM’s to parse [24, 40].

Original: The ﬁne-tuned T5 performs better overall than the few shot GPT-J models.
Revised: The ﬁne-tuned T5 performs better overall than the few shot GPT-J models.

Original: In particular, the T5 Large models perform strongly on both the IID and compositional data and can even parse complex compositional phrases.
Revised: In particular, the T5 Large models perform strongly on both the IID and compositional data and can even parse complex compositional phrases.

Original: Notably, the T5 small model performs better than the GPT-J 6B model, which has two orders of magnitude more parameters.
Revised: Notably, the T5 small model performs better than the GPT-J 6B model, which has two orders of magnitude more parameters.

Original: This dynamic is particularly true in the compositional splits in the data where the GPT-J few shot models never exceed 10% parsing accuracy.
Revised: This dynamic is particularly true in the compositional splits in the data where the GPT-J few shot models never exceed 10% parsing accuracy.

Original: Overall, these results indicate TalkToModel can understand user utterances with a high degree of accuracy using our best performing T 5 models.
Revised: Overall, these results indicate TalkToModel can understand user utterances with a high degree of accuracy using our best performing T 5 models.

Original: Further, we recommend using this model for the best results and use it for our remaining evaluation.
Revised: Further, we recommend using this model for the best results and use it for our remaining evaluation.

Original: [Table]
Revised: [Table]

Original: User Study: Utility of Explainability Dialogues
Revised: User Study: Utility of Explainability Dialogues

Original: In this subsection, we evaluate how well the end-to-end system enables users to understand ML models compared to current systems.
Revised: In this subsection, we evaluate how well the end-to-end system enables users to understand ML models compared to current systems.

Original: Study Overview We compare TalkToModel against explainerdashboard , one of the most popular open-source explainability dashboards [8] and measure their experiences using both systems.
Revised: Study Overview We compare TalkToModel against explainerdashboard , one of the most popular open-source explainability dashboards [8] and measure their experiences using both systems.

Original: This dashboard includes similar functionality to TalkToModel but provides access to explanations, predictions, and other operations through point-and-click interactions.
Revised: This dashboard includes similar functionality to TalkToModel but provides access to explanations, predictions, and other operations through point-and-click interactions.

Original: We perform this comparison using the Diabetes dataset, and a gradient boosted tree trained on the data [26].
Revised: We perform this comparison using the Diabetes dataset, and a gradient boosted tree trained on the data [26].

Original: To compare both systems in a controlled manner, we ask participants to answer general ML questions with TalkToModel and the dashboard.
Revised: To compare both systems in a controlled manner, we ask participants to answer general ML questions with TalkToModel and the dashboard.

Original: Each question is about basic explainability and model analysis, and participants answer using multiple choice, where one of the options is “Could not determine.”
Revised: Each question is about basic explainability and model analysis, and participants answer using multiple choice, where one of the options is “Could not determine.”

Original: if they cannot ﬁgure out the answer (though it is straightforward to answer all the questions with both interfaces).
Revised: if they cannot ﬁgure out the answer (though it is straightforward to answer all the questions with both interfaces).

Original: For example, questions are about comparing feature importances “Is glucose more important than age for the model’s predictions for data point 49?” or model predictions “How many people are predicted not to have diabetes but do not actually have it?”
Revised: For example, questions are about comparing feature importances “Is glucose more important than age for the model’s predictions for data point 49?” or model predictions “How many people are predicted not to have diabetes but do not actually have it?”

Original: Participants answer 10 total questions.
Revised: Participants answer 10 total questions.

Original: We divide the 10 questions into 2 blocks of 5 questions each.
Revised: We divide the 10 questions into 2 blocks of 5 questions each.

Original: Both blocks have similar questions but different values to control for memorization (exact questions given in Appendix A).
Revised: Both blocks have similar questions but different values to control for memorization (exact questions given in Appendix A).

Original: Participants use TalkToModel to answer one block of questions and the dashboard for the other block.
Revised: Participants use TalkToModel to answer one block of questions and the dashboard for the other block.

Original: In addition, we provide a tutorial on how to use both systems before showing users the questions for the system.
Revised: In addition, we provide a tutorial on how to use both systems before showing users the questions for the system.

Original: Last, we randomize question, block, and interface order to control for biases due to showing interfaces or questions ﬁrst.
Revised: Last, we randomize question, block, and interface order to control for biases due to showing interfaces or questions ﬁrst.

Original: Metrics Following previous work on evaluating human and ML coordination and trust, we assess several metrics to evaluate user experiences [7, 9, 11].
Revised: Metrics Following previous work on evaluating human and ML coordination and trust, we assess several metrics to evaluate user experiences [7, 9, 11].

Original: We evaluate the following statements along 1 - 7 Likert scale at the end of the survey:
Revised: We evaluate the following statements along 1 - 7 Likert scale at the end of the survey:

Original: • Easiness: I found the conversational interface easier to use than the dashboard interface • Conﬁdence: I was more conﬁdent in my answers using the conversational interface than the dashboard interface • Speed: I felt that I was able to more rapidly arrive at an answer using the conversational interface than the dashboard interface •
Revised: • Ease of Use: I found the conversational interface easier to use than the dashboard interface • Conﬁdence: I was more conﬁdent in my answers using the conversational interface than the dashboard interface • Speed: I felt that I was able to more rapidly arrive at an answer using the conversational interface than the dashboard interface •

Original: Likeliness To Use: Based on my experience so far with both interfaces, I would be more likely to use the conversational interface than the dashboard interface in the future
Revised: Likeliness To Use: Based on my experience so far with both interfaces, I would be more likely to use the conversational interface than the dashboard interface in the future

Original: To control for bias associated with the ordering of the terms conversational interface and dashboard interface, we randomized their ordering in the questions.
Revised: To control for bias associated with the ordering of the terms conversational interface and dashboard interface, we randomized their ordering in the questions.

Original: For example, users would either see
Revised: For example, users would either see

Original: I found the conversational interface easier to use than the dashboard interface or I found the dashboard interface easier to use than the conversational interface .
Revised: I found the conversational interface easier to use than the dashboard interface or I found the dashboard interface easier to use than the conversational interface .

Original: In addition to these metrics, we measure accuracy and time-taken to answer each question.
Revised: In addition to these metrics, we measure accuracy and time-taken to answer each question.

Original: Last, we asked to participants to write a short description comparing their experience with both interfaces to capture participants qualitative feedback about both systems.
Revised: Last, we asked to participants to write a short description comparing their experience with both interfaces to capture participants qualitative feedback about both systems.

Original: We compute the completion rate as the questions users provided and answer for and did not mark “could not determine.”
Revised: We compute the completion rate as the questions users provided and answer for and did not mark “could not determine.”

Original: We measure accuracy on completed questions.
Revised: We measure accuracy on completed questions.

Original: Participants answered questions at a higher rate more accurately using TalkToModel than the dashboard.
Revised: Participants answered questions at a higher rate more accurately using TalkToModel than the dashboard.

Original: [Table]
Revised: [Table]

Original: Recruitment
Revised: Recruitment

Original: Since TalkToModel provides a highly accessible way to understand ML models, we expect it to be useful for subject matter experts with variable degrees of ML expertise.
Revised: Since TalkToModel provides a highly accessible way to understand ML models, we expect it to be useful for subject matter experts with variable degrees of ML expertise.

Original: As such, we recruited 45 English speaking healthcare workers to take the survey using the Proliﬁc service [25].
Revised: As such, we recruited 45 English speaking healthcare workers to take the survey using the Proliﬁc service [25].

Original: This group comprises a range of healthcare workers, including doctors, pharmacists, dentists, psychiatrists, healthcare project managers, and medical scribes.
Revised: This group comprises a range of healthcare workers, including doctors, pharmacists, dentists, psychiatrists, healthcare project managers, and medical scribes.

Original: As another point of comparison, we recruited ML professionals with relatively higher ML expertise from ML Slack channels and email lists.
Revised: As another point of comparison, we recruited ML professionals with relatively higher ML expertise from ML Slack channels and email lists.

Original: We received 13 potential participants, all of which had graduate course level ML experience or higher, and included all of them in the study.
Revised: We received 13 potential participants, all of which had graduate course level ML experience or higher, and included all of them in the study.

Original: We received IRB approval for this study from our institution’s
Revised: We received IRB approval for this study from our institution’s

Original: IRB approval process.
Revised: IRB approval process.

Original: Metric
Revised: Metric

Original: Results A signiﬁcant majority of health care workers agreed they preferred TalkToModel in all the categories we evaluated (Table 3).
Revised: Results A signiﬁcant majority of health care workers agreed they preferred TalkToModel in all the categories we evaluated (Table 3).

Original: The same is true for the ML professionals, save for whether they were more likely to use TalkToModel in the future, where 53.8% of participants agreed they would instead use TalkToModel in the future.
Revised: The same is true for the ML professionals, save for whether they were more likely to use TalkToModel in the future, where 53.8% of participants agreed they would instead use TalkToModel in the future.

Original: In addition, participants subjective notions around how quickly they could use TalkToModel aligned with their actual speed of use, and both groups arrived at answers using TalkToModel signiﬁcantly quicker than the dashboard.
Revised: In addition, participants subjective notions around how quickly they could use TalkToModel aligned with their actual speed of use, and both groups arrived at answers using TalkToModel signiﬁcantly quicker than the dashboard.

Original: The median question answer time (measured at the total time taken from seeing the question to submitting the answer) using TalkToModel was 76 .
Revised: The median question answer time (measured at the total time taken from seeing the question to submitting the answer) using TalkToModel was 76 .

Original: 3 seconds, while it was 158 .
Revised: 3 seconds, while it was 158 .

Original: 8 seconds using the dashboard.
Revised: 8 seconds using the dashboard.

Original: Participants were also much more accurate and completed questions at a higher rate (i.e., they did not mark “could not determine) using TalkToModel
Revised: Participants were also much more accurate and completed questions at a higher rate (i.e., they did not mark “could not determine) using TalkToModel

Original: (Table 4).
Revised: (Table 4).

Original: While both health care workers and ML practioners clicked could not determine for around a quarter of the questions using the dashboard, this was only true for 13 .
Revised: While both health care workers and ML practioners clicked could not determine for around a quarter of the questions using the dashboard, this was only true for 13 .

Original: 8% of health care workers and 6 .
Revised: 8% of health care workers and 6 .

Original: 1% of ML professionals using TalkToModel, demonstrating the usefulness of the conversational interface.
Revised: 1% of ML professionals using TalkToModel, demonstrating the usefulness of the conversational interface.

Original: Further, on the questions they completed, both groups were much more accurate using TalkToModel than the dashboard.
Revised: Further, on the questions they completed, both groups were much more accurate using TalkToModel than the dashboard.

Original: Most surprisingly, though ML professionals agreed they preferred TalkToModel only about half the time, they answered all the questions correctly using it, while they only answered 62 .
Revised: Most surprisingly, though ML professionals agreed they preferred TalkToModel only about half the time, they answered all the questions correctly using it, while they only answered 62 .

Original: 5% of questions correctly using the dashboard.
Revised: 5% of questions correctly using the dashboard.

Original: These results indicate TalkToModel is a much more effective system for understanding
Revised: These results indicate TalkToModel is a much more effective system for understanding

Original: ML models for users with a variety of skill levels.
Revised: ML models for users with a variety of skill levels.

Original:  Conclusion
Revised:  Conclusion

Original: In this paper, we introduced TalkToModel, a modular platform for performing open-ended dialogues for understanding ML models.
Revised: In this paper, we introduced TalkToModel, a modular platform for performing open-ended dialogues for understanding ML models.

Original: We showed how end-users prefer TalkToModel over existing systems, ﬁnd it easier to use, and can understand their models more rapidly and accurately using the system.
Revised: We showed how end-users prefer TalkToModel over existing systems, ﬁnd it easier to use, and can understand their models more rapidly and accurately using the system.

Original: These results demonstrate that TalkToModel serves as a very effective route for providing explanations to end-users of all skill levels.
Revised: These results demonstrate that TalkToModel serves as a very effective route for providing explanations to end-users of all skill levels.

Original: In the future, it will be helpful to investigate applications of TalkToModel in-the-wild , such as in doctors’ ofﬁces, laboratories, or professional settings, where model stakeholders use the system to understand their models.
Revised: In the future, it will be helpful to investigate applications of TalkToModel in-the-wild , such as in doctors’ ofﬁces, laboratories, or professional settings, where model stakeholders use the system to understand their models.

Original:  Acknowledgments
Revised:  Acknowledgments

Original: The authors would like to thank the anonymous reviewers for their helpful feedback and all the funding agencies listed below for supporting this work.
Revised: The authors would like to thank the anonymous reviewers for their helpful feedback and all the funding agencies listed below for supporting this work.

Original: This work is supported in part by the NSF awards #IIS-2008461, #IIS-2008956, #IIS-2046873, #IIS-2040989, and research awards from Google,
Revised: This work is supported in part by the NSF awards #IIS-2008461, #IIS-2008956, #IIS-2046873, #IIS-2040989, and research awards from Google,

Original: JP Morgan, Amazon, Harvard Data Science Initiative, D 3 Institute at Harvard, and the HPI Research
Revised: JP Morgan, Amazon, Harvard Data Science Initiative, D 3 Institute at Harvard, and the HPI Research

Original: Center in Machine Learning and Data Science at UC Irvine.
Revised: Center in Machine Learning and Data Science at UC Irvine.

Original: HL would like to thank Sujatha and
Revised: HL would like to thank Sujatha and

Original: Mohan Lakkaraju for their continued support and encouragement.
Revised: Mohan Lakkaraju for their continued support and encouragement.

Original: The views expressed here are those of the authors and do not reﬂect the ofﬁcial policy or position of the funding agencies.
Revised: The views expressed here are those of the authors and do not reﬂect the ofﬁcial policy or position of the funding agencies.

Original: A Experimental Details
Revised: A Experimental Details

Original: In this appendix, we provide an overview of additional experimental details.
Revised: In this appendix, we provide an overview of additional experimental details.

Original: First, we provide additional details about the grammar.
Revised: First, we provide additional details about the grammar.

Original: Next, we describe how we generate our parsing training sets.
Revised: Next, we describe how we generate our parsing training sets.

Original: Further, we provide more details about the explanation selection procedure.
Revised: Further, we provide more details about the explanation selection procedure.

Original: After, we provide examples of the sentences we had mturk workers revise to create our gold parsing datsets.
Revised: After, we provide examples of the sentences we had mturk workers revise to create our gold parsing datsets.

Original: Finally, we provide additional details about the user study.
Revised: Finally, we provide additional details about the user study.

Original: A.1 Model Details
Revised: A.1 Model Details

Original: Finetuning To perform ﬁne-tuning for the T5 models, we split the dataset using a 90/10% train/validation split and train for 20 epochs to maximize the next token likelihood with a batch size of 32 .
Revised: Finetuning To perform ﬁne-tuning for the T5 models, we split the dataset using a 90/10% train/validation split and train for 20 epochs to maximize the next token likelihood with a batch size of 32 .

Original: We select the model with the lowest validation loss at the end of each epoch.
Revised: We select the model with the lowest validation loss at the end of each epoch.

Original: We ﬁne-tune with a learning rate of 1 e - 4 and the AdamW optimizer [20].
Revised: We ﬁne-tune with a learning rate of 1 e - 4 and the AdamW optimizer [20].

Original: and consider T5 Small, Base, and Large variants.
Revised: and consider T5 Small, Base, and Large variants.

Original: Guided Decoding When parsing the utterances, one issue is that their generations are unconstrained and may generate parses outside the grammar, resulting in the system failing to run the parse and bad user experiences.
Revised: Guided Decoding When parsing the utterances, one issue is that their generations are unconstrained and may generate parses outside the grammar, resulting in the system failing to run the parse and bad user experiences.

Original: To ensure the generations are grammatical, we constrain the decodings to be in the grammar [33].
Revised: To ensure the generations are grammatical, we constrain the decodings to be in the grammar [33].

Original: This technique, referred to as guided decoding , constrains the LLM generations to only allow those tokens that appear next in the grammar at any point during generation.
Revised: This technique, referred to as guided decoding , constrains the LLM generations to only allow those tokens that appear next in the grammar at any point during generation.

Original: Practically, we accomplish this by recompiling the grammar at inference time into an equivalent grammar consisting of the tokens in the LLM’s vocabulary.
Revised: Practically, we accomplish this by recompiling the grammar at inference time into an equivalent grammar consisting of the tokens in the LLM’s vocabulary.

Original: While decoding from the LLM, we ﬁx the likelihood of ungrammatical tokens to 0 at every generation step.
Revised: While decoding from the LLM, we ﬁx the likelihood of ungrammatical tokens to 0 at every generation step.

Original: Thus, the LLM only generates grammatical parses.
Revised: Thus, the LLM only generates grammatical parses.

Original: A.2 Grammar Details
Revised: A.2 Grammar Details

Original: In this subsection, we provide additional details about the grammar.
Revised: In this subsection, we provide additional details about the grammar.

Original: First, we describe the design of the grammar.
Revised: First, we describe the design of the grammar.

Original: After, we provide details about how we update the grammar for new datasets.
Revised: After, we provide details about how we update the grammar for new datasets.

Original: Design Recall from the main paper that the grammar serves as a logical form of user utterances, which TalkToModel can execute.
Revised: Design Recall from the main paper that the grammar serves as a logical form of user utterances, which TalkToModel can execute.

Original: Here, we provide more details about the grammar design.
Revised: Here, we provide more details about the grammar design.

Original: The grammar deﬁnes relations between the operations and the acceptable values arguments in Table 1.
Revised: The grammar deﬁnes relations between the operations and the acceptable values arguments in Table 1.

Original: For example, the grammar deﬁnes different acceptable values for the comparison argument in the filter operation, such as less than or equal to or greater than .
Revised: For example, the grammar deﬁnes different acceptable values for the comparison argument in the filter operation, such as less than or equal to or greater than .

Original: In addition, we structure the grammar to make parses appear closer to natural language text instead of a formal programming language like SQL or Python.
Revised: In addition, we structure the grammar to make parses appear closer to natural language text instead of a formal programming language like SQL or Python.

Original: The reason is that language models tend to perform better at translating utterances into grammars that are more similar to natural language instead of a programming language [33].
Revised: The reason is that language models tend to perform better at translating utterances into grammars that are more similar to natural language instead of a programming language [33].

Original: Consequently, we design the grammar, so that parses appear more like natural language text, without unnecessary parentheses and commas, and omitting unnecessary arguments where possible.
Revised: Consequently, we design the grammar, so that parses appear more like natural language text, without unnecessary parentheses and commas, and omitting unnecessary arguments where possible.

Original: In general, we found that simplifying the grammar and making it more like natural language as much as possible considerably improved performance.
Revised: In general, we found that simplifying the grammar and making it more like natural language as much as possible considerably improved performance.

Original: For example, the question “What are the three most important features for people older than thirty-ﬁve?” would simply translate to filter age greater than 35 and topk 3 .
Revised: For example, the question “What are the three most important features for people older than thirty-ﬁve?” would simply translate to filter age greater than 35 and topk 3 .

Original: Note, here, because TalkToModel is applied to only one dataset at a time, the dataset argument can be omitted for simplicity.
Revised: Note, here, because TalkToModel is applied to only one dataset at a time, the dataset argument can be omitted for simplicity.

Original: Practically, we implement the grammar in Lark [34] because the implementation supports interactive parsing, simplifying the process of implementing the guided decoding strategy.
Revised: Practically, we implement the grammar in Lark [34] because the implementation supports interactive parsing, simplifying the process of implementing the guided decoding strategy.

Original: Updating the Grammar For Datasets and User Utterances In the main paper, we discussed how we update the grammar based on the dataset.
Revised: Updating the Grammar For Datasets and User Utterances In the main paper, we discussed how we update the grammar based on the dataset.

Original: Here, we provide more description about how we update the grammar.
Revised: Here, we provide more description about how we update the grammar.

Original: We update the grammar based on the feature names and categorical feature values in the dataset.
Revised: We update the grammar based on the feature names and categorical feature values in the dataset.

Original: In particular, the acceptable values for the feature argument (Table 1) in the grammar becomes all the feature values in the dataset.
Revised: In particular, the acceptable values for the feature argument (Table 1) in the grammar becomes all the feature values in the dataset.

Original: Further, the value argument for a categorical feature becomes the set of categorical feature values that appear in the data for that feature.
Revised: Further, the value argument for a categorical feature becomes the set of categorical feature values that appear in the data for that feature.

Original: Because there are many possible values of numeric features, we instead extract potential numeric values from user utterances as they are provided to the system.
Revised: Because there are many possible values of numeric features, we instead extract potential numeric values from user utterances as they are provided to the system.

Original: Speciﬁcally, we set the value argument in the grammar for numeric features to contain the set of numeric values that appear in the user utterance.
Revised: Speciﬁcally, we set the value argument in the grammar for numeric features to contain the set of numeric values that appear in the user utterance.

Original: We additionally support string based numeric values (e.g., “ﬁfty-ﬁve” or “twelve”) to make the system handle a wider variety of cases.
Revised: We additionally support string based numeric values (e.g., “ﬁfty-ﬁve” or “twelve”) to make the system handle a wider variety of cases.

Original: A.3 Training Dataset Generation
Revised: A.3 Training Dataset Generation

Original: In this subsection, we provide details about the generation of the (utterance, parse) pair training dataset.
Revised: In this subsection, we provide details about the generation of the (utterance, parse) pair training dataset.

Original: To ensure that we generate a diverse and comprehensive set of (utterance, parse) pairs for training, we compose a total of 687 templates that use 6 different wildcard types.
Revised: To ensure that we generate a diverse and comprehensive set of (utterance, parse) pairs for training, we compose a total of 687 templates that use 6 different wildcard types.

Original: The templates consist of a diverse set of utterances that encompass the different operations permitted in the system.
Revised: The templates consist of a diverse set of utterances that encompass the different operations permitted in the system.

Original: The wildcards include categorical feature names, numeric feature names, class names, numeric feature values, categorical feature values, explanation types, and common ﬁltering expressions (e.g., “ {NUMERIC_FEATURE} above {NUMERIC_VALUE} ”).
Revised: The wildcards include categorical feature names, numeric feature names, class names, numeric feature values, categorical feature values, explanation types, and common ﬁltering expressions (e.g., “ {NUMERIC_FEATURE} above {NUMERIC_VALUE} ”).

Original: Because templates can have potentially many wildcards, we recursively enumerate all the wildcard values for each parse.
Revised: Because templates can have potentially many wildcards, we recursively enumerate all the wildcard values for each parse.

Original: Further, we also limit the number of values for certain wildcards to ensure the number of training pairs generated does not become extremely large.
Revised: Further, we also limit the number of values for certain wildcards to ensure the number of training pairs generated does not become extremely large.

Original: In particular, we limit the number of numeric values to 2 values per feature.
Revised: In particular, we limit the number of numeric values to 2 values per feature.

Original: In addition, to prevent templates with many wildcards from dominating the training dataset, we also downsample the number of values per wildcard to 2 values after the initial recursion.
Revised: In addition, to prevent templates with many wildcards from dominating the training dataset, we also downsample the number of values per wildcard to 2 values after the initial recursion.

Original: In this way, we the training dataset does not get dominated by a few templates that have many wildcards, which we found improves performance.
Revised: In this way, we the training dataset does not get dominated by a few templates that have many wildcards, which we found improves performance.

Original: As an example, an utterance template is “Explain the predictions on data with {NUMERIC_FEATURE} greater than {NUMERIC_VALUE} ” and the corresponding parse template is filter {NUMERIC_FEATURE} greater than {NUMERIC_VALUE} and explain feature importance .
Revised: As an example, an utterance template is “Explain the predictions on data with {NUMERIC_FEATURE} greater than {NUMERIC_VALUE} ” and the corresponding parse template is filter {NUMERIC_FEATURE} greater than {NUMERIC_VALUE} and explain feature importance .

Original: From there, we enumerate the numeric features in the dataset and a selection of numeric feature values, substituting these into {NUMERIC_FEATURE} and {NUMERIC_VALUE} respectively to generate data.
Revised: From there, we enumerate the numeric features in the dataset and a selection of numeric feature values, substituting these into {NUMERIC_FEATURE} and {NUMERIC_VALUE} respectively to generate data.

Original: A.4 Explanation Selection
Revised: A.4 Explanation Selection

Original: Here, we provide additional details about the explanation selection algorithm.
Revised: Here, we provide additional details about the explanation selection algorithm.

Original: For our explanation selection algorithm, we set σ = 0 .
Revised: For our explanation selection algorithm, we set σ = 0 .

Original: 05 , K to ﬂoor ( d 2 ) , and N = 10 , 000 .
Revised: 05 , K to ﬂoor ( d 2 ) , and N = 10 , 000 .

Original: Further, because it would not make sense to perturb categorical features using Gaussian noise, we permute these features to another value occurring in the feature 30% of the time.
Revised: Further, because it would not make sense to perturb categorical features using Gaussian noise, we permute these features to another value occurring in the feature 30% of the time.

Original: We additionally use both LIME [30] and
Revised: We additionally use both LIME [30] and

Original: KernelSHAP [21] with their default settings while computing explanations.
Revised: KernelSHAP [21] with their default settings while computing explanations.

Original: In addition, we include
Revised: In addition, we include

Original: LIME with the following kernel widths: [0 . 25 , 0 . 50 , 0 .
Revised: LIME with the following kernel widths: [0 . 25 , 0 . 50 , 0 .

Original: 75 , 1 . 0] , to generate explanations with a variety of different localities.
Revised: 75 , 1 . 0] , to generate explanations with a variety of different localities.

Original: In addition, if the different in ﬁdelity between the top two explanation methods is small, so it is hard to determine which explanation is most accurate, we use the explanation stability metric proposed by Alvarez-Melis and Jaakkola [3] to break ties, because it is more desirable for the explanation to robust to perturbations [35, 2].
Revised: In addition, if the different in ﬁdelity between the top two explanation methods is small, so it is hard to determine which explanation is most accurate, we use the explanation stability metric proposed by Alvarez-Melis and Jaakkola [3] to break ties, because it is more desirable for the explanation to robust to perturbations [35, 2].

Original: In order to use the stability metric proposed by Alvarez-Melis and Jaakkola [3] to break ties if the explanations ﬁdelities are quite close (less than δ = 0 . 01 ), we compute the jaccard similarity between feature rankings instead of the l 2 norm as is used in their work.
Revised: In order to use the stability metric proposed by Alvarez-Melis and Jaakkola [3] to break ties if the explanations ﬁdelities are quite close (less than δ = 0 . 01 ), we compute the jaccard similarity between feature rankings instead of the l 2 norm as is used in their work.

Original: The reason is that the norm might not be comparable between explanation types, because they have different ranges, while the jaccard similarity should not be affected.
Revised: The reason is that the norm might not be comparable between explanation types, because they have different ranges, while the jaccard similarity should not be affected.

Original: Further, we compute the area under the top k curve using the jaccard similarity stability metric, to make this measure more robust.
Revised: Further, we compute the area under the top k curve using the jaccard similarity stability metric, to make this measure more robust.

Original: A.5 Gold Parsing Dataset
Revised: A.5 Gold Parsing Dataset

Original: In this subsection, we provide examples of 10 of the sentences provided to mturk workers to revise during our data generation process for each dataset.
Revised: In this subsection, we provide examples of 10 of the sentences provided to mturk workers to revise during our data generation process for each dataset.

Original: The examples are provided in Table 5 and illustrate the different types of utterances revised by mturkers to create a comprehensive testing set.
Revised: The examples are provided in Table 5 and illustrate the different types of utterances revised by mturkers to create a comprehensive testing set.

Original: Also, we provide the number of (utterance, parse) pairs in the IID and compositional splits in Table 6.
Revised: Also, we provide the number of (utterance, parse) pairs in the IID and compositional splits in Table 6.

Original: A.6 User Study Questions
Revised: A.6 User Study Questions

Original: In this subsection, we provide the questions participants answered in the user study.
Revised: In this subsection, we provide the questions participants answered in the user study.

Original: The questions are provided in Table 7.
Revised: The questions are provided in Table 7.

Original: One of the two question blocks, Block 1 or Block 2, is shown for TalkToModel and the other is shown for the dashboard (the ordering of TalkToModel and the dashboard is also
Revised: One of the two question blocks, Block 1 or Block 2, is shown for TalkToModel and the other is shown for the dashboard (the ordering of TalkToModel and the dashboard is also

Original: [Table]
Revised: [Table]

Original: Howdothefeaturesofthedatainteractinthemodel’spredictionsonthisparticulardata?
Revised: Howdothefeaturesofthedatainteractinthemodel’spredictionsonthisparticulardata?

Original: G e r m a n
Revised: G e r m a n

Original: Ifpeopleinthedatawereunemployed,howimportantwouldtheageandloanamountfeaturesbeforpredictingcreditrisk?
Revised: Ifpeopleinthedatawereunemployed,howimportantwouldtheageandloanamountfeaturesbeforpredictingcreditrisk?

Original: whatwouldhappentothelikelihoodofbeingbadcreditriskifweweretoincreasetheloanamountby250forthedatapointwithid89whataretopthreemostimportantfeaturesfordeterminingwhetherthosewhoareapplyingforfurnitureloansaregoodcreditrisk?Whatistheaverageloanamountforpeoplewithnocurrentloansandthatdonotownahouse?
Revised: whatwouldhappentothelikelihoodofbeingbadcreditriskifweweretoincreasetheloanamountby250forthedatapointwithid89whataretopthreemostimportantfeaturesfordeterminingwhetherthosewhoareapplyingforfurnitureloansaregoodcreditrisk?Whatistheaverageloanamountforpeoplewithnocurrentloansandthatdonotownahouse?

Original: Howaccurateareyouatpredictingwhetherpeoplewhoareaskingforloansforhomeappliancesaregoodcreditrisk?
Revised: Howaccurateareyouatpredictingwhetherpeoplewhoareaskingforloansforhomeappliancesaregoodcreditrisk?

Original: Inthedataset,iftheloandurationweretobeincreasedby2years,whatwouldthepredictionsforthedatabe?Couldyoushowmesomeexamplesthemodelpredictsincorrectlyandhowaccuratethemodelisonthedata?
Revised: Inthedataset,iftheloandurationweretobeincreasedby2years,whatwouldthepredictionsforthedatabe?Couldyoushowmesomeexamplesthemodelpredictsincorrectlyandhowaccuratethemodelisonthedata?

Original: Whatdoyoupredictontheinstancesinthedata?Also,couldyoushowmeanexampleofafewmistakesyoumakeinthesepredictions?Butwhydidyouthinkthesepeoplearebadcreditrisk?
Revised: Whatdoyoupredictontheinstancesinthedata?Also,couldyoushowmeanexampleofafewmistakesyoumakeinthesepredictions?Butwhydidyouthinkthesepeoplearebadcreditrisk?

Original: Ifthesepeoplewerenotunemployed,what’sthelikelihoodtheyaregoodcreditrisk?Why?
Revised: Ifthesepeoplewerenotunemployed,what’sthelikelihoodtheyaregoodcreditrisk?Why?

Original: COMPAS
Revised: COMPAS

Original: Diabetes
Revised: Diabetes

Original: German
Revised: German

Original: [Table] [Table]
Revised: [Table] [Table]

Original: Overall   randomized).
Revised: Overall   randomized).

Original: The two question blocks include similar concepts to ensure a similar level of difﬁculty but include different numbers to discourage memorization between the question blocks
Revised: The two question blocks include similar concepts to ensure a similar level of difﬁculty but include different numbers to discourage memorization between the question blocks

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: Whatarethethreemostimportantfeaturesforthemodel’spredictionsonpeopleolderthan30withbmi’sabove
Revised: Whatarethethreemostimportantfeaturesforthemodel’spredictionsonpeopleolderthan30withbmi’sabove

Original: [Table]
Revised: [Table]

Original: A.7 User Study Length & Compensation
Revised: A.7 User Study Length & Compensation

Original: The survey took around 30 minutes for participants to complete.
Revised: The survey took around 30 minutes for participants to complete.

Original: We compensated the ML professionals by providing them with a $20 gift card.
Revised: We compensated the ML professionals by providing them with a $20 gift card.

Original: We paid the proliﬁc workers $14 .
Revised: We paid the proliﬁc workers $14 .

Original: 74 /hour on average for completing the survey, considering their individual completion times
Revised: 74 /hour on average for completing the survey, considering their individual completion times

Original: [Table]
Revised: [Table]

Original: B Additional Experiments
Revised: B Additional Experiments

Original: In this appendix
Revised: In this appendix

Original: [Table]
Revised: [Table]

Original: we provide additional experimental results.
Revised: we provide additional experimental results.

Original: First, we provide experimental results where we show the advantages of explanation selection.
Revised: First, we provide experimental results where we show the advantages of explanation selection.

Original: Second, we give results on the affects of the number of training templates.
Revised: Second, we give results on the affects of the number of training templates.

Original: After, we provide error analysis for our parsing models.
Revised: After, we provide error analysis for our parsing models.

Original: Last, we give additional user study results.
Revised: Last, we give additional user study results.

Original: B.1 Example Conversation
Revised: B.1 Example Conversation

Original: In this subsection, we provide an example dialogue using the system, in Table 8.
Revised: In this subsection, we provide an example dialogue using the system, in Table 8.

Original: [Table]
Revised: [Table]

Original: B.2 Advantages of Explanation Selection
Revised: B.2 Advantages of Explanation Selection

Original: In the main paper, we discussed how we select explanations based on those that have the highest ﬁdelity in order to ensure the user receives the most accurate explanations possible.
Revised: In the main paper, we discussed how we select explanations based on those that have the highest ﬁdelity in order to ensure the user receives the most accurate explanations possible.

Original: In this subsection, we provide more details about the advantages of explanation selection and show that without the procedure, users may receive comparatively lower ﬁdelity explanations, demonstrating the importance of the technique.
Revised: In this subsection, we provide more details about the advantages of explanation selection and show that without the procedure, users may receive comparatively lower ﬁdelity explanations, demonstrating the importance of the technique.

Original: Our evaluation procedure is as follows.
Revised: Our evaluation procedure is as follows.

Original: For a data point, we compute the topk ﬁdelity AUCs from all the explanations we consider (details about the explanation pool in Appendix A.4).
Revised: For a data point, we compute the topk ﬁdelity AUCs from all the explanations we consider (details about the explanation pool in Appendix A.4).

Original: Next, we compute several metrics that capture the improvement in ﬁdelity using our selection technique.
Revised: Next, we compute several metrics that capture the improvement in ﬁdelity using our selection technique.

Original: We compute the absolute improvement over the worst ﬁdelity explanation, absolute improvement over the median
Revised: We compute the absolute improvement over the worst ﬁdelity explanation, absolute improvement over the median

Original: [Table]
Revised: [Table]

Original: We repeat this evaluation procedure for the three datasets we consider in the main paper: Compas,
Revised: We repeat this evaluation procedure for the three datasets we consider in the main paper: Compas,

Original: Diabetes and German Credit.
Revised: Diabetes and German Credit.

Original: The results provided in Table 9 demonstrate that explanation ﬁdelity can be much worse without selecting for explanations.
Revised: The results provided in Table 9 demonstrate that explanation ﬁdelity can be much worse without selecting for explanations.

Original: For instance, if experts without sufﬁcient data science experience were to run an explanation type arbitrarily, these results demonstrate they could have relatively much less faithful explanations
Revised: For instance, if experts without sufﬁcient data science experience were to run an explanation type arbitrarily, these results demonstrate they could have relatively much less faithful explanations

Original: B.3 Effects of the number of training templates
Revised: B.3 Effects of the number of training templates

Original: In this subsection, we provide experimental details about the effects of the number of training templates on the parsing accuracy of the system.
Revised: In this subsection, we provide experimental details about the effects of the number of training templates on the parsing accuracy of the system.

Original: Because we use a template strategy to generate training data (Section 1), we must decide on how many prompts to write and include in the training scheme.
Revised: Because we use a template strategy to generate training data (Section 2), we must decide on how many prompts to write and include in the training scheme.

Original: This raises the question of how the number of templates affects model performance.
Revised: This raises the question of how the number of templates affects model performance.

Original: To understand this behavior, we retrain the T5-Base model, randomly sampling the number of training templates over different percentages of the original templates set.
Revised: To understand this behavior, we retrain the T5-Base model, randomly sampling the number of training templates over different percentages of the original templates set.

Original: In particular, we sweep over the following percentages [20% , 40% , 60% , 80% , 100%] on the diabetes dataset, downsampling and retraining 5 times per template.
Revised: In particular, we sweep over the following percentages [20% , 40% , 60% , 80% , 100%] on the diabetes dataset, downsampling and retraining 5 times per template.

Original: We give the results in Figure 2.
Revised: We give the results in Figure 2.

Original: We see that there are clear accuracy gains over using a smaller number of templates.
Revised: We see that there are clear accuracy gains over using a smaller number of templates.

Original: Further, the gains for the compositional model performance seem to somewhat level off, but this is not the case for the IID split, suggesting further templates may help IID performance.
Revised: Further, the gains for the compositional model performance seem to somewhat level off, but this is not the case for the IID split, suggesting further templates may help IID performance.

Original: [Figure]
Revised: [Figure]

Original: B.4 Parsing Error Analysis
Revised: B.4 Parsing Error Analysis

Original: In the main text, we demonstrated that the ﬁne-tuned T5 models performed considerably better than few-shot GPT-J (Table 2).
Revised: In the main text, we demonstrated that the ﬁne-tuned T5 models performed considerably better than few-shot GPT-J (Table 2).

Original: In this subsection, we perform additional error analysis for why this occurs.
Revised: In this subsection, we perform additional error analysis for why this occurs.

Original: [Table]
Revised: [Table]

Original: This dynamic brings up the question: what is the cause of these poor few-shot results?
Revised: This dynamic brings up the question: what is the cause of these poor few-shot results?

Original: Since the few-shot GPT-J models select the (utterance, parse) pairs from the synthetic dataset using nearest neighbors on a sentence embedding model, it could be possible these issues are due to the sentence embedding model failing to select good pairs.
Revised: Since the few-shot GPT-J models select the (utterance, parse) pairs from the synthetic dataset using nearest neighbors on a sentence embedding model, it could be possible these issues are due to the sentence embedding model failing to select good pairs.

Original: In particular, this nearest neighbors technique could fail to select pairs with the operations necessary to parse the user utterance, and not the model failing to learn from the examples.
Revised: In particular, this nearest neighbors technique could fail to select pairs with the operations necessary to parse the user utterance, and not the model failing to learn from the examples.

Original: To evaluate whether this is the case, we compute the percent of mistakes that do not include the operations necessary to parse the user utterance for GPT-J. The results provided in
Revised: To evaluate whether this is the case, we compute the percent of mistakes that do not include the operations necessary to parse the user utterance for GPT-J. The results provided in

Original: Table 10 demonstrate that, especially for the 10-Shot case, the operations needed to parse the user utterance are included in the prompts, indicating the issues are likely due to the model’s capacity to learn few-shot, rather than the selection mechanism.
Revised: Table 10 demonstrate that, especially for the 10-Shot case, the operations needed to parse the user utterance are included in the prompts, indicating the issues are likely due to the model’s capacity to learn few-shot, rather than the selection mechanism.

Original: In this work, we were limited by using up to 6 -billion parameter GPT-J, but it could be possible to achieve better results with larger models, as results on emergent abilitiees suggest [39].
Revised: In this work, we were limited by using up to 6 -billion parameter GPT-J, but it could be possible to achieve better results with larger models, as results on emergent abilitiees suggest [39].

Original: B.5 User Study Results: Per Question Likert Scores
Revised: B.5 User Study Results: Per Question Likert Scores

Original: In this subsection, we provide additional user study results.
Revised: In this subsection, we provide additional user study results.

Original: In addition to the questions asked at the end of the survey (Table 3 and Table 4), we also asked users to rate their experiences using both interfaces on a 1 - 7 Likert while they were taking the survey.
Revised: In addition to the questions asked at the end of the survey (Table 3 and Table 4), we also asked users to rate their experiences using both interfaces on a 1 - 7 Likert while they were taking the survey.

Original: In particular, we asked users how much they agreed with the following statements:
Revised: In particular, we asked users how much they agreed with the following statements:

Original: • I am conﬁdence I completed my answer correctly.
Revised: • I am conﬁdence I completed my answer correctly.

Original: • Completing this task took me a lot of effort.
Revised: • Completing this task took me a lot of effort.

Original: • The interface was useful for completing the task.
Revised: • The interface was useful for completing the task.

Original: • Based on my experience so far, I trust the interface to understand machine learning models.
Revised: • Based on my experience so far, I trust the interface to understand machine learning models.

Original: • Based on my experience so far, I would use the interface again to understand machine learning models.
Revised: • Based on my experience so far, I would use the interface again to understand machine learning models.

Original: To evaluate these results, we compute the mean and standard deviation of the Likert score for the 1 st through 5 th question each user sees (question ordering is randomized so users see different questions ﬁrst).
Revised: To evaluate these results, we compute the mean and standard deviation of the Likert score for the 1 st through 5 th question each user sees (question ordering is randomized so users see different questions ﬁrst).

Original: We compute this for each statement and interface.
Revised: We compute this for each statement and interface.

Original: The results for the medical workers are provided in Figure 3 and the ML professionals in Figure 4.
Revised: The results for the medical workers are provided in Figure 3 and the ML professionals in Figure 4.

Original: Overall, the medical workers clearly prefer
Revised: Overall, the medical workers clearly prefer

Original: TalkToModel while answering the questions.
Revised: TalkToModel while answering the questions.

Original: Interestingly, they seem to gain trust in TalkToModel over time, going from “somewhat agree” to “agree” with the statement “Based on my experience so far, I trust the interface to understand ML models” by the end of the survey.
Revised: Interestingly, they seem to gain trust in TalkToModel over time, going from “somewhat agree” to “agree” with the statement “Based on my experience so far, I trust the interface to understand ML models” by the end of the survey.

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: C o m p l e t e l y D
Revised: C o m p l e t e l y D

Original: i s a g r ee
Revised: i s a g r ee

Original: D i s a g r ee
Revised: D i s a g r ee

Original: S o m e w h a t D
Revised: S o m e w h a t D

Original: i s a g r ee
Revised: i s a g r ee

Original: N e u t r a l S o m e w h a t
Revised: N e u t r a l S o m e w h a t

Original: A g r ee
Revised: A g r ee

Original: A g r ee C o m p l e t e
Revised: A g r ee C o m p l e t e

Original: l y A g r ee
Revised: l y A g r ee

Original: I am confident
Revised: I am confident

Original: I
Revised: I

Original: [Table]
Revised: [Table]

Revised: [Figure]

Original:  [Figure]
Revised: [Table] [Figure] [Table] [Figure]

Original: [Table][Figure] [Table] [Figure]
Revised: [Table]

Original: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: C
Revised: C

Original: [Figure]
Revised: [Figure]

Original: p l e t e l y D
Revised: p l e t e l y D

Original: i
Revised: i

Original: [Figure]
Revised: [Figure]

Original: D i s a g r ee
Revised: D i s a g r ee

Original: S o m e w h a t D
Revised: S o m e w h a t D

Original: i s a g
Revised: i s a g

Original: [Figure]
Revised: [Figure]

Original: ee
Revised: ee

Original: N e u t r a l S o m e w h a t
Revised: N e u t r a l S o m e w h a t

Original: A g r ee
Revised: A g r ee

Original: A g r ee C o m p l e t e
Revised: A g r ee C o m p l e t e

Original: l y A g r ee
Revised: l y A g r ee

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: r
Revised: r

Original: [Figure]
Revised: [Figure]

Original: D i s a g r ee
Revised: D i s a g r ee

Original: S o m e w h a t D
Revised: S o m e w h a t D

Original: i s a g r ee
Revised: i s a g r ee

Original: N e u t r a l S o m e w h a t
Revised: N e u t r a l S o m e w h a t

Original: A g r ee A g r ee
Revised: A g r ee A g r ee

Original: [Figure]
Revised: [Figure]

Original: o
Revised: o

Original: [Figure]
Revised: [Figure]

Original: l e t e
Revised: l e t e

Original: l y A g r ee
Revised: l y A g r ee

Original: Based on my experience with the interface so far, I would use the interface again to understand machine learning models.
Revised: Based on my experience with the interface so far, I would use the interface again to understand machine learning models.

Original: [Figure] [Figure]
Revised: [Figure] [Figure]

Original: t e l y D
Revised: t e l y D

Original: i
Revised: i

Original: [Figure]
Revised: [Figure]

Original: a
Revised: a

Original: [Figure]
Revised: [Figure]

Original: r
Revised: r

Original: [Figure]
Revised: [Figure]

Original: D i s a g r ee
Revised: D i s a g r ee

Original: S o m e w h a t D
Revised: S o m e w h a t D

Original: i s a g r ee
Revised: i s a g r ee

Original: N e u t r a l S o m e w h a t
Revised: N e u t r a l S o m e w h a t

Original: A g r ee
Revised: A g r ee

Original: A g r ee C o m p l e t e
Revised: A g r ee C o m p l e t e

Original: l y A g r ee
Revised: l y A g r ee

Original: I am confident I completed
Revised: I am confident I completed

Original: [Figure]
Revised: [Figure]

Original: correctly
Revised: correctly

Original: [Figure]
Revised: [Figure]

Original: C
Revised: C

Original: [Figure]
Revised: [Figure]

Original: l e t e l y D
Revised: l e t e l y D

Original: i
Revised: i

Original: [Figure]
Revised: [Figure]

Original: D i s a g r ee
Revised: D i s a g r ee

Original: S o m e w h a t D
Revised: S o m e w h a t D

Original: i s a g r ee
Revised: i s a g r ee

Original: N e u t r a l S o m e w h a t
Revised: N e u t r a l S o m e w h a t

Original: A g r ee
Revised: A g r ee

Original: A g r ee C o m p l e t e
Revised: A g r ee C o m p l e t e

Original: l y A g r ee
Revised: l y A g r ee

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: D
Revised: D

Original: [Figure]
Revised: [Figure]

Original: D
Revised: D

Original: [Figure]
Revised: [Figure]

Original: N e u t r a
Revised: N e u t r a

Original: [Figure]
Revised: [Figure]

Original: o m e w h a t A g r ee
Revised: o m e w h a t A g r ee

Original: A g r ee C o m p l e t e
Revised: A g r ee C o m p l e t e

Original: l y A g r ee
Revised: l y A g r ee

Original: Based on my experience with the interface so far, I would use the interface again to understand machine learning models.
Revised: Based on my experience with the interface so far, I would use the interface again to understand machine learning models.

Original: [Figure]
Revised: [Figure]

Original: C Interface Screenshots
Revised: C Interface Screenshots

Original: In this appendix, we provide additional interface screen shots for both TalkToModel and the dashboard baseline.
Revised: In this appendix, we provide additional interface screen shots for both TalkToModel and the dashboard baseline.

Original: C.1 TalkToModel Interface
Revised: C.1 TalkToModel Interface

Original: We provide additional screenshots of the TalkToModel GUI interface in Fig.
Revised: We provide additional screenshots of the TalkToModel GUI interface in Fig.

Original: 5 and Fig.
Revised: 5 and Fig.

Original: The interface is a text chat interface, where users provide input and the system response.
Revised: The interface is a text chat interface, where users provide input and the system response.

Original: On the right side of the interface, users can “pin” messages they ﬁnd interesting.
Revised: On the right side of the interface, users can “pin” messages they ﬁnd interesting.

Original: In addition, we provide a feature where users can get help to generate a question in a particular category (Fig. 7).
Revised: In addition, we provide a feature where users can get help to generate a question in a particular category (Fig. 7).

Original: This feature inputs a random synthetic training utterance into the command bar from the category of choice.
Revised: This feature inputs a random synthetic training utterance into the command bar from the category of choice.

Original: C.2 Dashboard Interface
Revised: C.2 Dashboard Interface

Original: We provide example screenshots for the baseline dashboard interface in Fig.
Revised: We provide example screenshots for the baseline dashboard interface in Fig.

Original: 8 and
Revised: 8 and

Original: Fig.[8].
Revised: Fig.[8].

Original: In depth description can be found in the project’s documentation https://explainerdashboard.readthedocs.io/en/latest/.
Revised: In depth description can be found in the project’s documentation https://explainerdashboard.readthedocs.io/en/latest/.

Original: The dashboard provides different ways to understand ML models using point and click interactions.
Revised: The dashboard provides different ways to understand ML models using point and click interactions.