The models were trained for a maximum of 5000 iterations, with AdamW optimizer , a learning rate of 2x$10^{^-5}$ and a batch size of 4. We used a linear warmup schedule for the first $0.1$ fraction of the steps. All the hyper-parameters were optimized on the provided development set. Evaluation Metrics: We study the variants of the same model by training with different proportions of the negotiation seen, namely, $f \in \lbrace 0.0, 0.2, 0.4, 0.6, 0.8, 1.0\rbrace $. We compare the models on two evaluation metrics: MAE: Mean Absolute Error between the predicted and ground-truth agreed prices along with Accuracy$\pm k$: the percentage of cases where the predicted price lies within $k$ percent of the ground-truth. We use $k=5$ and $k=10$ in our experiments.

We refer to this model as Prices-only. We compare two variants for BERT-based models. First, for the BERT method, we keep only the first [CLS] token in the input and then train the model with fine-tuning using a single feed-forward network on top of the [CLS] representation. Secondly, we call our complete approach as BERT+GRU, where we use a recurrent network with BERT fine-tuning, as depicted in Figure FIGREF3. Training Details: Given the multiple segments in our model input and small data size, we use BERT-base , having output dimension of 768. To tackle the variance in product prices across different categories, all prices in the inputs and outputs were normalized by the listing price. The predictions were unnormalized before final evaluations. Further, we only considered the negotiations where an agreement was reached. These were the instances for which ground truth was available ($\sim 75\%$ of the data). We use a two-layer GRU with a dropout of $0.1$ and 50 hidden units.

Experimental Details	We perform experiments on the CB dataset to primarily answer two questions: 1) Is it feasible to predict negotiation outcomes without observing the complete conversation between the buyer and seller? 2) To what extent does the natural language incorporation help in the prediction? In order to answer these questions, we compare our model empirically with a number of baseline methods. This section presents the methods we compare to, the training setup and the evaluation metrics. Methods: The first baseline is the Listing Price (LP) where the model ignores the negotiation and returns the listing price of the product. Similarly, we use Target Price (TP), where the model just returns the target price for the buyer. We also consider the mean of Listing and Target price (TP+LP/2) as another baseline. Although trivial, these baselines help in benchmarking our results and also show good performance in some cases. Next, we build another baseline which completely ignores the natural language incorporation. In this case, the model only sees a sequence of prices shared across the messages in the negotiation. We keep the input format the same as our model and all the parameters are randomly initialized to remove learning from natural language.

Results and Discussion	We present our results in Figure FIGREF6. We also show Accuracy$\pm 10$ for different product categories in the Appendix. First, Target Price (TP) and (TP+LP)/2 prove to be strong baselines, with the latter achieving $61.07\%$ Accuracy$\pm 10$. This performance is also attested by relatively strong numbers on the other metrics as well. Prices-only, which does not incorporate any knowledge from natural language, fails to beat the average baseline even with $60\%$ of the negotiation history. This can be attributed to the observation that in many negotiations, before discussing the price, buyers tend to get more information about the product by exchanging messages: what is the condition of the product, how old it is, is there an urgency for any of the buyer/seller and so on. Incorporating natural language in both the scenario and event messages paves the way to leverage such cues and make better predictions early on in the conversation, as depicted in the plots. Both BERT and BERT-GRU consistently perform well on the complete test set.

Problem Setup	We study human-human negotiations in the buyer-seller bargaining scenario, which has been a key research area in the literature . In this section, we first describe our problem setup and key terminologies by discussing the dataset used. Later, we formalize our problem definition. Dataset: For our explorations, we use the Craigslist Bargaining dataset (CB) introduced by . Instead of focusing on the previously studied game environments , , the dataset considers a more realistic setup: negotiating the price of products listed on Craigslist. The dataset consists of 6682 dialogues between a buyer and a seller who converse in natural language to negotiate the price of a given product (sample in Table TABREF1). In total, 1402 product ad postings were scraped from Craigslist, belonging to six categories: phones, bikes, housing, furniture, car and electronics. Each ad posting contains details such as Product Title, Category Type and a Listing Price. Moreover, a secret target price is also pre-decided for the buyer. The final price after the agreement is called the Agreed Price, which we aim to predict.

We focus on buyer-seller negotiations  where two individuals negotiate the price of a given product. Leveraging the recent advancements ,  in pre-trained language encoders, we attempt to predict negotiation outcomes early on in the conversation, in a completely data-driven manner (Figure FIGREF3). Early prediction of outcomes is essential for effective planning of an automatically negotiating agent. Although there have been attempts to gain insights into negotiations , , to the best of our knowledge, we are the first to study early natural language cues through a data-driven neural system (Section SECREF3). Our evaluations show that natural language allows the models to make better predictions by looking at only a fraction of the negotiation. Rather than just realizing the strategy in natural language, our empirical results suggest that language can be crucial in the planning as well. We provide a sample negotiation from the test set  along with our model predictions in Table TABREF1.

Following , who use BERT for extractive text summarization, we add a [CLS] token at the beginning of each segment. We also alternate between a sequence of 0s and 1s for segment embeddings to differentiate between the scenario and the events. Architecture and Learning: BERT representation for each [CLS] token is a contextualized encoding for the associated word sequence after it. In order to further capture the sequential nature of negotiation events, we pass these [CLS] representations through Gated-Recurrent Units (GRU). Recurrent Networks have been shown to be useful along with Transformer architectures . Finally, a feed-forward network is applied to predict the agreed price for the negotiation. The model is end-to-end trained and fine-tuned using the Mean Squared Error (MSE) loss between the predicted price and the ground-truth.

This number is lower than average for Housing, Bike and Car, resulting in relative better performance of Price-only model for these categories over others. The models also show evidence of capturing buyer interest. By constructing artificial negotiations, we observe that the model predictions at $f$=$0.2$ increase when the buyer shows more interest in the product, indicating more willingness to pay. With the capability to incorporate cues from natural language, such a framework can be used in the future to get negotiation feedback, in order to guide the planning of a negotiating agent. This can be a viable middle-ground between following the average human behavior through supervised learning or exploring the wild by optimizing on rewards using reinforcement learning , .

Conclusion	We presented a framework to attempt early predictions of the agreed product prices in buyer-seller negotiations. We construct sentence templates to encode the product scenario, exchanged messages and associated auxiliary information into the same hidden space. By combining a recurrent network and the pre-trained BERT encoder, our model leverages natural language cues in the exchanged messages to predict the negotiation outcomes early on in the conversation. With this capability, such a framework can be used in a feedback mechanism to guide the planning of a negotiating agent.

Defining the problem: Say we are provided with a product scenario $S$, a tuple: (Category, Title, Listing Price, Target Price). Define the interactions between a buyer and seller using a sequence of $n$ events $E_n:<e_{1}, e_{2}, ..., e_{n}>$, where $e_{i}$ occurs before $e_{j}$ iff $i<j$. Event $e_{i}$ is also a tuple: (Initiator, Type, Data). Initiator is either the Buyer or Seller, Type can be one of (message, offer, accept, reject or quit) and Data consists of either the corresponding natural language dialogue, offer price or can be empty. Nearly $80\%$ of events in CB dataset are of type `message', each consisting a textual message as Data. An offer is usually made and accepted at the end of each negotiation. Since the offers directly contain the agreed price (which we want to predict), we only consider `message' events in our models.

There is no clear winner, although using a recurrent network proves to be more helpful in the early stages of the negotiation. Note that BERT method still employs multiple [SEP] tokens along with alternating segment embeddings (Section SECREF3). Without this usage, the fine-tuning pipeline proves to be inadequate. Overall, BERT-GRU achieves $67.08\%$ Accuracy$\pm 10$ with just the product scenario, reaching to $71.16\%$ with $60\%$ of the messages and crosses $90\%$ as more information about the final price is revealed. Paired Bootstrap Resampling  with $10,000$ bootstraps shows that for a given $f$, BERT-GRU is better than its Prices-only counterpart with $95\%$ statistical significance. The prices discussed during the negotiation still play a crucial role in making the predictions. In fact, in only $65\%$ of the negotiations, the first price is quoted within the first $0.4$ fraction of the events. This is visible in higher performance as more events are seen after this point.

BERT in Negotiations: Early Prediction of Buyer-Seller Negotiation Outcomes	The task of building automatic agents that can negotiate with humans in free-form natural language has gained recent interest in the literature. Although there have been initial attempts, combining linguistic understanding with strategy effectively still remains a challenge. Towards this end, we aim to understand the role of natural language in negotiations from a data-driven perspective by attempting to predict a negotiation's outcome, well before the negotiation is complete. Building on the recent advancements in pre-trained language encoders, our model is able to predict correctly within 10% for more than 70% of the cases, by looking at just 60% of the negotiation. These results suggest that rather than just being a way to realize a negotiation, natural language should be incorporated in the negotiation planning as well. Such a framework can be directly used to get feedback for training an automatically negotiating agent.

Approach	Pre-trained language models, such as BERT ,  have recently gained huge success on a wide range of NLP tasks. However, since our framework deals with various auxiliary pieces (category, price, etc.), we cannot directly leverage these language models, which have only been trained on natural language inputs. Instead of relying on additional representations along with BERT outputs, we propose a simple, yet effective way to incorporate the auxiliary information into the same embedding space. Our model hierarchically builds a representation for the given negotiation to finally predict the agreed price. We present our complete architecture in Figure FIGREF3. Encoding the input: In order to effectively capture the natural language dialogue and the associated auxiliary information, we make use of pre-defined sentence templates. Table TABREF5 shows how we represent the category, target price and the product title in natural language sentences. These sentences are concatenated to form our Scenario $S$. Moving ahead in a similar manner, we define templates to capture the negotiator identity (buyer/seller) and any message which is conveyed. As shown in Figure FIGREF3, the scenario $S$ and the events are separated with the usage of [SEP] tokens.

Category-wise performance	We show the category-wise performance in Figure FIGREF11.

Given the scenario $S$ and first $n$ events $E_n$, our problem is then to learn the function $f_{n}$: $A = f_{n}(S, E_n)$ where $A$ refers to the final agreed price between the two negotiating parties.

Introduction	Negotiations, either between individuals or entities, are ubiquitous in everyday human interactions ranging from sales to legal proceedings. Being a good negotiator is a complex skill, requiring the ability to understand the partner's motives, ability to reason and to communicate effectively, making it a challenging task for an automated system. While research in building automatically negotiating agents has primarily focused on agent-agent negotiations , , there is a recent interest in agent-human negotiations  as well. Such agents may act as mediators or can be helpful for pedagogical purposes . Efforts in agent-human negotiations involving free-form natural language as a means of communication are rather sparse. Researchers  recently studied natural language negotiations in buyer-seller bargaining setup, which is comparatively less restricted than previously studied game environments , . Lack of a well-defined structure in such negotiations allows humans or agents to express themselves more freely, which better emulates a realistic scenario. Interestingly, this also provides an exciting research opportunity: how can an agent leverage the behavioral cues in natural language to direct its negotiation strategies? Understanding the impact of natural language on negotiation outcomes through a data-driven neural framework is the primary objective of this work.

Question: what evaluation metrics were used?
Answer: Accuracy, MAE: Mean Absolute Error