Download the Full Ebook and Access More Features - ebooknice.

com

(Ebook) Generative Deep Learning, 2nd Edition

(Third Early Release) by David Foster ISBN
9781098134174, 1098134176

https://ebooknice.com/product/generative-deep-learning-2nd-
edition-third-early-release-44980648

OR CLICK HERE

DOWLOAD EBOOK

Download more ebook instantly today at https://ebooknice.com

 Instant digital products (PDF, ePub, MOBI) ready for you
Download now and discover formats that fit your needs...

Start reading on any device today!

(Ebook) Generative Deep Learning: Teaching Machines to

Paint, Write, Compose, and Play, 2nd Edition (Seventh
Early Release) by David Foster ISBN 9781098134181,
1098134184
https://ebooknice.com/product/generative-deep-learning-teaching-
machines-to-paint-write-compose-and-play-2nd-edition-seventh-early-
release-49406866
ebooknice.com

(Ebook) Generative Deep Learning by David Foster ISBN

9781492041948, 1492041947

https://ebooknice.com/product/generative-deep-learning-10521496

ebooknice.com

(Ebook) Generative Deep Learning: Teaching Machines to

Paint, Write, Compose, and Play, 2nd Edition by David
Foster ISBN 9781098134181, 9781098134150, 1098134184,
109813415X
https://ebooknice.com/product/generative-deep-learning-teaching-
machines-to-paint-write-compose-and-play-2nd-edition-50832860

ebooknice.com

(Ebook) Biota Grow 2C gather 2C cook by Loucas, Jason;

Viles, James ISBN 9781459699816, 9781743365571,
9781925268492, 1459699815, 1743365578, 1925268497
https://ebooknice.com/product/biota-grow-2c-gather-2c-cook-6661374

ebooknice.com
(Ebook) Fundamentals of Deep Learning, 2nd Edition (Early
Release) by Nithin Buduma, Nikhil Buduma, Joe Papa ISBN
9781492082170, 1492082171
https://ebooknice.com/product/fundamentals-of-deep-learning-2nd-
edition-early-release-38249182

ebooknice.com

(Ebook) Learning Go, 2nd Edition (Early Release) by Jon

Bodner ISBN 9781098139285, 1098139283

https://ebooknice.com/product/learning-go-2nd-edition-early-
release-46867700

ebooknice.com

(Ebook) Learning Go, 2nd Edition (4th Early Release) by

Jon Bodner ISBN 9781098139285, 1098139283

https://ebooknice.com/product/learning-go-2nd-edition-4th-early-
release-50199580

ebooknice.com

(Ebook) Cambridge IGCSE and O Level History Workbook 2C -

Depth Study: the United States, 1919-41 2nd Edition by
Benjamin Harrison ISBN 9781398375147, 9781398375048,
1398375144, 1398375047
https://ebooknice.com/product/cambridge-igcse-and-o-level-history-
workbook-2c-depth-study-the-united-states-1919-41-2nd-edition-53538044

ebooknice.com

(Ebook) Deep Learning with R, 2nd Edition (Final Release)

by Francois Chollet, Tomasz Kalinowski, J. J. Allaire ISBN
9781633439849, 1633439844
https://ebooknice.com/product/deep-learning-with-r-2nd-edition-final-
release-43847448

ebooknice.com
 Generative Deep Learning
Teaching Machines to Paint, Write, Compose, and
Play

With Early Release ebooks, you get books in their earliest form—
the author’s raw and unedited content as they write—so you can
take advantage of these technologies long before the official
release of these titles.

David Foster
Generative Deep Learning
by David Foster
Copyright © 2023 Applied Data Science Partners Ltd. All rights
reserved.
Printed in the United States of America.
Published by O’Reilly Media, Inc., 1005 Gravenstein Highway North,
Sebastopol, CA 95472.
O’Reilly books may be purchased for educational, business, or sales
promotional use. Online editions are also available for most titles
(http://oreilly.com). For more information, contact our
corporate/institutional sales department: 800-998-9938 or
corporate@oreilly.com.

Acquisitions Editor: Nicole Butterfield

Development Editor: Michele Cronin

Production Editor: Christopher Faucher

Interior Designer: David Futato

Cover Designer: Karen Montgomery

Illustrator: Kate Dullea

July 2019: First Edition

March 2023: Second Edition

Revision History for the Early Release

2022-06-28: First Release
2022-08-08: Second Release
 2022-08-29: Third Release
See http://oreilly.com/catalog/errata.csp?isbn=9781098134181 for
release details.
The O’Reilly logo is a registered trademark of O’Reilly Media, Inc.
Generative Deep Learning, the cover image, and related trade dress
are trademarks of O’Reilly Media, Inc.
The views expressed in this work are those of the author and do not
represent the publisher’s views. While the publisher and the author
have used good faith efforts to ensure that the information and
instructions contained in this work are accurate, the publisher and
the author disclaim all responsibility for errors or omissions,
including without limitation responsibility for damages resulting from
the use of or reliance on this work. Use of the information and
instructions contained in this work is at your own risk. If any code
samples or other technology this work contains or describes is
subject to open source licenses or the intellectual property rights of
others, it is your responsibility to ensure that your use thereof
complies with such licenses and/or rights.
978-1-098-13412-9
Chapter 1. Generative
Modeling

A NOTE FOR EARLY RELEASE READERS

With Early Release ebooks, you get books in their earliest form—
the author’s raw and unedited content as they write—so you can
take advantage of these technologies long before the official
release of these titles.
This will be the 1st chapter of the final book. Please note that
the GitHub repo will be made active later on.
If you have comments about how we might improve the content
and/or examples in this book, or if you notice missing material
within this chapter, please reach out to the editor at
mcronin@oreilly.com.
 CHAPTER GOALS
In this chapter you will:

Learn the key differences between generative and

discriminative models.
Understand the desirable properties of a generative model.
Learn about the core probabilistic concepts that will be used
throughout this book
Explore the different families of generative model and how
they each tackle the core challenges.
Pull the codebase that accompanies the examples of
generative models in this book, using Git.
Learn about Docker from first principles and why it is a
useful technology for developing and deploying machine
learning models of any kind.
Learn how to run the codebase on a GPU using Google
Cloud Platform.

This chapter is a general introduction to the field of generative

modeling. We will explore the theoretical concepts that underpin
generative models and also walk through the practical steps required
to start building generative models on your own hardware or in the
cloud.
We will start with a gentle theoretical introduction to generative
modeling. In this following section, we will see how generative
modeling is the natural counterpart to the more widely studied
discriminative modeling and investigate the properties that a good
generative model should have. We will lay out the core probabilistic
concepts that are important to know, in order to fully appreciate how
different model architectures tackle the challenge of generative
modeling. This will lead us naturally onto the final subsection, which
lays out the five families of generative modeling architecture that
dominate the field today.

What Is Generative Modeling?

A generative model can be broadly defined as follows:

Generative modeling is a branch of machine learning that deals

with the creation of models that can generate new data points
that are similar to the training data.
What does this mean in practice? Suppose we have a dataset
containing images of horses. We may wish to build a model that can
generate a new image of a horse that has never existed but still
looks real because the model has learned the general rules that
govern the appearance of a horse. This is the kind of problem that
can be solved using generative modeling.
A summary of a typical generative modeling process is shown in
Figure 1-1.
First, we require a dataset consisting of many examples of the entity
we are trying to generate. This is known as the training data, and
one such data point is called an observation.
 Figure 1-1. The generative modeling process

Each observation consists of many features—for an image

generation problem, the features are usually the individual pixel
values. It is our goal to build a model that can generate new sets of
features that look as if they have been created using the same rules
as the original data. Conceptually, for image generation this is an
incredibly difficult task, considering the vast number of ways that
individual pixel values can be assigned and the relatively tiny number
of such arrangements that constitute an image of the entity we are
trying to simulate.
A generative model must also be probabilistic rather than
deterministic. If our model is merely a fixed calculation, such as
taking the average value of each pixel in the dataset, it is not
generative because the model produces the same output every time.
The model must include a stochastic (random) element that
influences the individual samples generated by the model.
In other words, we can imagine that there is some unknown
probabilistic distribution that explains why some images are likely to
be found in the training dataset and other images are not. It is our
job to build a model that mimics this distribution as closely as
possible and then sample from it to generate new, distinct
observations that look as if they could have been included in the
original training set.

Generative Versus Discriminative Modeling

In order to truly understand what generative modeling aims to
achieve and why this is important, it is useful to compare it to its
counterpart, discriminative modeling. If you have studied machine
learning, most problems you will have faced will have most likely
been discriminative in nature. To understand the difference, let’s
look at an example.
Suppose we have a dataset of paintings, some painted by Van Gogh
and some by other artists. With enough data, we could train a
discriminative model to predict if a given painting was painted by
Van Gogh. Our model would learn that certain colors, shapes, and
textures are more likely to indicate that a painting is by the Dutch
master, and for paintings with these features, the model would
upweight its prediction accordingly. Figure 1-2 shows the
discriminative modeling process—note how it differs from the
generative modeling process shown in Figure 1-1.
 Figure 1-2. The discriminative modeling process

One key difference is that when performing discriminative modeling,

each observation in the training data has a label. For a binary
classification problem such as our artist discriminator, Van Gogh
paintings would be labeled 1 and non–Van Gogh paintings labeled 0.
Our model then learns how to discriminate between these two
groups and outputs the probability that a new observation has label
1—i.e., that it was painted by Van Gogh.
For this reason, discriminative modeling is synonymous with
supervised learning, or learning a function that maps an input to an
output using a labeled dataset. Generative modeling is usually
performed with an unlabeled dataset (that is, as a form of
unsupervised learning), though it can also be applied to a labeled
dataset to learn how to generate observations from each distinct
class.
Let’s take a look at some mathematical notation to describe the
difference between generative and discriminative modeling.
 Discriminative modeling estimates p(y|x) —the probability of a
label y given observation x.

Generative modeling estimates p(x) —the probability of

observing observation x.
If the dataset is labeled, we can also build a generative model
that estimates the distribution p(x|y).

In other words, discriminative modeling attempts to estimate the

probability that an observation x belongs to category y. Generative
modeling doesn’t care about labeling observations. Instead, it
attempts to estimate the probability of seeing the observation at all.
The key point is that even if we were able to build a perfect
discriminative model to identify Van Gogh paintings, it would still
have no idea how to create a painting that looks like a Van Gogh. It
can only output probabilities against existing images, as this is what
it has been trained to do. We would instead need to train a
generative model, which can output sets of pixels that have a high
chance of belonging to the original training dataset.

Advances in Machine Learning

To understand why generative modeling can be considered the next
frontier for machine learning, we must first look at why
discriminative modeling has been the driving force behind most
progress in machine learning methodology in the last two decades,
both in academia and in industry.
From an academic perspective, progress in discriminative modeling
is certainly easier to monitor, as we can measure performance
metrics against certain high-profile classification tasks to determine
the current best-in-class methodology. Generative models are often
more difficult to evaluate, especially when the quality of the output
is largely subjective. Therefore, much emphasis in recent years has
been placed on training discriminative models to reach human or
superhuman performance in a variety of image or text classification
tasks.
For example, for image classification, the key breakthrough came in
2012 when a team led by Geoff Hinton at the University of Toronto
won the ImageNet Large Scale Visual Recognition Challenge
(ILSVRC) with a deep convolutional neural network. The competition
involves classifying images into one of a thousand categories and is
used as a benchmark to compare the latest state-of-the-art
techniques. The deep learning model had an error rate of 16%—a
massive improvement on the next best model, which only achieved a
26.2% error rate. This sparked a deep learning boom that has
resulted in the error rate falling even further year after year. The
2015 winner achieved superhuman performance for the first time,
with an error rate of 4%, and the current state-of-the-art model
achieves an error rate of just 2%. Many would now consider the
challenge a solved problem.
As well as it being easier to publish measurable results within an
academic setting, discriminative modeling has historically been more
readily applicable to business problems than generative modeling.
Generally, in a business setting, we don’t care how the data was
generated, but instead want to know how a new example should be
categorized or valued. For example:
Given a satellite image, a government defense official would
only care about the probability that it contains enemy units, not
the probability that this particular image should appear.
A customer relations manager would only be interested in
knowing if the sentiment of an incoming email is positive or
 negative and wouldn’t find much use in a generative model that
could output examples of customer emails that don’t yet exist.
A doctor would want to know the chance that a given retinal
image indicates glaucoma, rather than have access to a model
that can generate novel pictures of the back of an eye.

As most solutions required by businesses are in the domain of

discriminative modeling, there has been a rise in the number of
Machine-Learning-as-a-Service (MLaaS) tools that aim to
commoditize the use of discriminative modeling within industry, by
largely automating the build, validation, and monitoring processes
that are common to almost all discriminative modeling tasks.

The Rise of Generative Modeling

While discriminative modeling has so far provided the bulk of the
impetus behind advances in machine learning, in the last 10 years
many of the most interesting advancements in the field have come
through novel applications of deep learning to generative modeling
tasks.
In particular, there has been increased media attention on generative
modeling projects such as StyleGAN from NVIDIA,1 which is able to
create hyper-realistic images of human faces, and the GPT-2
language model from OpenAI,2 which is able to complete a passage
of text given a short introductory paragraph.
Figure 1-3 shows the striking progress that has already been made
in facial image generation since 2014.3 There are clear positive
applications here for industries such as game design and
cinematography, and improvements in automatic music generation
will also surely start to resonate within these domains. It remains to
be seen whether we will one day read news articles or novels written
by a generative model, but the recent progress in this area is
staggering and it is certainly not outrageous to suggest that this one
day may be the case. While exciting, this also raises ethical
questions around the proliferation of fake content on the internet
and means it may become ever harder to trust what we see and
read through public channels of communication.

Figure 1-3. Face generation using generative modeling has improved significantly
in the last eight years4

As well as the practical uses of generative modeling (many of which

are yet to be discovered), there are three deeper reasons why
generative modeling can be considered the key to unlocking a far
more sophisticated form of artificial intelligence, that goes beyond
what discriminative modeling alone can achieve.
First, purely from a theoretical point of view, we should not be
content with only being able to excel at categorizing data but should
also seek a more complete understanding of how the data was
generated in the first place. This is undoubtedly a more difficult
problem to solve, due to the high dimensionality of the space of
feasible outputs and the relatively small number of creations that we
would class as belonging to the dataset. However, as we shall see,
many of the same techniques that have driven development in
discriminative modeling, such as deep learning, can be utilized by
generative models too.
Second, it is highly likely that generative modeling will be central to
driving future developments in other fields of machine learning, such
as reinforcement learning (the study of teaching agents to optimize
a goal in an environment through trial and error). For example, we
could use reinforcement learning to train a robot to walk across a
given terrain. The general approach would be to build a computer
simulation of the terrain and then run many experiments where the
agent tries out different strategies. Over time the agent would learn
which strategies are more successful than others and therefore
gradually improve. A typical problem with this approach is that the
physics of the environment is often highly complex and would need
be calculated at each timestep in order to feed the information back
to the agent to decide its next move. However, if the agent were
able to simulate its environment through a generative model, it
wouldn’t need to test out the strategy in the computer simulation or
in the real world, but instead could learn in its own imaginary
environment.
Finally, if we are to truly say that we have built a machine that has
acquired a form of intelligence that is comparable to a human’s,
generative modeling must surely be part of the solution. One of the
finest examples of a generative model in the natural world is the
person reading this book. Take a moment to consider what an
incredible generative model you are. You can close your eyes and
imagine what an elephant would look like from any possible angle.
You can imagine a number of plausible different endings to your
favorite TV show, and you can plan your week ahead by working
through various futures in your mind’s eye and taking action
accordingly. Current neuroscientific theory suggests that our
perception of reality is not a highly complex discriminative model
operating on our sensory input to produce predictions of what we
are experiencing, but is instead a generative model that is trained
from birth to produce simulations of our surroundings that accurately
match the future. Some theories even suggest that the output from
this generative model is what we directly perceive as reality. Clearly,
a deep understanding of how we can build machines to acquire this
ability will be central to our continued understanding of the workings
of the brain and general artificial intelligence.

The Generative Modeling Framework

With this in mind, let’s begin our journey into the exciting world of
generative modeling. To begin with we shall look at the simplest
examples of generative models and some of the ideas that will help
us to work through the more complex architectures that we will
encounter later in the book.

Hello World!
Let’s start by playing a generative modeling game in just two
dimensions. I’ve chosen a rule that has been used to generate the
set of points X in Figure 1-4. Let’s call this rule pdata. Your challenge
is to choose a different point x = (x1, x2) in the space that looks
like it has been generated by the same rule.
Figure 1-4. A set of points in two dimensions, generated by an unknown rule pdata

Where did you choose? You probably used your knowledge of the
existing data points to construct a mental model, pmodel, of
whereabouts in the space the point is more likely to be found. In this
respect, pmodel is an estimate of pdata. Perhaps you decided that
pmodel should look like Figure 1-5—a rectangular box where points
may be found, and an area outside of the box where there is no
chance of finding any points.
To generate a new observation, you can simply choose a point at
random within the box, or more formally, sample from the
distribution pmodel. Congratulations, you have just devised your first
generative model!

Figure 1-5. The orange box, pmodel, is an estimate of the true data-generating
distribution, pdata

While this isn’t the most complex example, we can use it to

understand what generative modeling is trying to achieve. The
following framework sets out our motivations.
 THE GENERATIVE MODELING FRAMEWORK
We have a dataset of observations X.
We assume that the observations have been generated
according to some unknown distribution, pdata.
We want to build a generative model pmodel that mimics
pdata. If we achieve this goal, we can sample from pmodel to
generate observations that appear to have been drawn from
pdata.
The desirable properties of pmodel are:
Accuracy: If pmodel(x) is high, x should like it has been
drawn from pdata. If pmodel(x) is low, x should not look
like it has been drawn from pdata.
Generation: It should be possible to easily sample a
new observation x from pmodel(x)
Representation: It should be possible to understand
how different high-level features (e.g. in our example,
continents) are represented by pmodel.

Let’s now reveal the true data-generating distribution, pdata, and see
how the framework applies to this example.
As we can see from Figure 1-6, the data-generating rule is simply a
uniform distribution over the land mass of the world, with no chance
of finding a point in the sea.
 Figure 1-6. The orange box, pmodel, is an estimate of the true data-generating
distribution pdata (the gray area)

Clearly, our model pmodel is an oversimplification of pdata. We can

inspect points A, B and C to understand the successes and failures of
our model in terms of how accurately it mimics pdata.
Point A is an observation that is generated by our model but
does not appear to have been generated by pdata as it’s in the
middle of the sea.
Point B could never have been generated by pmodel as it sits
outside the orange box. Therefore, our model has some gaps in
its ability to produce observations across the entire range of
potential possibilities.
Point C is an observation that could be generated by pmodel and
also by pdata.
Despite it’s shortcomings, the model is easy to sample from, because
it is simply a uniform distribution over the orange box. We can easily
choose a point at random from inside this box, in order to sample
from it.
Also, we can certainly say that our model is a simple representation
of the underlying complex distribution, that captures some of the
underlying high-level features. The true distribution is separated into
areas with lots of land mass (continents) and those with no land
mass (the sea). This is a high-level feature that is also true of our
model, except we have one large continent, rather than many.
This example has demonstrated a very basic example of the
fundamental concepts behind generative modeling. The problems we
will be tackling in this book will be far more complex and high-
dimensional, but the underlying framework through which we
approach the problem will be the same as outlined in “The
Generative Modeling Framework”.
It is worth delving a little deeper into the idea of learning a
representation of high-dimensional data, as it is a topic that will
reoccur throughout this book.

Representation Learning
The core idea behind representation learning is that instead of trying
to model the high-dimensional sample space directly, we should
instead describe each observation in the training set using some low-
dimensional latent space and then learn a mapping function that can
take a point in the latent space and map it to a point in the original
domain. In other words, each point in the latent space is the
representation of some high-dimensional image.
What does this mean in practice? Let’s suppose we have a training
set consisting of grayscale images of biscuit tins (Figure 1-7).

Figure 1-7. The biscuit tin dataset

To us, it is obvious that there are two features that can uniquely
represent each of these tins: the height and width of the tin. Given a
height and width, we could draw the corresponding tin, even if its
image wasn’t in the training set. However, this is not so easy for a
machine—it would first need to establish that height and width are
the two latent space dimensions that best describe this dataset, then
learn the mapping function, f, that can take a point in this space and
map it to a grayscale biscuit tin image. The resulting latent space of
biscuit tins and generation process are shown in Figure 1-8.
Deep learning gives us the ability to learn the often highly complex
mapping function f in a variety of ways. We shall explore some of
the most important techniques in later chapters of this book. For
now, it is enough to understand at a high level what representation
learning is trying to achieve.
One of the advantages of using representation learning is that we
can perform operations within the more manageable latent space
that affect high-level properties of the image. It is not obvious how
to adjust the shading of every single pixel to make a given biscuit tin
image taller. However, in the latent space, it’s simply a case of
adding 1 to the height latent dimension, then applying the mapping
function to return to the image domain. We shall see an explicit
example of this in the next chapter, applied not to biscuit tins but to
faces.
Figure 1-8. The latent space of biscuit tins and the function f that maps a point in
the latent space to the original image domain

Representation learning comes so naturally to us as humans that

you may never have stopped to think just how amazing it is that we
can do it so effortlessly. Suppose you wanted to describe your
appearance to someone who was looking for you in a crowd of
people and didn’t know what you looked like. You wouldn’t start by
stating the color of pixel 1 of your hair, then pixel 2, then pixel 3,
etc. Instead, you would make the reasonable assumption that the
other person has a general idea of what an average human looks
like, then amend this baseline with features that describe groups of
pixels, such as I have very blonde hair or I wear glasses. With no
more than 10 or so of these statements, the person would be able to
map the description back into pixels to generate an image of you in
their head. The image wouldn’t be perfect, but it would be a close
enough likeness to your actual appearance for them to find you
among possibly hundreds of other people, even if they’ve never seen
you before.
Note that representation learning doesn’t just assign values to a
given set of features such as blondeness of hair, height, etc., for
some given image. The power of representation learning is that it
actually learns which features are most important for it to describe
the given observations and how to generate these features from the
raw data. Mathematically speaking, it tries to find the highly
nonlinear manifold on which the data lies and then establish the
dimensions required to fully describe this space. This is shown in
Figure 1-9.
 Figure 1-9. The cube represents the extremely high-dimensional space of all
images; representation learning tries to find the lower-dimensional latent subspace
or manifold on which particular kinds of image lie (for example, the dog manifold)

In summary, representation learning establishes the most relevant

high-level features that describe how groups of pixels are displayed
so that is it likely that any point in the latent space is the
representation of a well-formed image. By tweaking the values of
features in the latent space we can produce novel representations
that, when mapped back to the original image domain, have a much
better chance of looking real than if we’d tried to work directly with
the individual raw pixels.
As generative modeling is so closely connected to statistical
modeling of probability distributions, it now makes sense to
introduce some core probabilistic concepts that will be used
throughout this book to explain the theoretical background of each
model.

Core Probability Theory

Firstly, if you have never studied probability or statistics, don’t worry.
To build and run many of the deep learning models that we shall see
later in this book, it is not essential to have a deep understanding of
statistical theory. However, to gain a full appreciation of the task that
we are trying to tackle, it’s worth trying to build up a solid
understanding of basic probabilistic theory. This way, you will have
the foundations in place to understand the different families of
generative model that we will introduce later in this chapter.
As a first step, we shall define four key terms: sample space, density
function, parametric modeling, and maximum likelihood estimation.
 SAMPLE SPACE
The sample space is the complete set of all values an
observation x can take.
In our previous example, the sample space consists of all points
of latitude and longitude x = (x1, x2) on the world map.
For example, x = (40.7306, –73.9352) is a point in the sample
space (New York City).

PROBABILITY DENSITY FUNCTION

A probability density function (or simply density function), p(x),
is a function that maps a point x in the sample space to a
number between 0 and 1. The sum5 of the density function over
all points in the sample space must equal 1, so that it is a well-
defined probability distribution.6
In the world map example, the density function of our model is 0
outside of the orange box and constant inside of the box.

While there is only one true density function pdata that is assumed to
have generated the observable dataset, there are infinitely many
density functions pmodel that we can use to estimate pdata. In order
to structure our approach to finding a suitable pmodel(X) we can use
a technique known as parametric modeling.
 PARAMETRIC MODELING
A parametric model, pθ (x), is a family of density functions that
can be described using a finite number of parameters, θ.
The family of all possible boxes you could draw on Figure 1-5 is
an example of a parametric model. In this case, there are four
parameters: the coordinates of the bottom-left (θ1, θ2) and top-
right (θ3, θ4) corners of the box.
Thus, each density function pθ (x) in this parametric model (i.e.,
each box) can be uniquely represented by four numbers,
θ = (θ1, θ2, θ3, θ4).
 LIKELIHOOD
The likelihood L (θ ∣ x) of a parameter set θ is a function that
measures the plausibility of θ, given some observed point x.
It is defined as follows:

L (θ|x) = pθ (x)

That is, the likelihood of θ given some observed point x is

defined to be the value of the density function parameterized by
θ, at the point x.
If we have a whole dataset X of independent observations then
we can write:

L (θ|X) = Π pθ (x)
x∈X

Since this product can be quite computationally difficult to work

with, we often use the log-likelihood ℓ instead:

ℓ (θ|X) = Σ log pθ (x)

x∈X

There are statistical reasons why the likelihood is defined in this

way, but it is enough for us to understand why, intuitively, this
makes sense. We are simply defining the likelihood of a set of
parameters θ to be equal to the probability of seeing the data
under the model parameterized by θ.
In the world map example, an orange box that only covered the
left half of the map would have a likelihood of 0—it couldn’t
possibly have generated the dataset as we have observed points
in the right half of the map. The orange box in Figure 1-5 has a
 positive likelihood as the density function is positive for all data
points under this model.

It therefore makes intuitive sense that the focus of parametric

modeling should be to find the optimal value θ̂ of the parameter set
that maximizes the likelihood of observing the dataset X. This
technique is quite appropriately called maximum likelihood
estimation.

MAXIMUM LIKELIHOOD ESTIMATION

Maximum likelihood estimation is the technique that allows us to
estimate θˆ—the set of parameters θ of a density function, pθ (x)

, that are most likely to explain some observed data X.

More formally:

ˆ
θ =argmax L (θ|X)
θ

ˆ
θ is also called the maximum likelihood estimate (MLE).

We now have all the necessary terminology to start describing the

different families of generative model.

Families of Generative Model

Whilst all generative models ultimately aim to solve the same task,
they all take slightly different approaches to the problem. The
challenge faced by all generative models is simple to express - how
can the model learn an accurate representation p(x) of the true
distribution, when there is so much conditional dependence between
the input features? Moreover, p(x) must be able to be sampled from
- which also adds a great deal of complexity, because the true
distribution is almost always highly complex and so cannot be
accurately described using simple distributions.
We can group generative modeling approaches into five main
families:
Variational Autoencoders
Generative Adversarial Networks
Autoregressive Models
Flow-based Models
Energy-based Models

Generative Model Families

In this section, we will give a brief overview of each family. Note that
these families are not mutually exclusive - there are many examples
of models that are a hybrid between two different kinds of approach
- for example, VAE-GAN (https://arxiv.org/abs/2006.12226). You
should think of the families as different general approaches to
generative model, rather than explicit model architectures.

Variational Autoencoders
Short summary to be completed after other chapters are
completed.

Generative Adversarial Networks

Short summary to be completed after other chapters are
completed.

Autoregressive Models
Short summary to be completed after other chapters are
completed.
Flow-based Models
Short summary to be completed after other chapters are
completed.

Energy-based Models
Short summary to be completed after other chapters are
completed.

Generative Model Taxonomy

Now that we have explored a high-level description of each model
family, it is also useful to start seeing some of the similarities and
difference between the approaches and grouping them into a
taxonomy. This is shown in Figure 1-10.
 Figure 1-10. A taxonomy of generative modelling approaches

The first split that we can make is between models where the
probability density p(x) is explicit and those where it is implicit.
Implicit models do not aim to estimate the probability distribution at
all, but instead focus solely on producing a stochastic procedure
which directly generates data. The best know example of implicit
generative models are are Generative Adversarial Networks.
We can further split explicit density models into those that directly
optimise the probability density (tractable models) and those that
only optimise an approximation of it approximate. Tractable
models place constraints on the model architecture, rather than
approximating the distribution to be optimised.
For example autoregressive models place a ordering on the input
features, so that the output can be generated sequentially - e.g.
word by word, or pixel by pixel. Flow based models achieve
tractability by applying a series of invertible functions to a simple
distribution, in order to generate more complex distributions.
Conversely, approximate density models include variational
autoencoders, which optimise an approximation of the probability
distribution by introducing a latent variable. Some energy based
models (e.g. Boltzman machines) also utilize approximate methods,
but do some via Markov Chain sampling, rather than variational
methods.
A common thread that runs through all of the generative model
families types is learning a parametric function that can learn
sufficiently complex relationships between the input parameters, or
transform a simple distribution such as a multivariate normal
distribution into a complex distribution over images. Deep Learning
is the tool that provides this capability. Almost all sophisticated
generative models have a deep learning model at their core, because
they are extremely good at learning complex relationships between
input parameters and can be trained from scratch, using a training
set of data, rather than hard-coded with information a priori.
We shall introduce deep learning in Chapter 2, with practical
examples. In the following section, we will get ourselves set up to
start building concrete examples of deep learning models, by
introducing the codebase that accompanies this book and setting up
your development environment.

Setting Up Your Environment

Throughout this book, there are many worked examples of how to
build the models that we will be discussing in the text.
To get access to these examples, you’ll need to clone the Git
repository that accompanies this book. Git is an open source version
control system and will allow you to copy the code locally so that
you can run the notebooks on your own machine, or in a cloud-
based environment. You may already have this installed, but if not,
follow the instructions relevant to your operating system.
To clone the repository for this book, navigate to the folder where
you would like to store the files and type the following into your
terminal:
Example 1-1. Cloning the repository
git clone https://github.com/davidADSP/GDL_code.git

Always make sure that you have the most up-to-date version of the
codebase by running the following command:
Example 1-2. Pulling the repository
git pull

You should now be able to see the files in a folder on your machine.
Docker
The codebase for this book is intended to be used with Docker - a
free containerisation technology that makes getting started with a
new codebase extremely easy, regardless of your architecture or
operating system. If you have never used Docker, don’t worry. In
this section, we will explain the reason for using this technology and
how to get started.
First you will need to download Docker Desktop for free from
https://www.docker.com/products/docker-desktop/.

Why is Docker useful?

A common problem you may have faced when using other people’s
code is that it simply doesn’t run on your machine. This can be
especially frustrating, especially when it runs just fine on the
developer’s machine and they cannot help you with specific bugs
that occur when deploying onto your operating system.
There are two reasons why this might be the case:
1. The underlying Python version or packages that you have
installed are not identical to the ones that were used during
development of the codebase
2. There are fundamental differences between your operating
system and the developer’s operating system that mean that the
code does not run in the same way.
The first of these problems can be mostly solved by using virtual
environments. The idea here is that you create an environment for
each project that contains the required Python interpreter and
specific required packages and is separated from all other projects
on your machine. For example, you could have one project running
Python 3.8 with Tensorflow 2.10 and another running Python 3.7
with Tensorflow 1.15. Both versions of Python and Tensorflow would
exist on your machine, but within isolated environments so they
cannot conflict with each other.
Anaconda and Virtualenv are two popular ways to create virtual
environments. Typically, codebases are shipped with a
requirements.txt file that contains the specific Python package
versions that you need to run the codebase.
However, solely using virtual environments does not solve the
second problem - how can you ensure that your operating system is
set up in the same way as the developer’s? For example, the code
may have been developed on a Windows machine, but you have a
Mac and the errors you are seeing are specific to macOS. Or perhaps
the codebase manipulates the filesystem using scripts written in
bash, which you do not have on your machine.
Docker solves this problem. Instead of specifying only the required
Python packages, the developer specifies a recipe to build what is
known as an image, which contains everything required to run the
app, including an operating system and all dependencies. The recipe
is called the Dockerfile - it is a bit like the requirements.txt
files, but for the entire runtime environment rather than just the
Python packages.
Let’s first take a look at the Dockerfile for the Generative Deep
Learning codebase and see how it contains all the information
required to build the image.

The Dockerfile
In the codebase that you pulled from GitHub, there is a file simply
called Dockerfile. This is the recipe that Docker will use to build the
image and is shown in Example 1-3. We’ll walk through line by line,
explaining what each step does.
Example 1-3. The Dockerfile
FROM tensorflow/tensorflow
RUN apt-get update
RUN apt-get install -y unzip graphviz
RUN pip install --upgrade pip
WORKDIR /app
COPY ./requirements.txt /app
RUN pip install -r /app/requirements.txt
COPY /models/. /app/models
COPY /utils/. /app/utils
COPY /notebooks/. /app/notebooks
COPY /scripts/. /app/scripts
COPY /setup.cfg /app
ENV PYTHONPATH="${PYTHONPATH}:/app"
The first line defines the base image. Our base image is an
Ubuntu 18.04 (Linux) operating system, with Tensorflow 2
preinstalled. This is pulled from DockerHub - the online store of
publicly available images
(https://hub.docker.com/r/tensorflow/tensorflow/)
.
Update apt-get, the Linux package manager and install
relevant packages
Upgrade pip the Python package manager
Change the working directory to /app.
Copy the requirements.txt file into the image and use pip
to install all relevant Python packages
Copy relevant folders into the image
Update the PYTHONPATH so that we can import functions that
we write from our /app directory

You can see how the Dockerfile can be thought of as a recipe for
building a particular run-time environment. The magic of Docker is
that you do not need to worry about installing a resource intensive
virtual machine on your computer - Docker is incredible lightweight
and allows you to build an environment template purely using code.
A running version of an image is called a container. You can think
of the image as like a cookie cutter, that can be used to create a
particular cookie (the container). There is one other file that we
need to look at before we finally get to build our image and run the
container - the docker-compose.yaml file.

The docker-compose.yaml file

Docker Compose is an extension to Docker that allows you to define
how you would like your containers to run, through a simple YAML
file, called docker-compose.yaml.
For example, you can specify which ports and folders should be
mapped between your machine and the container. Folder mapping
allows the container to treat folders on your machine as if they were
folders inside the container. Therefore any changes you make to
mapped files and folders on your machine will be immediately
reflected inside the container. Port mapping will forward any traffic
on a local port through to the container. For example, we could map
port 8888 on your local machine to port 8888 in the container, so
that if you visit localhost:8888 in your browser, you will see
Jupyter, which is running on port 8888 inside the container. The
ports do not have have to be the same - for example you could map
port 8000 to port 8888 in the container if you wanted.
The alternative to using Docker Compose is specify all of these
parameters in the command line when using the docker run
command. However, this is cumbersome and it is much easier to just
use a Docker Compose YAML file. Docker Compose also gives you
the ability to specify multiple services that should be run at the same
time (for example, a application container and a database), and how
they should talk to eachother. However, our purposes, we only need
a single service - the container that runs Jupyter, so that we can
interact with the generative deep learning codebase.
Let’s now take a look at the Docker Compose YAML file in
Example 1-4.
Example 1-4. The docker-compose.yaml file
version: '3'
services:
app:
build:
context: .
dockerfile: Dockerfile
tty: true
volumes:
- ./data/:/app/data
- ./models/:/app/models
- ./utils/:/app/utils
- ./notebooks/:/app/notebooks
- ./run/:/app/run
- ./scripts/:/app/scripts
ports:
- "$JUPYTER_PORT:$JUPYTER_PORT"
- "$TENSORBOARD_PORT:$TENSORBOARD_PORT"
env_file:
- ./.env
entrypoint: jupyter lab --ip 0.0.0.0 --port=$JUPYTER_PORT
--no-browser --allow-root
This specifies the version of Docker Compose to use (currently
version 3)
Here, we specify the services we wish to launch
We only have one service, which we call app
Here, we tell Docker where to find the Dockerfile (the same
directory as the docker-compose.yaml file)
This allows us to open up an interactive command line inside the
container, if we wish
Here, we map folders on our local machine (e.g. ./data), to
folders inside the container (e.g. /app/data).
Here, we specify the port mappings - the dollar sign means that
it will use the ports as specified in the .env file (e.g.
JUPYTER_PORT=8888)
The location of the .env file on your local machine.
The command that should be run when the container runs -
here, we run JupyterLab.
Building the image and running the container
We’re now at a point where we have everything we need to build
our image and run the container. Building the image is simply a case
of running the command shown in Example 1-5 in your terminal,
from the folder where your docker-compose.yml is located.
Example 1-5. Building the image
docker compose build

You should see Docker start to run through the steps in the
Dockerfile as shown in Figure 1-11. You can use the command
docker images to see a list of the images that have been built on
your machine.

Figure 1-11. Building the Docker image

Then, to run the container based on the image we have just created,
we use the command shown in Example 1-6.
Example 1-6. Running the container
docker compose up
You should see that Docker launches the Jupyter notebook server
within the container and provides you with a URL to the running
server, as shown in Figure 1-12.

Figure 1-12. Running the container

Because we have mapped port 8888 in the container to port 8888 on

your machine, you can simply navigate to the address starting
http://127.0.0.1:8888/lab?token= into a web browser and
you should see the running Jupyter server. The folders that we
mapped across in the docker-compose.yaml file should be visible
on the left hand side, as shown in Figure 1-13.
 Figure 1-13. the Jupyter server

Congratulations! You now have a functioning Docker container that

you can use to start working through the Generative Deep Learning
codebase! To stop running the Jupyter server, you use Ctrl-C and
to bring down the running container, you use the command docker
compose down. Because the volumes are mapped, you won’t lose
any of your work that you save whilst working in the Jupyter
notebooks, even if you bring the container down.
As a recap, Figure 1-14 shows the connections between the
codebase, the image and the container.

Figure 1-14. A diagram showing how we can use Docker to build an image and
bring up a container that runs a specific image.

Using a GPU
The default Dockerfile and docker-compose.yaml file assume
that you do not want to use a local GPU to train your models. If you
do have a GPU that you wish to use, I have provided two extra files
called Dockerfile-gpu and docker-compose-gpu.yaml files
that can be used in place of the default files.
Discovering Diverse Content Through
Random Scribd Documents
 Rápolt (fanyarul): Ágnes, jegyezze meg magának, hogy egy nő
sohasem szennyes. Csak a férfiak, akikkel érintkezik.
Ágnes: Hát ne érintkezzék velük. És különben: maga az, aki…
Ezzel itt maga érintkezik…
Rápolt (felelni akar).
Ágnes: Köszönöm; elég. Ne beszéljünk többet róla.
Rápolt: Helyes. Maga olyan fenséges lett Ágnes, hogy mi igazán
nem értjük már egymást.
Ágnes (lassan): És én nagyon örülök neki, hogy nem értjük többé
egymást.
Rápolt: Jaj! Irgalom! Tudja mit, Ágnes, inkább igaza van. Inkább
magának ajándékozom az egész ügyet, Lizit, a szomoruságát, az
embervoltát, a szenvedő, finom asszony voltát, mindent.
Ágnes (magánkivül): Nem. Hát látja, ez az a mi tűrhetetlen
magában. Ne adja föl ilyen könnyen a meggyőződéseit és… az
embereit. Ragaszkodjék hozzájuk.
Rápolt (legyint; ránéz, lassan): Nem érdemes, Ágnes.
(Kürtszó.)
Ágnes: Istenem… most oda kellene menni a gyülekezéshez… ha
már a menetben nem veszek részt, legalább jelentkeznem kellene az
elnöknőnél.
Zólyomy: Hát jelentkezzék, Ágnes.
Ágnes: De, hogy menjek oda? Neki vágjak annak a tömegnek
ott? És mit csináljak a sátorral addig?
Zólyomy: Én elkísérem. A tömeget kikerűljük, vagy átvágunk
rajta. Ne féljen tőle: én magával leszek.
Ágnes: Jó… De a sátor?
 Zólyomy: Andor itt marad.
Ágnes: Itt marad?
Rápolt: Itt.
Ágnes: Nem lesz kellemetlen egyedűl maradnia itt?
Rápolt: Ellenkezőleg; egész életem legfőbb óhajtása és egyetlen
programmja: bevenni magamat egy rokoko-sátorba, ki nem
mozdulni belőle, onnan nézni, hogy az emberek ide-oda futkosnak és
komolyan veszik magukat.
Ágnes (mosolyogva, de halk komolysággal): Hát akkor vegye be
magát a rokoko sátorba és nézze, amint mi komolyan vesszük
magunkat… Jőjjön Kálmán. (Zólyomyval, aki úgyszólván vezeti,
elmegy jobb felé.) Siessünk… elkésünk…
Rápolt (utánuk néz; nagyon komolyan fütyürész; azután bemegy
a sátorba; félig lefekszik a kerti kanapéra, amely bent van;
cigarettára gyújt).

HETEDIK JELENET.

Rápolt, Lizi.
Lizi (belopózik; nagyon óvatosan jön; nyilvánvaló, hogy
leselkedett, a távozó Ágnes és Zólyomy után néz, nem fordulnak-e
vissza. Folyton őket figyelve keresi Rápoltot).
Rápolt (hevertében észreveszi; csodálkozik és mulat rajta, azután
rászól): Lizi!
Lizi (megrettenve áll meg).
Rápolt: Gyere ide, Lizi.
 Lizi (a szívére szorítja a kezét): Istenem, de megijedtem… (szinte
didereg). Istenem, istenem!…
Rápolt: Gyere ide Lizi és tudod mit… most mondd el nekem
szépen a történetedet.
Lizi: Nem megyek kérem. Hanem legyen olyan szíves, jőjjön ki
abból a sátorból.
Rápolt: Dehogy megyek. Örülök, hogy benne vagyok. Én soha
többé, Lizi, ebből a sátorból ki nem jövök.
Lizi: De nagyon szépen kérem…
Rápolt: Gyere te ide…
Lizi: Én oda nem mehetek.
Rápolt:… és mondd el nekem végre a történetedet. Szükségem
van rá… legjobbkor jönne… embersorsokon gondolkoztam… mondd
el már, Lizi… Az isten áldjon meg, hiszen én még azt sem kívánom,
hogy igazat mondj… De az csak nevetséges, hogy még csak hazudni
sem akarsz… Gyere szépen… Mondd, hogy az apád becsületben
megőszült ezredes volt… anyád báróné… jött egy gróf és a gróf
házasságot igért…
Lizi: (kétségbeesve): Kérem szépen… ne tréfáljon most… jöjjön
ki… nagyon kell sietni…
Rápolt: Miért kell, Lizi?
Lizi: Mert nem szabad, hogy magát én velem meglássák.
(Állandóan jobb felé figyel és mindig újra eltávolodik jobb felé.)
Rápolt: Félsz, hogy kompromittállak? (Kétségbeesett mozdulat.)
Vagy hogy te kompromittálsz engem? (Igenlés.) Attól ne tarts Lizi…
Nem lehet már engem. – (Hirtelen.) Te! Én úgy látom, te már megint
meg akarod magadat ölni.
Lizi (zavarodottan): Én…
 Rápolt: Mit hurcolsz már megint magaddal? Tőrt? Revolvert?
Mérget? – Mérget, mi? Ezúttal mérget. Hol van? Mutasd.
(Parancsolóan.) Mutasd! (Kis üveget vesz át.) Hol vetted ezt?
Lizi (lesütött szemmel, halkan): Elhoztam a patikából. A
patikussegédtől.
Rápolt: „Elhoztam.“ (A lopás mozdulatát mutatja.) Hányszor
mondtam neked Lizi, hogy a te… hm… foglalkozásodnak az a legfőbb
veszedelme, hogy az ember erkölcsi fogalmait… más téren is
megigazítja… Lopni nem szabad.
Lizi (remegve): Én… én…
Rápolt: Azt hitted, hogy jogot ad az elhozására az, hogy meg
akarod vele mérgezni magadat!
Lizi (nagyon halkan): Igen.
Rápolt: Vidd vissza. Annyival inkább, mert tudod mi ez?
Lizi: Méreg.
Rápolt: Strichnin. Ezzel fiam meg ne mérgezd magadat, mert ez
keservesen fáj. Irtózatos görcsök. Akkor már inkább a ciánkáli: az
gyorsan végez. – Vidd vissza, Lizi. (Visszaadja neki.)
Lizi: Visszaviszem.
Rápolt: No jó… Isten áldjon meg, Lizi. De ha nem mérgezed meg
magadat, gyere el hozzám, kapsz egy szép könyvet… Odaadom azt a
könyvet, amelyben valaki letérdel egy… olyan lány elé, mint te vagy
és azt mondja neki: „Nem te vagy ez, hanem az emberiség egész
nyomorúsága az, amely elé letérdelek“, – megmutatom neked a
Dűrer-kötetet és a Holbein-rajzokat… vagy eljátszom neked valamit a
zongorán… vagy holdfotografiákat mutatok… vagy gyönyörű
mikroszkopiai felvételeket… szóval a leggyönyörűbb jutalmakra van
kilátásod. No, szervusz, Lizi.
 Lizi (kétségbeesve): De hiszen én… mondani akartam valamit…
Kérem, kérem szépen: jőjjön már ki a sátorból: én nem mehetek be
oda.
Rápolt (kijön): Mondani akartál valamit… No mi az Lizi? mit
akartál mondani?
Lizi (mély lélekzetet vesz): Tudja kérem… tudja-e… hogy mit akar
Zólyomy?…
Rápolt (csodálkozva): Hogy mit akar… Hát mit akar, Lizi?
Lizi: El akarja venni… a Radics Ágnes kisasszonyt.
Rápolt: Jól teszi, Lizi, ha akarja. Igaza van.
Lizi: De még ma el akarja jegyezni. Holnap már ki is akarja iratni
az ujságba, hogy eljegyezte.
Rápolt: Lehet, Lizi. Kitünően vagy értesűlve.
Lizi: De még ma el akarja jegyezni.
Rápolt: No… és…
Lizi (magánkívül, halkan): De hát kérem… ne engedje ezt… a jó
isten szerelmére, hát ne engedje ezt.
Rápolt: Lizi, te egészen fantasztikus vagy. Hogy kerülsz te ahhoz,
hogy… És hogy ne engedjem én ezt? Zsák a foltját. Jancsi Julcsát!…
Hogy ne engedjem én ezt?
Lizi: Ne engedje. Ne engedje.
Rápolt: A mindenségét, mért ne engedjem Lizi?
Lizi (egészen halkan, nagyon szemrehányóan): Hiszen szereti.
Rápolt: Ki?
Lizi: Maga.
 Rápolt: Kit?
Lizi: A Radics Ágnes kisasszonyt.
Rápolt (a lefojtott nyugtalansága most egy másodpercre
fölszabadul és a lélekzete akadozik tőle): Lizi… Lizi… ez óriási…
micsoda kábult dolgokat fecsegsz te itt össze…
Lizi (egészen felsőbbségesen, de szerényen, szinte fájdalmasan):
Ne tagadja. Hiszen szereti. Hiszen beteg tőle, úgy szereti…
Rápolt: Hát… (Ellent akar mondani; levegő után kapkod, azután
elfordul, rövid küzdelem után abbahagyja a tagadást. A rendes
hangján, csak halk izgatottsággal:) Hát lehet. De ha úgyis volna, Lizi,
mit erőlködjem… hiába volna.
Lizi (nagyon komolyan, mély lélegzettel): De hiszen… ő is szereti
magát.
Rápolt (bosszúsan): Lizi!…
Lizi (kétségbeesve): Ő is szereti magát.
Rápolt (izgatottan): Lizi ne beszélj bolondokat.
Lizi (kétségbeesve): Ő is szereti magát.
Rápolt: Részeg vagy. Menj.
Lizi: Ő is…
Rápolt: Hol álmodtál ilyen bolondokat. Eredj.
Lizi (egészen odamegy hozzá): Amikor maga másfél évvel ezelőtt
hirtelen elutazott, akkor hetekig ki volt sírva a szeme. Egész
éjszakákat átsírt. Utána akart magának menni. Majdnem belehalt.
Rápolt (rábámul; fölindultan dadogva): Hon… nan tudod te ezt,
Lizi?
 Lizi: Tudom. Tudjuk mi az ilyesmit, ha akarjuk. Cselédektől…
másoktól… egyik kávéházban ma éjjel ezt hallja az ember, másik
kávéházban holnap azt…
Rápolt (kellemetlenül érinti a kávéházak emlegetése): Úgy…
egyik kávéházban ma éjjel ezt… másikban holnap azt… (Fanyarul,
nyugodtan:) Na… köszönöm, Lizi… ezeket a kávéházi értesüléseket.
Nagyon kedves vagy. És én… (habozik) én majd talán… (Hirtelen:)
Eh, nem!
Lizi: Mit nem? Miért nem?
Rápolt (csúfolódva): Nem! Hiszen tudod Lizi: én azt akarom,
hogy engem kérjen meg az a nő, aki engem akar… Ő fáradozzék én
értem… (Komolyabban:) Vagy legalább tegyen ő is valamit.
Lizi (megint kétségbeesve): De nem, nem… azt csak mi tesszük,
hogy…
Rápolt: Mit?
Lizi: Hogy megmutatjuk… Hogy fáradozunk. Úrilányok azt nem
teszik.
Rápolt: Ne mondd! – Nem lehet belőletek kiirtani ezt a furcsa
véleményt az úrilányokról… ezt a nagy tiszteletet… És ezt a
romantikus hajlandóságot… Te valószínüleg azt kívánod tőlem, hogy
álljak oda elébe, mint Romeó… Csak nem fogok neki forrón
szerelmet vallani?
Lizi: De igen. Azt kell.
Rápolt: Borúljak térdre előtte!
Lizi: Igen. Azt kell.
Rápolt: Bolond vagy, Lizi… Egy ilyen okos lánynak nem kell az.
Lizi: Minden lánynak az kell.

É
 Rápolt: Bolond vagy, Lizi. (Fanyarúl:) Én nem csinálok ilyen
dolgokat. Én nem esedezem, én nem epedezem, nem viaskodom…
Lizi: De hiszen akkor elviszi Zólyomy. Ne engedje, a jó isten
szerelmére. Ne engedje… Csak annyit tegyen meg, csak azt próbálja
meg: fogja meg a kezét; ölelje meg; és csókolja meg. Akár egy szót
se szóljon.
Rápolt: Bolond vagy, Lizi.
Lizi: Csak ezt az egyet tegye meg, ezt csak megpróbálhatja.
Ennyit csak érdemes megpróbálni. Igérje meg, hogy ezt megteszi.
Rápolt: Lizi, igazán részeg vagy.
Lizi: Igérje meg. (Jobbra tekint.) Nézze már jön… egyedül van…
most megteheti… igérje meg…
Rápolt: Eredj, Lizi.
Lizi: Addig nem megyek, míg meg nem igéri.
Rápolt: Eredj már… Hát megigérem.
Lizi (elsiet bal felé; intően, halkan): Megigérte!
Rápolt (mosolyogva, bosszankodva bólint).
Lizi (eltünt).
Rápolt (jobbfelé fordul).

NYOLCADIK JELENET.

Rápolt, Ágnes.
(Sötétedik. Lampiónok gyúlnak ki. Zene hallatszik.)

Á
 Ágnes (lassan jön. Zavarja, hogy egyedül van Rápolttal).
Rápolt (nagy zavarban van): Visszajött, Ágnes?
Ágnes: Vissza.
Rápolt: Kálmán hol maradt?
Ágnes: Az útig elkísért… Lerója a kötelezettségeit a hölgyeknél,
hogy azután majd maga mehessen… leróni a kötelezettségeit.
Rápolt: Nem fogok sietni. Nem igen vannak kötelezettségeim.
Ágnes (tesz-vesz, hogy ne kelljen ránéznie): Az elnöknő
kérdezősködött maga után.
Rápolt: Az elnöknő… Oh, az elnöknőt különösen kedvelem.
„Rembrandt“ mondtam neki tegnap, – „Hja, az, aki Amerikában él,
ugy-e“ – kérdezte kedvesen. „Nem“, – mondom én, – „hanem az
(súgva, mintha egy titkot mondana), aki az Eroikát írta!“ „Hja, –
mondja ő, – amelyiket Drezdában játszottak.“ Uh!
Ágnes: Miért él itt közöttük? Menne el…
Rápolt: Éppen ezért maradok itt. Jobbomon Beethoven, balomon
Bach… Rembrandt és Michelangelo… hallatlan és csodálatos titkaim
vannak… közöttük olyan erős vagyok, mint egy Isten.
Ágnes (vállvonogatva, halkan): Csalás.
Rápolt: Lehet. (Szünet. Zavarodottság.)
Ágnes: Én most… bemegyek a sátorba… Kirakom a holmimat.
Rápolt (hirtelen): Várjon még,
Ágnes: Miért?
Rápolt: Csak… ráér… Ugy-e? (Szünet.) Sok arra az ember?
Ágnes: Nagyon sok.
 Rápolt: Különösen a kapu körül… ugy-e?
Ágnes: Igen… különösen a kapu körül… ott nagyon sok.
Rápolt: Ott van… a legtöbb sátor is. (Közeledik hozzá.)
Ágnes: Ott. (Szünet.) Ni… már a lampionokat is meggyújtják.
Rápolt: Az ám. Sorra kigyullad mind. (Mellette van.) Milyen cifrák.
Ágnes (nagy zavarban): Nemsokára megindul a körmenet is.
Rápolt: Meg? Hiszen még nincs hét óra.
Ágnes: Dehogy nincs, el is múlt.
Rápolt: Igazán? Persze, el is múlt már… hiszen már sötétedik…
nézze meg az ember…
Ágnes: Oh… ni csakugyan… már csakugyan egészen sötét van…
De milyen sötét van… Most még korán sötétedik…
Rápolt: Még… korán… (Két-három bátortalan nekifutamodás
után, hirtelen megfogja a kezét.)
Ágnes (megdermedve néz rá).
Rápolt (nem ereszti el a kezét; magához húzza; átkarolja és
lassan ajkon csókolja).
Ágnes (engedi; félig ájultan, reszkető fölindulásban tűri el a
hosszu csókját; azután remegve és dadogva, álmélkodva és
megdöbbenve mondja): Andor… maga…? maga…? (Szünet. Rápolt
mozdulatlanul áll.) Hát maga engem…?
Rápolt (szégyenkezve, de boldogan, zavartan int igent).
(Szünet.)
Ágnes (szinte kiáltva): Maga szeret engem?
 Rápolt (szégyenkezve): Nagyon. (Fölemelt fejjel, hangosan.)
Nagyon.
Ágnes (reszketve, dadogva): Maga… És… és mit akar tőlem…?
Rápolt: Én? (Természetesen, a rendes hangján.) Semmit. Csak
szeretem.
Ágnes: Azt… azt sem akarja, hogy én szeressem?
Rápolt: De… oh, azt igen.
Ágnes: Én… (csüggedten:) nem hiszem… hogy szeret engem…
Nem lehet… Nem merem… Sohasem fogom merni…
Rápolt (gyöngéden): Ágnes…
Ágnes (hátralép, elhárítja; összeszedi magát): Mondja meg akkor
most nekem, Andor, hogy… hogy másfél évvel ezelőtt miért utazott
el… egyetlen szó nélkül… egy olyan nap után, amelyet együtt
töltöttünk…
Rápolt (kínosan): Nem, nem, kérem Ágnes. Azt ne kivánja tőlem;
minek az?
Ágnes: Kivánom. Anélkül lehetetlen nekem… csak eltürnöm is a
közellétét.
Rápolt: Kérem, Ágnes, ne…!
Ágnes: Akkor menjen.
Rápolt (könyörögve): Nem… Ágnes… (Más hangon.) Hát jó. Hát
nézze Ágnes, én aznap este, amikor magával együtt voltam…
(szégyenkező és dacos a hangja) találkoztam Kollerrel a
doktorukkal… És ő akkor megmondta nekem, hogy… a maga
édesanyja menthetetlen… egy hónapja van… Azt mondta: énnekem
mondja meg, én erős férfi vagyok, én legyek erős, én álljak
(gúnyosan) a maga oldalán… Az átkozott barom: hogy én erős férfi
vagyok és én nem szorulok kíméletre…
Á É
 Ágnes (nagy szemmel): És?
Rápolt: És én úgy félek a haláltól… úgy rettegek mindattól, ami
vele jár, az előkészületektől, a búcsúzkodástól, a hosszu hetektől,
amelyek alatt várni kell rá, azután a siratástól, a temetéstől, annyira
nem bírom el, annyira tiltakozik ellene bennem minden, úgy
megbénít… én úgy nem tudok hősies lenni, vigasztalni, rendelkezni,
előkészíteni, temetést megrendelni, annyira nem tudok gyászt
mutatni, ha meg is vagyok semmisülve, olyan ferde, hazug és
ügyetlen minden mozdulatom, hogy én… hiába szerettem magát…
és az édesanyját is… én azt a gondolatot, hogy mindez rám vár, nem
bírtam ki. (Aggódva néz Ágnesre.)
Ágnes (halkan, lassan, nagy lélegzettel): Hát ezért?
Rápolt: Ezért.
Ágnes: Ezért hagyott itt. Itt tudott hagyni.
Rápolt: Itt hagytam azzal, hogy majd visszajövök magáért.
(Szünet.) Haragszik rám?
Ágnes (nemet int. Szünet): Gyáva volt, Andor. (Szünet; más
hangon, a kezét a fejére szorítva.) De most legalább értem!
(Halkabban:) Most legalább tudom, hogy azért mégis…
Rápolt: Hogy szerettem.
Ágnes: Nagyon rossz dolog volt, Andor. Nagyon veszedelmes.
Rápolt: Ágnes… én úgy bíztam magában…
Ágnes: Nagyon rosszul tette.
Rápolt: Eh, Ágnes… maga nem olyan, mint más lányok…
Ágnes: Olyan vagyok.
Rápolt: Nem olyan… Megérti… és… tudja… és… (Közeledik
feléje.) Hideg volt az ajka, mint a jég.

Á
 Ágnes (védekezik): Nem, nem.
Rápolt: Hideg volt és remegett…
Ágnes: Nem, nem… kérem… (Hirtelen.) Vigyázzon. Jön Zólyomy.
(Mindketten megrettennek. Merev várakozás.)

KILENCEDIK JELENET.

Voltak, Zólyomy.
Zólyomy: Itt vagyok. Mindent elintéztem.
Ágnes (nem néz a szemébe): Lerótta… minden kötelezettségét?
Zólyomy: Mindent. Kötelesség nincs több, csak öröm és élvezet:
itt maradni.
(Szünet. Zavarodottság.)
Zólyomy: Hát itt mi az ujság?
Ágnes: Itt… semmi…
Zólyomy: Forgalom?
Ágnes: Semmi.
Zólyomy: Ugy látszik Andornak igaza lesz.
Ágnes: Igen.
Rápolt: Igen… úgy látszik…
(Szünet.)
Zólyomy: Mindjárt indul a menet.
 (Senki sem válaszol.)
Zólyomy: Andor, nem akarod megnézni?
Rápolt: Hm… nem tudom…
Zólyomy: Menj, nézd meg. A nők ugyis keresnek már…
Rápolt: Ke… keresnek? Akkor…
Zólyomy: Igen. Járd sorra őket. Eredj.
Rápolt: Hát… én… én… igen… (habozik indulni készül; Ágnesre
néz.)
Ágnes (felindultan, halkan): Hm… Ne menjen Andor.
Zólyomy: Engedje csak: hadd rójja le a kötelezettségeit.
Ágnes (küzd magával; nem mer szembeszállni vele; másképpen
védekezik: kacérságot játszik): Én… én azt akarom… hogy… azt
akarom, hogy más nővel szemben ne legyen kötelezettsége. Csak
velem szemben.
Rápolt és Ágnes (jobbfelé néznek).
Zólyomy (összevont szemöldökkel nézi őket).
Zólyomy (csodálkozva néz rá; odamegy hozzá, halkan): Én azt
szeretném, Ágnes… ha elmenne.
Ágnes (remegve mosolyog): Én nem…
Zólyomy (minden halk energiájával): Én azt akarom, hogy
elmenjen.
Ágnes (remegve néz vele farkasszemet): Én pedig nem akarom.
(Hosszú szünet.)
Ágnes (reszketve, igyekszik elfogulatlan lenni): Nézze… Andor…
már indul a menet.
Rápolt: Az ám… Csakugyan. Indul a menet.
(Zene harsan fel.)
– Függöny. –
 MÁSODIK FELVONÁS

Rápolt lakása. Nagy szoba, amelyet műteremnek lehetne tartani, ha

a hátsó – utcára nyíló – ablakai nagyobbak volnának. Teljes
kényelem; angol bútorok, de egy ekzótikus vonás az egészen; valami
tarkaság, amelyet a lakás ura, az úri szürkeségbe mindenütt belevitt.
Zongora. Balra ajtó az előszobába. Jobbra függönyös ajtó a lakás
másik két szobájába.

ELSŐ JELENET.

Inas, Lizi; majd Inas, Rápolt.

(A telefon hosszasan cseng. A telefon szavára a jobboldali ajtón
átsétál az inas, odamegy a telefonhoz és hanyagul a kezébe veszi a
kagylót.)
Az inas: Halló… tessék… itt Rápolt nagyságos úr lakása. – Az
inas. – A nagyságos úr? – Nem, nincs itthon. – De igen; hazajön,
talán mindjárt itt is lesz, nyolc óra elmúlt, ilyentájban mindig
hazajön. (Idegesen:) Hogy… mit mondjak, kérem? Hogy ide tetszik
jönni? – De kicsoda, ki, ki, ki?… (Az utolsó szavakat már kiabálta;
most nyugodtabban, de még mindig a készülékbe:) De hát most mit
mondjak neki… (Vállvonogatva leteszi a kagylót.) Nem mondja meg,
hogy ki beszélt… (Az íróasztalhoz megy, elvesz egy szivart; rágyújt.
Az előszoba felől zajt hall; háta mögé dugja a szivart, de nem nagy
ijedelemmel.)
 Lizi (balról jön, felindultan, magánkívül, mintha nem volna
eszméletnél, nagyon halkan): Itthon van már a nagyságos úr?
Az inas: Nincs, kisasszony. De mindjárt itt lehet.
Lizi: Igen. Akkor…
Az inas: Tessék megvárni.
Lizi: Nem… akkor előbb hazamegyek; azután majd visszajövök.
Mondja meg, kérem, legyen olyan szíves.
Az inas: Igenis… de hát, – nem a kisasszony telefonozott már
egyszer?
Lizi: Nem… én majd visszajövök… (Elmegy.)
Az inas: Nem a kis… (Lizi elment.) Nem ő telefonozott? Hát ki a
csuda lehetett… (Ujra meggyújtja a szivarját és dünnyögve
szivogatja, amikor az előszoba felől ismét zaj hallatszik úgy, hogy a
szivart bosszankodva ismét el kell rejtenie.)
Rápolt (szórakozott, elgondolkozó, szinte szomorú): Jó estét.
Az inas: Jó estét kívánok, nagyságos úr.
Rápolt: Volt itt valaki?
Az inas: A Lizi kisasszony volt itt. Éppen most ment el.
Rápolt: Innen ment el? Mi baja volt, hogy úgy szaladt?
Az inas: Nem tudom kérem… csak azt mondta, hogy visszajön
majd.
Rápolt: Úgy? Nem hiszem, hogy itthon maradok. A kapitány úr
nem volt itt?
Az inas: Nem, nagyságos úr.
Rápolt: Levél?
 Az inas: Nincs, nagyságos úr.
Rápolt: Jó. Elmehetsz.
Az inas: De valami telefonüzenet jött kérem. Valaki azt mondta,
hogy idejön. De nem mondta meg a nevét.
Rápolt: Hát miért nem kérdezted?
Az inas: Kérdeztem kérem, de már letette a kagylót.
Rápolt: Jó… Legfeljebb nem talál itthon. Elmehetsz. Várj csak…
vacsoráztál már?
Az inas: Igenis.
Rápolt: No, vedd el a szivarodat.
Az inas (boldogan röhögve mutatja): Már elvettem, nagyságos úr.
Gondoltam, nem tetszik haragudni.
Rápolt: Nem. – Hová mégy?
Az inas: Átmegyek kérem Zólyomy kapitány úrhoz… (Rápolt
kérdő pillantására:) A privátdinerrel huszonegyezünk.
Rápolt: Jó. Eredj.
Az inas (megy).
Rápolt (a telefonkészülékhez megy; a könyvet a kezébe veszi;
lapoz benne, azután leveszi a kagylót): Nagysád kérem:
nyolcvannégyet. – Köszönöm. – Halló: Radicséktól… Itt Rápolt. Maga
az, János? Kérem, kérdezze meg Ágnes kisasszonyt, hogy jobban
van-e már és fogadna-e most engem. – Mi? Nincs otthon? Hát hol
van? – Hová ment? (Hitetlenül:) Hová? Én hozzám… (Az előszoba
felől zajt hall, odafordul; lecsapja a kagylót.)
 MÁSODIK JELENET.

Rápolt, Ágnes.
Ágnes (nyugodt, de sápadt; rejtegeti a nyugtalanságát, de alig
bír a fölindulásával; nyugodtan lép be, de azután mozdulatlanul és
sápadtan nekitámaszkodik az ajtónak, amelyen nyugodt, gyors
mozdulattal belépett).
Rápolt (elámulva): Ágnes! (Boldogan:) Ágnes! (Most siet csak
feléje.) Egyetlen és édes, ragyogó és drága lány…
Ágnes (sápadtan és mozdulatlanul támaszkodik az ajtónak.
Nagyon komolyan): Örül, hogy itt vagyok?
Rápolt (nem tudja, hogyan jelezze az örömét. Keresi a szót):
Nevetek örömemben!…
Ágnes (nagyon komolyan): Várjon még. Még nem tudja, hogy
miért jöttem ide.
Rápolt: Feltételezem, kedves, egyetlen, szép Ágnes, hogy nem
azért, mert utál engem.
Ágnes (komolyan megcsóválja a fejét): Nem.
Rápolt: Folytatni akarja és be akarja fejezni a tavaszi ünnepen
félbeszakított beszélgetésünket.
Ágnes (komolyan bólint): Igen.
Rápolt: Meg akarja nekem mondani, hogy maga is… hogy maga
is…
Ágnes: Szégyelli kimondani!
Rápolt: Hogy… maga is szeret engem.
Ágnes: Igen. De…
 Rápolt: De?…
Ágnes: De… (Eddig elhárította Rápolt minden közeledését. Most
kinyujtja a kezét és odavezetteti magát egy karosszékhez. Leül.) Én
itt vagyok… eljöttem… De meg is kell engem tartania. (Szünet. Kissé
fölindultan:) Tartson meg engem, Andor.
Rápolt (tréfásan ijedt arcot vág): Én? – Maga tartson meg
engem, Ágnes.
Ágnes (hosszan, szótlanul megrázza a fejét): Nem. Ez így nem jó.
Igy nem lehet. Igy megint elveszít. Most, Andor, én értem… én
értem küzdenie kell.
Rápolt (keserves arcot vág).
Ágnes: Tudom: utálja a szót is. De én nem tehetek róla és nem
tehetek másképpen. Meg kell mondanom és türnie kell ezeket a
szavakat… én… a házasságot sem nevezhetem másnak, csak
házasságnak. És gyerekekre, síró pólyás gyerekekre, akik
házasságokból születni szoktak, nincs más szavam, mint hogy
gyerekek… (Szünet.)
Rápolt (előbb nem akar szólni, azután halk mosolygással): Ágnes,
– magától kitelik… (Nem akarja folytatni.)
Ágnes: Mi?
Rápolt: Hogy azt mondja a bábára sincs más szava, legfeljebb az,
hogy tudós asszony.
Ágnes (halványan elmosolyodik): Ezek nevetséges és kicsinyes
dolgok, Andor, de aki az életet élni akarja, az nem kerülheti el a
nevetséges és kicsinyes dolgokat. Honnan tudjam én azt, Andor,
hogy maga szeret engem?
Rápolt (természetesen): Onnan, Ágnes, hogy mondom.
Ágnes: Miért higyjem én magának el azt, amit mond?

Á
 Rápolt: Istenem… hát… hát… Higyje el Ágnes: én szeretem
magát… én soha ilyen egyszerüen, nyugodtan, zavartalanul és
tisztán boldog nem voltam… én szeretem magát egy nevető, derüs
és nagy szerelemmel és…
Ágnes: De a szerelem nem lehet mindig derüs és nevető.
Rápolt: Dehogy nem… Oh igen.
Ágnes: Nem. Egy asszonynak, minden asszonynak fájdalmat és
veszedelmet és talán halált jelent a szerelem…
Rápolt (megérti): Ah! Látja Ágnes: én akkor… én akkor… én
tudnék… tudnék akkor hű és… (nem tudja folytatni; szégyelli)… hogy
mondjam én ezt most!…
Ágnes (föláll; odalép hozzá; komolyan): Andor, maga olyan
könnyedén, követelőzve, kényelmesen, önzően és szeszélyesen sétál
az életen át, mint azok a művészek, azok a legnagyobb tehetségek,
akik visszaélnek a művészjogaikkal. (Nagyon lassan, kiszámítottan.)
Pedig maga nem is művész.
Rápolt (keservesen érintette ez a szó; küzd magával, elfordul, a
foga között): De az vagyok.
Ágnes: Nem tehetség.
Rápolt (kétségbeesve, haragosan): De az vagyok.
Ágnes (örül a haragjának. Kiszámítottan): Én elhiszem. De
mindenki más azt mondja magáról, hogy dilettáns.
Rápolt (ordítva): Nem vagyok az.
Ágnes: Én elhiszem. De a művészek, az igaziak nem félnek a
kicsinyes és nevetséges dolgoktól. Azok kiállnak, harcolnak,
verejtékeznek és verekszenek. Beethoven nem ijedt meg a cvikkeres
emberektől és Michelangeló véres szemmel és ájuldozva meredt
hetekig a Sixtina mennyezetére, amíg kicsinylő megjegyzések
kisérték a munkáját és epés rosszindulat várta, hogy kész lesz-e már.
Az igazi művészek dolgoznak és az igazi tehetségek bátrak, Andor.
Rápolt (elfordulva hallgatta. Remeg az idegességtől): Óh… várjon
csak, majd megmutatom én! Itt (a zongora felé mutat) készen van
már minden és alig várom, hogy a szemükbe nézhessek azoknak a…
(hirtelen szégyenkezve elhallgat).
Ágnes (gyöngéden): Azoknak a cvikkereseknek?
Rápolt (szégyenkezve): Igen.
Ágnes (mosolyogva): Jó… Nagyon jól van. (Komolyan.) Akkor…
megmondom, Andor, miért jöttem ide.
Rápolt (dacosan visszafordul): Mert mégis bízik bennem. Éppen
úgy, mint, mint én magamban.
Ágnes: Éppen úgy. Azért. De én, Andor, egy borzasztó
veszedelemben voltam.
Rápolt: Milyen veszedelemben?
Ágnes: Abban, hogy magát szerettem, de haragból, dacból és
keserüségből valaki másnak…
Rápolt: Óh! De hiszen annak most már vége.
Ágnes (komolyan): Várjon. Nem: hogy a felesége leszek. Hanem,
hogy dacból és keserüségből… szerelmes leszek valakibe, akit nem
szeretek.
Rápolt (hitetlenül): Ágnes!
Ágnes: Higyje el nekem. Rákényszerítettem a… (szégyenkezve:)
a vágyaimat, hogy hozzá forduljanak; rászoktattam magamat, hogy
őt gondoljam magam mellé; megfojtottam az akaratomat is, hogy az
ő akarata cselekedjék helyettem is. (Borzongva:) Már… majdnem…
az övé… voltam…

Á
 Rápolt (halkan): De most Ágnes…
Ágnes (más hangon; erősen, elszántan): Most idejöttem… egész
nap ezen töprengtem… idejöttem, hogy magához kössem magamat
elszakíthatatlanul és elválaszthatatlanul és örökre… Ha maga is
akarja…
Rápolt: Én…
Ágnes: Ha meg tud tartani… Ha meg tud védeni. Mert utánam…
mindjárt… egypár perc mulva… idejön majd és visszakövetel majd…
Zólyomy.
Rápolt (meglepetve): Ki?
Ágnes (szinte lesben állva, oldalt néz rá): Zólyomy.
Rápolt: Zólyomy? Hogyan? Miért?
Ágnes: Ő is ott járt nálunk déltájban. Vele sem akartam beszélni.
Erre meghivatta magát vacsorára az apámmal. Fél kilencre ott lesz.
És én… én azt mondtam… mondják – meg – neki, hogy – én –
idejöttem – magához.
Rápolt: Igen… nekem is azt mondták, hogy idejön.
Ágnes: Zólyomynak is azt fogják mondani. És ő – ő utánam jön.
Rápolt (bólint; kelletlen grimászt vág és kelletlenül, egy újjal
megvakarja a fejét).
Ágnes (nagy szemmel): Fél?
Rápolt: N… n… nem. Hanem…
Ágnes: Hanem?
Rápolt: Hanem… m… m… m… jobban szerettem volna…
Ágnes: Ha én intézem el ezt a dolgot.
Rápolt: Igen, Ágnes.
Á
 Ágnes: Ezt magának kell elintéznie. Mert én… (dideregve:) félek
tőle. Magának kell bátornak lennie.
Rápolt (undorral, kétségbeesve): Bátornak. Mondja, mindjárt,
hogy hősnek.
Ágnes: Fél?
Rápolt: Nem félek. Csak utálom… kellemetlen… mi lesz most
itt…! Mi jön itt…! Mérkőzni! Kiabálni! Verekedni! „Ő az enyém.“ –
„Nem, ő az enyém.“ „Egyikünk fölösleges, uram.“ – „Magam is azt
gondolom, uram.“ Brr!
Ágnes: Fél?
Rápolt (rákiált): Nem félek, ha mondom.
Ágnes (boldog felvillanás fut át az arcán erre a kiáltásra, aztán
megszédül és megtámolyodik).
Rápolt (ijedten): Mi az, Ágnes: Megijesztettem? Bocsánat. Nem
akartam.
Ágnes: Nem, nem azért.
Rápolt: Üljön le ide. Hát mi az? Miért?
Ágnes: Én… látja… én idejöttem magához… én jöttem el…
eljöttem a… maga lakásába…
Rápolt: Azt nagyon helyesen tette. És?
Ágnes: És… és itt akarok maradni. Itt akarok… (nem tudja
kimodja-e) itt akarok… ma és…
Rápolt: Bölcs, derék, jó, hasznos, helyes és kitünő dolgot akar.
Ágnes (türelmetlenül): Nem, ne mondja ezt így. Ne mondja így,
hogy (az ő hangján) hogy bölcs, derék, hasznos, helyes dolgot
csináltam. Ez nehéz út volt. Ez nagy és bátor dolog volt… értse meg,

É
hogy egy lány… Én itt akarok maradni… ma… (halkan, remegve.) ma
éjszaka… és örökké. (Szünet.) Értse meg, hogy…
Rápolt (meghatva): Megértem, Ágnes.
Rápolt (megöleli, de az utcai, hátsó ablakot hevesen
megzörgetik.)
Ágnes (rémülten fölpattan): Zólyomy.
Rápolt: Nem, nem, – dehogy ő.
Ágnes: De igen… (reszketve:) Istenem…
Rápolt: De nyugodjék meg Ágnes. – Hát így fél tőle?
Ágnes (dideregve int nemet).
Rápolt: De nem ő az, ha mondom. (Odamegy az ablakhoz; kinéz
a függöny mögül; visszafordul.)
Ágnes: Ugy-e hogy ő?
Rápolt: Nem.
Ágnes (bámulva, nyugodtan): Hát ki?
Rápolt (nem nagy zavarban, de egy kissé habozva): Nem ő…
hanem az a… lány, akinek tegnap köszöntem a Püspökkertben…
(Ágnes nem érti.) Az, aki miatt… a kis vitánk volt…
Ágnes: Mit akar itt?
Rápolt (vállvonogatva): Nyilván… be akar jönni.
Ágnes (felpattan, kezébe veszi a kabátját): Andor, maga nagyon
hamar alkalmat adott nekem rá, hogy megbánjam, amit tettem.
Rápolt (bámulva): Mit, Ágnes? Miért, Ágnes?
Ágnes (ingerülten, lázasan): Gondolhattam volna rá, gondolnom
kellett volna rá, amikor ide indultam, kik azok… kik azok… akik
magához el szoktak látogatni. Kikkel helyezem egy sorba magamat,
kikkel helyez maga egy sorba engem.
Rápolt (boldogan): Ágnes, drága Ágnes, hiszen maga féltékeny.
Ágnes (megvetően): Ne higyje. Csak meg vagyok bántva. Meg
vagyok alázva. A maga gondolkozása, a maga multja, a maga
társasága, a maga lakása megszégyenített és lefokozott…
Rápolt: Ágnes, maga azelőtt jószívű nő és nagylelkű ember volt…
Én megint azzá akarom tenni, – én behívom ide ezt a boldogtalan
teremtést.
Ágnes (izgatottan): Behívja? Azt hiszi, hogy én itt maradok… vele
együtt… egy levegőt szíva… (a kalapja után nyúl).
Rápolt (rákiált): Itt marad. Tegye le a kalapját. Most itt marad.
(Az ablakhoz megy. Kinyitja.) Bejöhetsz Lizi… Kulccsal csukd be
magad mögött az ajtót. (Visszajön.)
Ágnes (szenvedő, megbántott arccal áll; az arcán az utálata és a
méltatlankodása viaskodik az érdeklődésével és az
engedelmességével).
Rápolt (visszajön): Álljon oda Ágnes az ajtóba, a függöny mögé…
(a jobboldali ajtó függönyére mutat). Nem is kell nagyon elrejtőznie.
Egy cseppet sem kell rejtőznie.
Ágnes (a függöny mögé áll).
Rápolt (elől, középen vár).

HARMADIK JELENET.

Rápolt, Ágnes, Lizi.

Hallani az előszoba ajtajának a nyílását; a kulcs csörrenését.
 Lizi (lélegzet nélkül, kábultan, vakon besiet; leveti magát a Rápolt
lábához és reszketve, összeomolva, egy didergő csomóban ott
marad).
Rápolt (lenéz rá; bólint; hallgat; vár; lassan): Mi baj van Lizi?
Lizi: Meghalok.
Rápolt (szünet után): Honnan jössz, Lizi?
Lizi: Otthonról.
Rápolt: Láttalak hazamenni. Minek rohantál haza?
Lizi: Megmosakodni. Véresre suroltam az arcomat és a kezemet…
Rápolt: Tisztának akartad magadat érezni?
Lizi:… hogy lejőjjön rólam minden érintésnek a nyoma…
Rápolt: Miért nem maradtál otthon, Lizi?
Lizi: Mert otthon nem bírtam volna ki… otthon megöltem volna
magamat.
Rápolt: Még csak félkilenc Lizi. Honnan szöktél el ilyen korán?
Lizi: Odaát… a Piac-téren… a kávéházból…
Rápolt: Odarendeltek?
Lizi: Igen.
Rápolt: Már délután?
Lizi: Igen.
Rápolt: Innod kellett?
Lizi: Igen.
Rápolt: Többen voltak?
 Lizi: Sokan.
Rápolt: Zajosak voltak? Durvák voltak?
Lizi (szótlanul bólint; azután fölemeli a fejét): Lármáztak…
kiabáltak… (reszketve:) És egyszerre körülnéztem… és az arcuk, a
szemük, a leheletük… olyan volt, mintha farkasok és sertések közé
jutottam volna.
Rápolt: És erre elszöktél.
Lizi (int).
Rápolt: Hm… És mit akarsz most itt, Lizi?
Lizi: Csak hadd maradjak itt egy kicsit… csak egy félórát, csak
egy negyed órát… Egy kicsit hadd pihenjem ki magamat, mert olyan
vagyok, mintha évek óta szaladnék.
Rápolt (halkan, de rideg hangon, Ágnes számára): Nem
maradhatsz itt, Lizi.
Lizi (reszketve): Kérem, ne küldjön el. Csak egy negyed órát…
csak tíz percet… Hadd hunyjam be a szememet, hadd szívjam be a
levegőt… (bágyadtan, behunyt szemmel:) hadd vegyek itt nyugodtan
lélegzetet pár percig…
Rápolt (keményen): Nem maradhatsz itt, Lizi.
Lizi (fölretten): Ne küldjön el. Ha most elküld, én nem bírom
tovább, én megölöm magamat.
Ágnes (megmozdul, előrelép; mintha közbe akarna lépni).
Rápolt: Megölöd magadat?
Lizi: Meg.
Rápolt: Én jutalmat igértem neked, ha nem leszel öngyilkossá.
Lizi (csüggedten): De most nem akarja megadni.
 Rápolt: De megadom. Eljátszom neked a Stabat mater dolorosat.
Lizi (érdeklődve fölnéz; halkan, gondolkozva): Azt, amelyikben az
a sok magas hang van?
Rápolt (mosolyt nyel el): Azt. Stabat mater dolorosa, juxta
crucem lacrimosa, dum pendebat filius. Jó lesz?
Lizi: Jó.
Rápolt: Akkor azután elmégy.
Lizi: El.
Rápolt: Nem ölöd meg magadat.
Lizi: Nem.
Rápolt (hátralép).
Ágnes (egészen kijön az ajtó mellől).
Lizi (fölállott; boldogan készül rá, hogy a zenét hallgatja majd;
észreveszi Ágnest; megretten; szégyenkezve szedi össze magát,
lesimogatja a ruháját, rendbeszedi a haját egy gyors mozdulattal;
halálos zavarban dadog): Jaj, istenem!… Én… én bocsánatot kérek,
kérem szépen, én már megyek… (mentegetőzve fordul Rápolthoz)…
hiszen én nem tudtam… (mintha össze akarná magát húzni és el
akarna tünni)… de most már rögtön elmegyek.
Rápolt (néz Ágnesre, nem szól-e egy szót): Hm… eredj, Lizi.
Lizi (hirtelen megáll; nem bír magával; kifakad a száján): Hála a
jó istennek; hála a jó istennek.
Rápolt: Minek örülsz, Lizi?
Lizi: Semminek, semminek…
Rápolt (keményen): Mondd meg, minek örülsz.

Á
Welcome to our website – the ideal destination for book lovers and
knowledge seekers. With a mission to inspire endlessly, we offer a
vast collection of books, ranging from classic literary works to
specialized publications, self-development books, and children's
literature. Each book is a new journey of discovery, expanding
knowledge and enriching the soul of the reade

Our website is not just a platform for buying books, but a bridge
connecting readers to the timeless values of culture and wisdom. With
an elegant, user-friendly interface and an intelligent search system,
we are committed to providing a quick and convenient shopping
experience. Additionally, our special promotions and home delivery
services ensure that you save time and fully enjoy the joy of reading.

Let us accompany you on the journey of exploring knowledge and

personal growth!

ebooknice.com