
English: 
[MUSIC PLAYING]
JIAN LI: Hello, everyone.
My name's Jian.
I'm a software engineer
on the TensorFlow team.
Today, my colleague
Pulkit and I will
be talking about the TensorFlow
model optimization toolkit.
Model optimization means
transforming your machine
learning models to make
them efficient to execute.
That means faster computation
as well as a lower memory,
storage, and battery usage.
And it is focused on
inference instead of training.
And because of the above
mentioned benefits,
optimization can
unlock use cases
that are otherwise impossible.
Examples include speech
recognition, face unlock,
object detection, music
recognition, and many more.
The model optimization
toolkit is a suite
of TensorFlow and
TensorFlow Lite tools
that make it simple to
optimize your model.
Optimization is an
active research area
and there are many techniques.

Italian: 
 [MUSICA IN ESECUZIONE] 
 JIAN LI: Ciao a tutti. 
 Il mio nome è Jian. 
 Sono un ingegnere del software nel team di TensorFlow. 
 Oggi, io e il mio collega Pulkit lo faremo 
 parliamo del toolkit di ottimizzazione del modello TensorFlow. 
 Ottimizzazione del modello significa trasformare la tua macchina 
 modelli di apprendimento per renderli efficienti da eseguire. 
 Ciò significa un calcolo più veloce e una memoria inferiore, 
 conservazione e utilizzo della batteria. 
 Ed è focalizzato sull'inferenza invece che sull'addestramento. 
 E a causa dei vantaggi sopra menzionati, 
 l'ottimizzazione può sbloccare casi d'uso 
 altrimenti impossibili. 
 Gli esempi includono riconoscimento vocale, sblocco facciale, 
 rilevamento di oggetti, riconoscimento musicale e molti altri. 
 Il toolkit per l'ottimizzazione del modello è una suite 
 degli strumenti TensorFlow e TensorFlow Lite 
 che rendono semplice ottimizzare il tuo modello. 
 L'ottimizzazione è un'area di ricerca attiva 
 e ci sono molte tecniche. 

English: 
Our goal is to
prioritize the ones that
are general across
model architectures
and across various
hardware accelerators.
There are two major techniques
in the toolkit, quantization
and pruning.
Quantization stimulates flow
calculation in lower bits,
and pruning forces
zero interconnection.
Today we are going to
focus on quantization
and we'll briefly
talk about pruning.
Now let's take a closer
look at quantization.
Quantization is a general
term describing technologies
that reduce the numerical
precision of static parameters
and execute the operations
in lower precision.
Precision reduction
makes the model smaller,
and a lower precision execution
makes the model faster.
Now let's dig a bit more onto
how we perform quantization.
As a concrete example,
imagine we have
a tensor with float values.
In most cases, we are wasting
most of the representation
space in the float number line.
If we can find a linear
transformation that

Italian: 
 Il nostro obiettivo è dare la priorità a quelli che 
 sono generali in tutte le architetture del modello 
 e su vari acceleratori hardware. 
 Ci sono due tecniche principali nel toolkit, la quantizzazione 
 e potatura. 
 La quantizzazione stimola il calcolo del flusso in bit inferiori, 
 e la potatura non forza l'interconnessione. 
 Oggi ci concentreremo sulla quantizzazione 
 e parleremo brevemente di potatura. 
 Ora diamo uno sguardo più da vicino alla quantizzazione. 
 La quantizzazione è un termine generico che descrive le tecnologie 
 che riducono la precisione numerica dei parametri statici 
 ed eseguire le operazioni con minore precisione. 
 La riduzione di precisione rende il modello più piccolo, 
 e una minore precisione di esecuzione rende il modello più veloce. 
 Ora approfondiamo un po 'come eseguiamo la quantizzazione. 
 Come esempio concreto, immagina di avere 
 un tensore con valori float. 
 Nella maggior parte dei casi, stiamo sprecando la maggior parte della rappresentazione 
 spazio nella riga del numero in virgola mobile. 
 Se riusciamo a trovare una trasformazione lineare che 

Italian: 
 mappa il valore float su int8, possiamo ridurre la dimensione del modello 
 di un fattore quattro. 
 Quindi i calcoli possono essere eseguiti tra i valori int8, 
 ed è da qui che arriva l'accelerazione. 
 Quindi ci sono due approcci principali per fare la quantizzazione, post 
 formazione e durante l'allenamento. 
 Il post training opera su un modello già addestrato 
 ed è basato sul convertitore TensorFlow Lite. 
 Durante l'allenamento, la quantizzazione esegue un peso aggiuntivo 
 messa a punto e poiché è necessaria la formazione, 
 è una build su un'API Keras TensorFlow. 
 Diverse tecniche offrono un compromesso 
 tra facilità d'uso e accuratezza del modello. 
 La tecnica più facile da usare è la gamma dinamica 
 quantizzazione, che non richiede dati. 
 Può esserci qualche perdita di precisione, ma otteniamo due o tre volte 
 accelerare. 
 Perché il calcolo in virgola mobile 
 è ancora necessario per l'attivazione, 
 è pensato solo per funzionare su CPU. 
 Se vogliamo una maggiore velocità sulla CPU o vogliamo 

English: 
maps the float value onto int8,
we can reduce the model size
by a factor of four.
Then computations can be
carried out between int8 values,
and that is where the
speed up comes from.
So there are two main approaches
to do quantization, post
training and during training.
Post training operates on
a already trained model
and is built on top of
TensorFlow Lite converter.
During training, quantization
performs additional weight
fine-tuning, and since
training is required,
it is a build on top of
a TensorFlow Keras API.
Different techniques
offers a trade off
between ease of use
and model accuracy.
The most easy to use
technique is the dynamic range
quantization, which
doesn't require any data.
There can be some accuracy loss
but we get a two to three times
speed up.
Because floating
point calculation
is still needed
for the activation,
it's only meant to run on CPU.
If we want extra speed
up on CPU or want

English: 
to run the model on
hardware accelerators,
we can use integer quantization.
It runs a small set of
unlabeled calibration data
to collect the min-max
range on activation.
This removes the floating
point calculation
in the computer graph, so
there is a speed up on CPU.
But more importantly,
it allows the model
to run on hardware accelerators
such as DSP and TPU,
which are faster and more
energy efficient than CPU.
And if accuracy is
a concern, we can
use Quantization Aware Training
to fine-tune the weights.
It has all the benefits
of integer quantization,
but it requires training.
Now let's have a operator level
breakdown on the post training
quantization.
Dynamic range quantization
is fully supported
and integer quantization
is supported
for most of the operators.
The missing piece is the
recurrent neural network
support, and that
blocks use cases
such as speech and language
where a context is needed.
To unblock those use
cases, we have recently

Italian: 
 per eseguire il modello su acceleratori hardware, 
 possiamo usare la quantizzazione intera. 
 Esegue una piccola serie di dati di calibrazione senza etichetta 
 per raccogliere l'intervallo min-max all'attivazione. 
 Ciò rimuove il calcolo in virgola mobile 
 nel grafico del computer, quindi c'è una velocità sulla CPU. 
 Ma ancora più importante, consente il modello 
 per funzionare su acceleratori hardware come DSP e TPU, 
 che sono più veloci ed efficienti dal punto di vista energetico rispetto alla CPU. 
 E se la precisione è un problema, possiamo 
 utilizzare Quantization Aware Training per mettere a punto i pesi. 
 Ha tutti i vantaggi della quantizzazione intera, 
 ma richiede addestramento. 
 Ora diamo una ripartizione a livello di operatore sulla formazione post 
 quantizzazione. 
 La quantizzazione della gamma dinamica è completamente supportata 
 e la quantizzazione intera è supportata 
 per la maggior parte degli operatori. 
 Il pezzo mancante è la rete neurale ricorrente 
 supporto e che blocca i casi d'uso 
 come discorso e linguaggio in cui è necessario un contesto. 
 Per sbloccare questi casi d'uso, abbiamo recentemente 

Italian: 
 aggiunta una quantizzazione ricorrente della rete neurale 
 e ha creato una soluzione chiavi in ​​mano tramite l'API post training. 
 Il modello RNN creato con Keras 2.0 può essere convertito e quantizzato 
 con l'API post training. 
 Questa diapositiva mostra il flusso di lavoro end-to-end 
 nella configurazione post allenamento. 
 Creiamo il convertitore TensorFlow Lite 
 e caricare il modello RNN salvato. 
 Quindi impostiamo i flag di ottimizzazione post allenamento 
 e fornire i dati di calibrazione. 
 Successivamente, siamo in grado di chiamare il metodo convert per convertire 
 e quantizzato il modello. 
 Questa è esattamente la stessa API e flusso di lavoro per i modelli 
 senza RNN, quindi non è prevista alcuna modifica API per gli utenti finali. 
 Diamo uno sguardo alle sfide 
 della quantizzazione RNN. 
 La quantizzazione è una trasformazione con perdite. 
 La cella RNN ha uno stato di memoria che persiste 
 su più timestamp, quindi errori di quantizzazione 
 può accumularsi sia nella direzione dello strato che nel tempo 
 direzione. 
 La cella RNN contiene molti calcoli, 

English: 
added a recurrent neural
network quantization
and built a turnkey solution
through the post training API.
RNN model build with Keras 2.0
can be converted and quantized
with the post training API.
This slide shows the
end to end workflow
in the post training setup.
We create the TensorFlow
Lite converter
and load the saved RNN model.
We then set the post
training optimization flags
and provide calibration data.
After that, we are able to call
the convert method to convert
and quantized the model.
This is the exact same API
and workflow for models
without RNN, so there is no
API change for the end users.
Let's take a look
at the challenges
of the RNN quantization.
Quantization is a
lossy transformation.
RNN cell has a memory
state that persists
across multiple timestamps,
so quantization errors
can accumulate in both the
layer direction and the time
direction.
RNN cell contains
many calculations,

Italian: 
 e determinare il numero di bit e la scala 
 è un problema di ottimizzazione globale. 
 Inoltre, le operazioni quantizzate sono limitate 
 dalle capacità hardware. 
 Alcune operazioni non sono consentite su alcune piattaforme hardware. 
 Abbiamo risolto la sfida e creato la specifica di quantizzazione 
 per RNN. 
 La specifica completa è piuttosto complicata, 
 e questa diapositiva mostra questa specifica ingrandendo 
 in una delle porte LSTM. 
 Come ho già detto, ci sono molti calcoli in una cella. 
 Per bilanciare prestazioni e precisione, 
 manteniamo il più possibile i calcoli a otto bit 
 e va solo a bit più alti quando richiesto dalla precisione. 
 Come puoi vedere dal diagramma, le metriche 
 le operazioni correlate sono a 8 bit e le operazioni relative al web 
 sono una miscela di 8 bit e 16 bit. 
 E per favore nota, l'uso di bit più alti 
 è solo interno alla cella. 
 L'attivazione dell'ingresso e dell'uscita per la cella RNN sono tutti a 8 bit. 

English: 
and determining the number
of bits and the scale
is a global
optimization problem.
Also, quantized
operations are restricted
by hardware capabilities.
Some operations are not allowed
on certain hardware platforms.
We solved the challenge and
created the quantization spec
for RNN.
The full spec is
quite complicated,
and this slide shows
this spec by zooming
into one of the LSTM gates.
As I mentioned, there are
many calculations in one cell.
To balance performance
and accuracy,
we keep eight bit calculations
as much as possible
and it only goes to higher
bits when required by accuracy.
As you can see from
the diagram, metrics
related operations are in 8
bit, and web related operations
are a mixture of
8 bit and 16 bits.
And please note, the
use of higher bits
is only internal to the cell.
The input and output activation
for RNN cell are all 8 bits.

Italian: 
 Ora vediamo i dettagli della quantizzazione RNN. 
 Diamo un'occhiata alla precisione e alle prestazioni. 
 Questa tabella mostra alcuni numeri di accuratezza pubblicati 
 su alcuni set di dati. 
 È un modello di riconoscimento vocale che consiste 
 di 10 strati di LSTM quantizzato. 
 Come puoi vedere, modello quantizzato intero 
 ha la stessa precisione del modello quantizzato a gamma dinamica, 
 e la perdita di accuratezza è trascurabile 
 rispetto al caso del galleggiante. 
 Inoltre, questo è un modello permanente, quindi quantizzazione RNN 
 funziona anche con la potatura. 
 Come previsto, c'è una riduzione delle dimensioni del modello di quattro volte 
 perché i pesi statici sono quantizzati a 8 bit. 
 Dal punto di vista delle prestazioni, c'è da due a quattro volte 
 accelerare su una CPU e una velocità più di 10 volte 
 su DSP e TPU. 
 Quindi quei numeri sono coerenti con i numeri 
 da altri operatori. 
 Quindi ecco i principali takeaway. 
 TensorFlow ora supporta la quantizzazione RNN / LSTM. 
 È una soluzione chiavi in ​​mano tramite l'API post training. 

English: 
Now we see the details
of RNN quantization.
Let's look at the accuracy
and the performance.
This table shows some
published accuracy numbers
on a few data sets.
It's a speech recognition
model that consists
of 10 layers of quantized LSTM.
As you can see,
integer quantized model
has the same accuracy as the
dynamic range quantized model,
and the accuracy
loss is negligible
compared with the float case.
Also, this is a permanent
model, so RNN quantization
works with pruning as well.
As expected, there is a four
time model size reduction
because static weights
are quantized to 8 bits.
Performance-wise, there
is a two to four times
speed up on a CPU and a
more than 10 times speed
up on DSP and TPU.
So those numbers are
consistent with the numbers
from other operators.
So here are the main takeaways.
TensorFlow now supports
the RNN/LSTM quantization.
It is a turnkey solution
through the post training API.

Italian: 
 Permette più piccoli, più veloci e più energia 
 esecuzione efficiente che può essere eseguita su DSP e TPU. 
 Esistono già modelli di produzione 
 che utilizzano la quantizzazione. 
 E per favore controlla il link per maggiori dettagli sui casi d'uso. 
 Guardando avanti, il nostro prossimo passo lo farà 
 essere quello di espandere la quantizzazione ad altri neuroni ricorrenti 
 reti, come GRU e SRU. 
 Abbiamo anche in programma di aggiungere Quantization Aware Training per RNN. 
 Ora lo passo al mio collega Pulkit. 
 Grazie. 
 PULKIT BHUWALKA: Grazie. 
 Grazie Jian. 
 Ciao, mi chiamo Pulkit. 
 Lavoro sul kit di strumenti per l'ottimizzazione del modello. 
 E parliamo di ... 
 il clicker non sembra funzionare. 
 Non ho capito, possiamo tornare indietro di una diapositiva? 
 Sì. 
 Quantization Aware Training. 
 Quindi Quantization Aware Training è una tecnica del tempo di addestramento 

English: 
It enables smaller,
faster, and a more energy
efficient execution that
can run on DSP and TPU.
There are already
production models
that use the quantization.
And please check the link for
more details on the use cases.
Looking forward,
our next step will
be to expand quantization
to other recurrent neural
networks, such as
the GRU and SRU.
We also plan to add Quantization
Aware Training for RNN.
Now I'll hand it over
to my colleague Pulkit.
Thank you.
PULKIT BHUWALKA: Thanks.
Thanks Jian.
Hi, my name is Pulkit.
I work on model
optimization tool kitting.
And let's talk about--
clicker doesn't
seem to be working.
Sorry, can we go back a slide?
Yes.
Quantization Aware Training.
So Quantization Aware Training
is a training time technique

English: 
for improving the accuracy
of quantized models.
The way it works is
that we introduced
some of the errors
which actually happened
during quantized inference
into the training process,
and that actually helps
the trainer learn around
these errors and get
a more accurate model.
Now let's just try to
get a sense of why is
this needed in the first place.
So we know that
quantized models,
they run in lower precision,
and because of that,
it's a lossy process, and that
leads to an accuracy drop.
And while quantized models are
super fast and we want them,
but nobody wants
an accurate model.
So the goal is to kind of
get the best of both worlds,
and that's why we
have this system.
To get a sense of why these
losses get introduced,
one is that we actually have a--
once we have quantized
models, these parameters
are in lower precision.
So, in a sense, you have more
coarse information, fewer
buckets of information.
So that's where you have
information representation
loss.
The other problem is
that, when you're actually

Italian: 
 per migliorare l'accuratezza dei modelli quantizzati. 
 Il modo in cui funziona è che abbiamo introdotto 
 alcuni degli errori realmente accaduti 
 durante l'inferenza quantizzata nel processo di addestramento, 
 e questo aiuta effettivamente l'allenatore a imparare 
 questi errori e ottenere un modello più accurato. 
 Ora proviamo solo a farci un'idea del perché 
 questo era necessario in primo luogo. 
 Quindi sappiamo che i modelli quantizzati, 
 corrono con una precisione inferiore e, per questo motivo, 
 è un processo con perdite e ciò porta a un calo della precisione. 
 E mentre i modelli quantizzati sono super veloci e noi li vogliamo, 
 ma nessuno vuole un modello accurato. 
 Quindi l'obiettivo è ottenere il meglio da entrambi i mondi, 
 ed è per questo che abbiamo questo sistema. 
 Per avere un'idea del motivo per cui queste perdite vengono introdotte, 
 uno è che in realtà abbiamo un ... 
 una volta che abbiamo i modelli quantizzati, questi parametri 
 hanno una precisione inferiore. 
 Quindi, in un certo senso, hai informazioni più grossolane, meno 
 secchi di informazioni. 
 Quindi è lì che hai la rappresentazione delle informazioni 
 perdita. 
 L'altro problema è quello, quando lo sei effettivamente 

English: 
doing these computations,
then you have computation loss
when you're actually adding
to coarse values instead
of finer buckets of values.
Typically, during matrix
multiplication type
of operations, even if
you're doing it at int8,
you accumulate these
values to int32,
and then you rescale
them back to int8,
so you have that rescaling loss.
The other thing is
that, generally,
when we run these quantized
models during inference,
there are various inference
optimizations that
get applied to the graph,
and because of that,
the training graph and
the inference graph
can be subtly different,
which also can potentially
introduce some of these errors.
And how do we recover
lost accuracy?
Well, for starters, we try
to make the training graph as
similar as possible
to the inference graph
to remove these
subtle differences.
And the other is
that we actually
introduce these errors
which actually happened
during inference, so the
trainer learns around it
and machine learning
does its magic.

Italian: 
 facendo questi calcoli, si ha una perdita di calcolo 
 quando invece stai effettivamente aggiungendo a valori grossolani 
 di più fini bucket di valori. 
 Tipicamente, durante il tipo di moltiplicazione di matrici 
 di operazioni, anche se lo fai a int8, 
 accumuli questi valori in int32, 
 e poi li riscali di nuovo a int8, 
 quindi hai quella perdita di riscalaggio. 
 L'altra cosa è che, generalmente, 
 quando eseguiamo questi modelli quantizzati durante l'inferenza, 
 ci sono varie ottimizzazioni di inferenza che 
 vengono applicati al grafico e, per questo motivo, 
 il grafico di allenamento e il grafico di inferenza 
 può essere leggermente diverso, il che può anche potenzialmente 
 introdurre alcuni di questi errori. 
 E come recuperiamo la precisione persa? 
 Bene, per cominciare, proviamo a creare il grafico di allenamento come 
 simile il più possibile al grafico di inferenza 
 per rimuovere queste sottili differenze. 
 E l'altro è che in realtà 
 introdurre questi errori realmente accaduti 
 durante l'inferenza, così il formatore impara ad aggirarlo 
 e l'apprendimento automatico fa la sua magia. 

Italian: 
 Ad esempio, quando si tratta di imitare gli errori, 
 come puoi vedere nel grafico qui, 
 si passa dai pesi alla precisione inferiore. 
 Quindi diciamo che se i tuoi pesi sono in virgola mobile, 
 si scende a int8 e poi si torna su 
 in virgola mobile. 
 Quindi, in quel senso, in realtà 
 imitato ciò che accade durante l'inferenza quando sei 
 esecuzione con una precisione inferiore. 
 Quindi fai effettivamente i tuoi calcoli, 
 e perché sia ​​i tuoi input che i tuoi pesi sono a int8 
 e le perdite sono state introdotte, 
 il calcolo avviene correttamente. 
 Ma poi, dopo il calcolo, tu 
 aggiungi un altro quant falso al tipo di goccia 
 torna a una precisione inferiore. 
 L'altra cosa è che modelliamo la parte dell'inferenza. 
 Quindi, ad esempio, se hai notato nella diapositiva precedente, 
 la falsa operazione quantistica è avvenuta dopo l'attivazione del valore. 
 Quindi questa è una delle ottimizzazioni 
 che è successo durante l'inferenza, che il valore viene piegato. 
 E quello che facciamo è questo quando stiamo effettivamente costruendo 

English: 
So for example, when it
comes to mimicking errors,
as you can see in
the graph here,
you go from weights
to lower precision.
So let's say if your weights
are in floating point,
you go down to int8,
and then you go back up
to floating point.
So in that sense,
you've actually
mimicked what happens
during inference when you're
executing at lower precision.
Then you actually
do your computation,
and because both your inputs
and your weights are at int8
and the losses have
been introduced,
the computation
happens correctly.
But then after the
computation, you
add another fake
quant to kind of drop
back to lower precision.
The other thing is we
model the inference part.
So for example, if you
noticed in the previous slide,
the fake quant operation came
after the value activation.
So this is one of
the optimizations
that happened during inference,
that the value gets folded in.
And what we do is that when
we're actually constructing

Italian: 
 il tuo grafico, ci assicuriamo che questo tipo di ottimizzazioni 
 essere aggiunto in. 
 E diamo un'occhiata ai numeri. 
 Quindi i numeri sono abbastanza buoni. 
 Quindi se guardi la diapositiva, lo siamo 
 quasi quanto la linea di base float su varie versioni 
 modelli che abbiamo provato. 
 Quindi questo è davvero potente. 
 Puoi effettivamente eseguire un modello che 
 ti dà una precisione quasi altrettanto buona ed è quantizzato. 
 Allora qual è il valore per gli utenti? 
 Ebbene, da un lato ne hai uno semplice, quasi uno 
 line API che puoi utilizzare per quantizzare il tuo modello, 
 addestrarlo, convertirlo e andare avanti ed eseguirlo. 
 Funziona alla grande per sviluppatori di app, ingegneri ML e così via 
 cetera. 
 Potresti voler fare un passo avanti, 
 e poi abbiamo un'API leggermente più complicata, 
 dove è come, ehi, puoi tipo di configurazione 
 la tua quantizzazione come vuoi, 
 e questo sarebbe qualcosa che è 
 abbastanza utile per gli ingegneri ML, alcuni ricercatori. 
 E se vuoi andare completamente là fuori, 
 puoi effettivamente configurare completamente 
 schemi di algoritmo di quantizzazione, bit diversi, eccetera, 

English: 
your graph, we make sure that
these sorts of optimizations
get added in.
And let's look at the numbers.
So the numbers are pretty good.
So if you look at
the slide, we're
almost as close as the float
baseline on various version
models that we've tried.
So this is really powerful.
You can actually
execute a model which
gives you nearly as good
accuracy and is quantized.
So what's the value to users?
Well, you have on the one
hand a simple, almost one
line API that you can use
to quantize your model,
train it, convert it, and
go ahead and execute it.
This works great for app
developers, ML engineers, et
cetera.
You might want to
go one step ahead,
and then we have a slightly
more complicated API,
where it's like, hey,
you can kind of configure
your quantization
however you want,
and this would be
something that's
quite useful to ML
engineers, some researchers.
And if you want to go
completely out there,
you can actually
completely configure
quantization algorithm schemes,
different bits, et cetera,

Italian: 
 cosa vuoi, e questo fornisce un ottimo fertile 
 terreno per ricercatori o ingegneri hardware. 
 Quindi, fondamentalmente, l'API è, facile è facile, difficile è possibile. 
 Quindi diamo un'occhiata a come lo facciamo. 
 Bene, questo è il tuo modello Keras standard. 
 Se vuoi, diciamo, quantizzare 
 l'intero modello, in genere costruisci il modello, 
 importa tensorflow come tf, model.compile, model.fit, 
 vai avanti, vero? 
 Ora, diamo un'occhiata a cosa quantizzare il modello 
 sembra. 
 Più o meno la stessa cosa, giusto? 
 Importa tensorflow_model_optimization 
 come tfmot. 
 Questo è il pacchetto che metti. 
 Costruisci il tuo modello, quantizza il modello, 
 e poi vai avanti. 
 Fai il tuo adattamento alla compilazione, tutto questo, continua con quello. 
 Ora, potresti non voler quantizzare l'intero modello. 
 Forse vuoi quantizzare un sottoinsieme del tuo modello, 
 perché alcune parti del modello sono o più sensibili 
 alle perdite di quantizzazione, o vuoi 
 per ottenere il massimo dalle prestazioni. 
 Quindi vuoi quantizzare solo una parte del tuo modello. 
 E in quel caso, è ancora piuttosto semplice, giusto 

English: 
what do you want, and this
provides a very good fertile
ground for researchers
or hardware engineers.
So basically, the API is, easy
is easy, hard is possible.
So let's look at
how do we do this.
So well, this is your
standard Keras model.
If you want to,
let's say, quantize
your entire model, typically
you construct the model,
import tensorflow as tf,
model.compile, model.fit,
go ahead, right?
Now, let's look at what
quantizing the model
looks like.
Pretty much the
same thing, right?
Import
tensorflow_model_optimization
as tfmot.
That's the package you put in.
You construct your model,
quantize the model,
and then just go ahead.
You do your compile fit, all
of that, continue with that.
Now, you might not want to
quantize the entire model.
Maybe you want to quantize
a subset of your model,
because some parts of the
model are either most sensitive
to quantization
losses, or you want
to get the most
performance out of them.
So you want to quantize
only a part of your model.
And in that case, it's
still pretty simple, just

Italian: 
 leggermente diverso. 
 Quindi, ad esempio, hai un livello di annotazione quantizzato. 
 Gli dici quali livelli vuoi quantizzare, 
 e poi lo applichi alla fine, 
 e poi sei a posto. 
 Oltre a ciò, potresti voler controllare la quantizzazione 
 all'interno di uno strato. 
 Quindi, ad esempio, hai un livello particolare, 
 ma vuoi controllare quali pesi vuoi quantizzare, 
 come vuoi quantizzarlo. 
 E in quel caso, inoltre, è un'API abbastanza simile. 
 Usi quantize annotate layer, ma quando lo fai effettivamente 
 passa nel livello, passi anche in una configurazione specifica, 
 e questa configurazione dice all'infrastruttura 
 come quantizzare effettivamente questo livello. 
 E il resto dell'API è lo stesso. 
 Diamo un'occhiata a come definisci questa configurazione. 
 Quindi questa configurazione ci dice in gran parte due cose. 
 Uno è quello che c'è all'interno di quello strato 
 che vuoi quantizzare e l'altro 
 è come vuoi quantizzarlo. 
 Quindi ci dici quale peso o quale attivazione 
 vuoi quantizzare. 

English: 
slightly different.
So for example, you have a
quantized annotate layer.
You tell it which layers
you want to quantize,
and then you apply
it at the end,
and then you're good to go.
Beyond that, you might want
to control the quantization
within a layer.
So for example, you
have a particular layer,
but you want to control which
weights you want to quantize,
how you want to quantize it.
And in that case, also,
it's pretty similar API.
You use quantize annotate
layer, but when you actually
pass in the layer, you also
pass in a specific config,
and this config tells
the infrastructure
how to actually
quantize this layer.
And the rest of the
API is the same.
Let's look at how you
define this config.
So this config is largely
telling us two things.
One is that what is
it within that layer
that you want to
quantize, and the other
is how you want to quantize it.
So you tell us which
weight or which activation
you want to quantize.

Italian: 
 E l'altra cosa è che ci dici ... 
 ci dai, passaci un quantizzatore, 
 e questo quantizzatore è fondamentalmente un oggetto 
 che incapsula il tipo di algoritmo su come 
 per quantizzare questo. 
 Ti diamo un sacco di quelli integrati, 
 ma puoi scrivere il tuo. 
 Potresti voler quantizzare il tuo livello. 
 Quindi supponiamo che tu abbia un algoritmo speciale, 
 come uno strato convoluzionale di fantasia che scrivi, 
 e vuoi quantizzare anche quello. 
 Bene, lo fai quasi esattamente allo stesso modo. 
 Quantizzi annoti il ​​tuo livello, passi in una configurazione, 
 e questa configurazione ci dice come dovremmo 
 quantizza il tuo livello di fantasia. 
 E ancora, ci dici cosa quantizzare, come quantizzarlo. 
 E in questo caso, cosa sembri ... 
 quello che noti è che c'è come un quantizzatore di istogrammi, 
 e questo è, diciamo, un quantizzatore speciale. 
 E un quantizzatore speciale è interessante, 
 perché questo ti consente di controllare completamente 
 che tipo di strategia stai usando per quantizzare il tuo modello. 
 Tu, in questo caso, potresti usare un istogramma 

English: 
And the other thing
is you tell us--
you give us-- pass
us a quantizer,
and this quantizer is
basically an object
that encapsulates kind of
the algorithm about how
to quantize this.
We give you a bunch
of built-in ones,
but you can write your own.
You might want to
quantize your own layer.
So let's say you have
a special algorithm,
like a fancy convolutional
layer that you write,
and you want to
quantize that as well.
Well, you do it almost
in exactly the same way.
You quantize annotate your
layer, you pass in a config,
and this config tells
us how we should
quantize your fancy layer.
And again, you tell us what to
quantize, how to quantize it.
And in this case,
what do you look--
what you notice is that there
is like a histogram quantizer,
and this is, let's say,
a special quantizer.
And a special quantizer
is interesting,
because that allows you
to completely control
what sort of strategy you're
using to quantize your model.
You, in this case,
could use a histogram

English: 
to determine the range
and then quantize it.
And that's how you would
write the algorithm.
And it's pretty simple.
You just implement two methods.
One is build, which is
basically for you to construct
any variables you need.
And then in the call method,
we give you a bunch of tensors,
you quantize them
however you wish.
You return us the tensors and
we'll take care of the rest.
And it doesn't end here.
We actually provide
you the ability
to completely kind of
define your own schemes,
specify how each layer
should be quantized,
going so far as to kind of--
I mentioned earlier
that you can--
we fuse the values
for you, for example,
so you can actually define
your own kind of transforms,
which tell what sort
of manipulations
you want to do on the graph.
So in summary,
Quantization Aware Training
is an API which
helps you recover
your accuracy while getting
the benefits of quantization.
It's a pretty simple
API for easy tasks,
but quite flexible if you want
to do more complicated things.
And it simulates
quantization loss

Italian: 
 per determinare l'intervallo e quindi quantizzarlo. 
 Ed è così che scriveresti l'algoritmo. 
 Ed è abbastanza semplice. 
 Devi solo implementare due metodi. 
 Uno è build, che è fondamentalmente da costruire 
 tutte le variabili di cui hai bisogno. 
 E poi nel metodo di chiamata, ti diamo un mucchio di tensori, 
 li quantizzi come preferisci. 
 Restituiscici i tensori e al resto pensiamo noi. 
 E non finisce qui. 
 In realtà ti forniamo l'abilità 
 per definire completamente i tuoi schemi, 
 specificare come ogni strato dovrebbe essere quantizzato, 
 arrivando al punto di ... 
 Ho detto prima che puoi ... 
 fondiamo i valori per te, ad esempio, 
 in modo che tu possa effettivamente definire il tuo tipo di trasformazioni, 
 che dicono che tipo di manipolazioni 
 vuoi fare sul grafico. 
 Quindi, in sintesi, Quantization Aware Training 
 è un'API che ti aiuta a recuperare 
 la tua precisione mentre ottieni i vantaggi della quantizzazione. 
 È un'API piuttosto semplice per attività facili, 
 ma abbastanza flessibile se vuoi fare cose più complicate. 
 E simula la perdita di quantizzazione 

Italian: 
 ciò accade su vari backend e schemi differenti. 
 Puoi configurarlo. 
 Ci sono cose più interessanti in arrivo. 
 Abbiamo rilasciato l'addestramento per la scarsità 
 Time API qualche tempo fa. 
 Ma ora stiamo lavorando su un'esecuzione del kernel sparsa, 
 e sta arrivando. 
 E poi avrai una storia end-to-end, 
 che puoi addestrare modelli sparsi ed eseguirlo sul dispositivo. 
 E puoi anche usare la quantizzazione e la scarsità 
 insieme, e questo è abbastanza potente quando vanno insieme. 
 Quindi questo è il toolkit per l'ottimizzazione del modello. 
 È una suite di strumenti che rende i tuoi modelli più veloci e più piccoli. 
 Quantizzazione e scarsità sono le tecniche principali 
 che noi abbiamo. 
 Puoi trovarci su github / model-optimization. 
 Si prega di presentare eventuali richieste, dubbi, bug o feedback 
 che hai e lavoriamo sempre 
 per rendere quei modelli più piccoli e più veloci. 
 Grazie. 
 [MUSICA IN ESECUZIONE] 

English: 
that happens on various
different backends and schemes.
You can kind of configure that.
There are cooler
things coming up.
We released the
sparsity training
time API sometime back.
But now we're working on
sparse kernel execution,
and that's coming up.
And then you'll have
an end to end story,
that you can train sparse
models and execute it on device.
And you can also use
quantization and sparsity
together, and that's quite
powerful when they go together.
So that's the model
optimization toolkit.
It's a suite of tools that make
your models faster and smaller.
Quantization and sparsity
are the main techniques
that we have.
You can find us on
github/model-optimization.
Please file any requests,
concerns, bugs, or feedback
that you have, and
we're always working
on making those models
smaller and faster.
Thank you.
[MUSIC PLAYING]
