We introduce the THEaiTRE project, 1 which aims to produce and stage the first computer-generated theatre play. This play will be presented on the occasion of the 100th anniversary of Karel Čapek's play R.U.R. [ Čapek, 1920], for which the word "robot" was invented by Čapek.

The project, currently in its early stages, is at the intersection of artificial intelligence research and theatre studies. The core of our approach is to use state-of-the-art deep neural models trained and fine-tuned on theatre play data. However, our team includes both experts on natural language processing and theatre experts, and our solution will be based on research and exchange of experience from both fields.

In this paper, we first review related previous works (Section 2) and data resources available to us (Section 3). We then draft the approaches we are following and intending to follow in the project (Section 4) and present the project timeline (Section 5).

computer-aided systems allowing various degrees of automation and different abilities in learning from data [Kybartas and Bidarra, 2017;Riedl, 2018]. Since recurrent neural networks (RNN) were applied for text generation [Bahdanau et al., 2015;Sutskever et al., 2014], research in story generation has mostly focused on fully data-driven, fully automated approaches. As plain RNNs were found unsuitable for producing longer, coherent texts [Wiseman et al., 2017], multiple improvements have been proposed.

The first line of work focuses on providing a higher-level semantic representation to the networks and conditioning the generation on it. Martin et al. [2018] and Ammanabrolu et al. [2019;2020] use an event-based representation, where an event roughly represents a clause (predicate, subject, direct and indirect object). The model generates the story at the event level and subsequently realizes the individual events to surface sentences. Tu et al. [2019] take a similar approach, using frame semantics and also conditioning sentence generation on other information, such as sentiment.

Other works focus on explicit entity modelling across the generated story, e.g., Clark et al. [2018]. Here, each entity has its own distributed representation (embedding), which is updated on each mention of the entity in the story.

Multiple authors attempt to increase long-term coherence by hierarchical story generation. Fan et al. [2018] generate first a short prompt/tagline, then use it to condition the full story generation. Yao et al. [2019] take a similar approach, using a "storyline" -a list of entities and items to be introduced in the story in the given order. Fan et al. [2019] then combine the hierarchical generation with explicit entity modelling. Their system generates outputs using anonymized but tracked entities, which are subsequently lexicalized in the context of the story by generating referring expressions.

Several works experiment with altering the base RNN architecture: Wang and Wan [2019] use a modified Transformer architecture [Vaswani et al., 2017], which is trained as a conditional variational autoencoder. Tambwekar et al. [2019] utilize reinforcement learning with automatically induced rewards to train their event-based model. Ammanabrolu et al. [2019;2020] [2019] apply GPT-2 fine-tuned for both story generation and common-sense reasoning to improve coherence.

While research in this area has progressed considerably, most experiments have been performed on rather short and simple stories, such as the ROCStories corpus [Mostafazadeh et al., 2016]. Many works focus on limited tasks, such as single-sentence continuation generation [Tu et al., 2019]. The state-of-the-art results still cannot match human performance, producing repetitive and dull outputs [See et al., 2019].

For our needs, we are mostly interested in classifications and abstractions over theatre play scripts or their parts. In the field of theatre studies, there is a vast amount of research on the structure and interpretation of theatre plays. Unfortunately, the results of such research are not made available in forms and formats that would easily allow us to use these as data and annotations in machine learning approaches.

The Thirty-Six Dramatic Situations by Polti [1921] 2 is a classic work, in which the author presented a supposedly ultimate list of all categories of possible dramatic situations that can occur in a theatre play (e.g. "adultery" or "conflict with a god"), further subclassified into 323 situational possibilities.

Although not directly related to theatre plays, the work of [Propp, 1968] is also essential. Propp analyzed Russian folk tales and identified 31 functions, similar to Polti's situations but somewhat more down-to-earth (e.g. "villainy" or "wedding"), as well as 7 abstract character types (e.g. "villain" or "hero") and other abstractions.

Polti's and Propp's categorizations are sometimes used in analyzing and generating narratives, although typically not in drama. The works closest to our focus is probably that of [Gervás et al., 2016] or Lombardo et al. [2018], who devised an ontologies of abstractions for annotating scripts, based on both of the mentioned works, as well as on more recent plot categorization studies [Booker, 2004;Tobias, 2011].

There are also works producing drama analyses in the form of networks, capturing various relations between the characters in the play [Moretti, 2014;Horstmann, 2019;Fischer et al., 2019].

There already is a range of partially or fully artificially generated works of art -e.g. a short sci-fi movie with an LSTMgenerated and human-post-edited script [Benjamin et al., 2016], a musical based on suggestions from several automated tools [Colton et al., 2016], a human-picked collection of computer generated poems [Materna, 2016], or a theatre play written with the help of a next word suggestion tool [Helper, 2018]. While this demonstrates the technical possibility of such an approach, the mixed reception of the outcomes shows that the employed technologies are not (yet?) on par with humans [See et al., 2019]. We thus believe a more specialized and complex approach is needed here.

Theatre play scripts are not easily available for our purposes. As no reasonable corpus is available, we have to create one ourselves. The corpus will contain Czech and English theatre play scripts and synopses (plot summaries), and will be used to train and fine-tune our systems, described in following sections. We are also collecting film and TV series scripts, which are easier to obtain in large quantities, although they are not a perfect match for our setting. Unfortunately, due to copyright reasons, we will not be able to release the full corpus.

In most cases, scripts cannot be downloaded for free, and for most scripts it seems that they are only available in print or scanned. Even electronically available scripts come in various formats and there seems to be no technical standards in this respect. For our project, we need to devise a common representation format, and automatically or semi-automatically convert and normalize the data into the format, marking character names, lines, scenic notes, scene settings, etc. [Croce et al., 2019]. Also the scripts and synopses need to be paired together. At the moment, we only have collected and partially converted several hundreds of documents.

As a theatre play script is a highly structured and complex piece of text, we plan to take a hierarchical approach composed of several steps to generating the full script, also employing human inputs in the process. The overall idea is to start from a brief description of the play, gradually expanding it into more detailed act and scene synopses, and finally generating the individual scene dialogues. We currently envision using generative neural models for the final step (Section 4.1), conditioned by prompts generated by hierarchical generation approaches (Section 4.2).

Large neural language models (LMs), such as GPT-2 [Radford et al., 2019; see Section 2.1], are able to generate believable texts in certain domains (e.g. news articles). This is not the case for the domain of theatre plays. The original GPT-2 must have had a number of plays (or movie scripts) in the training data, which is evident when it is presented with a suitable starting prompt. It can produce a text that follows the formal structure and has some level of content coherence. However, the basic attributes of a dramatic situation are missing: there is no plot, and the scene is not moving towards a conclusion. Other problems include having new characters appear randomly in the middle of the scene or falling into a state of repeating the same sentence forever.

Our basic workflow would be to seed an LM with a prompt which is the beginning of a dramatic situation. The LM would generate the rest of the whole dialogue. We plan to finetune the LM to theatre plays to see how far this approach can go. Then we plan to restrict the generation by enforcing that only certain predetermined characters speak, possibly in a pregenerated order. This can be achieved by stopping the generation at the end of a character's line, adding the name of the next desired character and then resuming the generation process.

To make the characters more internally consistent and different from each other at the same time, we plan to devise individual LMs specialized to specific character types, based on a clustering of the characters across plays. The part of each character would then be generated by a different LM; i.e., the script would consist of several LMs "talking" to each other.

We also plan to extend our experiments with hierarchical generation from large pretrained LMs. We will use an approach similar to Fan et al. [2018] and Yao et al. [2019] (see Section 2.1): starting with generating a title or a prompt for the story, then generating a textual synopsis. The generation of the play from the synopsis will follow as a novel step, not present in previous works. We are considering multiple options of what to choose as the synopsis representation: the play background/setting from play databases, more detailed synopses from fan websites, or scenic remarks extracted from texts of plays themselves. Ultimately, the choice will be made based on data availability. The setup will also include generating "play metadata", such as the main theme, list of characters, narrative type, etc.

The final step will use a similar approach as the base LM generation (see Section 4.1). We also plan on using explicit embeddings for individual characters in the play and using explicit entity tracking/coreference [Clark et al., 2018;Fan et al., 2019]. Since the available automatic coreference tools [e.g., Clark and Manning, 2016;Lee et al., 2017] are typically not trained for processing dialogic texts, they may require adaptation.

The hierarchical generation approach relies on data that contain information of various granularity, as described in Section 4.2. However, most of the available data contain only the title and the script of the play, missing other invaluable information. In our project, we intend to synthesize the missing data; synthetic data are frequently used in various tasks, such as machine translation [Bojar and Tamchyna, 2011;Sennrich et al., 2016].

We can generate synthetic data with the use of the classical task of text summarization; abstractive summarization in particular [Rush et al., 2015]. The main idea is to take a long document and summarize it into a few sentences, then take these synthetic data and use them for training the generative models in the hierarchical approach. With various summarizing models, we can first abstract the whole script of a theatre play into a detailed synopsis, then the detailed synopsis into a short plot synopsis, and eventually the short synopsis into the play title. With these summarizing models, we can fill the gaps in our datasets, so that the hierarchical generation models can be trained on all theatre scripts available to us, even if they lack some or all higher-level summaries.

We plan to train the Transformer model [Vaswani et al., 2017] for the summarization tasks. As we expect the amount of available training play-summary pairs to be scarce, we will pretrain our models on other summarization tasks, such as news abstract generation for which plenty of parallel data is available [Straka et al., 2018], followed by fine-tuning the pretrained models on our in-domain theatre data.

Due to the specific nature of the genre, where a lot of what is meant is not explicitly said by any of the characters, we know that the summarization may be difficult or impossible to do, and this component thus cannot be entirely relied on.

We plan on using machine translation (MT) for two purposes:

(1) Since we have limited amounts of training data scattered across both English and Czech, we need the generation to take advantage of data in both languages. Therefore, we plan to generate new training data by translating either Czech texts to English or vice versa. (2) We would like the same resulting generated play to be available instantly in both languages. Therefore, we plan to generate it in one of the languages and use MT to bring the result over to the other language.

For both applications, we are going to use our in-house state-of-the-art Czech-English model [Popel, 2018]. However, theatre play scripts are a specific domain of data for which our MT models were not specifically trained. To tackle this problem, we will finetune [Miceli Barone et al., 2017] the general MT models on theatre parallel data, possibly also applying automated heuristical pre-processing and/or postediting [Rosa et al., 2012].

To ensure a satisfactory result, we intend to complement the automated generation with interventions from theatre professionals, using a human-in-the-loop approach.

We currently envision using the automated system to generate texts and the human to choose parts of the output to use in the play. This could be done e.g. in an iterative interactive way, where the system generates several options for a line of the script, the human picks one of the options to add to the script, the system generates continuation options, etc.

Moreover, only the dialogues of the characters will be fully automatically generated. The subsequent realization and performance of the play will be in the hands of theatre professionals, who will analyze and interpret the script, devise stage directions, rehearse the play, design the scene, and finally perform the play for a live audience, all of which will further shape the perception of the play by the spectators.

After some preliminary work, the project started in April 2020. The first automatically generated THEaiTRE play will be premiered in January 2021, at the occasion of the 100th anniversary of the premiere of the play R.U.R. [ Čapek, 1920]. A premiere of a second play, generated from an improved version of our system, is planned for 2022.

The project can be tracked at https://theaitre.com