We present THEaiTRE, a starting research project aimed at automatic generation of theatre play scripts. This paper reviews related work and drafts an approach we intend to follow. We plan to adopt generative neural language models and hierarchical generation approaches, supported by summarization and machine translation methods, and complemented with a human-in-the-loop approach.
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 Cˇapek’s play R.U.R. [Cˇ apek, 1920], for which the word “robot” was invented by Cˇ 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). 2
While we are not aware of any generation systems specifically aimed at theatre play generation, research in story/narrative generation has been quite active in the past years, with Copyright c 2020 by the paper’s authors. Use permitted under Creative Commons License Attribution 4.0 International (CC BY 4.0). 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. [
Other works focus on explicit entity modelling across the
generated story, e.g., Clark et al. [
Multiple authors attempt to increase long-term coherence
by hierarchical story generation. Fan et al. [
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] extend this work by experimenting with various sentence realization techniques, including retrieval from database and post-editing.
Latest works use massive pretrained language models based on the Transformer architecture, such as GPT-2 [Radford et al., 2019], for generation. See et al. [2019] use GPT-2 directly and show that it is superior to plain RNNs. Mao et al. [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]. 2.2
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 [
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. [
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]. 2.3
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.
2https://en.wikipedia.org/wiki/The_Thirty-Six_Dramatic_ Situations
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. 4
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). 4.1
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. 4.2
We also plan to extend our experiments with hierarchical
generation from large pretrained LMs. We will use an approach
similar to Fan et al. [
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. 4.3
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. 4.4
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]. 4.5
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. 5
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. [Cˇ 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
The THEaiTRE project is supported by the Technology Agency of the Czech Republic grant TL03000348. and partially supported by SVV project number 260 575.