SlowGuess/NeurIPS_2023_OCR huggingface dataset:
Zhijian Duan
CFCS, School of Computer Science
zjduan@pku.edu.cn
Yurong Chen
chenyurong@pku.edu.cn
Haoran Sun
sunhaoran0301@stu.pku.edu.cn
Xiaotie Deng
& CMAR, Institute for AI
xiaotie@pku.edu.cn
Automated auction design aims to find empirically high-revenue mechanisms through machine learning. Existing works on multi item auction scenarios can be roughly divided into RegretNet-like and affine maximizer auctions (AMAs) approaches. However, the former cannot strictly ensure dominant strategy incentive compatibility (DSIC), while the latter faces scalability issue due to the large number of allocation candidates. To address these limitations, we propose AMenuNet, a scalable neural network that constructs the AMA parameters (even including the allocation menu) from bidder and item representations. AMenuNet is always DSIC and individually rational (IR) due to the properties of AMAs, and it enhances scalability by generating candidate allocations through a neural network. Additionally, AMenuNet is permutation equivariant, and its number of parameters is independent of auction scale. We conduct extensive experiments to demonstrate that AMenuNet outperforms strong baselines in both contextual and non-contextual multi-item auctions, scales well to larger auctions, generalizes well to different settings, and identifies useful deterministic allocations. Overall, our proposed approach offers an effective solution to automated DSIC auction design, with improved scalability and strong revenue performance in various settings.
One of the central topics in auction design is to construct a mechanism that is both dominant strategy incentive compatible (DSIC) and individually rational (IR) while bringing high expected revenue to the auctioneer. The seminal work by Myerson [1981] characterizes the revenue-maximizing mechanism for single-parameter auctions. However, after four decades, the optimal auction design problem in multi-parameter scenarios remains incompletely understood, even in simple settings such as two bidders and two items [Dütting et al., 2019]. To solve the problem, recently, there has been significant progress in automated auction design [Sandholm and Likhodedov, 2015b, Dütting et al., 2019]. Such a paradigm formulates auction design as an optimization problem subject to DSIC and IR constraints and then finds optimal or near-optimal solutions using machine learning.
The works of automated auction design can be roughly divided into two categories. The first category is the RegretNet-like approach [Curry et al., 2020, Peri et al., 2021, Rahme et al., 2021b,a, Duan et al., 2022, Ivanov et al., 2022], pioneered by RegretNet [Dütting et al., 2019]. These works
represent the auction mechanism as neural networks and then find near-optimal and approximate DSIC solutions using adversarial training. The second category is based on affine maximizer auctions (AMAs) [Roberts, 1979, Likhodedov and Sandholm, 2004, Likhodedov et al., 2005, Sandholm and Likhodedov, 2015a, Guo et al., 2017, Curry et al., 2023]. These methods restrict the auction mechanism to AMAs, which are inherently DSIC and IR. Afterward, they optimize AMA parameters using machine learning to achieve high revenue.
Generally, RegretNet-like approaches can achieve higher revenue than AMA-based approaches. However, these works are not DSIC. They can only ensure approximate DSIC by adding a regret term in the loss function as a penalty for violating the DSIC constraints. There are no theoretical results on the regret upper bound, and the impact of such regret on the behaviors of strategic bidders. Even worse, computing the regret term is time-consuming [Rahme et al., 2021b]. AMA-based approaches, on the other hand, offer the advantage of guaranteeing DSIC and IR due to the properties of AMAs. However, many of these approaches face scalability issues because they consider all deterministic allocations as the allocation menu. The size of the menu grows exponentially, reaching  $(n + 1)^m$  for  $n$  bidders and  $m$  items, making it difficult for these approaches to handle larger auctions. Even auctions with 3 bidders and 10 items can pose challenges to the AMA-based methods.
To overcome the limitations above, we propose a scalable neural network for the DSIC affine maximizer auction design. We refer to our approach as AMenuNet: Affine maximizer auctions with Menu Network. AMenuNet constructs the AMA parameters, including the allocation menu, bidder weights, and boost variables, from the bidder and item representations. After getting the parameters, we compute the allocation and payment results according to AMA. By setting the representations as the corresponding contexts or IDs, AMenuNet can handle both contextual [Duan et al., 2022] and non-contextual classic auctions. As AMenuNet only relies on the representations, the resulting mechanism is guaranteed to be DSIC and IR due to the properties of AMAs.
Specifically, we employ two techniques to address the scalability issue of AMA-based approaches: (1) Firstly, we parameterize the allocation menu. We predefine the size of the allocation menu and train the neural network to compute the allocation candidates within the menu, along with the bidder weights and boost variables. This allows for more efficient handling of large-scale auctions. (2) Secondly, we utilize a transformer-based permutation-equivariant architecture. Notably, this architecture's parameters remain independent of the number of bidders or items. This enhances the scalability of AMenuNet, enabling it to handle auctions of larger scales than those in training.
We conduct extensive experiments to demonstrate the effectiveness of AMenuNet. First, our performance experiments show that in both contextual and classic multi-item auctions, AMenuNet can achieve higher revenue than strong DSIC and IR baselines. AMenuNet can also achieve comparable revenue to RegretNet-like approaches that can only ensure approximate DSIC. Next, our ablation study shows that the learnable allocation menu provides significant benefits to AMenuNet, from both revenue and scalability perspectives. Thirdly, we find that AMenuNet can also generalize well to auctions with a different number of bidders or items than those in the training data. And finally, the case study of winning allocations illustrates that AMenuNet can discover useful deterministic allocations and set the reserve price for the auctioneer.
Automated mechanism design[Conitzer and Sandholm, 2002, 2004, Sandholm and Likhodedov, 2015b] has been proposed to find approximate optimal auctions with multiple items and bidders [Balcan et al., 2008, Lahaie, 2011, Dütting et al., 2015]. Meanwhile, several works have analyzed the sample complexity of optimal auction design problems [Cole and Roughgarden, 2014, Devanur et al., 2016, Balcan et al., 2016, Guo et al., 2019, Gonczarowski and Weinberg, 2021]. Recently, pioneered by RegretNet [Dütting et al., 2019], there is rapid progress on finding (approximate) optimal auction through deep learning [Curry et al., 2020, Peri et al., 2021, Rahme et al., 2021b,a, Duan et al., 2022, Ivanov et al., 2022]. However, as we mentioned before, those RegretNet-like approaches can only ensure approximate DSIC by adding a hard-to-compute regret term.
Our paper follows the affine maximizer auction (AMA) [Roberts, 1979] based approaches. AMA is a weighted version of VCG [Vickrey, 1961], which assigns weights  $w$  to each bidder and assigns boosts to each feasible allocation. Tuning the weights and boosts enables AMAs to achieve higher revenue than VCG while maintaining DSIC and IR. Different subsets of AMA have been studied
in various works, such as VVCA [Likhodedov and Sandholm, 2004, Likhodedov et al., 2005, Sandholm and Likhodedov, 2015b],  $\lambda$ -auction [Jehiel et al., 2007], mixed bundling auction [Tang and Sandholm, 2012], and bundling boosted auction [Balcan et al., 2021]. However, these works set all the deterministic allocations as candidates, the size of which grows exponentially with respect to the auction scale. To overcome such issue, we construct a neural network that automatically computes the allocation menu from the representations of bidders and items. Curry et al. [2023] is the closest work to our approach that also parameterizes the allocation menu. The key difference is that they optimize the AMA parameters explicitly, while we derive the AMA parameters by a neural network and optimize the network weights instead. By utilizing a neural network, we can handle contextual auctions by incorporating representations as inputs. Additionally, the trained model can generalize to auctions of different scales than those encountered during training.
Contextual auctions are a more general and realistic auction format assuming that every bidder and item has some public information. They have been widely used in industry [Zhang et al., 2021, Liu et al., 2021]. In the academic community, previous works on contextual auctions mostly focus on the online setting of some well-known contextual repeated auctions, such as posted-price auctions [Amin et al., 2014, Mao et al., 2018, Drutsa, 2020, Zhiyanov and Drutsa, 2020], where the seller prices the item to sell to a strategic buyer, or repeated second-price auctions [Golrezaei et al., 2021]. In contrast, our paper focuses on the offline setting of contextual sealed-bid auctions, similar to Duan et al. [2022], a RegretNet-like approach.
Sealed-Bid Auction. We consider a sealed-bid auction with  $n$  bidders and  $m$  items. Denote  $[n] = \{1,2,\dots,n\}$ . Each bidder  $i \in [n]$  is represented by a  $d_x$ -dimensional vector  $\boldsymbol{x}_i \in \mathbb{R}^{d_x}$ , which can encode her unique ID or her context (public feature) [Duan et al., 2022]. Similarly, each item  $j \in [m]$  is represented by a  $d_y$ -dimensional vector  $\boldsymbol{y}_j \in \mathbb{R}^{d_y}$ , which can also encode its unique ID or context. By using such representations, we unify the contextual auction and the classical Bayesian auction. We denote by  $X = [\boldsymbol{x}_1,\boldsymbol{x}_2,\ldots,\boldsymbol{x}_n]^T \in \mathbb{R}^{n\times d_x}$  and  $Y = [\boldsymbol{y}_1,\boldsymbol{y}_2,\ldots,\boldsymbol{y}_m]^T \in \mathbb{R}^{m\times d_y}$  the matrices of bidder and item representations, respectively. These matrices follow underlying joint probability distribution  $F_{X,Y}$ . In an additive valuation setting, each bidder  $i$  values each bundle of items  $S \subseteq [m]$  with a valuation  $v_{i,S} = \sum_{j\in S}v_{ij}$ . The bidder has to submit her bids for each item  $j \in [m]$  as  $\boldsymbol{b}_i := (b_1,b_2,\dots,b_m)$ . The valuation profile  $V = (v_{ij})_{i\in [n],j\in [m]} \in \mathbb{R}^{n\times m}$  is generated from a conditional distribution  $F_{V|X,Y}$  that depends on the representations of bidders and items. The auctioneer does not know the true valuation profile  $V$  but can observe the public bidder representations  $X$ , item representations  $Y$ , and the bidding profile  $B = (b_{ij})_{i\in [n],j\in [m]} \in \mathbb{R}^{n\times m}$ .
Auction Mechanism. An auction mechanism  $(g,p)$  consists of an allocation rule  $g:\mathbb{R}^{n\times m}\times$ $\mathbb{R}^{n\times d_x}\times \mathbb{R}^{m\times d_y}\to [0,1]^{n\times m}$  and a payment rule  $p:\mathbb{R}^{n\times m}\times \mathbb{R}^{n\times d_x}\times \mathbb{R}^{m\times d_y}\to \mathbb{R}_{\geq 0}^n$ . Given the bids  $B$ , bidder representations  $X$ , and item representations  $Y$ ,  $g_{ij}(B,X,Y)\in [0,1]$  computes the probability that item  $j$  is allocated to bidder  $i$ . We require that  $\sum_{i = 1}^{n}g_{ij}(B,X,Y)\leq 1$  for any item  $j$  to guarantee that no item is allocated more than once. The payment  $p_i(B,X,Y)\geq 0$  computes the price that bidder  $i$  needs to pay. Bidders aim to maximize their own utilities. In the additive valuation setting, bidder  $i$ 's utility is  $u_{i}(\boldsymbol {v}_{i},B;X,Y)\coloneqq \sum_{j = 1}^{m}g_{ij}(B,X,Y)v_{ij} - p_{i}(B,X,Y)$  given  $\boldsymbol {v},B,X,Y$ . Bidders may misreport their valuations to benefit themselves. Such strategic behavior among bidders could make the auction result hard to predict. Therefore, we require the auction mechanism to be dominant strategy incentive compatible (DSIC), which means that for each bidder  $i\in [n]$ , reporting her true valuation is her optimal strategy regardless of how others report. Formally, let  $B_{-i} = (b_{1},\ldots ,b_{i - 1},b_{i + 1},\ldots ,b_{n})$  be the bids except for bidder  $i$ . A DSIC mechanism satisfies
$$
u _ {i} \left(\boldsymbol {v} _ {i}, \left(\boldsymbol {v} _ {i}, B _ {- i}\right); X, Y\right) \geq u _ {i} \left(\boldsymbol {v} _ {i}, \left(\boldsymbol {b} _ {i}, B _ {- i}\right); X, Y\right), \quad \forall i, \boldsymbol {v} _ {i}, B _ {- i}, X, Y, \boldsymbol {b} _ {i}. \tag {DSIC}
$$
Furthermore, the auction mechanism needs to be individually rational (IR), which ensures that truthful bidding results in a non-negative utility for each bidder. Formally,
$$
u _ {i} \left(\boldsymbol {v} _ {i}, \left(\boldsymbol {v} _ {i}, B _ {- i}\right); X, Y\right) \geq 0, \quad \forall i, \boldsymbol {v} _ {i}, B _ {- i}, X, Y. \tag {IR}
$$
Affine Maximizer Auction (AMA). AMA [Roberts, 1979] is a generalized version of VickreyClarkeGroves (VCG) auction [Vickrey, 1961] that is inherently DISC and IR. An AMA consists
of positive weights  $w_{i}\in \mathbb{R}_{+}$  for each bidder and boost variables  $\lambda (A)\in \mathbb{R}$  for each allocation  $A\in \mathcal{A}$ , where  $\mathcal{A}$  is the allocation menu, i.e., the set of all the feasible (possibly random) allocations. Given  $B,X,Y$ , AMA chooses the allocation that maximizes the affine welfare:
$$
g (B, X, Y) = A ^ {*} := \arg \max  _ {A \in \mathcal {A}} \sum_ {i = 1} ^ {n} w _ {i} b _ {i} (A) + \lambda (A), \quad \tag {Allocation}
$$
where  $b_{i}(A) = \sum_{j=1}^{m} b_{ij} A_{ij}$  in additive valuation setting. The payment for bidder  $k$  is
$$
p _ {k} (B, X, Y) = \frac {1}{w _ {k}} \left(\sum_ {i \neq k} w _ {i} b _ {i} \left(A _ {- k} ^ {*}\right) + \lambda \left(A _ {- k} ^ {*}\right)\right) - \frac {1}{w _ {k}} \left(\sum_ {i \neq k} w _ {i} b _ {i} \left(A ^ {*}\right) + \lambda \left(A ^ {*}\right)\right).
$$
Here we denote by  $A_{-k}^{*} \coloneqq \arg \max_{A \in \mathcal{A}} \sum_{i \neq k} w_{i} b_{i}(A) + \lambda(A)$  the allocation that maximizes the affine welfare, with bidder  $k$ 's utility excluded. Our definition of AMA differs slightly from previous literature [Roberts, 1979], whose allocation candidates are all the  $(n + 1)^{m}$  deterministic solutions. Instead, we explicitly define the allocation menu so that our definition is more general. As we will show in Appendix A, such AMAs are still DSIC and IR.
In this section, we introduce the optimization problem for automated mechanism design and our proposed approach, AMenuNet, along with its training procedure.
4.1 Auction Design as an Optimization Problem
We begin by parameterizing our auction mechanism as  $(g^{\theta},p^{\theta})$ , where  $\theta$  represents the neural network weights to be optimized. We denote the parameter space as  $\Theta \ni \theta$  and the class of all parameterized mechanisms as  $\mathcal{M}^{\Theta}$ . The optimal auction design seeks to find the revenue-maximizing mechanism that satisfies both DSIC and IR:
$$
\max  _ {\theta \in \Theta} \operatorname {R e v} \left(g ^ {\theta}, p ^ {\theta}\right) := \mathbb {E} _ {(V, X, Y) \sim F _ {V, X, Y}} \left[ \sum_ {i = 1} ^ {n} p _ {i} ^ {\theta} (V, X, Y) \right] \tag {OPT}
$$
$$
\mathrm {s . t .} \quad (g ^ {\theta}, p ^ {\theta}) \mathrm {i s D S I C a n d I R}
$$
where  $\mathrm{Rev}(g^{\theta},p^{\theta})$  is the expected revenue of mechanism  $(g^{\theta},p^{\theta})$ . However, there is no known characterization of a DSIC general multi-item auction [Dütting et al., 2019]. Thus, we restrict the search space of auctions to affine maximizer auctions (AMAs) [Roberts, 1979]. AMAs are inherently DSIC and IR, and can cover a broad class of mechanisms: Lavi et al. [2003] has shown that every DSIC multi-item auction (where each bidder only cares about what they get and pay) is almost an AMA (with some qualifications).
The AMA parameters consist of positive weights  $\boldsymbol{w} \in \mathbb{R}_{+}^{n}$  for all bidders, an allocation menu  $\mathcal{A}$ , and boost variables  $\lambda \in \mathbb{R}^{|A|}$  for each allocation in  $\mathcal{A}$ . While the most straightforward way to define  $\mathcal{A}$  is to include all deterministic allocations, as done in prior work [Likhodedov and Sandholm, 2004, Likhodedov et al., 2005, Sandholm and Likhodedov, 2015b], this approach suffers from scalability issues as the number of allocations can be as large as  $(n + 1)^m$ . To address this challenge, we propose AMenuNet, which predefines the size of  $\mathcal{A}$  and constructs it along with the other AMA parameters using a permutation-equivariant neural network.
4.2 AMenuNet Architecture
Denote by  $s = |\mathcal{A}|$  the predefined size of the allocation menu. AMenuNet takes as input the representations of bidders  $X$  and items  $Y$ , and constructs all the  $s$  allocations, the bidder weights  $w$ , and the boost variables  $\lambda \in \mathbb{R}^s$  through a permutation-equivariant neural network architecture as illustrated in Figure 1. The architecture consists of an encode layer, a menu layer, a weight layer, and a boost layer. The final allocation and payment results can be computed by combining the submitted bids  $B$  according to AMA (see Equation (Allocation) and Equation (Payment)).
Figure 1: A schematic view of AMenuNet, which takes the bidder representations  $X$  (including the dummy bidder) and item representations  $Y$  as inputs. These representations are assembled into a tensor  $E \in \mathbb{R}^{(n + 1)\times m\times (d_x + d_y)}$ . Two  $1\times 1$  convolution layers are then applied to obtain the tensor  $L$ . Following  $L$ , multiple transformer-based interaction modules are used to model the mutual interactions among all bidders and items. The output tensor after these modules is denoted as  $J$ .  $J$  is further split into three parts:  $J^{\mathcal{A}} \in \mathbb{R}^{(n + 1)\times m\times s}$ ,  $J^{\boldsymbol{w}} \in \mathbb{R}^{(n + 1)\times m}$  and  $J^{\lambda} \in \mathbb{R}^{(n + 1)\times m\times s}$ . These parts correspond to the allocation menu  $\mathcal{A}$ , bidder weights  $\pmb{w}$ , and boosts  $\lambda$ , respectively. Finally, based on the induced AMA parameters and the submitted bids, the allocation and payment results are computed according to the AMA mechanism.
We first introduce a dummy bidder  $n + 1$  to handle cases where no items are allocated to any of the  $n$  bidders. We set such dummy bidder's representation  $x_{n + 1}$  as a  $d_x$ -dimensional vector with all elements set to 1.
Encode Layer. The encode layer transforms the initial representations of all bidders (including the dummy bidder) and items into a joint representation that captures their mutual interactions. In contextual auctions, their initial representations are the contexts. In non-contextual auctions, similar to word embedding [Mikolov et al., 2013], we embed the unique ID of each non-dummy bidder or item into a continuous vector space, and use the embeddings as their initial representations. Based on that, we construct the initial encoded representations for all pairs of  $n + 1$  bidders and  $m$  items  $E \in \mathbb{R}^{(n + 1)\times m\times (d_x + d_y)}$ , where
$$
E _ {i j} = \left[ \boldsymbol {x} _ {i}; \boldsymbol {y} _ {j} \right] \in \mathbb {R} ^ {d _ {x} + d _ {y}}
$$
is the initial encoded representation of bidder  $i$  and item  $j$ .
We further model the mutual interactions of bidders and items by three steps. Firstly, we capture the inner influence of each bidder-item pair by two  $1 \times 1$  convolutions with a ReLU activation. By doing so, we get
$$
L = \operatorname {C o n v} _ {2} \circ \operatorname {R e L U} \circ \operatorname {C o n v} _ {1} \circ E \in \mathbb {R} ^ {(n + 1) \times m \times d},
$$
where  $d$  is the dimension of the new latent representation for each bidder-item pair, both  $\mathrm{Conv}_1$  and  $\mathrm{Conv}_2$  are  $1 \times 1$  convolutions, and  $\mathrm{ReLU}(x) := \max(x, 0)$ .
Secondly, we model the mutual interactions between all the bidders and items by using the transformer [Vaswani et al., 2017] based interaction module, similar to Duan et al. [2022]. Specifically, for each bidder  $i$ , we model her interactions with all the  $m$  items through transformer on the  $i$ -th row of  $L$ , and for each item  $j$ , we model its interactions with all the  $n$  bidders through another transformer on the  $j$ -th column of  $L$ :
$$
I _ {i, *} ^ {\mathrm {r o w}} = \mathrm {t r a n s f o r m e r} (L _ {i, *}) \in \mathbb {R} ^ {m \times d _ {h}}, I _ {*, j} ^ {\mathrm {c o l u m n}} = \mathrm {t r a n s f o r m e r} (L _ {*, j}) \in \mathbb {R} ^ {(n + 1) \times d _ {h}},
$$
where  $d_h$  is the size of the hidden nodes of transformer; For all the bidders and items, their global representation is obtained by the average of all the representations
$$
e ^ {\mathrm {g l o b a l}} = \frac {1}{(n + 1) m} \sum_ {i = 1} ^ {n + 1} \sum_ {j = 1} ^ {m} L _ {i j}.
$$
Thirdly, we get the unified interacted representation
$$
I _ {i j} := [ I _ {i j} ^ {\mathrm {r o w}}; I _ {i j} ^ {\mathrm {c o l u m n}}; e ^ {\mathrm {g l o b a l}} ] \in \mathbb {R} ^ {2 d _ {h} + d}
$$
by combining all the three representations for bidder  $i$  and item  $j$ . Two  $1 \times 1$  convolutions with a ReLU activation are applied on  $I$  to encode  $I$  into the joint representation
$$
I ^ {\text {o u t}} := \operatorname {C o n v} _ {4} \circ \operatorname {R e L U} \circ \operatorname {C o n v} _ {3} \circ I \in \mathbb {R} ^ {(n + 1) \times m \times d _ {\text {o u t}}}.
$$
By stacking multiple interaction modules, we can model higher-order interactions among all bidders and items.
For the final interaction module, we set  $d_{\mathrm{out}} = 2s + 1$  and we denote by  $J \in \mathbb{R}^{(n + 1)\times m\times (2s + 1)}$  its output. We then partition  $J$  into three tensors:  $J^{\mathcal{A}} \in \mathbb{R}^{(n + 1)\times m\times s}$ ,  $J^{\boldsymbol{w}} \in \mathbb{R}^{(n + 1)\times m}$  and  $J^{\lambda} \in \mathbb{R}^{(n + 1)\times m\times s}$ , and pass them to the following layers.
Menu Layer. To construct the allocation menu, we first normalize each column of  $J^{\mathcal{A}}$  through softmax function. Specifically,  $\forall j \in [m], k \in [s]$ , we denote by  $J_{*,j,k}^{\mathcal{A}} \in \mathbb{R}^{n+1}$  the  $j$ -th column of allocation option  $k$ , and obtain its normalized probability  $\tilde{J}_{*,j,k}^{\mathcal{A}}$  by
$$
\tilde {J} _ {*, j, k} ^ {\mathcal {A}} := \operatorname {S o f t m a x} (\tau \cdot J _ {*, j, k} ^ {\mathcal {A}})
$$
where  $\operatorname{Softmax}(\pmb{x})_i \coloneqq e^{x_i} / (\sum_{k=1}^{n+1} e^{x_k}) \in (0,1)$  for all  $\pmb{x} \in \mathbb{R}^{n+1}$  is the softmax function, and  $\tau > 0$  is the temperature parameter. Next, we exclude the probabilities associated with the  $n+1$ -th dummy bidder to obtain the allocation menu:
$$
\mathcal {A} = \tilde {J} _ {1: n} ^ {\mathcal {A}} \in \mathbb {R} ^ {n \times m \times s}.
$$
Thus, for each allocation  $A \in \mathcal{A}$  we satisfy  $A_{ij} \in [0,1]$  and  $\sum_{i=1}^{n} A_{ij} \leq 1$  for any bidder  $i$  and any item  $j$ .
Weight Layer. In this work, we impose the constraint that each bidder weight lies in  $(0,1]$ . Given  $J^{\boldsymbol{w}}\in \mathbb{R}^{(n + 1)\times m}$ , for each bidder  $i\leq n$  we get her weight by
$$
w _ {i} = \mathrm {S i g m o i d} (\frac {1}{m} \sum_ {j = 1} ^ {m} J _ {i j} ^ {\boldsymbol {w}}),
$$
where  $\operatorname{Sigmoid}(x) \coloneqq 1 / (1 + e^{-x}) \in (0,1)$  for all  $x \in \mathbb{R}$  is the sigmoid function.
Boost layer. In boost layer, we first average  $J^{\lambda}$  across all bidders and items. We then use a multi-layer perceptron (MLP), which is a fully connected neural network, to get the boost variables  $\lambda$ . Specifically, we compute  $\lambda$  by