Data-to-text Generation with Entity Modeling

Recent approaches to data-to-text generation have shown great promise thanks to the use of large-scale datasets and the application of neural network architectures which are trained end-to-end. These models rely on representation learning to select content appropriately, structure it coherently, and verbalize it grammatically, treating entities as nothing more than vocabulary tokens. In this work we propose an entity-centric neural architecture for data-to-text generation. Our model creates entity-specific representations which are dynamically updated. Text is generated conditioned on the data input and entity memory representations using hierarchical attention at each time step. We present experiments on the RotoWire benchmark and a (five times larger) new dataset on the baseball domain which we create. Our results show that the proposed model outperforms competitive baselines in automatic and human evaluation.


Introduction
Data-to-text generation is the task of generating textual output from non-linguistic input (Reiter and Dale, 1997;Gatt and Krahmer, 2018). The input may take on several guises including tables of records, simulations of physical systems, spreadsheets, and so on. As an example, Figure 1 shows (in a table format) the scoring summary of a major league baseball (MLB) game, a play-by-play summary with details of the most important events in the game recorded chronologically (i.e., in which play), and a human-written summary.
Modern approaches to data-to-text generation have shown great promise (Lebret et al., 2016;Mei et al., 2016;Perez-Beltrachini and Lapata, 2018;Puduppully et al., 2019;Wiseman et al., 2017) thanks to the use of large-scale datasets and neural network models which are trained end-toend based on the very successful encoder-decoder architecture (Bahdanau et al., 2015). In contrast to traditional methods which typically implement pipeline-style architectures (Reiter and Dale, 2000) with modules devoted to individual generation components (e.g., content selection or lexical choice), neural models have no special-purpose mechanisms for ensuring how to best generate a text. They simply rely on representation learning to select content appropriately, structure it coherently, and verbalize it grammatically.
In this paper we are interested in the generation of descriptive texts such as the game summary shown in Figure 1. Descriptive texts are often characterized as "entity coherent" which means that their coherence is based on the way entities (also known as domain objects or concepts) are introduced and discussed in the discourse (Karamanis et al., 2004). Without knowing anything about baseball or how game summaries are typically written, a glance at the text in Figure 1 reveals that it is about a few entities, namely players who had an important part in the game (e.g., Brad Keller, Hunter Dozier) and their respective teams (e.g., Orioles, Royals). The prominent role of entities in achieving discourse coherence has been long recognized within the linguistic and cognitive science literature (Kuno, 1972;Chafe, 1976;Halliday and Hasan, 1976;Karttunen, 1976;Clark and Haviland, 1977;Prince, 1981), with Centering Theory (Grosz et al., 1995) being most prominent at formalizing how entities are linguistically realized and distributed in texts.
In this work we propose an entity-centric neural architecture for data-to-text generation. Instead of treating entities as ordinary tokens, we create entity-specific representations (i.e., for players and teams) which are dynamically updated as text is  being generated. Our model generates descriptive texts with a decoder augmented with a memory cell and a processor for each entity. At each time step in the decoder, the processor computes an updated representation of the entity as an interpolation between a candidate entity memory and its previous value. Processors are each a gated recurrent neural network and parameters among them are shared. The model generates text by hierarchically attending over memory cells and the records corresponding to them.
We report experiments on the benchmark RO-TOWIRE dataset (Wiseman et al., 2017) which contains statistics of NBA basketball games paired with human-written summaries. In addition, we create a new dataset for MLB (see Figure 1). Compared to ROTOWIRE, MLB summaries are longer (approximately by 50%) and the input records are richer and more structured (with the addition of play-by-play). Moreover, the MLB dataset is five times larger in terms of data size (i.e., pairs of tables and game summaries). We compare our entity model against a range of recently proposed neural architectures including an encoder-decoder model with conditional copy (Wiseman et al., 2017) and a variant thereof which generates texts while taking content plans into account (Puduppully et al., 2019). Our results show that modeling entities explicitly is beneficial and leads to output which is not only more coherent but also more concise and grammatical across both datasets.
Our contributions in this work are three-fold: a novel entity-aware model for data-to-text generation which is linguistically motivated, yet resource lean (no preprocessing is required, e.g., to extract document plans); a new dataset for data-to-text generation which we hope will encourage further work in this area; a comprehensive evaluation and comparison study which highlights the merits and shortcomings of various recently proposed datato-text generation models on two datasets.

Related Work
The sports domain has attracted considerable attention since the early days of generation systems (Robin, 1994;Tanaka-Ishii et al., 1998). Likewise, a variety of coherence theories have been developed over the years (e.g., Mann and Thomson 1988;Grosz et al. 1995) and their principles have found application in many symbolic text generation systems (e.g., Scott and de Souza 1990;Kibble and Power 2004). Modeling entities and their communicative actions has also been shown to improve system output in interactive storytelling (Cavazza et al., 2002;Cavazza and Charles, 2005) and dialogue generation (Walker et al., 2011).
More recently, the benefits of modeling entities explicitly have been demonstrated in various tasks and neural network models. Ji et al. (2017) make use of dynamic entity representations for language modeling. And Clark et al. (2018) extend this work by adding entity context as input to the decoder. Both approaches condition on a single entity at a time, while we dynamically represent and condition on multiple entities in parallel. Kiddon et al. (2016) make use of fixed entity representations to improve the coverage and coherence of the output for recipe generation. Bosselut et al. (2018) model actions and their effects on entities for the same task. However, in contrast to our work, they keep entity representations fixed during generation. Henaff et al. (2017) make use of dynamic entity representations in machine reading. Entity representations are scored against a query vector to directly predict an output class or combined as a weighted sum followed by softmax over the vocabulary. We make use of a similar entity representation model, extend it with hierarchical attention and apply it to data-to text generation. The hierarchical attention mechanism was first introduced in Yang et al. (2016) as a way of learning document-level representations. We apply attention over records and subsequently over entity memories.
Several models have been proposed in the last few years for data-to-text generation (Mei et al. 2016;Lebret et al. 2016;Wiseman et al. 2017, inter alia) based on the very successful encoderdecoder architecture (Bahdanau et al., 2015). Various attempts have also been made to improve these models, e.g., by adding content selection (Perez-Beltrachini and Lapata, 2018) and content planning (Puduppully et al., 2019) mechanisms. However, we are not aware of any prior work in this area which explicitly handles entities and their generation in discourse context.

Background: Encoder-Decoder with Conditional Copy
The input to our model is a table of records (see Figure 1). Records in turn have features, represented as {r j,l } L l=1 where L is the number of features in each record. Examples of features are values (r j,1 ; e.g., 8.0, Baltimore) or entities (r j,2 ; e.g., Orioles, C. Mullins). The model output y is a document containing words y = y 1 · · · y |y| where |y| is the document length. Following previous work (Wiseman et al., 2017;Puduppully et al., 2019), we embed features into vectors, and then use a multilayer perceptron to obtain a vector representation r j for each record: indicates vector concatenation, W r ∈ R n×nL , b r ∈ R n are parameters, and ReLU is the rectifier activation function.
Let {e j } |r| j=1 denote the output of the encoder. We use an LSTM decoder to compute the probability of each target word, conditioned on previously generated words, and on e j . In the case of ROTOWIRE, we follow previous work (Wiseman et al., 2017;Puduppully et al., 2019) and consider e j = r j . The first hidden state of the decoder is initialized by the average of the record vectors, In the case of MLB, information encoded in play-by-play is sequential. Recall, that it documents the most important events in a game in chronological order. To account for this, we encode MLB records into {e j } |r| j=1 with a bidirectional LSTM. We impose an ordering on records in the box score (i.e., home team followed by away team) which is in turn followed by play-by-play where records are naturally ordered by time. The decoder is initialized with the concatenation of the hidden states of the final step of the encoder.
At time step t, the input to the decoder LSTM is the embedding of the previously predicted word y t−1 . Let d t denote the hidden state of the t-th LSTM unit. We compute attention scores α t,j over the encoder output e j and obtain dynamic context vector q t as the weighted sum of the hidden states of the input: where W a ∈ R n×n , j α t,j = 1, W c ∈ R n×2n , and d att t is the attention vector. The probability of output text y conditioned on the input table r is modeled as:  Figure 2: Diagram of entity memory network (block A) and hierarchical attention (blocks B and C). Module f θ represents update equations (6)- (8) where θ is the set of trainable parameters. The gate represents the entity memory update (Equation (9)). Block B covers Equations (10) and (11), and block C Equations (12) and (13). where W y ∈ R |Vy|×n , b y ∈ R |Vy| are parameters and |V y | is the output vocabulary size. We further augment the decoder with a copy mechanism i.e., the ability to copy values from the input; copy implies y t = r j,1 for some t and j (e.g., Royals, Orioles, 9, 2 in the summary in Figure 1 are copied from r). We use the conditional copy method proposed in Gulcehre et al. (2016) where a binary variable is introduced as a switch gate to indicate whether y t is copied or not.

Entity Memory and Hierarchical Attention
We extend the basic model from Section 3 with entity memory and hierarchical attention. Figure 2 provides a schematic overview of our architecture.

Entity Memory
In order to render the model entity-aware, we compute x k as an average of record representation for each unique entity k (i.e., one of r j,2 values): We initialize u t=−1,k , the memory representation of an entity at time t = −1, as: where u t=−1,k ∈ R p and W i ∈ R p×n .
To capture the fact that discourse in descriptive texts may shift from one entity to the next, e.g., some entities may be salient in the beginning of the game summary (see Brad Kelly in the text in Figure 1), others only towards the end (see Dozier in Figure 1), and a few throughout (e.g., references to teams), we update entity representations at each time step during decoding. We use gate γ t to indicate whether there should be an update in the entity representation: where t >= 0, σ is the sigmoid function, W d ∈ R p×p , and b d ∈ R p . We also compute δ t,k , the extent to which the entity representation should change, andũ t,k , the memory of the candidate entity: where denotes element-wise multiplication, Figure 2).
An element in gate γ t will have value approaching 1 if an update in any u t−1,k is required. The value of an element in gate δ t,k will approach 1 if the corresponding value of the element in u t−1,k changes. Equation (9) computes the update in entity memory as an interpolation over the gated representation of the previous value of the entity memory and the candidate entity memory: where u t,k represents entity k at time t.
Previous work (Henaff et al., 2017;Ji et al., 2017;Clark et al., 2018) employs a normalization term over u t,k . We empirically found that normalization hurts performance and hence did not include it in our model.

Hierarchical Attention
We hypothesize that our generator should first focus on entities (e.g., the main players and their teams) and then on the records corresponding to theses entities (e.g, player performance in the game). Our model implements this view of text generation via a hierarchical attention mechanism which we explain below. We also expect that focusing on entities first should improve the precision of the texts we generate as the entity distribution will constrain the probability distribution of records corresponding to each entity.
To better understand the hierarchical attention mechanism, we can view the encoder output e j as a 2-dimensional array g k,z where k ∈ [1, K] represents entities and z ∈ [1, Z] represents records of entities and there is a one-to-one correspondence between positions j and k, z. We compute attention over g k,z , the encoder output, as: where W a ∈ R n×n , z α t,k,z = 1 (see block B in Figure 2). We compute the entity context as: while attention over entity vectors u t,k is: with W h ∈ R n×p , k Ψ t,k = 1. And the encoder context q t (see block C in Figure 2) is computed as follows: We feed q t into Equation (2) and compute p gen (y t |y <t , r), the probability of generating output text y conditioned on records r, as shown in Equation (3).  We experimented with feeding k Ψ t,k u t,k as input context along the lines of Clark et al. (2018); however, results on the development dataset degraded performance, and we did not pursue this approach further.

Training and Inference
Our training objective maximizes the log likelihood of output text given an input table of records: where D is the training set consisting of pairs of record tables and output game summaries. During inference, we make use of beam search to approximately obtain the best outputŷ among candidate outputs y :ŷ = arg max y p(y |r)

Experimental Setup
Data We performed experiments on two datasets. The first one is ROTOWIRE (Wiseman et al., 2017) which contains NBA basketball game statistics matched with human-written summaries. In addition, we created MLB, a new dataset which contains baseball statistics and corresponding human-authored summaries obtained from the ESPN website. 2 Basic statistics on the two datasets are given in Table 1. As can be seen, MLB is approximately five times larger than ROTOWIRE, with richer vocabulary and longer summaries. For ROTOWIRE, we used the official training, development, and test splits of 3,398/727/728 instances. Analogously, for MLB we created a split of 22,821/1,739/1,744 instances. Game summaries in MLB were tokenized using nltk and hyphenated words were separated. Sentences containing quotes were removed as they included opinions and non-factual statements unrelated to the input tables. Sometimes MLB summaries contain a "Game notes" section with incidental information which was also removed.
For MLB, the value of L in Equation (1) is 6, and for ROTOWIRE it is 4. The first four features are similar in both datasets and include value (r j,1 ; e.g., 8.0, Baltimore), entity (r j,2 ; e.g., Orioles, C. Mullins), record type (r j,3 ; e.g., RBI, R,H) and whether a player is on the home-or away-team (r j,4 ). MLB has two additional features which include the inning of play (r j,5 ; e.g., 9, 7, and -1 for records in the box score), and play index, a unique play identifier for a set of records in a play (r j,6 ; e.g., 0, 10, and -1 for records in the box score).
Information Extraction For automatic evaluation, we make use of the Information Extraction (IE) approach proposed in Wiseman et al. (2017). The idea is to use a fairly accurate IE tool to extract relations from gold summaries and model summaries and then quantify the extent to which the extracted relations align or diverge (see Section 7 for the specific metrics we use).
The IE system first identifies candidate entities (i.e., players, teams) and values (i.e., numbers), and given an "entity, value" pair it predicts the type of relation. For example, in ROTOWIRE, the relation for the pair "Kobe Bryant, 40" is PTS. Training data for the IE system is obtained automatically by matching entity-value pairs from summary sentences against record types. The IE system has an ensemble architecture which combines convolutional and bidirectional LSTM models.
We reused the updated IE models from Puduppully et al. (2019) for ROTOWIRE 3 and trained our own IE system for MLB. Box and line scores in MLB are identical in format to ROTOWIRE and pose no particular problems to the IE system. However, it is difficult to extract information from play-by-play and match it against the input tables. Consider the sentences Ryan O'Hearn homered or Keller gave up a home run from Figure 1 where we can identify entities (Ryan O'Hearn, Keller) and record types (home-run-batter, home-run-pitcher) but no specific values. We created a dummy value of -1 for such cases and the IE system was trained to predict the record type of entity value pairs such as (Ryan O'Hearn, -1) or (Keller, -1). Moreover, 3 https://github.com/ratishsp/data2text-1/ the IE system does not capture attributes such as inning and team scores in play-by-play as it is difficult to deterministically match these against corresponding spans in text. The IE system thus would not be able to identify any records in the snippet tied 1-1 in the fourth. On MLB, the system achieved 83.4% precision and 66.7% recall (on held out data). We note that designing a highly accurate IE module for MLB is in itself a research challenge and outside the scope of this paper.
In order to compare our model against Puduppully et al. (2019), we must have access to content plans which we extracted from ROTOWIRE and MLB by running the IE tool on gold summaries (training set). We expect the relatively low IE recall on MLB to disadvantage their model which relies on accurate content plans.
Training Configuration Model hyperparameters were tuned on the development set. We used the Adagrad optimizer (Duchi et al., 2011) with an initial learning rate of 0.15, decayed by 0.97 for every epoch after the 4th epoch. We used truncated BPTT (Williams and Peng, 1990) of length 100 and made use of input feeding (Luong et al., 2015). We summarize the hyperparameters of the ROTOWIRE and MLB models in the Appendix. All models were implemented on a fork of OpenNMT-py (Klein et al., 2017).

System Comparison
We compared our entity model against the following systems: TEMPL is a template-based generator; we reused TEMPL from Wiseman et al. (2017) for RO-TOWIRE and created a new system for MLB. The latter consists of an opening sentence about the two teams playing the game. It then describes statistics of pitchers (innings pitched, runs and hits given etc.) followed by a description of play-by-play (home run, single, double, triple etc.).
ED+CC is the encoder-decoder model with conditional copy from Section 3 and the best performing system in Wiseman et al. (2017).
NCP+CC is the best performing system in Puduppully et al. (2019); it generates content plans by making use of pointer networks (Vinyals et al., 2015) to point to the input e j ; the resultant content plans are then encoded using a BiLSTM followed by an LSTM decoder with an attention and copy mechanism.

Results
Automatic Evaluation We first discuss the results of automatic evaluation using the metrics defined in Wiseman et al. (2017). Letŷ be the gold output and y the model output. Relation Generation measures how factual y is compared to input r. Specifically, it measures the precision and number of relations extracted from y which are also found in r. Content Selection measures the precision and recall of relations betweenŷ and y. Content Ordering measures the Damerau-Levenshtein distance between relations in y and relations inŷ. In addition, we also report BLEU (Papineni et al., 2002) with the gold summaries as reference. Table 2 (top) summarizes our results on the RO-TOWIRE test set (results on the development set are available in the Appendix). We report results for our dynamic entity memory model (ENT), the best system of Wiseman et al. (2017) (WS-2017 which is an encoder-decoder model with conditional copy, and NCP+CC (Puduppully et al., 2019). We see that ENT achieves scores comparable to NCP+CC, but performs better on the metrics of RG precision, CS precision, and CO. ENT achieves substantially higher scores in CS precision compared to WS-2017 and NCP+CC, without any planning component; CS recall is worse for ENT compared to NCP+CC mainly because the latter model is trained to first create a content plan with good coverage of what to say.   Table 2). This suggests that the task of creating MLB game summaries is hard, even for a template system which does not perform any sophisticated generation.

Ablation Experiments
We further examined how individual model components contribute to the quality of the generated summaries. To assess the impact of hierarchical attention (Section 4.2) over ED+CC, we report the performance of a stripped-down variant of our model without dynamic entity memory. Specifically, the entity memory was kept static and set to u t=−1,k (see Equation (5)). In this model, attention over entity vectors is: We next examined the contribution of dynamic memory, by adding it to this model without the gate γ t (i.e., we set γ t to one) and Equation (7) then becomes: Finally, we obtain our final ENT model, by incorporating the update gate mechanism.
The results of the ablation study are shown in Table 3. We compare ED+CC against variants "+Hier", "+Dyn" and "+Gate" corresponding to successively adding hierarchical attention, dynamic memory, and the update gate mechanism. On both datasets, hierarchical attention, improves relation generation, content selection, and BLEU. Dynamic memory and the update gate brings further improvements to content selection and BLEU.
Because it conditions on entities, ENT is able to produce text displaying nominal coreference which is absent from the outputs of ED+CC and WS-2017. We present an example in Table 4 (and in the Appendix) where entities Dwight Howard and James Harden are introduced and then later referred to as Howard and Harden. We also see that while generating the last sentence about the next game, ENT is able to switch the focus of attention from one team (Rockets) to the other (Nuggets), while NCP+CC verbalises Nuggets twice.
Human-Based Evaluation Following earlier work (Wiseman et al., 2017;Puduppully et al., 2019), we also evaluated our model by asking humans to rate its output in terms of relation generation, coherence, grammaticality, and conciseness. Our studies were conducted on the Amazon Mechanical Turk platform. For ROTOWIRE, we compared ENT against NCP+CC, Gold, and TEMPL. We did not compare against WS-2017 or ED+CC, since prior work (Puduppully et al., 2019) has shown that NCP+CC is superior to these models in terms of automatic and human-based evaluation. For MLB, we compared ENT against NCP+CC, ED+CC, Gold, and TEMPL.
In the first study, participants were presented with sentences randomly selected from the game summary (test set) together with corresponding box and line score tables and were asked to count supporting and contradicting facts in these sentences. We evaluated 30 summaries and 4 sentences per summary for each of ROTOWIRE and MLB. We elicited 5 responses per summary.
As shown in Table 5, on ROTOWIRE ENT yields a comparable number of supporting and contradicting facts to NCP+CC (the difference is The Houston Rockets (18-5) defeated the Denver Nuggets (10-13) 108-96 on Tuesday at the Toyota Center in Houston. The Rockets had a strong first half where they outscored . . . The Rockets were led by Donatas Motiejunas, who scored a game-high of 25 points . . . James Harden also played a factor in the win, as he went 7-for . . . Coming off the bench, Donatas Motiejunas had a big game and finished with 25 points . . . The only other player to reach double figures in points was Arron Afflalo, who came off the bench for 12 points . . . Coming off the bench, Arron Afflalo chipped in with 12 points . . . The Nuggets' next game will be on the road against the Boston Celtics on Friday, while the Nuggets will travel to Boston to play the Celtics on Wednesday. The Houston Rockets (18-5) defeated the Denver Nuggets (10-13) 108-96 on Monday at the Toyota Center in Houston. The Rockets were the superior shooters in this game, going . . . The Rockets were led by the duo of Dwight Howard and James Harden. Howard shot 9-for-11 from the field and . . . Harden on the other hand recorded 24 points (7)(8)(9)(10)(11)(12)(13)(14)(15)(16)(17)(18)(19)(20)(2)(3)(4)(5)(8)(9), 10 rebounds and 10 assists, The only other Nugget to reach double figures in points was Arron Afflalo, who finished with 12 points (4-17 FG,. . . The Rockets' next game will be on the road against the New Orleans Pelicans on Wednesday, while the Nuggets will travel to Los Angeles to play the Clippers on Friday. not statistically significant). TEMPL has the highest number of supporting facts, even relative to gold summaries, and very few contradicting facts. This is expected as TEMPL output is mostly factual, it essentially parrots statistics from the tables. On MLB, ENT yields a number of supporting facts comparable to Gold and NCP+CC, but significantly lower than ED+CC and TEMPL. Contradicting facts are significantly lower for ENT compared to NCP+CC, but comparable to ED+CC and higher than TEMPL and Gold.
We also evaluated the quality of the generated summaries. Following earlier work (Puduppully et al., 2019), we presented participants with two summaries at a time and asked them to choose which one is better in terms of Grammaticality (is the summary written in well-formed English?), Coherence (do the sentences in summary follow a coherent discourse?), and Conciseness (does the summary tend to repeat the same content?) We divided the four competing systems (Gold, TEMPL, NCP+CC, and ENT) into six pairs of summaries for ROTOWIRE and the five competing systems (Gold, TEMPL, ED+CC, NCP+CC, and ENT) into ten pairs for MLB. We used Best-Worst scaling (Louviere and Woodworth, 1991 Table 5: Average number of supporting and contradicting facts in game summaries and best-worst scaling evaluation (higher is better) on ROTOWIRE and MLB datasets. Systems significantly different from ENT are marked with an asterisk * (using a one-way ANOVA with posthoc Tukey HSD tests; p ≤ 0.05).
. et al., 2015), a more reliable alternative to rating scales. The score of a system is computed as the number of times it was rated best minus the number of times is rated worst (Orme, 2009). Scores range from −100 (absolutely worst) to 100 (absolutely best). We elicited judgments for 30 test summaries for ROTOWIRE and MLB; each summary was rated by 3 participants. As shown in Table 5, on ROTOWIRE Gold receives highest scores in terms of Grammaticality, which is not unexpected. ENT comes close, achieving better scores than NCP+CC and TEMPL, even though our model only enhances the coherence of the output. Participants find ENT on par with Gold on Coherence and better than NCP+CC and TEMPL whose output is stilted and exhibits no variability. In terms of Conciseness, TEMPL is rated best, which is expected since it does not contain any duplication, the presented facts are mutually exclusive; ENT is comparable to NCP+CC and better than Gold.
As far as MLB is concerned, ENT achieves highest scores on Grammaticality and Coherence. It is rated high on Conciseness also, second only to TEMPL whose scores are lowest on Grammaticality and Coherence. Perhaps surprisingly, Gold is rated lower than ENT on all three metrics; we hypothesize that participants find Gold's output too verbose compared to the other systems. Recall that MLB gold summaries are relative long, the average length is 542 tokens compared to ROTOWIRE whose summaries are almost half as long (see Table 1). The average length of output summaries for ENT is 327 tokens.
Taken together, our results show that ENT performs better than comparison systems on both RO-TOWIRE and MLB. Compared to NCP+CC, it is conceptually simpler and more portable, as it does not rely on content plans which have to be extracted via an IE system which must be reconfigured for new datasets and domains.

Conclusions
In this work we presented a neural model for datato-text generation which creates entity-specific representations (that are dynamically updated) and generates text using hierarchical attention over the input table and entity memory. Extensive automatic and human evaluation on two benchmarks, ROTOWIRE and the newly created MLB, show that our model outperforms competitive baselines and manages to generate plausible output which humans find coherent, concise, and factually correct. However, we have only scratched the surface; future improvements involve integrating content planning with entity modeling, placing more emphasis on play-by-play, and exploiting dependencies across input tables.   (8-13 FG, 3-4 3PT, 4-5 FT) to go with 9 rebounds. Tobias Harris scored 21 points (10-20 FG, 1-3 3PT, 0-0 FT) to go with 10 rebounds. Andre Drummond scored 19 points (7-11 FG, 0-0 3PT, 5-9 FT) to go with 17 rebounds. Kent Bazemore scored 17 points (7-9 FG, 3-5 3PT, 0-0 FT) to go with 4 rebounds. Aron Baynes scored 15 points (5-6 FG, 0-0 3PT, 5-6 FT) to go with 7 rebounds. Al Horford scored 13 points (6-15 FG, 1-5 3PT, 0-0 FT) to go with 5 rebounds. The Atlanta Hawks' next game will be at home against the Dallas Mavericks, while the Detroit Pistons will travel to play the Bulls. NCP+CC The Atlanta Hawks (44-30) defeated the Detroit Pistons (39-35) 112-95 on Wednesday at the Palace of Auburn Hills. The Hawks came into this game riding a three-game losing streak and it was clear they did n't have it all on the floor. Paul Millsap led the way for the Hawks with 23 points (8-13 FG, 3-4 3Pt, 4-5 FT), along with nine rebounds, five assists and four steals, in 33 minutes. Al Horford chipped in 13 points (6-15 FG, 1-5 3Pt), and Kent Bazemore chipped in 17 points on 7-9 shooting, including 3-5 from deep. Kyle Korver chipped in 12 points (5-10 FG, 1-5 3Pt, 1-1 FT) and three rebounds in 29 minutes, while Tobias Harris chipped in 21 points (10-20 FG, 1-3 3Pt), 10 rebounds and five assists. Tobias Drummond had a double-double of his own with 19 points (7-11 FG, 5-9 FT) and 17 rebounds, along with two blocked shots, in 33 minutes. Andre Drummond had a double-double of his own, with 19 points (7-11 FG, 5-9 FT) and 17 rebounds, along with two blocked shots. The only other player to score in double digits for Detroit was Andre Drummond, who finished with 19 points (7-11 FG, 5-9 FT) and 17 rebounds, along with two blocked shots. The Pistons' next game will be on the road against the Cleveland Cavaliers on Friday, while the Pistons will travel to Minnesota to play the Timberwolves on Wednesday. , nine rebounds and four blocked shots, while Drummond had 19 points (7-11 FG, 5-9 FT), 17 rebounds and two blocked shots. It was his second double-double in a row, as he's combined for 45 points and 19 rebounds over his last two games. He's now averaging 15 points and 7 rebounds on the season. Jeff Teague was the other starter to reach double figures in points, as he finished with 12 points (3-13 FG, 2-3 3Pt, 4-4 FT) and 12 assists. The Hawks' next game will be at home against the Cleveland Cavaliers on Friday, while the Pistons will travel to Los Angeles to play the Clippers on Friday.