
English: 
ROHAN JAIN: Hi, all.
I'm Rohan, and I'm
here to talk to you
about how you can scale up
or input data processing
with tf.data.
So let's start with a high-level
view of your ML training job.
Typically, your ML training
step will have two phases to it.
The first is data
preprocessing, where
you're going to look
at the input files
and do all kinds of
transformations on them
to make them ready for
the next phase, which
is model computation.
While you're doing data
preprocessing, which
happens in the CPU,
you might be doing
some kind of things such as--
for images, you're
cropping them.
For videos, you may be
sampling them and whatnot.
So if your training
speed is slow,
you could have a bottleneck in
either one of these two places.
And I hope that the
talk on profiling
would give you an
indication on how
to figure out which
one of the two phases
you're getting slow at.

Italian: 
 ROHAN JAIN: Ciao a tutti. 
 Sono Rohan e sono qui per parlare con te 
 su come aumentare o inserire l'elaborazione dei dati 
 con tf.data. 
 Quindi iniziamo con una visione di alto livello del tuo lavoro di formazione ML. 
 In genere, la fase di formazione ML avrà due fasi. 
 Il primo è la pre-elaborazione dei dati, dove 
 guarderai i file di input 
 e fare tutti i tipi di trasformazioni su di loro 
 per renderli pronti per la fase successiva, che 
 è il calcolo del modello. 
 Mentre stai eseguendo la preelaborazione dei dati, che 
 succede nella CPU, potresti fare 
 cose come ... 
 per le immagini, le stai ritagliando. 
 Per i video, potresti campionarli e quant'altro. 
 Quindi, se la tua velocità di allenamento è lenta, 
 potresti avere un collo di bottiglia in uno di questi due punti. 
 E spero che il discorso sulla profilazione 
 ti darebbe un'indicazione su come 
 per capire quale delle due fasi 
 stai diventando lento a. 

Italian: 
 E sono qui per parlarti del primo tipo 
 di pre-elaborazione collo di bottiglia - il collo di bottiglia che 
 è la pre-elaborazione dei dati. 
 Quindi proviamo a esaminare cos'è veramente questo collo di bottiglia. 
 Quindi negli ultimi anni abbiamo fatto un lavoro fantastico 
 rendendo acceleratori che eseguono le operazioni di ML molto velocemente. 
 E quindi la quantità di tempo necessaria 
 noi per fare un'operazione con la matrice e tutto il resto 
 l'algebra lineare delle nostre operazioni è molto più piccola. 
 Ma gli host e le CPU che alimentano i dati 
 a questi acceleratori non sono riuscito a stargli dietro, 
 e così finisce per essere un collo di bottiglia. 
 Abbiamo pensato di poter mitigare questo problema 
 rendendo i modelli più complessi, 
 ma quello che succede è che gli acceleratori hanno dei vincoli 
 su quanta RAM hanno e, cosa più importante, 
 dove si distribuiscono questi modelli tende 
 essere qualcosa come un dispositivo mobile o qualcosa del genere, 

English: 
And I'm here to talk to
you about the first kind
of preprocessing bottleneck--
the bottleneck which
is data preprocessing.
So let's try to look into what
this bottleneck really is.
So in the last few years
we've done a fantastic job
making accelerators which do
the ML operations really fast.
And so the amount
of time it takes
us to do a matrix
operation and all
the linear algebra our
operations is a lot smaller.
But the hosts and the
CPUs that feed the data
to these accelerators have not
been able to keep up with them,
and so there ends up
being a bottleneck.
We thought that we
could mitigate this
by making the
models more complex,
but what happens is that the
accelerators have constraints
on how much RAM they have,
and, more importantly,
where you deploy
these models tends
to be something like a mobile
device or something like that,

Italian: 
 che tende a limitare la quantità di complessità 
 puoi introdurre nel tuo modello. 
 Quindi non ha funzionato davvero. 
 Il secondo approccio che le persone adottano è che loro 
 provare a trasformare lotti di dimensioni maggiori. 
 Ma lotti di dimensioni maggiori richiedono una quantità maggiore 
 di preelaborazione per assemblare il lotto, 
 quindi questo mette ulteriore pressione su di loro. 
 Ecco perché questo sta diventando un problema sempre più grande 
 all'interno di Alphabet e anche esternamente. 
 E ti parlerò di come 
 puoi risolverlo usando tf.data. 
 tf.data è il framework di pre-elaborazione dei dati di TensorFlow. 
 È veloce, è flessibile ed è facile da usare. 
 E puoi saperne di più sulla nostra guida. 
 Come sfondo per il resto del discorso, 
 Penso che passerò attraverso una tipica pipeline di dati tf.data, 
 e questo ci aiuterà nelle fasi successive. 
 Quindi supponiamo di avere alcuni dati in alcuni file di record tf.data che 

English: 
which tends to restrict
the amount of complexity
you can introduce
into your model.
So that hasn't
really panned out.
The second approach
people take is that they
try to turn larger batch sizes.
But larger batch sizes
require a larger amount
of preprocessing to
assemble the batch,
so then that puts
further pressure on them.
So that's why this is becoming
an increasingly larger problem
within Alphabet and
even externally.
And I'm going to
talk to you about how
you can solve it using tf.data.
tf.data is TensorFlow's data
preprocessing framework.
It's fast, it's flexible,
and it's easy to use.
And you can learn more
about it at our guide.
For background for
the rest of the talk,
I think I'm going to go through
a typical tf.data pipeline,
and that'll help us
in the later stages.
So suppose you have some data in
some tf.data record files which

Italian: 
 sono i tuoi dati di allenamento. 
 Quindi ora puoi iniziare con il record TF 
 insieme di dati con tali dati. 
 E poi, dopo, inizi a eseguire la preelaborazione. 
 Questa è in genere la maggior parte della logica. 
 Quindi, se si tratta di immagini, stai ritagliando, forse capovolgendo, 
 ogni sorta di cose lì. 
 Dopodiché, mescoli i dati così 
 che non ti alleni nell'ordine in cui ti alleni 
 vedere gli esempi e l'input. 
 E questo ti aiuta con la precisione dell'allenamento. 
 Dopodiché, lo faremo in batch in modo che l'acceleratore possa ora 
 fare uso di calcoli vettorizzati. 
 Infine, vuoi fare un po 'di pipeline del software in modo che tu 
 assicurarsi che mentre il modello è spento 
 lavorando su un batch di dati, il lato di pre-elaborazione può 
 produrre il lotto successivo in modo che tutto 

English: 
are your training data.
So you can now start
off with the TF record
data set with that data.
And then after that, you start
doing your preprocessing.
This is typically the
bulk of the logic.
So if it's images, you're
doing cropping, maybe flipping,
all sorts of things there.
After that, you
shuffle the data so
that you don't train to
the order in which you
see the examples and the input.
And that helps you with
their training accuracy.
And after that, we will batch it
so that the accelerator can now
make use of vectorized
computations.
Finally, you want to do some
software pipelining so that you
ensure that while
the model is off
working on one batch of data,
the preprocessing side can
produce the next batch
so that everything

English: 
works very efficiently.
Finally, you can then
feed this tf.data dataset
to a Keras model,
so that you can now
start doing your training.
So given that sort
of basic pipeline,
and suppose you
have a bottleneck,
the first thing I'd
recommend you to do
is to go through our single
host performance guide,
and try to utilize every
trick and transformation that
is available in tf-data
to be able to extract
the maximum possible
performance,
so that you're using all the
[INAUDIBLE] and whatever.
There's excellent information
at the guide that we have here.
And [INAUDIBLE] did a
great talk at the ML Tokyo
Summit, which you can take
a look at to learn more
about this.
So that's the first thing
I'd recommend you do.
But suppose you have
done that and you've
tried all the different
recommendations that we have

Italian: 
 funziona in modo molto efficiente. 
 Infine, puoi quindi alimentare questo set di dati tf.data 
 a un modello Keras, così ora puoi 
 inizia a fare il tuo allenamento. 
 Quindi, dato quel tipo di pipeline di base, 
 e supponi di avere un collo di bottiglia, 
 la prima cosa che ti consiglierei di fare 
 è esaminare la nostra guida alle prestazioni per host singolo, 
 e cerca di utilizzare ogni trucco e trasformazione che questo 
 è disponibile in tf-data per poter estrarre 
 la massima prestazione possibile, 
 in modo da utilizzare tutto [INCOMPRENSIBILE] e quant'altro. 
 Ci sono ottime informazioni nella guida che abbiamo qui. 
 E [INCOMPRENSIBILE] ha tenuto un gran discorso al ML Tokyo 
 Summit, a cui puoi dare un'occhiata per saperne di più 
 a questo proposito. 
 Quindi questa è la prima cosa che ti consiglio di fare. 
 Ma supponi di averlo fatto e di averlo fatto 
 provato tutti i diversi consigli che abbiamo 

Italian: 
 qui, ma hai ancora un collo di bottiglia su quei dati 
 parte di pre-elaborazione. 
 E non preoccuparti, non sei solo. 
 Questo è molto comune. 
 Lo abbiamo visto sempre di più con molto 
 dei clienti interni. 
 E quindi ora sono molto lieto di presentare un paio di soluzioni 
 su cui abbiamo lavorato nel team 
 per aiutarti a risolvere il problema. 
 Quindi la prima idea è perché non lo facciamo 
 basta riutilizzare il calcolo? 
 Quindi supponi di giocare con un modello diverso 
 architetture. 
 Il tuo input pre-elaborazione tipo di parte 
 tipo di rimane lo stesso. 
 E se è costoso e richiede tempo, perché non lo facciamo noi 
 fallo una volta, salvalo e poi 
 ogni volta successiva, leggiamo da esso, 
 e farlo velocemente? 
 Quindi abbiamo notato un gruppo di clienti interni, team 
 all'interno di Alphabet, che stavano cercando di farlo 

English: 
here, but you're still
bottlenecked on that data
preprocessing part.
And don't worry,
you're not alone.
This is very common.
We've increasingly
seen this with a lot
of internal customers.
And so now I'm very pleased to
present a couple of solutions
that we've been
working on on the team
to help you solve that problem.
So the first idea
is that why don't we
just reuse the computation?
So suppose you're playing
around with different model
architectures.
Your input pre-processing
sort of part
kind of remains the same.
And if it's expensive and
time-consuming, why don't we
just do it once,
save it, and then
every subsequent time,
we just read from it,
and do that quickly?
So we noticed a bunch of
internal customers, teams
within Alphabet, who
were trying to do this

English: 
on their own outside
of tf.data, and we
decided to bring
it in to tf.data
and make it incredibly fast,
flexible, and easy to use.
And so this is what
we call Snapshot.
The idea is what I
explained to you.
You materialize the output of
your data pre-processing once,
and then you can use
it many, many times.
This is incredibly
useful for playing around
with different
model architectures
and if you settle down
on an architecture doing
hyperparameter tuning.
And so you can get that
speed up using Snapshot.
Next, I'm going to go
through the pipeline
that we talked about before and
see how you can add Snapshot
to it to make it faster.
So that's the original
pipeline that we had.
And so notice that there's
this pre-processing step, which
is expensive.
So now with Snapshot, you just
add a snapshot transformation

Italian: 
 da soli al di fuori di tf.data, e noi 
 ha deciso di portarlo in tf.data 
 e renderlo incredibilmente veloce, flessibile e facile da usare. 
 E quindi questo è ciò che chiamiamo Snapshot. 
 L'idea è ciò che ti ho spiegato. 
 Si materializza l'output della pre-elaborazione dei dati una volta, 
 e poi puoi usarlo molte, molte volte. 
 Questo è incredibilmente utile per giocare 
 con diverse architetture di modello 
 e se ti accontenti di un'architettura facendo 
 ottimizzazione iperparametro. 
 E così puoi ottenere quella velocità usando Snapshot. 
 Successivamente, esaminerò la pipeline 
 di cui abbiamo parlato prima e vediamo come aggiungere Snapshot 
 ad esso per renderlo più veloce. 
 Quindi questa è la pipeline originale che avevamo. 
 E quindi nota che c'è questo passaggio di pre-elaborazione, che 
 è costoso. 
 Quindi ora con Snapshot, aggiungi solo una trasformazione snapshot 

English: 
right after that with a
directory [INAUDIBLE]..
And with this, everything that
is before the snapshot will now
be written to disk the
first time it's run.
And then every subsequent time,
we will just read from it.
And we would go through the
rest of the steps as usual.
One thing I'd like
to point out is
that we place the snapshot
at a particular location
before the shuffle, because
if it's after the shuffle,
everything gets frozen.
So all the randomization
that you get out
of shuffle you lose, because
every subsequent time,
you're just going to be reading
the same exact order again
and again.
So that's why we introduce it
at that stage in the pipeline.
So Snapshot, we
developed it internally.
There are internal
users and teams
that are using it and
deriving benefit out of it.
And now we're bringing it
to the open source world.

Italian: 
 subito dopo con una directory [INCOMPRENSIBILE] .. 
 E con questo, tutto ciò che è prima dell'istantanea lo sarà ora 
 essere scritto su disco la prima volta che viene eseguito. 
 E poi, ogni volta successiva, leggeremo semplicemente da esso. 
 E avremmo eseguito il resto dei passaggi come al solito. 
 Una cosa che vorrei sottolineare è 
 che posizioniamo l'istantanea in una posizione particolare 
 prima dello shuffle, perché se è dopo lo shuffle, 
 tutto si congela. 
 Quindi tutta la randomizzazione che ottieni 
 di shuffle si perde, perché ogni volta successiva, 
 leggerai di nuovo lo stesso identico ordine 
 e di nuovo. 
 Ecco perché lo introduciamo in quella fase della pipeline. 
 Quindi Snapshot, l'abbiamo sviluppato internamente. 
 Sono presenti utenti e team interni 
 che lo stanno utilizzando e ne traggono vantaggio. 
 E ora lo stiamo portando nel mondo open source. 

Italian: 
 Abbiamo pubblicato un RFC, che contiene maggiori informazioni al riguardo 
 e alcuni altri dettagli tecnici. 
 E questo sarà disponibile in TensorFlow 2.3, 
 ma credo che sarà disponibile in [INCOMPRENSIBILE] 
 in breve. 
 Quindi ricorda, ho parlato di due idee. 
 Quindi la seconda idea è che, ora, non tutta la computazione 
 è riutilizzabile, quindi perché supponi di avere qualcuno randomizzato 
 raccolti lì dentro. 
 E se l'hai scritto su disco e li rilessi, 
 di nuovo, perderesti quella randomizzazione. 
 E quindi un'istantanea probabilmente non lo è 
 applicabile in quello scenario. 
 Quindi la seconda idea è essere in grado di distribuire il calcolo. 
 Quindi la configurazione iniziale è che hai una CPU host, che 
 guida molti di questi acceleratori, 
 ma ora puoi scaricare questo calcolo 
 da questo host a forse un cluster. 

English: 
We published an RFC, which
has more information about it
and some other
technical details.
And this will be available
in TensorFlow 2.3,
but I believe it will be
available in the [INAUDIBLE]
shortly.
So remember, I talked
about two ideas.
So the second idea is that,
now, not all computation
is reusable, so because suppose
you had someone randomized
crops in there.
And if you wrote that to
disk and read them back,
you'd, again, lose
that randomization.
And so a snapshot
is probably not
applicable in that scenario.
So the second idea is to be able
to distribute the computation.
So the initial setup is that
you have one host CPU, which
is driving a bunch of
these accelerators,
but now you can offload
this computation
from this host to
maybe a cluster.

Italian: 
 E ora puoi utilizzare l'abilità 
 e la potenza di calcolo che tu 
 avere per tutti questi diversi lavoratori 
 per poter nutrire l'ospite, in modo che tu non lo sia 
 più colli di bottiglia nella pre-elaborazione dell'input 
 e le cose si muovono velocemente. 
 Questo è il servizio tf.data. 
 È una funzionalità tf.data che ti consente di ridimensionare 
 il carico di lavoro in orizzontale. 
 Quindi, se noti una lentezza nella pre-elaborazione dell'input, 
 puoi iniziare ad aggiungere lavoratori e aumenterà. 
 Ha un'architettura capolavoro, dove 
 il maestro guida il lavoro per i diversi lavoratori 
 e ti dà tolleranza ai guasti. 
 Quindi se uno dei lavoratori fallisce, sei comunque bravo 
 e puoi ancora fare progressi. 
 Quindi vediamo come puoi usare il servizio tf.data per l'esempio 

English: 
And now you can
utilize the ability
and the computational
power that you
have for all these
different workers
to be able to feed the
host, so that you're not
bottlenecked on the input
pre-processing anymore
and things move fast.
This is tf.data service.
It's a tf.data feature
that allows you to scale
your workload horizontally.
So if you're seeing a slowness
in your input pre-processing,
you can start adding workers,
and it'll just scale up.
It's got a master-worker
architecture, where
the master drives the work
for the different workers
and it gives you
fault tolerance.
So if one of the workers
fails, you're still good
and you still can make progress.
So let's see how you can use the
tf.data service for the example

English: 
that we have.
So here, instead of having sort
of an expensive pre-processing,
let's say you have some
randomized pre-processing.
So now this is not snapshotable,
because if you snapshot, then
you lose the randomization.
So we'll provide
you a binary which
allows you to run the data
service on the cluster setup
manager that you like, whether
it's Kubernetes or Cloud
or something like that.
And then once you have
that up and running,
you can just add a
distribute transformation
to your tf.data pipeline and
provide the master address.
Anything before the
distribute transformation
would now get run on the
cluster that you have set up
and everything after
will run on the host.
And so this allows you
to sort of scale up.
Again, note that
because we are not
doing any kind of
freezing of the data,

Italian: 
 che noi abbiamo. 
 Quindi qui, invece di avere una sorta di costosa pre-elaborazione, 
 diciamo che hai una pre-elaborazione casuale. 
 Quindi ora questo non è snapshot, perché se lo snapshot, allora 
 perdi la randomizzazione. 
 Quindi ti forniremo un file binario che 
 consente di eseguire il servizio dati nella configurazione del cluster 
 manager che ti piace, che si tratti di Kubernetes o Cloud 
 o qualcosa di simile. 
 E poi, una volta che hai installato e funzionante, 
 puoi semplicemente aggiungere una trasformazione di distribuzione 
 alla pipeline tf.data e fornire l'indirizzo principale. 
 Qualunque cosa prima della trasformazione di distribuzione 
 ora verrebbe eseguito sul cluster che hai configurato 
 e tutto dopo verrà eseguito sull'host. 
 E quindi questo ti consente di aumentare la scala. 
 Ancora una volta, nota che perché non lo siamo 
 fare qualsiasi tipo di congelamento dei dati, 

English: 
we can output this
transformation
as late as possible in there.
So notice that I've put it after
the shuffle transformation.
The service, like
Snapshot, has been
developed with internal users.
They've been using it.
And it's been, like, a
game-changer in terms
of [INAUDIBLE] utilization.
And now, again, we're
bringing it to you.
And so we published an RFC,
which was well-received,
and this should be
available in 2.3
for you to play around with.
So to summarize, what
did I talk about today?
So as with various trends
in hardware and software,
we've ended up in a scenario
where a lot of input machine
learning jobs are
getting bottlenecked
on input pre-processing.
And I've told
about two solutions
that tf.data team
has been working on

Italian: 
 possiamo produrre questa trasformazione 
 il più tardi possibile lì dentro. 
 Quindi nota che l'ho inserito dopo la trasformazione casuale. 
 Il servizio, come Snapshot, è stato 
 sviluppato con utenti interni. 
 Lo stanno usando. 
 Ed è stato un punto di svolta in termini 
 di utilizzo [INCOMPRENSIBILE]. 
 E ora, di nuovo, te lo stiamo portando. 
 E così abbiamo pubblicato un RFC, che è stato ben accolto, 
 e questo dovrebbe essere disponibile in 2.3 
 per te con cui giocare. 
 Quindi, per riassumere, di cosa ho parlato oggi? 
 Così come con le varie tendenze in hardware e software, 
 siamo finiti in uno scenario in cui molta macchina di input 
 i lavori di apprendimento stanno subendo colli di bottiglia 
 sulla pre-elaborazione dell'input. 
 E ho parlato di due soluzioni 
 su cui sta lavorando il team di tf.data 

English: 
to help you solve
this bottleneck.
First is Snapshot,
which allows you
to reuse your pre-processing,
so that you don't
have to do it multiple times.
And the second is
the tf.data service,
which allows you to distribute
this computation to a cluster,
so that you get the
scale-up that you need.
I hope you play around with
these and give us feedback.
And thank you for your time.
[MUSIC PLAYING]

Italian: 
 per aiutarti a risolvere questo collo di bottiglia. 
 Il primo è Snapshot, che ti consente 
 per riutilizzare la pre-elaborazione, in modo da non farlo 
 devo farlo più volte. 
 E il secondo è il servizio tf.data, 
 che ti consente di distribuire questo calcolo a un cluster, 
 in modo da ottenere lo scale-up di cui hai bisogno. 
 Spero che tu possa giocare con questi e darci un feedback. 
 E grazie per il tuo tempo. 
 [MUSICA IN ESECUZIONE] 
