
Spanish: 
Hola a todos.
Mi nombre es Chris Leary.
Soy ingeniero de compilación en Google.
Y estoy aquí hoy para decir
que podemos compilar TensorFlow
algo muy emocionante.
Y tenemos documentación
sobre cómo puedes compilar TensorFlow.
Y tenemos la documentación
de código abierto
del compilador de código abierto
para compilar
código abierto de TensorFlow.
Como dice el antiguo proverbio:
"Todo un pueblo cría a un compilador".
Muchas personas participan
en el desarrollo de XLA.
Aquí estoy hablando sobre XLA.
Hemos tenido muchas contribuciones.
Esperamos mucha más participación
de la comunidad
y contribuciones de la comunidad ahora
que es de código abierto.
Entonces quiero empezar hablando
de las fortalezas principales
de TensorFlow.
Es flexible, expresivo y extensible.
Y hemos oído de algunos
de esos atributos en el informe.
Entonces, ¿cómo se logra
esto en TensorFlow?
La flexibilidad se debe
en parte a su naturaleza.
Como su nombre TensorFlow.

English: 
[MUSIC PLAYING]
CHRIS LEARY: Hello, everybody.
I'm Chris Leary.
I'm a compiler
engineer at Google.
And I'm here today to tell you
that we can compile TensorFlow,
which is super exciting.
And we have documentation about
how you can compile TensorFlow.
And we have open
source documentation
about the open source
compiler that you can compile
open source TensorFlow with.
So as the ancient
proverb says, "It
takes a village to
raise a compiler."
And many people
have been involved
in the development of XLA.
I'm up here speaking about XLA.
But we've had a lot
of contributions.
And we look forward to a lot
more community involvement
and community contributions now
that it's in the open source.
So I wanted to start off
by talking about some
of the key strengths
of TensorFlow.
It's flexible, it's expressive,
and it's extensible.
And we've heard about
some of those attributes
in the keynote.
So how is this
accomplished in TensorFlow?
The flexibility is due in part
to its interpreted nature.
It's in the name, TensorFlow.

Korean: 
안녕하세요, 어려분
전 크리스 리어리이고
Google 컴파일러 엔지니어입니다
전 오늘 텐서플로우를 컴파일할 수
있다는 사실을 말씀드리고 싶습니다
정말 신나죠
저희는 텐서플로우를 어떻게 컴파일할 수
있는가에 대한 문서도 있습니다
또한 오픈 소스를 문서화 했고
이 문서는 오픈 소스 텐서플로우와
컴파일할 수 있는 오픈소스 컴파일러죠
고대 속담이 전하듯
"컴파일러를 카우기 위해선
마을 하나가 필요합니다"
많은 분들이 XLA 개발에
동참해 왔습니다
XLA에 대해 이야기하려고 나왔지만
기여해주신 분들이 정말 많습니다
게다가 오픈 소스이니만큼
더욱 많은 지역사회의
기여와 공헌이 기대됩니다
그럼 텐서플로우의 주요 장점에 대해
이야기하면서 시작해 보겠습니다
융통성 있고, 표현적이고
또 확장 가능 합니다
키노트 때 이러한 속성
몇 가지에 대해 들었죠
어떻게 이것이
텐서플로우에서 만들어질까요?
융통성은 해석화된 속성에 의해
부분적으로 가능합니다
텐서플로우의 이름에 있죠

Portuguese: 
Olá, pessoal. Me chamo Chris Leary.
Sou engenheiro de compilação na Google.
Estou aqui para dizer
que podemos compilar o TensorFlow!
O que é super animador.
Temos documentação
sobre como compilar o TensorFlow.
Temos uma documentação com código aberto
sobre o compilador livre
que pode compilar o TensorFlow,
que também tem código aberto.
Como diz o antigo ditado,
"com uma aldeia se faz um compilador".
Muitas pessoas estiveram envolvidas
no desenvolvimento de XLA.
Estou aqui para falar de XLA,
mas tivemos muitas contribuições
e queremos um envolvimento
ainda maior da comunidade
e contribuições da comunidade,
agora que o código é aberto.
Queria começar falando
de alguns pontos fortes do TensorFlow.
Ele é flexível, expressivo e extensível.
Falaram de alguns desses atributos
na palestra principal.
Como isso é feito no TensorFlow?
A flexibilidade é graças
na interpretação de sua natureza.
Está no nome dele: Tensor-Flow.

Japanese: 
みなさん、こんにちは。
クリス・レアリーです。
Google 社でコンパイラー
エンジニアを務めています。
TensorFlow をコンパイルできる
ということについてお話しします。
とても素晴しいことです。
TensorFlow のコンパイル方法に
ついての資料を紹介します。
TensorFlow オープンソースを
コンパイルする、
オープンソースコンパイラーについての
オープンソース資料も紹介します。
「コンパイラを育てるには、
村１つ必要である」という
ことわざがありますが、
XLA の開発には、
多くの人が携わってきました。
今日は XLA についてお話します。
多大な助力を得てきました。
より多くのコミュニティが
参加することを望んでおり、
コミュニティによる助力は、
オープンソースの中に反映されています。
TensorFlow の主要な長所から
お話したいと思います。
それは柔軟性、表現性、
そして拡張性です。
キーノート部分で、
これらの特性について知りました。
TensorFlow ではどのように
それが実現されるのでしょう。
柔軟性は、その解釈性に
ある程度反映しています。

Chinese: 
大家好
我是克里斯·利瑞
我是谷歌的编译工程师
我今天在这里要告诉大家
我们可以编译TensorFlow
这真的太让人兴奋了
并且我们有如何编译TensorFlow的相关文件
我们有可以用来编译TensorFlow的
开源资料
开源的编译器
因此 像古谚语说的那样
“需要整个社区来研发一个编译器“
很多人都参与了
XLA的研发
我在这里就是要跟大家介绍XLA的
有很多人的贡献
因而我们希望有更多的社群可以参与进来
感谢现在已经在做贡献的社群
这个工具是开源的
我想先从TensorFlow的主要优点
开始说
它非常的灵活，富有表现力并可扩展
我们已经在主题会上
听说了这些特征
TensorFlow是如何实现这些特征的呢？
灵活性一部分是因为它的自然属性
体现在它的名字上TensorFlow

Indonesian: 
Halo, semuanya.
Saya Chris Leary.
Saya insinyur kompilator di Google.
Saya di sini untuk berbagi bahwa TensorFlow
bisa dikompilasikan, seru sekali kan.
Dan kami punya dokumentasi soal
cara Anda bisa kompilasikan TensorFlow.
Kami punya dokumentasi sumber terbuka
soal kompilator sumber terbuka
yang bisa kompilasikan
sumber terbuka TensorFlow.
Seperti kata pepatah kuno, "Butuh
satu desa untuk membuat kompilator."
Banyak orang telah terlibat
dalam pengembangan XLA.
Saya di sini bicara soal XLA.
Tapi kami punya banyak kontribusi.
Kami nantikan lebih banyak
keterlibatan komunitas
dan kontribusi komunitas
sejak dijadikan sumber terbuka.
Jadi saya ingin mulai dengan bicara
tentang kekuatan utama TensorFlow.
Ini fleksibel, ekspresif,
dan bisa diperluas.
Kami dengar banyak atribut itu
dalam intisari.
Jadi bagaimana ini diraih di TensorFlow?
Fleksibilitasnya disebabkan oleh
sifat interpretasinya.
Ada dalam namanya, TensorFlow.

Japanese: 
まさに TensorFLow という
名前の通りです。
このデータフロープログラミング
モデルを使用します。
プログラムはグラフにパスしたら、
どのように作動するでしょうか。
実行可能なノードを見つけ、取得し
作動させて、
より多くのノードを
実行可能な状態にします。
そして作業を進め、
これらのノードを取得し実行します。
TensorFlow のコア部分にある
インタープリタループです。
ダイナミックです。
これはある程度、
パイソンへリテージの恩恵よるものです。
グラフを定義した時に、
フルレベルの表現機能を得ることができます。
何を表現できて、
何が表現できないかを教えてくれる
外部エンティティから
制限されることはありません。
またステートフルです。
別の環境でプログラミングするように
変数を使ってプログラムを実行します。
「ブラック・ボックス」
モジュラーと呼ばれます。
新しいデータフローオペレーションを
実行し、
オリジナル TensorFlow のデザイナーが
考えもしなかった、
TensorFlow にプラグイン
することが可能となります。
ここで知りたいのは、
どうやってこれらすべての長所を利用して
またスピードアップをはかるか
ということです。
ジェットエンジン上部に固定された
タンクだということです。
このようなタイプのアプローチに対して、
何ができるか具体的に示すものです。

Chinese: 
它使用这个数据流编程模型
这个程序所做的是
你给它一张图表
它发现一个可以执行的节点，抓住它
运行它，然后其它的一些节点也准备好运行了
然后它找到这些节点，运行他们
这就是TensorFlow最核心的解释循环
它是动态的
它一部分由Python组成
当你定义图表的时候
你需要使用完整的表达
并且不会被外部的一些
关于什么可以表达
什么不可以表达的规则所限制
并且它是有状态的
你需要用变量来编程
就像你在其它环境下编程一样
它使用“黑盒”模块
所以你能想出一个新的数据流操作
并把它插到TensorFlow
这些操作是最初TensorFlow开发者
从未想到过的
所以问题就在于我们如何
采用所有的优势
还可以使它运行的更快？
所以这是一辆在顶端
装有飞机引擎的坦克
我认为这正体现了
我们用这种手段想要达到的效果
我们实现这一点的方法是

Spanish: 
Utiliza este modelo de programación
de flujo de datos.
Entonces lo que hace el programa,
le das un gráfico, él encuentra
un nodo listo
para ejecutarse, lo agarra
lo ejecuta y luego un montón
de nodos más ya están listos.
Luego va y agarra esos nodos
y los ejecuta.
Eso es el bucle de interpretación
en el corazón de TensorFlow.
Dinámico.
Se debe en parte a su herencia Pythonic.
Puedes usar toda tu expresividad
al definir tu gráfico.
No hay restricción
por una entidad externa que dice
lo que puedes y no puedes expresar.
Y es dinámico.
Lo programas usando variables
igual a cómo programas en otros entornos.
Y es "Black-Box" modular.
Puedes generar una nueva operación
de flujo de datos y conectarla
con TensorFlow,
algo que los diseñadores originales
de TensorFlow no habían pensado.
Preguntamos
¿cómo tomamos todas esas fortalezas
y agregamos más velocidad?
Es un tanque
con motores de reacción
atornillados arriba.
Creo que ejemplifica bien
lo que haremos con este tipo de enfoque.
La forma en que lo logramos

English: 
It uses this data flow
programming model.
So what the program does,
you hand it a graph,
it finds a node that's ready
to execute, it grabs it,
it runs it, and then a bunch
more nodes become ready.
And then it goes and grabs
those nodes and executes them.
So that's the interpreter loop
at the heart of TensorFlow.
It's dynamic.
And this is owed in part
to its Pythonic heritage.
You get to use your
full expressiveness
when you define your graph.
And you're not constrained by
some external entity that tells
you what you can
and cannot express.
And it's stateful.
So you get to program
using variables
like you're used to programming
in other environments.
And it's "Black-Box" modular.
So you can come up with
a new dataflow operation
and plug it into TensorFlow
that the original TensorFlow
designers had never
even thought of.
So the question is how, do
we take all those strengths
and add more speed?
So this is a tank
with jet engines
bolted on the top of it.
I thought that
really exemplified
what we're going for with
this kind of approach.
So the way that
we accomplish this

Korean: 
이 데이터 플로우
프로그래밍 모델을 사용합니다
프로그램이 하는 일은 그래프를 넘겨주면
실행 준비가 된 노드를 찾아서
운행시키고 그러면
다른 많은 노드가 준비되죠
그러면 이 프로그램은 이 노드들을
잡아서 실행시킵니다
이것이 텐서플로우의 중심에 있는
인터프리터 루프입니다
역동적이죠
그리고 이는 부분적으로
파이썬에서 온 것입니다
그래프를 정의 내릴 땐 풍부한 표현력을
사용해야 합니다
무엇이 표현될 수 있고
될 수 없는가를 알려주는
외부 실체에 의해 제한되지 않습니다
상태개념도 있죠
다른 환경에서 프로그래밍을
해 온 것처럼 변수를 사용해서
프로그램할 수 있습니다
그리고 "블랙박스" 모듈러입니다
따라서 여러분은 새로운
데이터플로우 작동을 생각해 내서
원래의 텐서플로우 디자이너가
생각도 못했을 법한 것을
텐서플로우에 플러그인 할 수 있죠
따라서 문제는 어떻게 이 모든 강점에
속도를 더할 수 있을까 하는 것이죠
이건 윗쪽에 볼트로 접합된
제트엔진이 있는 탱크입니다
전 이 말이 이러한 접근법으로
하려는 일의 전형적인
예시인 것 같습니다
이를 성공하는 방법은

Portuguese: 
Ele usa um modelo
de programação de fluxo de dados.
O que o programa faz é
você insere um grafo,
ele acha um nódulo
pronto para executá-lo, pega-o,
executa e vários outros nódulos
ficam prontos.
E então pega esses nódulos e os executa.
Esse é o loop de interpretação
no cerne do TensorFlow.
Ele é dinâmico.
E isso se dá, em parte,
graças à herança do Python.
É possível usar expressividade total
ao definir o seu grafo.
Você não está limitado
por uma entidade externa
que define o que se pode ou não expressar.
E é declarativo.
É possível programar usando variáveis,
como se costuma programar
em outros ambientes.
E tem modelagem black-box:
é possível inventar
novas operações de fluxo de dados
e ligá-las ao TensorFlow,
coisas que os designers originais
do TensorFlow nem imaginaram.
A pergunta é: como usar
todos esses pontos fortes
e adicionar mais velocidade?
Isto é um tanque
com motores a jato em cima.
Achei que seria um bom exemplo
do que buscamos com esta abordagem.

Indonesian: 
Memakai model aliran data pemrograman.
Jadi apa yang dilakukan program,
Anda memberinya grafik
lalu dia temukan node yang siap
dieksekusi, mengambilnya
dan menjalankannya, lalu
node lainnya akan menjadi siap.
Kemudian, node akan diambil
dan dieksekusi.
Jadi itulah perulangan interpreter
di pusat TensorFlow.
Itu dinamis.
Ini karena ada bagian
warisan Pythonnya.
Anda bisa gunakan ekspresif penuh Anda
saat definisikan grafik.
Anda tak dibatasi oleh entitas
eksternal yang mengatur
apa yang bisa dan tak bisa
Anda ekspresikan.
Dan itu stateful.
Anda bisa memprogram dengan variabel
seperti yang biasa Anda lakukan
untuk pemrograman di lingkungan lain.
Dan ini modular "Kotak-Hitam".
Anda bisa lakukan
dengan operasi aliran data baru
dan memasukkannya ke TensorFlow
yang tak pernah dipikirkan
oleh desainer asli TensorFlow.
Lalu bagimana mengambil semua kekuatan itu
dan tambahkan kecepatan lebih?
Jadi inilah tank dengan mesin jet
dipasang di atasnya.
Saya pikir itu contoh tepat
yang kita lakukan dengan pendekatan ini.
Cara kita memperoleh ini

Portuguese: 
A forma de conseguir isso
é com compilação just-in-time via XLA,
que significa "Álgebra Linear Acelerada".
É a infraestrutura do compilador
que desenvolvemos.
Então você pode inserir
um grafo TensorFlow
e receber uma montagem
otimizada e especializada
para esse grafo.
Para mostrar como funciona,
vamos começar com uma shell,
como gostam os programadores.
Iniciando o vídeo,
você vai ver a shell do TensorFlow
que pode construir e executar
em código aberto.
E colocamos uma flag que diga
para entregar a montagem XLA
que foi produzida.
Então adicionamos uma expressão simples.
Pegamos quatro números
em ponto flutuante e os multiplicamos.
E colocamos isso explicitamente
na XLA do dispositivo CPU.
O compilador é exposto
como um dispositivo, em um modo,
dentro do TensorFlow.
Apertamos o Enter nesta expressão.
Pause.
Veremos só algumas instruções
de montagem serem emitidas.
Pessoas da plateia devem estar pensando
que conhecem essa montagem.

Indonesian: 
adalah dengan kompilasi
tepat waktu via XLA
yaitu singkatan untuk
Accelerated Linear Algebra.
Ini infrastruktur kompilator
yang kami kembangkan,
jadi Anda bisa ambil grafik TensorFlow
dan membagi kumpulan
teroptimasi dan terspesialisasi
untuk grafik itu.
Untuk menunjukkan Anda
cara kerjanya, kami akan mulai
dengan kerangka, seperti
yang disenangi pemrogram.
Jadi kalau kami mainkan video ini,
Anda akan lihat kerangka TensorFlow
yang bisa Anda bangun dan jalankan
dalam sumber terbuka.
Kami beri tanda untuk katakan,
pisahkan kumpulan XLA
yang dihasilkan.
Kami buat ekspresi sederhana.
Kami hanya ambil
empat angka floating point
lalu mengalikannya.
Kami simpan secara eksplisit
ke dalam perangkat CPU XLA.
Jadi kompilator diekspos
sebagai perangkat dalam satu mode
di dalam TensorFlow.
Jadi saat kita tekan Enter di ekspresi ini
lalu jeda, kita akan melihat
beberapa instruksi rakitan ditampilkan.
Beberapa pemirsa, tentunya,
oh, aku tahu rakitan itu.

English: 
is with just-in-time
compilation via XLA,
which stands for
Accelerated Linear Algebra.
And this is compiler
infrastructure
that we've developed, so that
you can take a TensorFlow
graph in and spit out optimized
and specialized assembly
for that graph.
And to show you how
this works, we're
going to start with a
shell, as programmers love.
So if we start
this video, you'll
see the TensorFlow shell,
as you can build and run
in open source.
And we're passing it a flag
to say, spit out the XLA
assembly that's produced.
So we're piecing in a
very simple expression.
So we're actually just taking
four floating point numbers
and multiplying them.
And we're putting
this explicitly
onto the XLA CPU device.
So the compiler is exposed
as a device in one mode
inside of TensorFlow.
So when we press Enter on
this expression and pause,
then we'll actually see just a
couple of assembly instructions
get emitted.
And some people in the audience
are like, oh, of course,
I know that assembly.

Korean: 
XLA를 통한 저스트인타임 컴파일으로
XLA는 가속화된
선형 대수학의 약자입니다
이는 저희가 개발해온
컴파일러 기반시설로
텐서플로우 그래프를 가지고
그 그래프를 위한 최적화되고
특별화된 조립을
만들어 내는 거죠
이것이 어떻게 작동하는가를
보여드리기 위해
프로그래머들이 좋아하는
쉘에서 시작하겠습니다
이 비디오를 시작하면
텐서플로우 쉘을 보실 겁니다
오픈 소스에서 만들고
실행할 수 있으니까 말이죠
플래그를 주고 생산된 XLA 어셈블리를
나타내라고 하는 거죠
아주 간단한 수식으로
조각을 맞추는 거죠
사실 그냥 네 가지 부동 소수점 수를
곱하고 있는 겁니다
저희는 이것을 XLA CPU 기기에
드러나게 넣고 있는 거죠
이 컴파일러는 텐서플로우 내의
한 모드에서 기기로 노출됩니다
이 수식에서 엔터키를 누르고 멈추면
몇 가지 어셈블리 지시사항이 나온 것을
볼 수 있죠
여러분들 중 몇 분은 아마 이러시겠죠
물론 저 어셈블리 알지

Japanese: 
これを実行する方法は、
XLA を通じたジャストインタイムの
コンピレーションであり、
これは加速一次代数をサポートしています。
これは、私達が開発した
コンパイラーインフラです。
TensorFlow グラフを取得することができ、
またそのグラフ用に最適化、特定化した
アセンブリを出力することが可能です。
これがどのように作動するかを
お見せするため、
プログラマーが好む、
シェルから始めることにしましょう。
このビデオをご覧になれば、
どのように TensorFlow シェルを構築し
オープンスペースで作動させるかを
理解することができます。
そしてそれをフラッグにパスし、
生成された XLA アセンブリを
出力するよう伝えます。
非常にシンプルな式に
繋ぎ合わせます。
４つのフローティングポイント
ナンバーを取得し、
これらを掛けます。
そして XLA CPU デバイスに
明確に入力します。
コンパイラーは ワンモードのデバイスとして
TensorFlow 内部に出現します。
この式とポーズの部分で
Enter キーを押すと、
数個のアセンブリインストラクションが
発行されるのを目にすることができます。
聴衆席の中で「もちろん、
そのアセンブリなら知っている」
という方がいらっしゃると思います。

Chinese: 
通过 XLA 实现即时编译
XLA 也就是加速线性代数
这是一个我们开发的编译器的基础
这样你可以将一个TensorFlow图表
然后将图表优化
并且重新组装
为了向你展示这是如何运作的
我们将从一个壳开始
正如程序员喜欢的那样
如果我们开始这个视频
你可以看到TensorFlow壳
你可以在开源中构建并且运行
我们给它一个标签
叫做翻译生成的 XLA 集合
然后我们输入一个非常简单的表达式
仅仅用四个浮点数
将它们相乘
然后我们把它放到
XLA CPU设备上
这样编译器就变成在TensorFlow里
处于一种模式的一台设备
当我们点击输入 然后暂停
我们就可以看到
一些汇编指令出现
你们中的一些人可能会说
当然啦 我知道那些汇编

Spanish: 
es con una compilación
justo a tiempo vía XLA
que significa "Álgebra Lineal Acelerada".
Infraestructura de compilación
que desarrollamos
para que uses un gráfico
de TensorFlow y obtengas un ensamblado
optimizado y especializado
para ese gráfico.
Y para mostrar cómo funciona esto
empezaremos con un shell,
lo que aman los programadores.
Si iniciamos este video, verás el shell
de TensorFlow,
ya que puedes construir y ejecutar
en código abierto.
Le estamos pasando un Flag
para que muestre
el ensamblado XLA que produjo.
Escribimos una expresión muy simple.
Estamos tomando cuatro números
en coma flotante
y multiplicándolos.
Y lo estamos poniendo explícitamente
en el dispositivo CPU XLA.
El compilador se expone
como un dispositivo en un modo
dentro de TensorFlow.
Entonces al presionar Enter
en esta expresión y hacer una pausa
veremos solo un par
de instrucciones de ensamblado
emitidas.
Y algunas personas en la audiencia seguro
que conocen ese ensamblado.

Indonesian: 
Tapi inti rakitan ini adalah
tidak ada perulangan,
karena kita tahu
kalau ada empat elemen
yang akan Anda kalikan di grafik.
Jadi sebenarnya
mengeluarkan satu intruksi
yang Anda butuh
di Vector Extended Architecture ini
untuk mengimplementasi
ekspresi itu di perangkat CPU.
Jadi optimasi dan spesialisasi
untuk grafik
yang Anda beri ke ekspresi
TensorFlow Anda.
Dan kalau kita lanjutkan,
kita juga akan lihat
kalau kita bisa meletakkan ekspresi
yang sama itu ke perangkat GPU
lalu menyusun kode rakitan GPU
di perangkat XLA_GPU
yang berkaitan pada apa
yang kita hasilkan di sisi CPU.
Sembari kita gulir ke atas,
rakitan GPU punya sedikit boilerplate
karena dia meluncurkan berbagai thread
yang harus cari tahu apa yang dilakukan.
Tapi nomor 4 di sini bilang,
aku meluncurkan empat thread GPU.
Aku khusus karena itu ekspresi sebenarnya
yang Anda ketik di TensorFlow.
Ini menunjukkan kami memahami
ekspresi yang Anda beri
saat waktu proses di grafik TensorFlow

English: 
But the point of
this assembly is
there are no loops,
because we knew
that there were exactly
four elements that you're
going to multiply in the graph.
So it actually emitted
the one instruction
that you need in this
Vector Extended Architecture
to implement that expression
on that CPU device.
So optimized and
specialized for the graph
that you fed in with your
TensorFlow expression.
And if we continue
on, we'll also
see that we can place that same
expression onto a GPU device
and compile some GPU assembly
code on the XLA_GPU device that
corresponds to what we
generated on the CPU side.
So as we scroll up,
the GPU assembly
has a little bit
more boilerplate,
because it's launching
multiple threads,
and threads have to
figure out what to do.
But this number
4 here is saying,
I am launching four GPU threads.
And I am specialized
for the fact
that that is the
exact expression
that you typed into TensorFlow.
So this shows that we understand
what expression you give us
at runtime in the
TensorFlow graph

Spanish: 
Pero el punto de este ensamblado
es que no hay bucles porque ya sabíamos
que habían con exactitud cuatro elementos
que multiplicarás en el gráfico.
En realidad, emitiste la única instrucción
que necesitas en esta
arquitectura vectorial extendida
para implementar esa expresión
en ese dispositivo de la CPU.
Tan optimizado y especializado
para el gráfico
que alimentaste
con tu expresión TensorFlow.
Y si seguimos adelante, también veremos
que podemos incluir esa misma expresión
en un dispositivo GPU
y compilar algún código GPU de ensamblado
en el dispositivo XLA_GPU
que corresponde a lo que generamos
en el lado de la CPU.
Mientras vamos hacia arriba, el GPU
tiene algo más de repetición
porque está lanzando varios hilos
y tienen que averiguar qué hacer.
El número cuatro aquí está diciendo
"estoy lanzando cuatro hilos de GPU".
Y estoy especializado
porque esta es la expresión exacta
que escribiste en TensorFlow.
Demuestra que entendemos la expresión
que nos diste
en tiempo de ejecución
en el gráfico de TensorFlow

Chinese: 
但是汇编的目的是
没有循环
因为我们知道有四个要素
你需要在图表中相乘
所以实际上它发出了一个指令
你需要这个向量扩展体系结构
在那台CPU设备上执行那个表达
所以优化并专业化你输入的图表
通过TensorFlow表达
如果我们继续的话
会发现我们可以在 GPU 使用相同的表达
并且将一些 GPU 汇编代码
编译到 XLA_GPU 设备上
让其与我们在 CPU 端生成的内容相对应
我们滑动到上方
GPU汇编有更多的样板
因为它需要启动多组代码
来发现需要做什么
但这里的数字"4"表明
我要启动四组GPU 代码
我非常的确信
这就是你需要输入
TensorFlow中的代码
这就代表我们理解了你给我们的表达
在TensorFlow图像运行的时候

Japanese: 
しかし、このアセンブリには
ループがありません。
そこには、グラフ内で掛け算する
４つのエレメンツしかありません。
その CPU デバイス上に
その式を実行するための、
この拡張ベクトルアーキテクチャー内に
必要なワンインストラクションを
出力したのです。
つまり、TensorFlow 式に
入力するグラフ用に最適化し
特定化したのです。
この作業を続ければ、
同じ式を GPU デバイス上に
配置することができ、
いくつかの GPU アセンブリーコードを
XLA_GPU デバイス上にコンパイルでき、
それは CPU サイド上に生成したものに
対応します。
スクロールアップすると、
GPU アセンブリは多少
ボイラープレートを得ることになります。
なぜなら、それが
マルチプルスレッドを出力し
スレッドはどうすべきか答えを
見つけなければいけないからです。
しかし、ここにある４の数字が意味するのは
今４つの GPU スレッドを
出力するところで、
TensoFlow 内に入力した
同一の式であることに
特定化しているということを
伝えています。
これが意味するのは、
TensorFlow グラフ内で
実行中にどんな式を入力し、
また最大スピード化のために

Portuguese: 
Mas o que importa nessa montagem
é que não há loops,
porque sabíamos que havia
exatamente quatro elementos
que seriam multiplicados no grafo.
Então ele emitiu a única instrução
que você precisa
nessa Arquitetura Vetorial Estendida
para implementar essa expressão
neste dispositivo CPU.
Otimizada e especializada
para o grafo que você inseriu
na sua expressão do TensorFlow.
Se continuarmos, também veremos
que você pode colocar
essa mesma expressão
em um dispositivo GPU
e compilar códigos de modelagem GPU
no dispositivo XLA_GPU,
que correspondem
ao que foi gerado no lado da CPU.
Deslocando a tela para cima,
a modelagem GPU
tem mais esqueleto,
porque está lançando
várias linhas de execução
e elas têm que entender o que fazer.
Mas o número "quatro" aqui diz
que está lançando quatro linhas de GPU.
E está especializado para o fato
de que essa é a mesma expressão
que você digitou no TensorFlow.
Isso mostra que entendemos
qual expressão você insere
no momento da execução
no grafo do TensorFlow

Korean: 
하지만 이 어셈블리의 요점은
루프가 없다는 겁니다
그래프에서 곱하게 될 엘러먼트가 정확히
네 개라는 점을 알기 때문이죠
따라서 이건 하나의
지시사항만을 만든거죠
그 CPU 기기에서 그 수식을
시행하기 위해 필요한
이 벡터 확장 건축에서
필요한 사항만을 말이죠
텐서플로우 수식에 넣은 그래프를 위해
최적화되고 특별화된 겁니다
또한 우리가 계속 이어 나가면
똑같은 수식을
GPU 기기에 넣을 수 있고
CPU 측면에서 우리가 만들어낸 것에
상응하는 XLA_GPU 상의 일부 GPU
어셈블리 코드를 컴파일할 수도
있다는 것을 알 수 있죠
스크롤을 올리면 GPU 어셈블리에
보일러 플레이트가 좀더 많죠
여러 스레드를 시작하기 때문이고
스레드가 할 일을
알아내야 하기 때문이죠
하지만 여기 이 숫자 4는
GPU 스레드 4개를 시작할거라고
그리고 이것이 텐서플로우에서
입력한 그대로의 수식이라는 사실을
확실히 말하는 거죠
이건 텐서플로우 그래프에서 런타임으로
여러분이 저희에게 주신 것을 이해하고

Japanese: 
どんな式をコンパイルしたかを
理解しているということです。
それでは、プレゼンの方に戻りましょう
ありがとうございます。
日常ベースで使用する場合、
通常 TensorFlow シェル内で
CPU と GPU 対応の XLA がどのように
作動するかを見てきました。
これらすべての要素で欠けているのが
あなたです。
スイッチを押すのは、あなたになります。
TensorFlow を構築する際、
これを作動させて、あなたの使用環境
ファイル GitHub テーマに合わせて
どんなパフォーマンスを見せるか
確認することを強くお勧めします。
そしてコンピレーションが
TensorFlow の使用方法に
どのような利益をもたらすかを
フィードバックして下さい。
どこに努力を注ぐべきかを知るために、
コミュニティからのさらなる参加を
必要としています。
なぜなら、コンピレーションを使うことで
かなり多くのことが実現できるからです。
多くの潜在的な方法が存在します。
ジャストインタイムコンピラー
と呼びました。
このジャストインタイムとは、
一体どんなことなのでしょう。
ジャストインタイムの真髄は、
コンパイルするプログラムが
ランタイムで
構築されるということです。

Indonesian: 
lalu kompilasikan berdasarkan itu
untuk kecepatan maksimum.
Kita kembali ke presentasi.
Terima kasih.
Kita lihat bahwa XLA untuk CPU dan GPU
bekerja di kerangka standar TensorFlow,
seperti yang Anda pakai
dalam kehidupan sehari-hari.
Jadi bahan yang kurang
dari semua ini adalah Anda.
Kami butuh Anda menyalakannya.
Sembari Anda membangun TensorFlow,
kami mendorong Anda
untuk menyalakan ini, lihat kinerjanya
dalam kasus Anda, menyimpan isu GitHub
dan beri tahu bagaimana
kompilasi bisa bermanfaat
seperti saat memakai TensorFlow.
Kami butuh banyak
keterlibatan dari komunitas
untuk paham harus
memprioritaskan upaya di mana
karena banyak yang bisa dilakukan
dengan kompilasi.
Banyak potensi cara yang bisa dicoba.
Maka saya bilang
kompilator tepat waktu.
Apa maksud tepat waktu ini?
Inti dari tepat waktu adalah
program yang harus dikompilasi
dibangun di waktu proses.
Jadi saat saya mengetik ekspresi
TensorFlow lalu menekan Enter

Spanish: 
y luego compilamos basados en eso
con velocidad máxima.
Volvamos a la presentación.
Gracias.
Vemos que XLA para CPU y GPU trabaja
en el shell estándar de TensorFlow
de la misma manera
que lo usarías a diario.
El ingrediente faltante eres tú.
Necesitamos que lo enciendas.
Así que a medida que avanzas
y construyes TensorFlow
te animamos a que uses esto
y veas cómo opera en tu caso,
registres errores de GitHub
y nos cuentes cómo la compilación
podría beneficiarse de la forma
en que utilizas TensorFlow.
Con mayor participación de la comunidad
sabremos dónde priorizar los esfuerzos
porque se puede hacer mucho
con la compilación.
Hay un montón de caminos que puedes usar.
Hablé de la compilación justo a tiempo.
Entonces, ¿qué es esto 
de "justo a tiempo"?
La esencia de justo a tiempo
es que el programa a ser compilado
se construye en tiempo de ejecución.
Cuando escribo una expresión TensorFlow
y presiono Enter

Korean: 
이를 기초해서 최고 속도로
컴파일할 수 있음을 보여줍니다
그럼 프리젠테이션으로 돌아가면
감사합니다
보시다시피 CPU와
GPU를 위한 XLA이
표준 텐서플로우 쉘에서 잘 작동됩니다
여러분이 매일 사용하시는 거죠
따라서 여기서 없는 부분은
바로 여러분입니다
이걸 작동시킬 때 여러분이 필요한 거죠
여러분이 텐서플로우를 만들 때
이걸 작동시키길 권장하는 바입니다
여러분의 사용 사례에서는 어떻게
작동하나 보고 깃허브에 문제 제기하며
여러분이 컴파일하는 것이
텐서플로우를 사용하는 방식에
어떤 도움을 주는가 얘기해 주세요
어디에 우선적 노력을 기울어야하는가를
이해하려면 커뮤니티의 기여가
더욱 필요합니다
컴파일하는 것으로 할 수 있는 일이
많기 때문이죠
잠재적으로 여러분이 갈 수 있는
길이 많습니다
제가 저스트인타임 컴파일러를 말씀드렸죠
그럼 이 저스트인타임이 대체 뭘까요?
저스트인타임의 중점은
컴파일될 프로그램을
실행 시간에 만든다는 겁니다
텐서플로우 수식을 입력하고
엔터키를 누르고 나서

English: 
and then compile based
on it for maximum speed.
So if we switch back
to the presentation.
Thank you.
So we see that XLA
for CPU and GPU
works in standard
TensorFlow shell,
as you would use it
in a day to day basis.
So the missing ingredient
to all this is you.
We need you to turn it on.
So as you go and
build TensorFlow,
we really encourage
you to turn this
on, see how it performs for your
use case, file GitHub issues,
and tell us how you
think compilation
could benefit the way
that you use TensorFlow.
We really need more
involvement from the community
to understand where
to prioritize efforts,
because there's a lot of things
you could do with compilation.
There's a lot of potential
avenues you can go down.
So I've said
just-in-time compiler.
So what's this just-in-time
stuff all about?
The essence of just-in-time is
that the program to be compiled
is built at runtime.
So when I type in a TensorFlow
expression and press Enter,

Chinese: 
然后根据它编译来获得最快的速度
如果我们回到演讲
谢谢
我们已经看到在CPU和GPU中工作中
在TensorFlow壳中
你每天都会用到 XLA
因此在整个系统中
我们缺少的成分就是你
我们需要你来将它打开
当你开始构建TensorFlow时
我们鼓励你将它打开
看它是如何在你的用例中运行的
归档GitHub问题
并请你告诉我们你认为编译
是如何有益于你使用TensorFlow的
我们需要社群的更多参与
来知道那些地方需要我们的努力
因为你可以用编译做很多的事
有很多的潜在途径你可以去挖掘
我刚刚已经说了即时编译器
那么即时到底是什么意思呢？
即使的本质就是
程序在运行的时候被编译
所以当我输入TensorFlow表达 点击回车键

Portuguese: 
e que compilamos com base nela
para ter a maior velocidade.
Se voltarmos para a apresentação...
Obrigado.
Vemos que XLA para CPU e para GPU
funcionam no shell padrão do TensorFlow,
como você usa no seu dia a dia.
O ingrediente que falta
nisso tudo são vocês.
Precisamos que vocês usem-no!
Ao criar no TensorFlow,
encorajamos que vocês o ativem.
Veja como funciona no seu uso,
relate problemas no GitHub
e conte-nos como a compilação
pode beneficiar a forma
como você usa o TensorFlow.
Precisamos de mais envolvimento
da comunidade para entender
onde priorizar os esforços,
porque se pode fazer
muitas coisas com compilação.
Há muitos caminhos que se pode seguir.
Eu mencionei o compilador just-in-time.
E do que se trata essa tradução dinâmica?
A essência do just-in-time,
tradução dinâmica,
é que o programa a ser compilado
é criado no tempo da execução.

Spanish: 
no quiero estar en la línea
de comando por unos minutos
mientras descifras cómo compilarlo.
Necesitamos tener una compilación
de sobrecarga baja.
El ensamblado debe generarse
con mucha rapidez.
Otro aspecto es que en la investigación
de aprendizaje automático
no quieres decir cuál es el tamaño
de tu archivo batch al comenzar.
Dirás el tamaño correcto
del archivo batch
cuando sepas cuánto quieres que sea.
Entonces, las variables pueden actuar
muy tarde en el proceso.
Podrías decir el de tu batch
en el último segundo.
Y como es un compilador JIT,
lo compilará en el punto
que está definido.
Hacer un prototipo
con la libertad de TensorFlow
es lo esencial de la compilación justo
a tiempo.
En el diagrama de bloques
de niveles de TensorFlow
tenemos el núcleo existe de TensorFlow.
Y Todd hablará de esto
con más detalle en su próxima charla.
Pero las ranuras XLA
en el ecosistema TensorFlow
en la parte inferior derecha,
dónde tenemos algunas capacidades JIT
automáticas, encontraremos clústers
para JIT
para que coloques cosas explícitamente
en los dispositivos

English: 
I don't want to sit there at the
command line for a few minutes
while you figure out
how to compile it.
So we need to have low
overhead compilation.
In the blink of an eye, the
assembly has to be generated.
And another aspect of it
is that in ML research,
you don't want to say
what your batch size is
at the very beginning of time.
You want to be able to
say the batch size right
when you figure out
what you want it to be.
So variables can bind
very late in the process.
You could say your batch
size at the very last second.
And because it's a JIT compiler,
it will compile it at the point
that it's defined.
So you get to prototype with
the normal freedom of TensorFlow
development is the gist of
this just-in-time compilation.
So if we look at the
TensorFlow level block diagram,
we have the existing
TensorFlow core.
And Todd is going to be
talking about this in more
detail in his next talk.
But XLA slots into the
TensorFlow ecosystem
here on the bottom right,
where we have some auto JIT
capabilities, where we'll
find clusters to JIT
for you or you can place things
explicitly on devices, as we

Chinese: 
我不想要看着命令栏等待几分钟
让你慢慢研究如何编译它
所以我们需要有很低的编译开销
在眨眼之间，编译就可以完成
另一个方面就是在ML领域的研究
你不会想要在一开始
就说出你的缓存大小
你希望能够说出合适的缓存大小
当你知道你要多大缓存的时候
因此，变量可以在后续的过程中被绑定
你可以在最后说出你缓存的大小
因为这是一个JIT编译器
它会指定的时刻编译
你需要使用TensorFlow正常的自由度为原型
这就是即时编译的要点
如果我们看一下TensorFlow的框图
我们有现有的TensorFlow核心
托德将会在下次的座谈会中
做更详尽的介绍
但是将XLA放入TensorFlow的
生态系统的右下角
在这里我们有一些自动JIT功能
我们将为你找到JIT集群
或者你可以将东西放到设备的指定位置

Korean: 
컴파일 방법을 알아내는 몇 분 동안
명령 라인에 앉아 있고 싶지는 않죠
컴파일하는 시간이 짧아야겠죠
눈 깜짝할 새에
어셈블리가 만들어져야 하죠
또다른 측면은 ML 연구에서
아주 초반부터 배치 크기를
말하고 싶진 않다는 겁니다
무엇을 하고 싶은가를 알려고 할 때
배치 크기를 정확히 말하고 싶겠죠
이 과정에서 변수가
아주 늦게 바인드될 수 있습니다
아주 마지막 순간에
배치 크기를 말해도 되는 거죠
또한 JIT 컴파일러이기 때문에
이것이 정의되는 순간
컴파일 할 겁니다
따라서 텐서플로우 개발의
일반적 자유로움을 통해
프로토타입을 정할 수 있다는 것이
저스트인타임 컴파일의 요점이죠
텐서플로우 단계
블락 다이어그램을 보시면
이미 실존하는
텐서플로우 코어가 있습니다
토드가 다음 발표에서
이에 대해 더 자세히
설명해 주겠지만
XLA는 텐서플로우 생테계에서
여기 하단 오른쪽에 있죠
여기엔 일부 오토 JIT 능력도 있고
JIT에 클러스터를 찾아 주거나
기기에 겉으로 드러나게 해둘 수 있죠

Japanese: 
TensorFlow に式を入力し、
Enter キーを押します。
それをコンパイルする間、
数分間、コマンド行で待機している
つもりはありません。
ローオーバーヘッドコンピレーションが
必要になります。
またたく間に、
アセンブリーは生成されます。
そしてもう１つの特色は、
かなり早い段階で
ML リサーチ内でバッチがどのサイズかを
表示したくありません。
それがどのサイズにしたいのか
分かった時に、
バッチサイズが正しいかどうか
言えるようにしたいのです。
変数はプロセス中のかなり後の方で
取り決めできます。
バッチサイズについては、かなりぎりぎりの
タイミングで伝えれば良いのです。
JIT コンパイラーなので、
それが定義された時点でコンパイルされます。
TensorFlow 開発のノーマルフリーダムの
プロトタイプを得ることができ、
それがこのジャストインタイム
コンピレーションの要点となります。
TensorFlow レベルブロックの
ダイヤグラムを見れば、
既存する TensorFlow コアを
得ることができます。
トッドが次のスピーチで、
これについてさらに詳しく説明します。
しかし XLA はボトムライト上で
TensorFlow のエコシステムに
スロットインします。
そこには自動 JIT キャパビリティがあり、
JIT 用のクラスター見つけたり、
またデモビデオでお見せしたように

Portuguese: 
Quando digito uma expressão
no TensorFlow e aperto Enter,
não quero esperar na linha de comando
por alguns minutos enquanto
se pensa como compilá-lo.
Precisamos ter pouca
carga extra de compilação.
Em um piscar de olhos,
a montagem deve ser gerada.
Outro aspecto é que em pesquisas ML
não se quer dizer o tamanho do seu lote
no início do tempo.
Você quer poder dizer o tamanho do lote
quando você descobrir
o que quer que ele seja.
Então variáveis podem se associar
muito depois no processo.
Você pode dizer o tamanho do lote
no último segundo.
E como é um compilador JIT,
vai compilar no ponto em que foi definido.
Poder fazer protótipos
com a liberdade normal
do desenvolvimento do TensorFlow.
É a ideia por trás
da compilação just-in-time.
Se olharmos o diagrama
de bloqueio de níveis do TensorFlow,
temos o núcleo atual dele.
E o Todd vai falar mais
e em detalhes sobre isso
na próxima palestra.
Mas a XLA se insere
ao ecossistema do TensorFlow,
aqui no canto inferior direito,
onde há algumas capacidades
JIT automáticas,
onde há aglomerados para fazer JIT.
Ou você pode colocar coisas
explicitamente nos dispositivos,

Indonesian: 
saya tidak mau duduk
di baris perintah beberapa menit
saat Anda pikirkan cara kompilasinya.
Kita harus punya kompilasi biaya rendah.
Dalam sekejap, rakitan harus dihasilkan.
Aspek lain di penelitian ML,
Anda tak mau menyebut
ukuran batch Anda di awal.
Anda ingin bisa menyebut ukuran batch
tepat saat Anda tahu berapa yang Anda mau.
Variabel bisa mengikat di akhir proses.
Anda bisa menyebut ukuran batch
di saat terakhir.
Karena itu kompilator JIT,
itu akan mengompilasi
di saat dia didefinisikan.
Anda dapat prototipe
dengan kebebasan normal
dari pengembangan TensorFlow
adalah inti kompilasi tepat waktu ini.
Jika kita melihat diagram
blok tingkat TensorFlow
maka kita lihat inti TensorFlow yang ada.
Todd akan bahas lebih detail nanti.
XLA masuk ke dalam ekosistem TensorFlow
di kanan bawah sini, di mana
kami punya kemampuan JIT otomatis
di mana kami akan temukan cluster JIT
untuk Anda atau Anda bisa letakkan
hal secara eksplisit di perangkat

Spanish: 
como enseñamos
en el vídeo de demostración.
Creemos que lo que hemos desarrollado
con XLA
es un conjunto
de atributos complementarios.
La flexibilidad que obtenemos
a través de la interpretación
crea beneficios de optimización
de la compilación
por el otro lado.
El dinamismo permite
que escribas programas muy expresivos
porque descubrimos todas estas dimensiones
en el último momento
y especializamos para ellas,
sacamos los beneficios
de tener información estática
de todos los límites
de los tensores en tu gráfico.
Utilizamos semántica pura
para facilitar la compilación.
TensorFlow realmente maneja todas
las reagrupaciones
de las variables externas
después de activar el compilado ejecutable
creando una superficie más pequeña
para compilar
y hace que sea más fácil dirigirse
a nuevos dispositivos exóticos.
Puedes construir muchas
de las operaciones básicas de TensorFlow
desde estos primitivos
que sabemos cómo compilar.
Los beneficios de la optimización
de todas las cosas a la derecha
y puedes pensar y escribir
de la manera tradicional
que se refleja en el lado izquierdo.

Portuguese: 
como mostramos no vídeo demo.
O que desenvolvemos com XLA foi
um conjunto de atributos complementares.
A flexibilidade que obtemos
por meio da interpretação,
obtemos benefícios de otimização
da compilação, por outro lado.
O dinamismo que permite escrever
programas muito expressivos
porque descobrimos todas essas dimensões
no último minuto
e nos especializamos para elas.
Ganhamos os benefícios
de ter informação estática
sobre todos os limites
dos tensores em seu grafo.
Usamos semântica pura
para facilitar a compilação.
O TensorFlow lida com todos
os re-enlaces de variáveis externas
depois que o executável compilado
é executado,
o que produz uma área
de superfície menor para a compilação
e facilita eleger alvos,
como novos dispositivos exóticos.
É possível incrementar muitas
das operações centrais do TensorFlow
a partir das primitivas
que sabemos como compilar.
Tem-se os benefícios de otimização
de tudo o que está à direita
e se pode pensar e escrever
do jeito tradicional,
o que se vê no lado esquerdo.

English: 
showed in that demo video.
So what we think we've
developed with XLA
is a set of
complementary attributes.
So the flexibility that we
get through interpretation,
we get the optimization
benefits of compilation
on the flip side.
The dynamism that lets you
write very expressive programs,
because we find out all of these
dimensions at the last second
and then specialize for
them, we get the benefits
of having the static
information about all the bounds
of the tensors in your graph.
We use pure semantics to
make it easier to compile.
So TensorFlow
actually handles all
of the external
variable rebindings
after the compiled
executable is run,
which makes a smaller
surface area for compilation
and makes it easier to target,
say, new exotic devices.
And you're able to build up
many of the TensorFlow core
operations from these primitives
that we know how to compile.
So you get the
optimization benefits
of all of the things
on the right-hand side,
and you get to think and write
in the traditional way that's
reflected on the left-hand side.

Indonesian: 
seperti ditunjukkan dalam video demo.
Yang kami pikir telah
dikembangkan dengan XLA
adalah seperangkat atribut pelengkap.
Kefleksibelan yang kami punya
dari interpretasi adalah
kami dapatkan manfaat optimasi
dari kompilasi di sisi sebaliknya.
Dinamikanya membuat Anda
menulis program yang sangat ekspresif
karena kita tahu semua dimensi ini
di saat terakhir
lalu mengkhususkan untuk mereka,
kita dapat manfaat
dari memiliki informasi statis
soal semua ikatan tensor
di grafik Anda.
Kami gunakan semantik murni
untuk memudahkan mengompilasi.
TensorFlow mengatasi semua
pengikatan kembali variabel eksternal
setelah kode yang terkompilasi
dan bisa dieksekusi dijalankan
dan yang memperkecil area permukaan
untuk kompilasi
dan memudahkan menargetkan,
seperti perangkat eksotis yang baru.
Anda bisa membangun
banyak inti operasi TensorFlow
dari primitif ini yang kita tahu
cara mengompilasinya.
Anda dapat manfaat optimasi
dari semua hal di sisi kanan
dan Anda bisa pikir dan tulis
secara tradisional
yang direfleksikan di sisi kiri.

Korean: 
이 시범 영상에서 보여 드렸듯이 말이죠
XLA로 저희가 개발한 것은
상호 보완적 속성 셋트라고 생각합니다
해석을 통해 융통성을 얻고
다른 측면에서는
컴필레이션의 최적화 해택을
얻은 거죠
역동성은 아주 표현력이
높은 프로그램을 쓰게 해줍니다
마지막 순간에 이 모든 면적을 찾아서
특별화시키며 그래프의 텐서의
모든 바인딩에 대한
정적인 정보를 가지는
혜택도 얻기 때문이죠
컴파일하기 쉽도록 만들기 위해
순수 시멘틱을 사용됩니다
따라서 텐서플로우는 실제로
컴파일된 실행 파일이
실행된 후 외부 변수 재바인딩을
모두 제어합니다
이는 컴필레이션의 표면적을
더 작게 만들고
표적화하기 더 쉽게 만드는
새로운 이국적인 기기인 거죠
또한 우리가 컴파일하는 법을
알고 있는 이러한 기초요소로부터
텐서플로우 코어 운영의
많은 부분을 축적할 수 있을 겁니다
따라서 오른쪽에는
이 모든 최적화 혜택을 얻고
왼쪽에 반영된 전통적 방식으로
생각하고 써야 하는 거죠

Chinese: 
就像我们在演示视频中向大家展示的那样
我们用XLA开发的
是一组互补的功能
因此我们通过解释获得灵活性
在另一方面
我们也有编译的优化效益
这就可以让你开发非常富有表现力的程序
因为我们在最后一秒发现了所有的维度
然后将他们专业化
我们有了在你图表中
关于tensors的所有静态信息
我们使用纯语义让编译变得简单
因此TensorFlow实际处理所有
外部变量再链接
在编译执行之后
这让编译的表面积变小
使针对新锐设备的操作变得简单
你就可以构建很多TensorFlow核心操作
通过这些源代码
我们知道如何编译
因此你有了所有
在右手边的工具的优化优点
你可以用传统的方式思考和编写
就像在左边显示的那样

Japanese: 
デバイス上に明確に物事を配置することが
できる場所です。
XLA を使って開発したことは、
補足的な属性の集合です。
インタープリタを通じて得た柔軟性によって、
言い換えれば、コンピレーションの最適化
という利益を得ることになりました。
非常に表現性のあるプログラムを
書くことが可能なダイナミズムによって、
ぎりぎりの時点で
これらのディメンションを全て見つけ出し、
それ用に特定化し、
グラフ内のテンソルの境界に関する
スタティックインフォメーションを
得ることができます。
コンパイルを容易に行なうための
ピュアセマンティクスを使います。
TensorFlow は、コンパイルド
エクスキュータブルが作動した後
すべての外部変数
リバインデイングを処理します。
それによって、コンピレーション用の
表面エリアが小さくなり
新しいエゾティックデバイスを簡単に
目標とすることができます。
コンパイル方法を知っている
これらの原始関数から
多くの TensorFlow コアオペレーションを
構築することができます。
一方で、これらすべてに関する
最適化の恩恵を受けながら
他方では、反映される通常の方法を考え
それに書き始めています。

Spanish: 
¿Qué nos entusiasma de este enfoque?
Aceleraciones en el servidor.
Con esta compilación JIT
y la especialización
vemos ganancias con modelo
en comparadores de rendimiento
de hasta el 60%.
Esos son modelos que ejecutarías
en el centro de datos y micro comparadores
de rendimiento
aproximadamente en ese rango
de aceleración.
Y para un ejemplo interno extremo
vimos SyntaxNet obtener reducciones
de latencia
de alrededor de 200 microsegundos
a 5 microsegundos.
Y la razón de esto fue que SyntaxNet
tenía muchas pequeñas operaciones
en el gráfico
así que el intérprete tiene que ir
y agarrar cada pequeña operación.
Y ese proceso de ir
y agarrar las pequeñas operaciones
y ejecutarlas incurre en alguna sobrecarga
de latencia.
Y al compilar
eres capaz de eliminar 
toda esa sobrecarga de latencia.
Otra cosa que nos emociona
son las reducciones de la huella móvil.
Con nuestra compilación anticipada
ya hablamos de compilación justo a tiempo
pero también puedes pasar
por un proceso de construcción
para convertir modelos en ejecutables
si deseas hacerlo por adelantado.

English: 
So what has us excited
about this whole approach?
Server-side speed ups, for one.
So through this JIT
compilation and specialization
that we've talked about, we
see model-shaped benchmark wins
of up to 60%.
So those are models
as you would run
in the data center and
model-looking microbenchmarks
roughly in that speed up range.
And for one extreme
in-house example,
we saw SyntaxNet get
latency reductions
from around 200 microseconds
to 5 microseconds.
And the reason for
this was SyntaxNet
had a lot of little
operations in the graph,
so the interpreter has to go
grab each little operation.
And that process of going and
grabbing the little operations
and running them incurs
some latency overhead.
And by compiling,
you're actually
able to eliminate all that
latency overhead away.
Another thing that
has us excited
are mobile footprint reductions.
So with our ahead-of-time
compilation--
we talked about
just-in-time compilation,
but you can also go
through a build process
to turn models into executables
if you want to do that upfront.

Indonesian: 
Apa yang buat kita semangat
soal pendekatan ini?
Pertama, mempercepat sisi server.
Melalui kompilasi dan spesialisasi JIT
yang kita bicarakan ini,
kita lihat tolak ukur berbentuk model
menang hingga 60%.
Jadi ini model yang akan Anda jalankan
dalam pusat data dan
microbenchmark seperti model
kira-kira ada di sekitar kecepatan itu.
Satu contoh ekstrim dalam kantor yaitu
kita lihat SyntaxNet punya
penurunan latensi
dari sekitar 200 mikrodetik
ke 5 mikrodetik.
Alasan ini adalah SyntaxNet
punya banyak operasi kecil di grafik
jadi intepreter harus mengambil
tiap operasi kecil.
Dan proses mengambil operasi kecil
lalu menjalankannya
memicu beberapa biaya latensi.
Dan dengan mengompilasi, Anda
bisa mengeliminasi semua biaya latensi.
Hal lain yang seru
adalah pengurangan jejak seluler.
Jadi dengan kompilasi lebih cepat--
kita bicara soal kompilasi tepat waktu
tapi Anda bisa juga melalui
proses membangun
untuk mengubah model jadi
kode yang bisa dieksekusi kalau mau.

Korean: 
이 전반적 접근법이 왜 멋질까요?
하나는 서버측의 속도 향상이죠
말씀드린 이러한 JIT 컴필레이션과
특수화를 통해 최대 60%까지
모델 형성 벤치마크 획득을
볼 수 있습니다
이것이 데이터 센터에서 보게 될
모델들이자 대략
이 정도 범위의 속도 향상에서
모델처럼 보이는
마이크로 벤치마크인 거죠
저희 내부의 극단적인 예를 하나 들면
저희는 신택스네트의 지연속도가 거의
200 마이크로세컨즈에서
5 마이크로세컨즈로
줄어든 것을 봤습니다
그 이유는 신택스네트가
그래프에서의 작은 운영이 많아서
이 통역자는 각각의
작은 운영을 가져와야 했죠
이 작은 운영을 가서
잡아서 운영하는 과정에서
지연 속도가 발생하는 거죠
컴파일함으로써 사실
이 모든 지연 속도 발생을
없앨 수 있는 겁니다
또 다른 신나는 사실은
모바일 풋프린트 감소입니다
저희의 어헤드오브타임 컴파일을 통해
저스트인타임 컴파일에 대해
말씀 드렸는데
미리 하시고 싶으시면 모델을
실행파일로 바꾸는
제조 과정을 통할 수도 있죠

Chinese: 
那么这种方法最好的地方在于什么呢？
服务器端的是速度的提高
所以通过这个JIT的编译和专业化
我们看到这个模型的基准率
高达60%
这些是你在数据中心运行的模型
以及看向模型的微基准
也在加速范围之内
在一个极端的内部例子中
我们看到SyntaxNet的延迟
从200微秒减少到5微秒
原因就是
SyntaxNet在图表中有很多的运算
编译器必须要抓住每一个运算
运行这些小运算
会产生一些延迟
通过编译
你可以减少所有的这类延迟
另一个好处
是移动设备足迹的减少
使用我们提前的编译
也就是我们所说的即时翻译
但你也可以通过构建过程
将模型转换成可执行的的程序
如果你想这样做的话

Portuguese: 
O que nos deixou animados
com essa abordagem?
Mais velocidade do servidor, por exemplo.
Com a compilação e especialização
do JIT de que falamos,
vemos benchmarks com formato de modelo
ganharem até 60%.
São modelos que você executaria
no centro de dados
e microbenchmarks que parecem modelos,
nesse intervalo de aceleração.
Um exemplo extremo nosso,
vimos SyntaxNet obter reduções de latência
por volta de 200 microssegundos
a 5 microssegundos.
O motivo é que SyntaxNet
fazia muitas operaçõezinhas no grafo,
então o interpretador tinha
que pegar cada uma delas.
O processo de pegar
as operaçõezinhas e executá-las
incorre em cargas extras de latência.
Compilando, você pode eliminar
toda a sobrecarga de latência.
Outra coisa que nos deixou animados
foi a redução de pegadas móveis.
Com nossa compilação ahead-of-time...
Falamos de compilação just-in-time,
mas você também pode seguir
um processo de criação
para transformar modelos em executáveis,
se quiser fazê-lo no início.

Japanese: 
では、このアプローチ全体に関して
喜べることは何でしょうか。
１つに、サーバーサイドの
スピードアップが挙げられます。
これまでにお話しした、この JIT 
コンピレーションと特殊化を通じて
モデル型ベンチマーク が
60 パーセントまで到達しました。
これらはデータセンター内で
作動するはずのモデルであり
そのスピードアップレンジ内で
モデルルッキングマイクロベンチマークが
大雑把に見るモデルなのです。
非常に身近な例として、
SyntaxNet が待ち時間を
200 マイクロ秒から 5 マイクロ秒へと
減少しました。
その理由として、SyntaxNet はグラフ内に
小規模のオペレーションを持っていたため
インタープリタが各々の小さなオペレーションを
取得する必要がありました。
小規模のオペレーションを取得しに行く
というプロセスは、
いくらかのオーバーヘッド待ち時間を
誘因することになります。
コンパイルすることで、オーバーヘッド
待ち時間を除去することが可能です。
もう１つ、喜ばせてくれるのが
モバイルフットプリント軽減です。
先程はジャストインタイムでしたが、
今回は、アヘッドインタイムの
コンスピレーションを通じて
前もって行ないたい場合は、
モデルを実行可能な状態にするための
構築プロセスを通すことも可能です。

Chinese: 
所以这就是一个可执行的程序
就像你运行命令栏一样
这可以大大减少TensorFlow的运行时间
并且减少二进制文件大小
它还让你可以交错编译这些模型
比如ARM、 PowerPC已经x86 CPU平台
我们内部的一个例子是
一个移动设备的LSTM模型的大小
可以从2.6兆字节到600千字节
这减少了资源配置整整四倍
这个方法让我们兴奋的是
它可以分析整个图表
通过这个编译器，整个程序都变的简单
因此我们把它叫做高级优化器
可以让我们看到线性的代数层次图
并且创建一个用于整体优化
可重复利用的工具包
因此，虽然你的编译器在不同的平台上运行
CPU，GPU以及其它的外来设备
我们将一个指定平台上的信息参数化
通过这个高级优化工具包
这样你就可以混合和匹配

English: 
So this is just an
executable like you
would run on the
command line, and it's
able to eliminate much
of the TensorFlow runtime
and really reduce
the binary size.
And this lets you also
cross-compile these models
for ARM, PowerPC, and
x86 CPU platforms.
So one example that
we have in-house was
an LSTM model for mobile was
able to go from 2.6 megabytes
to less than 600
kilobytes, which
was a 4x reduction in
the deployment footprint.
The general thing that has us
excited about this approach
is that analyzing a whole
graph, a whole program
is made easy by this
compiler infrastructure.
So we have this thing called
the High-Level Optimizer that's
able to look at a linear
algebra level graph
and create a reusable toolkit
of global optimizations
to work on it.
So even though you compile for
different platforms, CPU, GPU,
and other exotic devices,
we've parameterized
out the things that
are specific to a given
platform at this high-level
optimization toolkit level.
And so you're able
to mix and match

Spanish: 
Así que esto es solo un ejecutable
que ejecutarías en la línea de comandos
y puede eliminar gran parte
del tiempo de ejecución TensorFlow
y realmente reducir el tamaño binario.
Y esto permite
hacer una compilación cruzada
de estos modelos para plataformas ARM,
PowerPc y x86 CPU.
Un ejemplo interno que tenemos
fue un modelo LSTM para móviles
que pudo pasar de 2,6 megabytes
a menos de 600 kilobytes
una reducción de cuatro vences
en la huella de implementación.
Lo principal que nos ha emocionado
de este enfoque
es que analizando todo un gráfico,
se facilita todo un programa
por esta infraestructura del compilador.
Tenemos esto llamado el Optimizador
de Alto Nivel
que es capaz de mirar un gráfico
de nivel de álgebra lineal
y crear una caja reutilizable
de herramientas de optimizaciones
para trabajar en ella.
Así que aunque compiles
para diferentes plataformas, CPU, GPU
y otros dispositivos exóticos,
hemos parametrizado
lo específico de una determinada
plataforma en este nivel de caja
de herramientas de optimización.
Así puedes mezclar y combinar

Portuguese: 
Isso é um executável,
executado na linha de comando,
e pode eliminar boa parte
do tempo de execução do TensorFlow
e reduzir bastante o tamanho do binário.
Também permite
uma compilação cruzada dos modelos
para ARM, PowerPC
e plataformas CPU x86.
Um exemplo nosso
é um modelo LSTM para móvel
que foi de 2,6 MB
para menos de 600 kB,
quatro vezes menos pegadas de implantação.
O fator em geral que nos animou
em relação a essa abordagem
é que analisar um grafo completo,
um programa inteiro,
fica mais fácil graças
a essa infraestrutura de compilação.
Temos algo chamado
"Otimizador de Alto Nível"
que analisa um grafo de álgebra linear
e cria toolkits reutilizáveis
com otimizações globais
para trabalhar nele.
Mesmo compilando
para plataformas diferentes,
CPU, GPU e outros dispositivos exóticos,
parametrizamos o que é específico
de uma certa plataforma
a nível desse toolkit
otimizador de alto nível.

Indonesian: 
Ini hanya kode tereksekusi
yang akan Anda jalankan
pada baris perintah,
dan itu bisa mengeliminasi
banyak waktu proses TensorFlow
dan mengurangi ukuran biner.
Anda juga bisa kompilasi silang model ini
untuk platform ARM,
PowerPC, dan komputer x86.
Contoh kami sendiri adalah
model LSTM untuk seluler
bisa turun dari 2,6 megabyte
jadi kurang dari 600 kilobyte, yaitu 4x
pengurangan dalam jejak penyebaran.
Hal umum yang seru soal pendekatan ini
adalah menganalisa keseluruhan grafik,
keseluruhan program dipermudah
oleh infrastruktur kompilator ini.
Jadi kita punya yang disebut
High-level Optimizer
yang bisa melihat grafik
tingkat aljabar linear
dan membuat alat yang bisa
digunakan dari optimasi global
untuk mengerjakannya.
Meski Anda mengompilasi
untuk platform berbeda, CPU, GPU
dan perangkat eksotik lain,
kami telah beri parameter
pada hal yang spesifik 
di platform tertentu
di tingkat alat optimasi tingkat tinggi.
Jadi Anda bisa mencoba-coba

Japanese: 
コマンド行で作動させる
実行可能なものであり、
TensorFlow ランタイムの大部分を
消去することができ、
バイナリーサイズを相当
減らすことができます。
ARM、PowerPC、 
x86 CPU プラットフォーム用に
これらのモデルをクロスコンパイル
することも可能です。
身近な例の１つとして、
モバイル用の LSTM モデルは
2.6 メガバイトから 600 キロバイト以下まで
行くことが可能であり、
フットプリント配置内で
4x リダクションとなりました。
このアプローチに関して、
喜べる代表的なことは
このコンパイラーインフラによって、
グラフ全体、プログラム全体を
分析することが簡単になったという点です。
ハイレベルオプティマイザーと
呼ばれるものがあり、
これは 一次代数レベルグラフを
見ることができ、
また作動用のグローバル最適化再利用
ツールキットを作り出すことができます。
CPU、GPU、新種のデバイスのような
異なるプラットフォーム用に
コンパイルしたとしても、
このハイレベル最適化ツールキットレベルで
与えられたプラットフォームに
特有のものをパラメタライズします。

Korean: 
따라서 이는 명령 라인에서
실행하는 실행파일인 셈이고
텐서플로우 실행시간을
상당량 제거할 수 있고
바이너리 파일 크기를 줄일 수 있죠
이는 또한 ARM, PowerPC
x86 CPU 플랫폼을 위한 모델들을
크로스 컴파일 할 수 있게 해줍니다
저희 내부에서 있었던 예시 하나는
핸드폰을 위한 STM 모델이
2.6 메가바이트에서
600 킬로바이트 이하로
내려갈 수 있었는데 이는
개발 풋프린트에 4배 이상의 감소였죠
이 접근법이 좋은 일반적인 이유는
전체 그래프
전체 프로그램을 분석하는 것이
이 컴파일러 기반 시설로
더 쉬워졌다는 점이죠
저희에게는 고수준
최적화라는 것이 있는데
이는 선형 대수학 수준의
그래프를 볼 수 있게 해주고
전반적 최적화의 재사용 가능한 툴키트를
만들어 줄 수 있죠
따라서 다른 플랫폼, CPU, GPU
다른 이국적 기기에서
컴파일하더라도 이 고수준
최적화 툴키트 레벨에서
주어진 플랫폼에 적합한
매개변수를 제공할 수 있는 거죠
따라서 플랫폼 중립적임과

Spanish: 
las piezas de una plataforma agnóstica
y las específicas
si hay alguna optimización que realmente
se beneficie, por ejemplo, las GPUs,
podrás usar eso para dirigir las GPUs
pero utilizar el conjunto general
de optimizaciones
en la caja de herramientas para dirigir
a todas las otras plataformas.
Hay advertencias, es experimental.
Está empezando.
No se compilan todas las operaciones
de TensorFlow.
Algo de esto se debe
a que las operaciones muy dinámicas
en las que es muy difícil
describir el tipo
no compilan por diseño.
Por ejemplo, un dynamic stitch
tiene un tipo muy difícil
para definir para sus operaciones.
Eso no es algo que XLA respalda
y puede que nunca
lo haga.
El rendimiento está mejorando a diario.
No todo es más rápido.
No dedicamos tanto tiempo a todo
lo que respaldamos.
Pero con la participación
de la comunidad y priorización
creemos que podríamos hacer mucho más.
Código abierto.
De verdad queremos que lo pruebes,
registres los errores
y digas cómo podría esta compilación
beneficiar tu carga de trabajo.

Japanese: 
アニョスティックプラットフォームと
特定ターゲットピースを
ミックスし、マッチさせることができます。
もし、本当にGPU に利益をもたらす
最適化があれば
GPU をターゲットするために、
それを使うことができます。
他のプラットフォームすべてを
ターゲットするために、
ツールキット内の最適化の
一般的な集合を使うことができます。
ここにカヴィアート（警告）があり、
これは実験用で、早過ぎる段階です。
すべての TensorFlow オペレーションが
コンパイルするわけではありません。
いくつかは非常にダイナミックな
オペレーションなので
どのタイプに定義するか難しく、
デザインによってコンパイルできません。
例えば、ダイナミックステッチは
そのオペレーション用に定義するための
非常に難しいタイプを持っています。
それは XLA がサポートするものではなく、
またサポートすることはないでしょう。
パフォーマンスは日ごとに改善しています。
すべてがより高速化するわけでは
ありません。
サポートする全てのプラットフォームに
同じ時間を充てることはできません。
しかし、コミュニティの参加と
優先化を通じて
より多くのことを実現できると
思います。
それはオープンソースになります、
ぜひファイルバグを試して下さい。
このコンピレーションがどのように
ワークロードに利益をもたらしたか
フィードバックして下さい。

English: 
the platform-agnostic and
the target-specific pieces,
so that if there's some
optimization that really
benefits, say, GPUs, you're able
to use that for targeting GPUs,
but you're able to use the
general set of optimizations
in the toolkit for targeting
all the other platforms.
So there are caveats here.
It's experimental.
It's still early days.
Not all TensorFlow
operations compile.
And some of this is because very
dynamic operations, that it's
very difficult to
describe the type for,
won't compile by design.
So for example, dynamic stitch
has a very difficult type
to define for its operations.
So that is not something that
XLA supports and it may never
support it.
The performance is
improving on a daily basis.
So not everything is faster.
And we haven't been able
to devote equal time to all
the platforms that we support.
But with the community's
involvement and prioritization,
we believe that we
could do much more.
So it's open source.
So really, we want you
to try it out, file bugs,
and let us know how
this compilation could
benefit your workload.

Portuguese: 
É possível combinar as partes
que independem da plataforma
e as que são específicas,
então se houver uma otimização
que beneficie GPUs
você pode usá-la para GPUs,
mas pode usar o conjunto geral
de otimizações do toolkit
para as outras plataformas.
Mas temos ressalvas.
É algo experimental.
Está ainda no início.
Nem todas as operações
do TensorFlow compilam.
Isso se dá em parte
porque operações muito dinâmicas,
cujo tipo é difícil de descrever,
não são compiladas por projeto.
Por exemplo, o stitch dinâmico
tem um tipo muito difícil de definir
para suas operações.
Isso é algo que XLA não comporta
e talvez nunca comporte.
O desempenho melhora a cada dia.
Então nem tudo está mais rápido.
E não conseguimos dedicar
a mesma quantidade de tempo
para todas as plataformas
que comportamos.
Mas com o envolvimento
e a priorização da comunidade,
acreditamos que podemos fazer muito mais.
Então o código é aberto.
Queremos que vocês testem,
relatem os erros
e falem como a compilação pode ser
benéfica à sua carga de trabalho.

Chinese: 
与平台无关的以及针对目标的碎片
这样如果有一些有利的优化
比如GPU，你可以用它来针对GPU
但你也可以使用这个工具箱里的通用优化器
来针对所有其他的平台
这里有一些警告
这是实验性的
还在初期阶段
不是所有的TensorFlow操作都能编译
一部分是因为非常动态的操作
要描述类型非常的困难
不能通过设计来编译
比如说，动态的指针的操作
就很难分类
这不被XLA支持
也可能永远不被支持
性能每天都在提高
但不是所有的平台都变快了
我们还没有能力对所有我们支持的平台
投入相同的时间
但随着社群的参与和优先化
我们相信我们还能做的更多
所以它是开源的
因此，我们想让你试一试，归档错误
并让我们知道这个编译器
可以如何有益于你的工作

Indonesian: 
platform atletik
dan bagian target spesifik.
Jika ada beberapa optimasi
yang sungguh bermanfaat
seperti GPU, Anda bisa pakai itu
untuk menargetkan GPU
dan Anda bisa pakai perangkat
optimasi umum
di peralatan untuk menargetkan
semua platform lain.
Ada keberatan di sini.
Ini eksperimental dan masih sangat awal.
Tidak semua operasi
TensorFlow mengompilasi.
Dan beberapa hal ini
karena operasi yang sangat dinamis
dan sangat sulit
untuk mendeskripsikan tipe
untuk desain tak terkompilasi.
Contohnya, stitch dinamis
punya tipe yang sangat sulit
untuk mendefinisikan operasinya.
Itu bukan yang didukung XLA
dan tak akan pernah didukung.
Kinerja meningkat setiap hari.
Jadi tidak semuanya lebih cepat.
Belum bisa curahkan waktu seimbang
untuk semua platform yang kami dukung.
Tapi dengan keterlibatan
komunitas dan prioritas,
kami yakin kami bisa lakukan hal lebih.
Ini sumber terbuka.
Jadi, kami ingin Anda mencobanya,
melaporkan bug, beri tahu
bagaimana kompilasi bisa
bermanfaat bagi pekerjaanmu.

Korean: 
표적에 적합함을 섞어서 정할 수 있죠
정말 혜택을 주는 최적화가 있을 때
예컨대 GPU라면, 이를 GPU를
표적하는 데에 사용할 수도 있지만
또한 다른 모든 플랫폼을
표적하는 툴키트에서
최적화의 일반적 세트도
사용할 수 있다는 거죠
주의사항이 있습니다
이건 실험적이고
아직 초기 단계입니다
모든 텐서플로우 운영이
컴파일하진 않습니다
이중 일부는 아주 역동적인 운영이고
유형을 묘사하기 굉장히 어려우며 설계상
컴파일되지 않기 때문이죠
예컨대 역동 스티치는 운영을 위해
정의내리기 굉장히 어려운 유형입니다
따라서 이는 XLA를
지원하지 않고 어쩌면 절대
지원하지 않겠죠
성능은 하루가 다르게 향상되고 있습니다
모든 것이 더 빠르지는 않죠
또한 저희가 지원하는
모든 플랫폼에 똑같은 시간을
할애하진 못했죠
하지만 커뮤니티의 참여와
우선 순위화를 통해
훨씬 더 많은 일을 할 수
있으리라 믿습니다
이건 오픈 소스죠
따라서 여러분이 시도해 보시고
버그를 보고해주시며
또한 이 컴파일이
여러분의 작업량에 주는 혜택을
알려주셨으면 좋겠습니다

English: 
So to recap, to go over the
benefits of compilation,
we're able to specialize
the code for the computation
that you handed to the compiler.
So we're able to eliminate
operation dispatch overhead.
We're able to fuse
operations together.
So normally, if you take
one operation at a time,
you'll pull in all the data
from memory, operate on it,
push it back out to memory, and
the next operation will come,
pull it back in from
memory, operate on it,
and spit it back out.
But when you have a
compiler in the mix,
you're actually able to pull
all the memory in one time,
operate on it with
all the operations
that you want to do at
a time, and then flush
it back out to memory.
So this is called fusion.
So we're able to avoid
these expensive round
trips to memory, which
can benefit power
on mobile platforms as well.
We're able to perform precise
and global buffer analysis.
So really, this means, because
we can look at the whole graph
and how all of the tensors
are flowing between all
the operations, we're able to
make compile time trade-offs
between memory usage and speed.

Chinese: 
让我们回顾一下编译的好处
我们可以将你输入编译器中的
计算机代码专业化
这样我们就可以减少操作调度开销
我们可以将所有的操作融合在一起
所以通常情况下，如果你一次进行一项操作
你可以从内存中获取所有的数据，运行它
把它放回内存，然后进行下一项操作
从内存中提取数据，运行它
然后放回内存
但如果你在混合平台中用一个编译器
你可以一次将所有的数据都从内存中提取出来
运行所有你想要
运行的操作
然后将数据储存回内存
这就叫做融合
这样我们就可以避免昂贵的来回使用内存
这也可以强化
移动平台
我们能够运行精确的全缓存分析
这就意味着
因为我们可以看到整体图
以及Tensors是如何在所有操作中运行的
我们就可以让编译时间
在内存使用情况和速度间权衡

Indonesian: 
Jadi, merangkum manfaat kompilasi:
kita bisa mengkhususkan
kode untuk komputasi
yang Anda berikan ke kompilator.
Jadi kita bisa mengeliminasi
operasi biaya dispatch.
Kita bisa menggabungkan operasi.
Normalnya, jika Anda ambil
satu operasi dalam satu waktu
maka Anda akan menarik semua data
dari memori, mengoperasikannya
lalu mengembalikan ke memori dan
operasi selanjutnya akan datang,
tarik dari memori, operasikan,
dan mengembalikannya.
Tapi ketika Anda punya kompilator,
Anda bisa menarik semua memori
dalam satu waktu, operasikan
pada semua operasi yang ingin dilakukan
dalam satu waktu,
lalu kembalikan ke memori.
Jadi ini namanya fusi.
Jadi kita bisa menghindari
perjalanan memori mahal ini
dan bisa memanfaatkan kekuatan
pada platform seluler juga.
Kita bisa melakukan analisis buffer
tepat dan global.
Ini artinya karena kita bisa melihat
keseluruhan grafik
dan cara semua tensor berhubungan
di antara semua operasi, kita bisa
menyingkat waktu kompilasi
antara penggunaan dan kecepatan memori.

Japanese: 
レカップし、コンピレーションの
恩恵を受けるために
コンパイラーに渡した算定用のコードを
特定することができます。
オーバーヘッドディスパッチオペレーションを
除去することができます。
オペレーションを融合することができます。
通常、１度に１つのオペレーションを行なう時
メモリーからすべてのデータを入力し、
それで処理を行ない
メモリーに戻し、
次のオペレーションを行ない
メモリーから取り出し、
処理を行ない、戻します。
しかし、ミックスでコンパイラーがあれば
１度にすべてのメモリーを
入力することができ、
１度に行ないたいオペレーション全てで
処理をおこなうことができ、
それをメモリーにフラッシュアウト
することができます。
これはフュージョンと呼ばれます。
これらのメモリーへの高くつく
ラウンドトリップを回避することができ、
それはモバイルプラットフォームに
パワーを付与することになります。
正確でグローバルなバッファ分析を
実行することができます。
これが意味するのは、
グラフ全体そして全てのオペレーション間で
全てのテンソルがどのように
フローイングしているかを確認でき、
メモリーユサージとスピード間の
タイムトレードオフをコンパイルできます。

Portuguese: 
Recapitulando os benefícios da compilação,
podemos especializar o código
para o cálculo que você passou
ao compilador.
Conseguimos eliminar a sobrecarga
do despacho da operação.
Podemos fundir operações.
Normalmente, se você toma
uma operação por vez,
você puxa os dados da memória,
opera neles, devolve-os à memória
e a próxima operação surge.
Puxa da memória,
opera nela e solta-a de novo.
Mas quando se tem um compilador,
é possível puxar toda a memória
de uma só vez,
mexer nela com todas
as operações que você deseje
e então devolvê-las à memória.
Isso se chama "fusão".
Evitamos essas idas custosas à memória,
o que pode ser benéfico para a energia
em plataformas móveis também.
Desempenhamos análises de buffer
precisas e globais.
Então, como podemos examinar
o grafo por completo
e como todos os tensores estão fluindo
entre todas as operações,
podemos fazer trade-offs
de tempo de compilação
entre uso da memória e velocidade.

Spanish: 
Para recapitular y repasar los beneficios
de la compilación
podemos especializar el código
para el cálculo
que entregaste al compilador.
Podemos eliminar la sobrecarga
de envío de la operación.
Somos capaces
de fusionar operaciones juntas.
Normalmente,
si tomas una operación a la vez
pondrás todos los datos
de la memoria, operarás
retrocederás a la memoria,
y la próxima operación vendrá
regresando de la memoria, operará en ella
y lo volverá a mostrar.
Pero cuando tienes un compilador
en la mezcla
de verdad puedes sacar
toda la memoria de una vez
operar con todas las operaciones
que deseas hacer a la vez
y descargarla
de nuevo en la memoria.
Esto se llama fusión.
Podemos evitar estos costosos viajes
a la memoria, que también beneficiará
la energía en las plataformas móviles.
Somos capaces de realizar análisis
de buffer precisos y globales.
Esto significa
que ya que podemos ver todo el gráfico
y cómo todos los tensores fluyen
entre todas las operaciones,
compilamos intercambios de tiempo
entre el uso de la memoria y la velocidad.

Korean: 
요약컨대 컴파일의 혜택을 복습해 보면
컴파일러에 넘겨주는 계산을 위한 코드를
특별화할 수 있습니다
따라서 운영 디스패치 시간을 없앨 수 있죠
운영을 서로 결합시킬 수 있죠
보통은 한 운영을 한 번에 한다면
모든 데이터를 메모리에서
꺼내서 운영시키고
메모리로 다시 넣고 다음 운영이 오면
메모리에서 다시 꺼내서 운영하고
다시 넣겠죠
하지만 컴파일러가 섞여 있다면
사실 모든 메모리를 한꺼번에 꺼내서
하고 싶은 모든 운영을 한번에
운영하고 다시 메모리로 넣을 수
있는 거죠
이를 퓨전이라고 부릅니다
이렇게 메모리로의 비용 큰 왕복 여정을
피할 수 있고, 휴대기기 플랫폼에서도
파워에 혜택을 줄 수 있죠
정확하고 전반적인 버퍼 분석을
시행할 수 있습니다
따라서 이는 전체 그래프를 볼 수 있고
모든 운영 사이에서
모든 텐서가 어떻게 흐르는지
알 수 있기 때문에
메모리 사용과 속도 사이의
컴파일 시간 균형을 얻을 수 있는거죠

Indonesian: 
Anda akan punya konkurensi tambahan
yang membutuhkan memori tambahan.
Jika memori Anda terbatas, Anda mungkin
ingin mengurangi penggunaan memori.
Dalam penghasil kode, kita bisa
beberkan dan vektorisasi, yang mana
beberapa kunci optimisasi
platform modern sekarang, melalui
dimensi yang diketahui ini.
Jadi kita tahu bahwa tensor
mengikat ukuran batch
dalam nilai tertentu.
Dengan mengkhususkan itu,
kita bisa membuka
keseluruhan kategori optimisasi
yang CPU dan GPU modern dan platform lain
didesain untuk berjalan paling efektif.
Anda punya kode yang bisa
dieksekusi lebih kecil
di belakang karena Anda hasilkan tepat
seperti yang Anda butuh untuk grafik ini.
Jadi bagaimana cara kerjanya?
Secara mendasar, program XLA 
adalah seperangkat
operasi TensorFlow
yang statis dan terurai.
Merupakan operasi primitif
seperti matematika
yang Anda rangkai
untuk membuat operasi makro.
Jadi ini bisa mendukung
banyak definisi jaringan

Spanish: 
Es posible que tengas una concurrencia
adicional
pero podría ser a costo
de memoria adicional.
Si hay limitación de memoria
pueden querer reducir
el uso máximo de memoria.
Y podemos, en el generador de código
desenrollar y vectorizar, unas
de las optimizaciones principales
para las plataformas modernas
a través de dimensiones conocidas
que obtenemos.
Sabemos que el límite tensor
para el tamaño
del batch es un valor particular.
Al especializarnos en ello
podemos desbloquear toda una categoría
de optimizaciones
con las que CPUs y GPUs
y otras plataformas modernas
están diseñadas para funcionar
con mayor eficacia.
Y como hemos observado, se obtienen
ejecutables mucho más pequeños
por atrás, porque generas
justo lo que necesitas
de este gráfico específico.
Entonces, ¿cómo funciona esto?
En esencia, un programa XLA es un conjunto
de operaciones TensorFlow estáticas
y descompuestas.
Son operaciones primitivas
de aspecto matemático
que compones
para realizar operaciones macro.
Esto es capaz de soportar
muchas definiciones de red neuronal

Japanese: 
付加コンコレンシーを得ることになりますが、
付加メモリーの負荷となります。
もしメモリーが抑制されていたら、
ピークメモリーユサージを
減らしたくなるでしょう。
ジェネレーターコード内で
アンロールとベクトライズすることができ、
それは、取得したこれらの
ディメンションを通じて
今日のモダンプラットフォーム用の
最適化キーとなります。
バッチサイズ用にバウンドされたテンソルは、
特定値であることがわかります。
特定化することによって、
モダン CPU、GPU、他のプラットフォームが
最大効率で作動するように指示された、
最適化カテゴリ全体を
アンロックすることが可能です。
より小さなエグゼキュータブルを
得ることになります。
まさにこの特定グラフに必要なものを
生成するからです。
アンダーフードではどのように
機能するのでしょうか。
根本的に、XLA プログラムは
スタティックで
分解された TensorFlow オペレーションの
集合体です。
マクロオペレーションを実行するために
構築する、
マスルッキングの原始オペレーションです。
今日、至る所で目にする
数多くのニューラルネット定義を
サポートすることが可能です。

Chinese: 
你可能会有额外的并发事件
它可能会消耗一些额外的内存
因此，如果你内存有限
你可能会想要减少峰值内存使用
我们可以通过代码生成器来实现
展开和矢量化
是当今现代平台的关键的优化
通过我们获取的已知的维度
我们知道Tensor
可以与一个特定大小的内存绑定
通过具体化
我们可以解锁整体类别的优化
这样CPU，GPU以及其它平台
可以更为有效的运行
就像我们提到的那样
我们在后端有更少的执行项
因为你为这个特定的图表
生产特定的运行项
那这在后台是如何运行的呢？
从根本上说 一个XLA程序是
一组静态的，TensorFlow分项操作
所以它们是一系列的基本操作
用来创造更为复杂的操作
它能够支持许多神经网络的定义

Portuguese: 
Você pode ter concorrências adicionais,
mas teria um custo adicional
sobre a memória.
Se sua memória for limitada,
você deve reduzir o pico de memória usada.
Podemos, no gerador de códigos,
desdobrar e vetorizar,
que são otimizações importantes
para as atuais plataformas de móvel,
por meio das dimensões conhecidas.
Sabemos que a limitação do tensor
para tamanho do batch
é um valor específico.
Especializando-nos para ele,
abrimos uma nova categoria de otimizações
que CPUs modernas, GPUs
e outras plataformas
são feitas para executar
de forma mais efetiva.
Como notamos, você obtém
executáveis muito menores ao final,
porque você gera exatamente o que precisa
para esse grafo específico.
E como isso funciona nos bastidores?
Um programa XLA é um conjunto
de operações estáticas
e decompostas do TensorFlow.
São operações primitivas de matemática
que você pode compor
para fazer operações macro.
Isso pode comportar
muitas definições de redes neurais

English: 
So you might have additional
concurrency that comes,
but it might be at the
cost of additional memory.
So if you were
memory constrained,
you may want to reduce
the peak memory usage.
And we're able to, in
the code generator,
unroll and vectorize, which
are some key optimizations
for today's modern platforms,
via these known dimensions
that we get.
So we know that the tensor
bound for batch size
is a particular value.
And by specializing
for it, we're
able to unlock a whole
category of optimizations
that modern CPUs and
GPUs and other platforms
are designed to run
most effectively.
And as we noted, you get
much smaller executables
out the back, because you
generate exactly what you
need for this specific graph.
So how does this
work under the hood?
Fundamentally, an
XLA program is a set
of static, decomposed
TensorFlow operations.
So they're math-looking
primitive operations
that you compose to
make macro operations.
So this is able to support
many neural net definitions

Korean: 
따라서 부가적인
컨커런시가 있을 수도 있지만
부가적인 메모리 비용도 따를 겁니다
메모리 제한이 있다면
최고 메모리 사용치를 줄여야겠죠
그리고 코드 제너레이터에서
언롤과 벡터라이징이 가능할 겁니다
이는 이렇게 이미 아는
디멘션을 통해 현대 플랫폼을 위한
일부 중요 최적화인 거죠
배치 크기를 위한 텐서가
특정값임을 알고 있죠
이를 위해 특별화함으로써
현대 CPU와 GPU, 다른 플랫폼이
가장 효율적으로
실행하도록 설계된 최적화의
전체 범주를 풀 수 있습니다
말씀 드렸듯 뒷쪽에서는
훨씬 더 작은 실행파일을 얻습니다
정확히 이 특정 그래프를 위해
필요한 것을
만들어 내니까 말이죠
그럼 언더 더 후드에서는
어떻게 작동될까요?
기본적으로 XLA 프로그램은
안정이고 분해된
텐서플로우 운영 세트입니다
마이크로 운영을 위해 여러분이 만드는
수학 같은 모습의 원시연산이죠
이는 오늘날 우리가 밖에서 본

Korean: 
많은 신경망 정의를 지원할 수 있죠
이는 전형적인 텐서플로우 예시입니다
이 그래프를 보신 분도 있을 겁니다
MatMul과 덧셈은 수학을 통해 알죠
Relu는 0과 어떤 값의
최대값을 멋지게 말하는 거죠
그런데 소프트맥스는 재미있습니다
다른 것들과 좀 다릅니다
소프트맥스는 오늘날 일반 텐서플로우에
C++로 직접 코딩되고
구현됩니다
문제는 정의를 지원한다면, 어째서
다른 텐서플로우 운영의
소프트맥스는 만들 수 없는 걸까요?
자주 듣는 답변 중 하나는
사람들이 그렇게 해서 오는 성능 감소를
원하지 않기 때문이죠
하지만 운영 컴포지션이
직접 코딩된 C++의
성능을 가진다면 어떨까요?
소프트맥스가 내부에 가진 것을 보면
점과 덧셈 뺄셈
그리고 EXP가 있습니다
이 모든 것이 수학과 같은 운영이죠
테드가 말하겠지만 사실
텐서플로우와 XLA의 연결고리의 역할은
빌트인 운영 디컴포지션이

Chinese: 
正如我们今天在参照组看到的一样
所以这就是一个经典的TensorFlow例子
你以前可能看到过这个图标
MatMul和Add
我在数学中学过它们
Relu只是一个花哨的说法来表达
零的最大值和一些值
softmax非常的有趣
它跟其他的操作不一样
在今天的TensorFlow中
softmax是用C++ 手动输入的
所以问题在于我们为什么
不能在其它的TensorFlow操作中
构建softmax
如果它们定义是一样的话？
我们听到的一个答案是
人们不想要这么做
而影响性能
但是如果操作组合
有和手动输入的C++一样的性能？
如果你看到softmax里的信息
它有点，添加，减少，和经验值
这都是类似数学的操作
也正是TensorFlow
和 XLA是如何连接的
托德将会向大家介绍
它通过操作分解被构建

Spanish: 
que hemos visto en la naturaleza hoy.
Este es un ejemplo clásico de TensorFlow.
Quizás vieron este gráfico antes.
MatMul y Add,
los conozco por las matemáticas.
Relu es una manera elegante de decir
máximo de cero y algún valor.
Pero entonces Softmax, ese es interesante.
Ese no es como los otros.
Softmax se implementa, codificado
a mano en C++ en Vanilla
que es ahora TensorFlow.
La pregunta es, ¿por qué no podemos
componer Softmax desde
las otras operaciones TensorFlow
si apoyan la definición?
Y una de las respuestas
que escuchamos
es que no quieren pagar una penalidad
de rendimiento por hacerlo.
Pero, ¿y si la composición
de la operación tuviera el rendimiento
del código C++ codificado a mano?
Si miran el tipo de cosas
que Softmax tiene adentro
tiene puntos y agrega y reduce y EXPs.
Son operaciones similares
a las matemáticas.
Y en realidad, lo que el puente
de TensorFlow
y XLA, de lo que hablará Todd,
hace es integrar
la descomposición de la operación

Indonesian: 
yang sering kita lihat sekarang ini.
Ini contoh klasik TensorFlow.
Anda mungkin pernah lihat ini.
MatMul dan Add, 
saya tahu itu dari matematika.
Relu itu cuma cara bilang yang keren
untuk maksimum nol dan beberapa nilai.
Lalu Softmax, itu agak menarik.
Ini tidak seperti lainnya.
Softmax diimplementasikan,
dan ditulis dalam C++
di TensorFlow vanilla masa kini.
Dan pertanyaannya, kenapa
kita tidak bisa menyusun softmax
dari operasi TensorFlow lainnya
jika mereka mendukung definisi itu?
Salah satu jawaban yang kita dengar
karena orang tidak ingin melakukan
hukuman kinerja untuk itu.
Tapi bagaimana jika komposisi operasi
memiliki kinerja
kode manual C++?
Jika Anda melihat hal
yang softmax miliki di dalamnya
dia memiliki titik dan tambah
dan kurang dan eksponensial.
Ini semua operasi dalam matematika.
Sebenarnya, yang disambungkan TensorFlow
ke XLA, yang Todd akan sampaikan
adalah dekomposisi operasi bawaan ini,
mengambil operasi makro

English: 
that we've seen
in the wild today.
So this is a classic
TensorFlow example.
You may have seen
this graph before.
So MatMul and Add, I
know those from math.
Relu is just a
fancy way of saying
max of zero and some value.
But then softmax, that's
kind of interesting one.
That one's not like
the other ones.
So softmax is implemented,
hand-coded in C++ in vanilla
TensorFlow today.
And the question is, why
can't we compose softmax out
of the other
TensorFlow operations
if they support the definition?
And one of the
answers that we hear
is because people don't
want to pay a performance
penalty for doing that.
But what if operation
composition had the performance
of the hand-coded C++?
So if you look at the kind of
stuff that softmax has inside,
it has dots and adds
and reduces and EXPs.
These are all
math-like operations.
And actually, what
the TensorFlow to XLA
bridge, that Todd
will talk about, does
is this built in
operation decomposition,

Japanese: 
これは TensorFlow の典型的な
サンプルです。
先程、こちらのグラフを
ご覧になったと思います。
MatMul と Add は
数学で使います。
Relu はゼロの最大値や他の値を
呼ぶ時に使う言い方です。
softmax は
興味深いものです。
他のものとは違うようです。
softmax は平凡な TensorFlow 内で
C++ で実行されハンドコードされます。
他の TensorFlow オペレーションが
定義をサポートしないのであれば、
そこから softmax を構築できないのか
ということが提起されます。
耳にする答えの１つが、
そのためにパフォーマンスペナルティを
払いたがらないという事実です。
ハンドコーディッド C++ の
パフォーマンスを
オペレーションコンポジションが
持っていなかったらどうなるでしょう。
softmax が包括しているものを
見てみると、
ピリオド、加算、約分、
また EXP があります。
これらは全てマスライクな
オペレーションです。
後でトッドが話しますが、
実際 XLA ブリッジに対して
TensorFlow が行なうのは、
マクロオペレーションを取得し、

Portuguese: 
que vemos por aí hoje em dia.
Este é um exemplo clássico do TensorFlow.
Vocês já devem ter visto esse grafo.
MatMul e Add, conheço ambas da matemática.
ReLU é outra forma de dizer
"o máximo de zero e outro valor".
Mas SoftMax já é mais interessante.
Essa não é como as outras.
SoftMax é implementada
por um código manual em C++
na versão "Vanilla" do TensorFlow.
A pergunta é: por que
não podemos compor SoftMax
com as outras operações do TensorFlow
se elas comportam a definição?
Uma das respostas que ouvimos
foi que as pessoas não querem
penalizar o desempenho
por fazer isso.
Mas e se a composição de operações
tivesse o desempenho do C++ manual?
Se olharmos o que SoftMax tem por dentro,
ela tem Dot, Add, Reduce e Exp.
Todas são operações matemáticas.
O que a ponte entre TensorFlow e XLA,
sobre a qual o Todd vai falar, faz
é essa operação
de decomposição embutida,

Indonesian: 
dan mengeluarkan beberapa operasi mikro
yang kita tahu cara mengompilasinya.
Jadi dengan komposisi operasi primitif,
kita masih bisa menghasilkan
kernel komposit tergabung dan teroptimasi,
seperti ditulis dengan tangan.
Ingat bahwa semua ini bisa
diekspresikan di TensorFlow.
Semua operasi yang kita tampilkan
di slide softmax
adalah operasi TensorFlow primitif
tapi XLA menghapus masalah kinerja
untuk menggabungkan
operasi TensorFlow ini.
Jadi kita juga bisa menghindari
ledakan kombinatorial
dari fusi operasi khusus.
Kita sering lihat di penelitian ML
dengan sel LSTM, di mana secara teknis
Anda perlu mengkhususkan setiap operasi
makro, untuk tiap seperangkat primitif
di dalam operasi makro,
untuk tiap ukuran dimensi,
untuk setiap backend,
CPU, GPU, platform berbeda,
untuk setiap perangkat dalam platform itu.
Tapi JIT bisa membaca apa
yang diberikan dalam grafik, gabungkan

Japanese: 
コンパイル方法を知る複数の
マイクロオペレーションを出力して、
分解されたオペレーション内に
構築するということです。
プリミティブオペレーション構築を通じて、
手動で入力したような、融合・最適化された
複合カーネルを生成することができます。
これは TensorFlow 内の
すべての表現となります。
Softmax スライドでお見せした、
これら全てのオペレーションは
すべてプリミティブ TensorFlow 
オペレーションです。
まとめられたこれらの TensorFlow 
オペレーションを構築するための、
パフォーマンスコンサーンを
XLA は取り除きます。
カスタムオペレーション融合による
複合急増を回避することができます。
例えば、これを LSTM セルの伴う
ML リサーチ内で数多く目にします。
そこでは、それぞれのマクロオペレーション、
マクロオペレーション内部の各々の原始集合体
それぞれのデイメンションサイズ、
それぞれのバックエンド、CPU、GPU
異なるプラットフォーム、
そのプラットフォーム内の各々のデバイス、
これらに対する技術的な特化を
行なっています。
しかし JIT はグラフ内に提供したものを
確認することができ、

Chinese: 
使用宏观操作
然后分解成我们知道的一些小操作
因此通过一些简单的原始操作
我们仍然可以融合并优化组成
就像你手动输入一样
这就是TensorFlow中的所有表达
我们在softmax幻灯片中显示的所有操作
都是原始的TensorFlow操作
但XLA消除了这些TensorFlow操作
组合在一起的性能问题
所以我们能够避免组合爆炸
有自定义操作融合引起的
比如说，我们在LSTM细胞的
ML研究中经常会看到
在这个研究中
你理论上可以指定每一个宏观操作
每一项宏观操作中的原始操作
在每一个维度上，每一个终端
CPU，GPU，不同的平台
这些平台下的每一台设备
但是 JIT可以查看

English: 
taking the macro
operation and emitting
several micro operations that we
know how to compile out of it.
So with the primitive
operation composition,
we're still able to generate
the fused and optimized
composite kernel, like you
would have written by hand.
So note that this is all
expressible in TensorFlow.
All those operations that we
showed in the softmax slide
are all primitive
TensorFlow operations,
but XLA removes the
performance concern
of composing these TensorFlow
operations together.
So we're also able to avoid
combinatorial explosions
of custom operation fusions.
For example, we see this
a lot in ML research
with LSTM cells, where
you would technically
have to specialize for every
macro operation, for every set
of primitives inside
the macro operation,
for every dimension
size, for every backend,
CPU, GPU, different
platforms, for every device
within that platform.
But the JIT is able
to look at what you've

Korean: 
매크로 운영을 하고
컴파일 방법을 알고 있는
몇 가지 마이크로 운영을
만들어 낸다는 점이죠
따라서 원시연산 컴포지션으로
여전히 혼합되고 최적화 된 혼합커널을
손으로 직접 할 때만큼이나
만들 수 있는 거죠
이 모든 것은 텐서플로우에서
표현할 수 있습니다
소프트맥스 슬라이드에서
보여드린 모든 운영은
모두 원시 텐서플로우 연산이지만
XLA이 이러한
텐서플로우 연산이 만드는
성능 걱정을 없애주는 거죠
커스텀 연산 퓨전의 결합적인 폭발 또한
피할 수 있는 겁니다
예컨대 이는 LSTM 셀을 이용한
ML 연구에서 많이 보죠
이는 모든 마이크로 운영
모든 마이크로 운영 내 원시 세트
모든 디멘션 크기, 모든 후단부
CPU, GPU, 다른 플랫폼
그 플랫폼 내의 모든 기기를 위해
특별화 되어야 합니다
하지만 JIT는 그래프에서
여러분이 제공한 것을

Spanish: 
tomando la macro operación y emitiendo
varias operaciones micro que sabemos
cómo compilar fuera de él.
Con la composición primitiva
de la operación
aún podemos generar el núcleo fusionado
y optimizado
como si hubiera sido escrito a mano.
Recuerden que todo esto
es expresable en TensorFlow.
Todas las operaciones que vimos
en la diapositiva de Softmax
son primitivas de TensorFlow
pero XLA elimina la preocupación
de componer estas operaciones
TensorFlow juntas.
Así también podemos evitar
explosiones combinatorias de fusiones
de operaciones personalizadas.
En la investigación de AA
con células LSTM, donde técnicamente
se especializan para cada macro operación,
para cada conjunto
de primitivas dentro de la macro operación
para cada tamaño de dimensión,
para cada backend
CPU, GPU, diferentes plataformas,
para cada dispositivo
dentro de esa plataforma.
Pero JIT es capaz
de ver lo que proporcionaste

Portuguese: 
pegar a operação macro
e emitir várias micro-operações
que sabemos como compilar.
Com a composição primitiva da operação,
ainda geramos o núcleo fundido,
otimizado e composto,
como se fosse escrito à mão.
Note que tudo isso
pode ser exprimido no TensorFlow.
Todas as operações
que mostramos no slide do SoftMax
são operações primitivas do TensorFlow,
mas a XLA remove a preocupação
com o desempenho
de combinar operações do TensorFlow.
Também evitamos explosões combinatórias
das fusões de operações personalizadas.
Por exemplo, acontece com frequência
em pesquisas de ML
com células de redes LSTM,
nas quais é preciso especializar-se
para cada operação macro,
cada conjunto de primitivas
dentro da operação macro,
cada tamanho de dimensão,
todos os back-end,
diferentes plataformas, CPU, GPU
e para todos os dispositivos
em cada plataforma.
Mas o JIT consegue ver
o que você forneceu no grafo,

Korean: 
보고 역동적 방식으로 퓨즈하게 해주고
운영하고 있는 플랫폼을 위한
최적화된 어셈블리를
만들어내는 거죠
또한 저희는 최소한의
표적 영역을 만들도록 노력했죠
이국적 기기가 이러한
XLA 원시 세트로 들어갈 수
있도록 말입니다
여러분이 LLVM 파이프라인과
스트림엑스큐터라고 부르는
실시간 플러그인이 있다면
잠재적 옵션으로
사실 XLA로
사실상 슬랏할 수 있습니다
CPU와 GPU 백엔드가
이 둘을 효율적으로
사용하고 있으니까 말이죠
따라서 저희는 개발 수명 동안
XLA가 유용하다고
생각합니다
프로토타입을 만드는 동안
JIT 컴필레이션을 사용해야죠
스캐일하면서
컴필레이션 캐싱을 사용해야죠
사람들이 서버에서 무언가를 요구할 때
매번 컴파일하지 않는 거죠
컴필레이션 캐쉬를 누르면 됩니다
여기 특정 최적화된
어셈블리 코드가 있군, 하고 말이죠
어헤드 오브 타임
컴필레이션을 사용할 수도 있죠
휴대기기와 임베디드 기기
이러한 플랫폼을 위한 지연 속도
최소화를 위해서 말입니다
이 프로그램의 안정적 속성을 통제하고
관찰할 수 있게 됩니다

Portuguese: 
fundir isso de forma dinâmica
e produzir a montagem otimizada
para a plataforma
em que você está trabalhando.
Também tentamos fazer disso
uma área de superfície mínima
para que os dispositivos exóticos
possam se encaixar em slots
nesse conjunto de primitivas XLA.
Se você usar um pipeline LLVM
e um plugin de tempo de execução
chamado StreamExecutor,
você pode encaixar em slot na XLA hoje
como uma opção em potencial
porque os back-ends da CPU
e da GPU estão usando ambos.
Achamos que o XLA é útil
ao longo do ciclo do desenvolvimento.
Você pode usar a compilação JIT
quando estiver criando o protótipo.
Pode usar caching de compilação
quando dimensiona.
Então, quando alguém faz
um pedido ao servidor,
não se compila toda vez,
acessa-se um cache de compilação
que diz: "aqui está o código de montagem
otimizado e especializado".
E é possível usar compilação ahead-of-time
para móvel e dispositivos embarcados
e também para minimizar a latência
nessas plataformas.
Então é possível controlar e observar
as propriedades estáticas do programa.

Chinese: 
你在图像中提供了什么信息
以一个动态的方式融合
然后为你运行的平台
生成最优的编译
我们也试图将表面积最小化
这样外部设备可以
和XLA的原始操作相连接
如果你有一个LLVM通道
并且有一个运行时间插件
我们可以调用StreamExecutor
然后你就可以用XLA作为一个潜在的选项
因为CPU和GPU后端
从始至终都非常高效的使用它们
因此我们认为XLA
对于开发周期非常的有用
因此当你在构建原型时
你可以使用JIT编译
你可以使用你定义的编译缓存
所以当人们从服务器发送请求时
你不用每次都编译
你使用的编译缓存可以识别
专业化和优化的编译代码
你能够使用移动设备
和嵌入式设备提前编译
来减少在这些平台上的延迟
这样你就可以控制并观察
程序的静态属性

Spanish: 
al gráfico,
fusionarlo de manera dinámica, producir
el ensamblado optimizado
para la plataforma
que estás ejecutando.
También hemos tratado de hacer
que sea una superficie mínima
de modo que los dispositivos
exóticos encajen en este conjunto XLA
de primitivas.
Si tienen una tubería LLVM
y un plug-in de tiempo de ejecución
que llamamos StreamExecutor,
entonces
puedes realmente expandir en XLA hoy
como una opción potencial
pues los backend del CPU y GPU
están utilizando efectivamente 
estos dos componentes
y pensamos que XLA es útil
en todo el ciclo de vida
del desarrollo.
Pueden usar la compilación JIT
cuando crean un prototipo.
El almacenamiento en caché
a medida que avanzas.
Cuando piden cosas desde el servidor
no compilarás cada vez.
Usarás una caché de almacenamiento
que dice aquí está
el código de ensamblaje
especializado y optimizado.
Y pueden usar
por adelantado la compilación
para dispositivos móviles e integrados,
y para minimizar la latencia
en esas plataformas.
Así que puedes controlar y observar
las propiedades estáticas del programa.

Indonesian: 
secara dinamis, lalu buat gabungan
teroptimasi untuk platform
yang sedang Anda jalankan.
Kami juga telah mejadikan
area permukaannya minimal
sehingga perangkat eksotik
bisa masuk ke set primitif XLA ini.
Jika Anda memiliki saluran dan
plug-in waktu proses LLVM
yang kita sebut StreamExecutor,
lalu Anda bisa masukkan XLA
sebagai opsi potensial,
karena back-end CPU dan GPU
secara efisien menggunakan dua hal ini.
Jadi kami pikir XLA berguna
selama siklus pengembangan.
Anda bisa pakai kompilasi JIT
saat Anda membuat prototipe.
Bisa gunakan penyimpanan kompilasi.
Saat orang meminta sesuatu dari server,
Anda tak mengompilasi setiap saat.
Anda memencet cache kompilasi
yang bilang, di sini adalah
kode pemasangan khusus dan teroptimasi.
Anda bisa menggunakan
kompilasi lebih cepat
untuk perangkat seluler dan tertanam
dan untuk minimalisasi latensi
pada platform tersebut.
Jadi Anda harus kendalikan dan observasi
sifat statis program.

Japanese: 
ダイナミックな方法で融合し、作動中の
プラットフォーム用アセンブリを生成し
最適化を行ないます。
最小限のサーフェースエリアを
構築しようとし、
それによって、新種デバイスが
この XLA 基本要素集合体に
スロットインすることができます。
LLVM パイプラインと、
StreamExecutor と呼ばれる
ランタイムプラグインがあれば
実際にポテンシャルオプションとして
XLA にスロットインできます。
CPU と GPU バックエンドが実質上、
これら２つの構成要素を使っているからです。
XLA は開発サイクルを通じて
有効だと見なしています。
プロトタイプする時に、
JIT コンピレーションを使うことができ
スケールする時にコンピレーション
キャッシングを使うことができます。
これらをサーバーから取得しようとすると、
毎回コンパイルするわけではなく、
特定・最適化されたアセンブリコードを伝える
コンピレーションキャッシュにヒットします。
モバイル用と埋め込みデバイス用、
プラットフォームの待ち時間最小化に
アヘッドオブタイムコンピレーションを
使うことができます
プログラムのスタティックプロパティを
管理し、監視することができます。

English: 
provided to it in the graph,
fuse it in a dynamic way,
and then produce the optimized
assembly for the platform
that you're running on.
We've also tried to make
it a minimal surface area,
so that exotic devices
can slot into this XLA
set of primitives.
So if you have a LLVM
pipeline and a runtime plug-in
that we call
StreamExecutor, then you
can actually slot into XLA
today as a potential option,
because the CPU
and GPU back ends
are effectively using
these two throughout
So we think that XLA is useful
throughout the development
lifecycle.
So you get to use
JIT compilation
when you're prototyping.
You get to use compilation
caching as you scale.
So when people request
things from the server,
you're not compiling every time.
You're hitting in a compilation
cache that says, ah, here's
the specialized and
optimized assembly code.
And you're able to use
ahead-of-time compilation
for mobile and embedded devices,
and for latency minimization
on those platforms.
So you get to
control and observe
static properties
of the program.

Portuguese: 
Sobretudo para dispositivos móveis
e embarcados,
isso pode ser importante
para reduzir o pico do uso de memória.
Vou passar a palavra ao Todd,
que trabalha com XLA
e é membro do time Google Brain,
para se aprofundar em XLA
no ecossistema do TensorFlow.
Todd?
Obrigado, Chris.
Vejamos.
Eu sou um engenheiro, certo?
Então quando Zach perguntou
se eu gostaria de apresentar
o trabalho que tenho feito
para um monte de gente, eu disse sim.
Mas pensei que ele temia
que eu mostrasse apenas esse slide.
É a documentação sobre como o TensorFlow
é integrado com a XLA.
E eu diria, "Bem, leiam o slide".
"Leremos ele juntos".
Mas não, não farei isso.
Quero usar esta oportunidade
para apresentar este símbolo aqui.
O que é este símbolo?

Spanish: 
En dispositivos móviles e incrustados
puede ser importante, por ejemplo
para reducir el uso máximo de memoria.
Y ahora voy a dejar
a Todd que trabaja en XLA
como miembro del Equipo de Google Brain
para hablar en profundidad de XLA
en el ecosistema de TensorFlow.
¿Todd?
Gracias, Chris.
Veamos, yo soy un ingeniero, ¿sí?
Cuando Zach me preguntó
si presentaría parte del trabajo
que he realizado con muchas personas más
le dije, sí, claro.
Pero siempre sentí en el fondo
como si había algún miedo suyo
de que yo vendría
a mostrar solo esta diapositiva.
Esta es la documentación
de cómo TensorFlow se integra con XLA.
Bueno, solo lean la diapositiva.
Como si lo hiciéramos juntos.
Pero no, no, no haré eso.
Quiero aprovechar esta ocasión
para introducir este símbolo aquí.
Entonces, ¿qué es este símbolo?

Indonesian: 
Terutama perangkat seluler
dan tertanam, ini bisa jadi penting.
Contohnya, untuk mengurangi
penggunaan memori.
Sekarang akan kuserahkan
pada Todd, yang bekerja pada XLA
sebagai anggota tim Google Brain
untuk membahas mendalam soal XLA
di ekosistem TensorFlow.
Todd?
Terima kasih, Chris. Mari lihat.
Saya insinyur, kan?
Saat Zach tanya pada saya,
kau mau menampilkan
beberapa kerjaan yang telah dikerjakan
dengan orang lain?
Saya bilang, tentu.
Tapi saya selalu merasa di pikiran
entah akan ada ketakutan padanya
mungkin saya akan tampil
untuk tunjukkan slide ini.
Ini dokumentasi untuk bagaimana
TensorFlow berintegrasi dengan XLA.
Akan seperti, baca saja slidenya.
Kita akan melihatnya bersama.
Tapi saya takkan lakukan itu.
Saya ingin ambil kesempatan ini
untuk memperkenalkan simbol ini.

English: 
Especially on mobile
and embedded devices,
this can be important,
for example,
for reducing peak memory usage.
And so now I'm going
to turn it over
to Todd, who works on XLA as
a member of the Google Brain
team, to deep dive on XLA
in the TensorFlow ecosystem.
So Todd?
TODD WANG: Thanks, Chris.
Let's see.
Oh, so maybe-- well,
I'm an engineer, right?
So like when Zach had
mentioned to me that, oh,
would you be willing to
present some of the work
that you've been working on
with a bunch of other people,
I said, yeah, sure.
But I always felt like
in the back of my mind
whether there would
be some fear of his
that maybe I'd come up here
to show this one slide.
This is the
documentation for how
TensorFlow integrates with XLA.
It'd be like, well,
just read the slide.
Like, we'll go along
with it together.
But no, no, I'm not
going to do that.
But I want to take
this opportunity
to introduce this
symbol here, right?

Chinese: 
尤其是在移动和切入式设备上
这非常的重要，比如说
减少内存使用量的峰值
现在我将话筒递给托德
他是Google Brain组的一员
深入研究TensorFlow生态系统的XLA
所以托德？
谢谢你 克里斯
让我们来看一看
我是一个工程师，对吗？
就像扎克对我提起的那样
你愿意跟大家分享一下
你跟其他人一直在做的一部分工作吗？
我说是的，当然了
但我一直觉得，在我的潜意识里
有一点点担心
我也许会站在这里
跟大家分享这个幻灯片
这个文档是有关
TensorFlow是如何与XLA集成的
比如请大家阅读幻灯片
比如让我们一起来看一看
不，不，我不会这样做的
但我想利用这次机会
在这里介绍这个符号，好吧？

Korean: 
특히 휴대 및 임베디드 기기 상에서
예컨대 최고 메모리 사용량을
줄이는 데에 중요할 수 있죠
그럼 이제 토드에게 넘기겠습니다
Google 두뇌 팀의 일원으로써
텐서플로우 생태계에서 XLA을
깊이 연구하고 있는 분이죠
토드?
고마워요, 크리스
전 엔지니어입니다
제크가 저에게 이러더군요
다른 사람들과 함께 작업해 온
일 몇 가지를 발표해 주겠냐고 물었고
전 당연히 한다고 했죠
하지만 제크가 좀 불안해 한다는
느낌이 제 마음 한 구석에 있었죠
이 슬라이드 한 장만
보여주면 어쩌나 하고 말이죠
이는 텐서플로우가
XLA와 어떻게 통합되는가를
문서화 한 것입니다
그냥 이 슬라이드를 읽으면 되겠죠
다 같이 따라 가는 거죠
그러지는 않을 겁니다
하지만 이 기회에
여기 이 상징을 소개하고 싶습니다

Japanese: 
とりわけ、モバイルおよび
埋め込みデバイス上で
ピークメモリーユサージを減少させる時に
重要な要素となります。
それでは、トッドに
バトンタッチしたいと思います。
彼は Google Brain メンバーとして
XLA に関する
TensorFlow エコシステム内に XLA を
浸透させるための事業に携わっています。
トッド、お願いします。
TODD WANG: 
クリス、ありがとう。
私はエンジニアを務めています。
ザックが私に、
今まで手がけてきた事業を
大勢の聴衆の前で
プレゼンしないかと言った時
「もちろん、喜んで」
と答えました。
でも、常に頭に浮かんでいたのは
この１枚のスライドを見せるために
私が登場してくるのではないかと
彼が恐れているのではないだろうか
ということでした。
これは TensorFlow がどのように XLA に
統合するかを示す資料です。
このスライドを読むといったような具合です。
これだけでプレゼンが終了という感じです。
いや、そんなことはしない
と思いました。
けれど、この機会を利用して
このシンボルを紹介したいと思います。
これは何のシンボルでしょうか。

Japanese: 
90年代を知る方なら、このシンボルが
「ウェブサイトは作動していません」
という意味を表していると
お分かりだと思います。
それではそのもたらす意味とは
何でしょうか。
これを実験的と呼ぶには、意味があります。
先程言及した資料という意味もあります。
まったく信用していないからではなく、
実際は、その逆です。
アプローチは実質、非常に強いものであり
直面しているチャレンジは、
乗り越えられるものです。
出てきた結果、つまり初期段階の結果は
全く素晴しいものです。
しかし、まだ作業は終了していません。
なので、これから皆さんに
紹介したいと思います。
コード用のアクチュアルオープンソース
ディレクトリの観点から、
お話し始めたいと思います。
この下には４つのディレクトリがあります。
これらの内部に実質何が入っているのかを
１つ１つ説明していきたいと思います。
一番目は XLA です。
見ての通り、これはコンパイラーの一種です。
クリスがすでにお話したと思います。
記憶を呼び起こすために、詳細に関して
別の観点から説明したいと思います。
この１枚のスライドに XLA があります。

Indonesian: 
Simbol apakah ini?
Semua orang dari tahun 90-an ingat
kalau simbol ini artinya
situs web saya tidak bekerja.
Apa yang penting di sini?
Ada alasan kenapa
kita sebut itu eksperimental.
Dan kami menyebutnya
dalam beberapa dokumentasi.
Bukan karena kami tak percaya
pada hal itu.
Faktanya, sebaliknya.
Kami pikir pendekatan itu sangat kuat.
Dan tantangan yang kami hadapi
itu bisa diatasi.
Hasil awal yang kami dapat sangat bagus
tapi kami masih belum selesai.
Itu sebabnya saya ingin sampaikan
pada Anda sekalian.
Saya akan sampaikan pembahasan ini
soal direktori sumber terbuka
nyata untuk kode.
Ada empat direktori di sana.
Saya akan bahas semua
untuk mendeskripsikan apa
yang ada di dalamnya.
Yang pertama adalah XLA.
Tidak mengejutkan, ini adalah kompilator
yang Chris baru saja bicarakan.
Sebagai penyegar atau mungkin
untuk menjelaskannya
dalam tingkat detail lain, yaitu
ini XLA dalam satu gambar, oke?

Korean: 
이 상징은 뭘까요?
90년대를 사신 분들이라면
이 상징은 제 웹사이트가
잘 안되고 있음을
의미한다고 기억하시겠죠
그럼 여기서 무엇이 중요할까요?
이를 실험적이라고 부르는 데에는
이유가 있습니다
그리고 일종의 문서에서
이런 식으로 언급하는 거죠
신빙성이 없어서가 아닙니다
사실 그 반대이죠
이 접근법은 정말 강력하다고 생각합니다
또한 저희가 직면한
문제들이 극복할 수 있는
일이라고 생각합니다
저희가 얻은 초반의 결과들은
정말 좋지만 분명
아직 완성되지는 않았죠
그것이 바로 제가 지금
발표하고 싶었던 이유입니다
그리고 제 발표는 코드의
실제 오픈 소스 디렉토리를
이용해서
이어 나가겠습니다
여기 4개의 디렉토리가 있죠
이 내부에 무엇이 있는지 각각을
설명하겠습니다
첫 번째는 XLA입니다
별로 새로운 사실은 아니지만
이것이 크리스가 방금 얘기한
일종의 컴파일러입니다
다시 새로운 설명을
덧붙이자면
XLA이 하나의 그림에 있죠?

Chinese: 
所以这是一个什么符号呢？
所以每一个有90年代记忆的人
都知道这个符号代表
我的网站无法正常运行，对吗？
那么它在这里的意义是什么？
这就是我们称它为实验性的原因
在一些文档中
我们也提到过这个，对吗？
这并不是因为我们不相信它
事实正相反
我们事实上认为我们的方法非常的强大
并且我们认为我们面对的挑战
是可以克服的
我们得到的早期结果非常的好
当我们还没有完成
这就是我现在为什么想向大家做演讲的原因
因此，我将这次的演讲
定义为代码的
开源目录
这下面有四种目录
我将一一向大家介绍
来描述它们内部实际上是什么
第一个就是XLA
不出意外的话，这就是克里斯
刚刚为大家介绍的编译器
作为重温
或者为大家在另一个层次描述
这是在一个图片中的XLA

English: 
So what is this symbol?
So everyone from
the '90s remembers
that this symbol meant
my website isn't really
working, right?
And so what's the
significance here?
Well, there's a reason why we
sort of call it experimental.
And on some of
the documentation,
we sort of mentioned
it like this, right?
And it's not because we
don't really believe in it.
In fact, it's the opposite.
We think that the approach
is actually really strong.
And we think that the
challenges that we face
are sort of surmountable.
The results that we're
getting, the early results,
are really good, but we're
definitely not done yet.
And so that's why I wanted to
present it to you guys now.
And so I'm going
to phrase this talk
in terms of the
actual open source
directories for the code.
There's four
directories down here.
And I'm going to
go through each one
to describe what's
actually inside of them.
And so the first one is XLA.
And so unsurprisingly, this
is sort of the compiler
that Chris was
just talking about.
As a refresher or maybe
sort of to describe it
at another level of
detail, right, like,
here's XLA in one picture, OK?

Spanish: 
Todos los de los 90 recuerdan
que este símbolo significa
que mi sitio web
no funciona, ¿cierto?
¿Y cuál es el significado aquí?
Hay una razón por la
que lo llamamos experimental.
Y en parte de la documentación
lo mencionamos de esta manera.
Y no es porque realmente
no creemos en ello.
De hecho, es todo lo contrario.
Creemos que el enfoque
es realmente muy fuerte.
Y pensamos que los desafíos
que enfrentamos
se pueden superar.
Los resultados que obtenemos, los primeros
son muy buenos,
pero no hemos terminado aún.
Y por eso quería presentarlo ahora.
Y en esta charla hablaré en términos
de los verdaderos directorios
para el código abierto.
Aquí hay cuatro directorios.
Y voy a pasar por cada uno
para describir qué está dentro de ellos.
Y el primero es XLA.
No es sorpresa,
es una especie de compilador
como del que habló Chris.
Como una actualización o para describirlo
con más detalle sería como...
Aquí está XLA en una imagen

Portuguese: 
Quem é da década de 90 sabe
que esse símbolo
representa um website
que não está funcionando, certo?
E qual é o significado aqui?
Há um motivo para chamarmos
tudo isso de experimental.
E na documentação mencionamos isso, certo?
Não é porque não acreditemos nisso.
Na verdade, é o contrário.
Achamos que essa abordagem é muito sólida.
Achamos que os desafios
que enfrentamos são superáveis.
Os primeiros resultados são muito bons,
mas com certeza ainda não terminamos.
Por isso quis mostrar isso para vocês.
Farei esta palestra com base
nos diretórios de código aberto
para o código.
Há quatro diretórios aqui.
Vou falar de cada um deles
e descrever o que há por dentro.
O primeiro é XLA.
E, não é surpresa alguma,
é o compilador de que o Chris falava.
Para relembrar ou descrevê-lo
em outro nível de detalhes,
aqui está o XLA em uma imagem.

English: 
And so this is generally
how compilers work, right?
When you talk to
compiler people,
it's like, well, you've got some
representations for the program
that you want.
And in the end, you want
to generate machine code.
That's what the thing does.
And in the middle,
it's like, you
go through these phases of,
like, rewriting the graphs
or, like, lowering the graphs,
different representations.
But at the end of the
day, that's kind of it.
And so on the left here,
we have the XLA graph.
And what this is
composed of, the nodes
are linear algebra
operations and the edges
are sort of the flow
of data, like tensors,
through these operations.
So that's pretty
straightforward.
We lower that to LLVM
IR in the middle here.
Now, LLVM is an open
source compiler toolkit
sort of framework
that's pretty popular.
IR's just an abbreviation
for its intermediate
representation.
So we've basically
lowered the representation
from sort of linear
algebra type stuff
to kind of assembly
type stuff, you know,
general assembly stuff.
And so LLVM then
takes that and does
co-generation, where we
co-generate for actual machine
platforms.

Japanese: 
コンパイラーがどのように作動するかを
一般的に示したものです。
コンパイラーについて例を挙げると、
実行したいプログラム用の記号を
得たようなものです。
最後には、マシーンコードを
生成したいと思っています。
そのような感じです。
中間では、これらの表現を使ったり、
グラフを書き換えたり
グラフや異なる記号を下げたりします。
一通り見ると、このような感じです。
左側には XLA グラフがあります。
これは、ノードや一次代数
オペレーションで構成されており
エッジは、これらのオペレーションを通じた
テンソルのようなデータフローです。
かなりすっきりした構図です。
中間にある LLVM IR に移ります。
LLVM はかなり名前の知られている
フレームワークの
オープンソースコンパイラー
ツールキットです。
IR は intermediate representation 
の略字です。
一次代数タイプから
アセンブリタイプ、
ジェネラルアセンブリに至るまで、
記号を減少します。
LLVM はそれを取得し、
コージェネレーションを行ないます。
アクチュアルマシーンプラットフォーム用に
コージェネレーションするものです。

Korean: 
이건 일반적으로 컴파일러가
작동하는 방식이죠
컴파일 하는 사람들이과
얘기하면 여러분이 원하는
프로그램을 위한 표상이
있는 셈이고
이 끝에는 여러분이
원하는 머신 코드가 있죠
이것이 그 역할입니다
중간에는
이러한 단계를 거치는 거죠
그래프를 다시 쓰거나
그래프나 다른 표상을 줄이는 등이죠
하지만 결국은 이것이죠
왼쪽에 XLA 그래프가 있고
이를 구성하는 노드는
선형 대수학 공식이고
선은 텐서와 같이 데이터 흐름인 겁니다
이 운영을 통해서 말이죠
어려운 점 없죠
이를 여기 중간의 LLVM IR로 내렸죠
LLVM은 오픈 소스 컴파일러 툴킷으로
굉장히 인기 있는 일종의 프래임워크죠
IR은 그냥 중간 수준의 표상의
줄임말입니다
따라서 저희는 기본적으로 표상을
선형 대수학에서
일종의 일반적 어셈블리로
낮춘 겁니다
그러면 LLVM이 이를 가지고
실제 기계 플랫폼으로 공동 재생을
하는 거죠

Portuguese: 
E é como um compilador
geralmente funciona.
Se falar com quem
trabalha com compilação,
há algumas representações do programa
que você deseja.
No final, queremos gerar
um código para a máquina.
É isso o que ele faz.
No percurso, você passa por fases,
como reescrever os grafos
ou reduzir os grafos
a diferentes representações.
Mas, no final das contas, é apenas isso.
No lado esquerdo, temos o grafo XLA.
E é composto de... Os nódulos
são operações de álgebra linear
e as pontas são os fluxos dos dados,
como os tensores,
por dessas operações.
É bem simples.
Reduzimos isso
para a IR da LLVM, no meio.
LLVM é um toolkit
de código aberto para compilação,
uma espécie de framework bem popular.
E IR é a abreviatura
de "Representação Intermediária".
Então reduzimos a representação
de coisas de álgebra linear
para coisas de montagem, sabe,
de montagem geral.
A LLVM pega tudo isso
e realiza a "cogeração",
em que se "cogera" para plataformas
de máquina de verdade.

Spanish: 
Y así es cómo funcionan los compiladores
si hablas con compiladores
tienes algunas representaciones
para el programa que quieres.
Y al final, quieres generar código
de máquina.
Eso es lo que hace esta cosa.
Y en el medio, es como si tú
pasaras por estas fases de reescritura
de los gráficos
o bajaras los gráficos,
diferentes representaciones.
Pero al final del día, es algo así.
Aquí a la izquierda
tenemos el gráfico XLA.
Y esto se compone de nodos
operaciones de álgebra lineal
y los bordes
son una especie de flujo
de datos, como tensores
a través de estas operaciones.
Es bastante sencillo.
Bajamos eso a LLVM IR aquí en el medio.
LLVM es un tipo de marco de conjunto
de herramientas de compilador
de código abierto que es bastante popular.
IR es solo una abreviatura
de su representación intermedia.
Básicamente bajamos la representación
de un tipo de álgebra lineal
a un tipo de ensamblado.
Cosas de ensamblado general.
Entonces LLVM toma eso
y hace una cogeneración
en la que cogeneramos
para plataformas.

Indonesian: 
Ini cara kerja kompilator secara umum.
Bicara ke kompilator,
Anda dapatkan representasi
untuk program yang Anda mau.
Akhirnya, Anda ingin menghasilkan
kode mesin.
Itulah yang dia lakukan.
Dan di pertengahan, melalui fase ini,
Anda menulis ulang grafik
atau menurunkan grafik,
representasi berbeda.
Tapi akhirnya, seperti itu.
Di sebelah kiri, ada grafik XLA.
Apa susunannya.
Nodenya adalah operasi aljabar linear
dan ujungnya adalah aliran data,
seperti tensor
melalui operasi-operasi ini.
Jadi ini cukup mudah.
Kita turunkan itu ke IR LLVM
di tengah sini.
LLVM adalah perangkat kompilator
sumber terbuka
seperti kerangka yang lumayan populer.
IR itu singkatannya representasi menengah.
Jadi cuma menurunkan representasi
dari hal-hal aljabar linear
untuk menyatukan tipe, hal penyatuan umum.
LLVM kemudian menangani itu dan melakukan
co-generation, kita co-generate
untuk platform mesin yang asli.

Chinese: 
这就是编译器通常的运行方法
当你跟一些编译人员对话时
你有了一些
想要的程序代表
最后，你想要生成机器代码
这就是编译器的功能
在这中间
你会经历一个阶段就像重绘图表
又或是简化图标，不同的代表
这就是一天的最后
所以在左端，我们有XLA图表
它是由什么组成的呢？
节点是线性代数操作
边缘是数据流，比如tensors
通过这些操作
这非常的直白
我们把那分解到中间的LLVM IR
现在， LLVM是一个开源编译工具箱
非常的受欢迎
IR是中间表现的缩写
我们基本上将表现形式
从线性代数
降低到编译的形式
最基本的编译形式
所以使用LLVM共生成
共生成实际的机器平台

Portuguese: 
Nos exemplos aqui, há o x86,
que comporta servidores
ou estações de trabalho,
ARM, para os telefones celulares,
ou mesmo PTX, todos para GPUs.
Então temos uma grande variedade
de suporte para as plataformas
em que se pode executar esse código.
O que vocês devem lembrar dessa imagem
é que isto é apenas um compilador
que está tomando coisas
de uma representação
e colocando-as em uma outra.
Em nosso contexto, o mais importante
é que enquanto pudermos
transformar coisas em grafos XLA,
o código de máquina
vai sair do outro lado.
O próximo diretório
nesse subdiretório do compilador
é TF para XLA.
E esses realmente são
os nomes dos diretórios, certo?
Não estamos tentando esconder nada.
O "tf2xla" é o que transforma
TensorFlow em XLA.
Semelhante à imagem anterior do XLA,
essa descreve o que é TensorFlow.
À esquerda, estão todas as diferentes
linguagens de programação

Indonesian: 
Contoh yang saya berikan, ada x86
yang mendukung server
atau stasiun kerja Anda
lalu ARM, untuk ponsel Anda
atau PTX, ini untuk GPU.
Kami memiliki jangkauan dukungan
yang luas untuk platform sebenarnya
untuk menjalankan kode.
Yang penting, hal yang ingin
Anda ingat dari gambar ini
adalah itu cuma kompilator,
mengambil sesuatu
dari satu representasi dan
menempatkannya pada yang lainnya.
Di konteks kami, hal pentingnya
yaitu selama kita bisa
mengubahnya ke grafik XLA
kita bisa dapatkan kode mesin.
Direktori selanjutnya untuk subdirektori
kompilator ini adalah tf2xla.
Secara harfiah, ini
adalah nama direktori asli.
Kami tidak coba sembunyikan apa pun.
TF ke XLA, adalah hal yang mengubah
TensorFlow menjadi XLA.
Mirip dengan gambar XLA
sebelumnya, ini gambar
yang menjelaskan apa itu TensorFlow.
Di sebelah kiri, ada bahasa
pemrograman berbeda

Korean: 
여기서 제가 드린 예시는 x86이고
여러분의 작업공간이나 서버를 지원하죠
휴대 가기의 ARM 같은 것이나
심지어 GPU에서도
작동하도록 PTX를 지원하죠
따라서 저희는 이 코드가 실행되는
실제 플랫폼에 대한 꽤 넓은 범주의
지원을 하고 있습니다
이 그림에서
기억하셔야 할 점은
이것이 컴파일러이고
한 표상에서 다른 것으로
옮긴다는 것이죠
저희 맥락에서 중요한 것은
XLA 그래프로 입력할 수만 있다면
머신 코드는 해결되죠
이 컴파일러 서브디렉토리 내의 다음
디렉토리는 TF에서 XLA로 가는 겁니다
말 그대로 이는
실제 디렉토리 이름이죠
뭔가를 숨기려는 건 아닙니다
TF에서 XLA는 당연히도
텐서플로우를 XLA로 변환시키는 것이죠
아까 보여 드린
XLA 그림과 흡사하게도
텐서플로우가 무엇인지
설명해 주는 그림이 여기 있습니다
왼쪽에는 사람들이 텐서플로우
프로그램을 만들기 위해 사용하는

Japanese: 
x86 を例にとりましょう。
これは携帯電話用にサーバー、
もしくはワークステーション、ARM
そして GPU 用に PTX を
サポートするものです。
このコードを作動できる
アクチュアルプラットフォーム用の
かなり幅広いサポートが得られるわけです。
このスライド上でから覚えておきたいことを
取り出して下さい。
コンパイラーがあります。
１つの記号から取り出し、
別の記号に入力するようなものです。
このコンテクストの中で、大切なことは
XLA グラフ内に入力できる間は、
アウトポップマシーンが
コードを入れてくれます。
このサブディレクトリコンパイラーの下にある
次のディレクトリは、
XLA に対する TF です。
ところで、これらは文字通り
リアルディレクトリネームです。
何も隠すつもりはありません。
ですから、XLA に対する TF は
見ての通り、
TensorFlow を XLA に
変換するものです。
XLA を説明した前のスライドと同じく、
このスライドでは、TensorFlow が
何かについて説明します。
左側には、TensorFlow 
プログラム構築に使われる

English: 
The examples I've given
here, there is x86,
so that supports, like,
servers or your workstations,
ARM, right, for
your mobile phones,
or even, like, PTX,
so this is for GPUs.
So we have a sort
of pretty wide range
of support for the
actual platforms
that we can run this code on.
And so the takeaway,
the thing you
want to remember
from this picture
is that, like, it's
just a compiler,
it's sort of like taking
things from one representation
and putting it down to another.
In our context,
the important thing
is that as long as we can
get things into an XLA graph,
then out pops
machine code for us.
So the next directory
under this compiler
subdirectory is TF to XLA.
And these, literally,
by the way,
are the real directory
names, right?
We're not trying to
hide anything here.
And
So TF to XLA, sort
of unsurprisingly,
it's the stuff that turns
TensorFlow into XLA.
And so similar to that
previous picture for XLA,
here's one picture that sort of
describes what TensorFlow is.
And so on the left, we've got
all the different programming

Spanish: 
Los ejemplos que he dado aquí,
aquí ven x86
entonces eso respalda servidores
o estaciones de trabajo
ARM para teléfonos móviles
o incluso PTX, esto es para GPUs.
Tenemos un rango bastante amplio
de soporte para las plataformas actuales
donde ejecutar este código.
Lo que te llevas, lo que quieren
recordar de esta imagen
es que como solo es un compilador
está tomando las cosas
de una representación
y las pone en otra.
En nuestro contexto, lo importante
es que siempre que podamos colocar cosas
en un gráfico XLA
eso nos mostrará el código de máquina.
El siguiente directorio
bajo este subdirectorio
compilador es TF a XLA.
Y éstos, son nombres
de directorios reales.
No intentamos esconder nada aquí.
Desde TF a XLA, algo que no sorprende
es lo que convierte TensorFlow a XLA.
Muy parecida a esta imagen anterior
para XLA
aquí está una imagen que describe un poco
qué es TensorFlow.
A la izquierda, tenemos
todos los distintos lenguajes

Chinese: 
比如说，有一个"x86"
它可以支持服务器，或是你的工作站
ARM可以支持你的移动电话
甚至是PTX，这就是GPU
因此我们可以支持
很多的实际平台
来运行这些代码
这就是你们需要
从这张图像上记住的要点
这就是一个编译器
这就像将事物从一种表达
简化为另一种
在我们的背景下，最重要的是
只要我们可以信息输入到XLA图表
然后就会弹出我们的机器代码
在这个编译器下的
下一个目录是从TF 到XLA
顺便说一句
这是这个目录的真实名称
我们在这里不想要隐藏任何事
从TF 到XLA
显然就是将TensorFlow转化为XLA
就像之前那个XLA的图片一样
这个图片描述了TensorFlow是什么
所以在左边，我们有人们用来
构建TensorFlow项目的

Spanish: 
de programación que pueden usar
para construir su programa TensorFlow.
Y Python es, probablemente,
el más ampliamente usado
ahora mismo, pero hay muchos otros
que sí soportamos.
Lo que haces cuando construyes
ese programa es construir este gráfico
el gráfico de TensorFlow.
Es la gráfica de todas sus operaciones
y todos los tensores que fluyen
a través de ellos.
Luego tomamos esa gráfica,
y como Rajat mencionó
tenemos un tiempo de ejecución
de C++ que sí ejecuta esto.
Y aquí hay dos componentes.
Uno se llama el ejecutor
y el otro son los núcleos.
El trabajo del ejecutor es moverse
a través de este gráfico
y al tocar cada nodo
busca en los núcleos
y encuentra el núcleo apropiado
y lo ejecuta.
Como ejemplo, etiqueté
dos de los nodos del gráfico
con los nombres de "añadir" y "Softmax".
Añadir es solo agregar dos cosas.
Y Chris se encargó de describir Softmax.
Entonces para agregar, piensas
que el ejecutor tocará
este nodo de adición y necesitas
agregar las dos entradas.
Lo hace viendo el interior de los núcleos

English: 
languages that people can use to
build their TensorFlow program,
right?
And Python is sort of
like the most widely
used, probably, right now,
but there's many others
that we do support.
And what you're
doing when you build
that program is that you're
constructing this graph,
the TensorFlow graph.
And this is the graph
of all your operations
and all of the tensors
flowing through them, OK?
And then we take that graph,
and as Rajat mentioned,
we have a C++ runtime that
actually executes this.
And so there's two
components here.
One is called the executor
and the other is the kernels.
So the job of the executor
is to actually walk
through this graph, and
when it hits each node,
it looks up in the kernels and
finds the appropriate kernel
and actually runs it.
And so as an example, I've
labeled two of the graph nodes
here, like, add and softmax.
Add is just adding two things.
And softmax, well, Chris
just described that.
And so for add,
you think about it,
like, the executor's
going to hit
this add node and need to add
the two inputs that come in.
And so it does that by
looking up inside the kernels,

Indonesian: 
yang bisa digunakan untuk membangun
program TensorFlow mereka.
Python itu yang paling sering
digunakan sekarang
tapi banyak lainnya yang kami dukung.
Yang dilakukan ketika membangun program
adalah yang Anda konstruksikan
di grafik ini, grafik TensorFlow.
Dan ini grafik semua operasi Anda
dan semua tensor yang mengalir di dalam.
Kita ambil grafik itu,
dan seperti yang Rajat bilang
kita punya waktu proses C++
yang mengeksekusi ini.
Ada dua komponen di sini.
Satu namanya eksekutor
dan satunya kernel.
Tugas eksekutor adalah berjalan
melewati grafik, dan saat dia
mengenai tiap node
dia mencari kernel dan
temukan kernel yang sesuai
lalu menjalankannya.
Contohnya, saya sudah melabeli
dua node grafik
di sini, yaitu tambah dan softmax.
Tambah cuma menambah dua hal.
Softmax, Chris sudah menjelaskan itu.
Untuk tambah, eksekutor akan menekan
node tambah ini dan perlu menambah
dua input yang masuk.
Dia melakukannya dengan melihat
ke dalam kernel

Korean: 
온갖 프로그래밍 언어가 있죠
파이썬이 아마 현재 가장 많이 사용되는
언어이겠지만 다른 언어들도 많이
지원되고 있습니다
이 프로그램을 만들 때
텐서플로우 그래프를
만들겠죠
이것이 모든 운영과 그를 통해
모든 텐서의 흐름을 보여주는 그래프이죠
그리고 나서 이 그래프로
라자트가 언급했듯
이를 실제로 실행시키는
C++ 실행시간이 있죠
두 가지 컴포넌트가 있습니다
실행자와 커넬이죠
실행자의 역할은 이 그래프를
실제로 살펴 보고 각각의 노드를 누르면
커널에서 찾아보고 적절한 커널을 찾아서
실제로 운영시키는 거죠
예컨대 여기 라벨이 붙은
두 가지 그래프 노드가 있죠
덧셈과 소프트맥스이죠
덧셈은 두 가지를 더 하는 것이고
소프트맥스는 크리스가 방금 설명했죠
덧셈은 이렇게 생각하시면 됩니다
실행자가 이 더하기 노드를
누르면 들어오는 두 인풋이
더해져야 한다고 말이죠
이는 커널 안을 찾아보고

Japanese: 
あらゆる異なるプログラミング言語の
全てが表示されています。
実質上、パイソンは最も広い範囲で
使用されていますが
その他の多くについても
サポートしています。
そのプログラムを構築する時、
この TensorFlow グラフを
構築していることになるのです。
全てのオペレーションと、それらを
通じてフローするテンソル全てのグラフです。
そのグラフを取り、
ラジャットが言及したように
実質上これを実行する
C++ ランタイムを持ちます。
ここには２つのコンポーネントがあり、
１つはエグゼキュターと呼ばれ、
もう１つはカーネルと呼ばれます。
エクゼキュターの役割は、
このグラフをウオークスルーすることです。
各々のノードをヒットする時
カーネル内を調べ、適切なカーネルを探し
実質上それを動かします。
例えば、ここにある add と softmax の
２つのグラフノードをラベルします。
Add は単純に２つのものを追加し、
softmax については、
クリスが説明してくれた通りです。
add については、
エグゼキューターが
この add ノードをヒットしに行き
入ってくる１つのインプットを
追加する必要があります。

Chinese: 
不同的编程语言
Python是现在最多被使用的
但还有很多语言我们都支持
你在构建程序时
要构建这个图表
也就是TensorFlow图表
这是你所有操作的一个图表
所有的tensors都经过它
然后我们用那个图表，就像拉雅提到的那样
我们有一个c++实际执行的运行时间
所以在这里有两个组件
一个叫做执行器，另一个叫做内核
执行器的工作是执行这张图表
但它达到每一个节点时
它会查询内核，然后找到合适的内核
再运行它
比如说，我标记了两个图像节点在这里
比如，add和softmax
add就仅仅是添加两件事
softmax，克里斯刚刚已经描述过了
所以add，你可以想一下
比如，执行器会遇到这个add节点
然后需要添加两个输入量
它通过查询内核来做到这一点

Portuguese: 
usadas para criar
os programas de TensorFlow.
Python é a mais usada hoje, provavelmente,
mas há outras que nós comportamos.
O que você faz ao criar um programa
é construir este grafo,
o grafo TensorFlow.
Este é o grafo de todas as operações
e de todos os tensores que fluem por elas.
E então pegamos esse grafo
e, como o Rajat mencionou,
temos um tempo de execução
do C++ que o executa.
Há dois componentes aqui.
Um é o executor e o outro
é o kernel, ou "núcleo".
O trabalho do executor
é percorrer esse grafo
e, quando atingir cada nódulo,
procura nos núcleos
o apropriado e o executa.
Um exemplo, nomeei
dois dos nódulos do grafo,
Add e SoftMax.
Add é somar duas cosas.
E SoftMax, bem, o Chris
acabou de descrever.
Para o Add, o executor
vai chegar nesse nódulo
e somar as duas entradas que apareceram.

Japanese: 
カーネル内部を探し、
また使っているデバイスに適した、
C++ ファースト実行を見つけ、
それから追加を実行します。
同じ事が softmax にも言えます。
softmax ノードをヒットし、
カーネル内を検索し
これは多少複雑になりますが、
シンプルな算術オペレーションタイプでは
ありませんが、
とにかく、それを探し、動かします。
基本的にこれが今日の TensorFlow が行なう
役割になります。
これは XLA がない状態です。
次のスライドでは、
どのように TensorFlow を取得し
これを XLA プログラムに変換するか
についてお見せします。
これはたくさんある議題の１つなので、
手短かにお話します。
左側には、
TensorFlow グラフがあります。
先程見せたものと同じものです。
softmax ラベルを
追加したものです。
右側には、生成しようとしたもの
XLA グラフを生成しようとしています。
１番目のスライドに書かれていたことを
思い出して下さい。
この記号に入力することができれば、
XLA が残りすべてを引き受けます。
マシーンコード向けにコンパイルします。
その方法を取ると、
ローカルエグゼキューターを持ちます。

Chinese: 
然后为你正在使用的设备
找到C++的快速实施
然后运行
添加的节点
与softmax相似
我们遇到softmax节点
我们查询核心
这个会复杂一些
这不仅仅是一个简单的算术运算
但是 还是会查看它，运行它
这就是TensorFlow的运行方式
这不需要XLA
下一张幻灯片
将描述我们如何使用TensorFlow
并将它以XLA程序运行
这可能需要运行很多程序
因此，我将为大家一一解释
在左端，我们有TensorFlow图表
就是我之前向大家展示的图表
它有add和softmax标签
在右边，我们想要生成的是
我们想要生成XLA图表
请记住，在第一张幻灯片上
只要我们能够
将信息转化为这种表达
然后XLA就可以处理余下的事
它会将信息编译为机器代码
我们又一个局部执行器

Korean: 
여러분이 사용하는 기기에서의
C++ 실행을 찾아서
실제로 덧셈을 실행하는
것이죠
소프트맥스도 마찬가지입니다
소프트맥스 노드를 누르면
커널 안을 찾아보겠죠
이건 조금 더 복잡합니다
단순한 산술 운영이 아니죠
하지만 여전히 찾아보고 운영합니다
이것이 기본적으로 오늘날
텐서플로우가 운영되는 방식입니다
XLA는 없죠
다음에 보여 드릴 슬라이드는
어떻게 텐서플로우를 XLA 프로그램으로
바꾸는가에 대한 것입니다
좀 복잡할 수도 있습니다
자세히 설명해 드리죠
왼족에는 텐서플로우 그래프가 있죠
방금 본 것과 같습니다
덧셈과 소프트맥스 노드가 있죠
오른쪽에는
이 XLA 그래프를
만들려고 하고 있습니다
첫 번째 슬라이드에서
이 표상으로 바꿀 수
있기만 하면 나머지는 XLA가
알아서 할 것이라고 했죠
이를 머신 코드로 컴파일해 줄 겁니다
방법은 로컬 실행자가 있다는 점이죠

Portuguese: 
E ele faz isso procurando
nos núcleos e encontrando
a implementação rápida do C++ para ele
para o seu dispositivo.
E então realiza a adição.
É semelhante para SoftMax.
Chega ao nódulo SoftMax,
procura nos núcleos,
mas essa é um pouco mais complicada.
Não é uma simples operação aritmética.
De todo modo, ele procura e executa.
É assim que o TensorFlow funciona hoje.
Sem XLA.
O próximo slide mostra
como tomamos o TensorFlow
e o transformamos em um programa XLA.
E aqui acontece muita coisa,
então vou explicar.
À esquerda, temos o grafo TensorFlow.
É igual ao que acabei de mostrar.
Tem as etiquetas Add e SoftMax.
À direita, estamos tentando
gerar o grafo XLA.
E lembre-se do primeiro slide:
se conseguirmos usar esta representação,
então o XLA tomará conta do resto.
Vai compilá-lo em código.

Spanish: 
y encuentra la implementación C++
para el dispositivo
en el que te encuentras
y luego de verdad ejecuta la adición.
Es similar para Softmax.
Iniciamos el nodo softmax.
Buscamos en el núcleo.
Este es un poco más complicado.
No es solo una simple
operación aritmética.
Pero aun así, lo busca, lo ejecuta.
Básicamente así funciona TensorFlow
en la actualidad.
Esto es sin XLA.
La siguiente diapositiva
muestra cómo tomamos
TensorFlow y lo convertimos
en un programa XLA.
Ocurren muchas cosas,
así que iremos paso a paso.
A la izquierda,
tenemos el gráfico TensorFlow.
Es lo mismo que acabo de mostrar.
Y tiene las etiquetas de adición
y Softmax.
A la derecha, intentamos generar
un gráfico de XLA.
Recuerden de la primera diapositiva
siempre que podamos obtener
cosas en esta representación
XLA se encargará del resto.
Va a compilar hasta tener el código
de la máquina.
Y hacemos esto con un ejecutor local
que es lo mismo

English: 
and finding the C++ fast
implementation for it
for the device that you're
on, and then actually performs
the addition.
Similar for softmax.
We hit the softmax node.
We look up in the kernel.
This one happens to be a
little bit more complicated.
It's not just a simple one
arithmetic operation type
thing.
But still, it looks
it up, runs it.
And so that's basically how
TensorFlow kind of works today.
This is without XLA.
So the next slide
is going to show
sort of how we take
TensorFlow and turn this
into an XLA program.
And this one may be-- it's kind
of a lot of stuff going on,
so I'll walk it through.
On the left, we've got
the TensorFlow graph.
This is that same
thing I just showed.
And it has the add and
softmax labels, OK?
On the right, what
we're trying to generate
is we're trying to
generate that XLA graph.
Remember from that
first slide about,
well, as long as
we can get things
into this representation,
then XLA's
going to take care
of all the rest.
It's going to compile the
thing down to machine code.
And so the way we do that, we
have a local executor, which

Indonesian: 
dan temukan implementasi
C++ cepat untuk itu
untuk perangkat yang Anda jalankan,
lalu melakukan penambahan.
Sama untuk softmax.
Kita tekan node softmax.
Kita cari di kernel.
Yang ini agak sedikit rumit.
Tidak seperti tipe operasi
aritmetika sederhana.
Tetap saja, dia mencari, dan jalankan.
Itulah dasar kerja TensorFlow.
Ini tanpa XLA.
Slide selanjutnya menunjukkan
cara kita pakai TensorFlow
dan ubah ini
menjadi program XLA.
Ini mungkin-- terlalu banyak hal,
jadi akan saya jelaskan.
Di kiri, kita punya grafik TensorFlow.
Sama seperti yang saya tampilkan.
Ada label tambah dan softmax.
Di kanan, yang kami coba hasilkan
adalah grafik XLA.
Ingat slide pertama,
selama kita bisa buat hal-hal
dalam representasi ini,
maka XLA akan mengatasi sisanya.
Dia akan mengompilasi menjadi kode mesin.
Dengan begitu, kita punya
eksekutor lokal, yang mana

Portuguese: 
Temos um executor local,
que é a mesma coisa
que usamos no tempo de execução
normal do TensorFlow,
mas trocamos os núcleos.
Lembre que na imagem anterior
isso era uma caixa laranja.
Inclusive, laranja indica TensorFlow,
para manter o tema,
e azul indica XLA
em todos os meus slides.
Trocamos a caixa laranja
com os núcleos do TensorFlow
pelos da XLA.
O trabalho destes núcleos,
em vez de executar a operação,
será criar o grafo.
Será tomar o grafo TensorFlow
e transformá-lo em um grafo XLA.
Um exemplo com Add: chegamos ao nódulo
e precisamos fazer algo.
Procuramos nos núcleos
e ele sabe transformar
o Add do TensorFlow no Add do XLA.
Nesse exemplo, é um para um.
Esse caso é muito simples.
Chris mencionou SoftMax,
que é uma operação composta.
É construída com uma porção de coisas,
como Dot, exponenciação
e coisas desse tipo.

Korean: 
이는 기본적으로 기본 텐서플로우
실행 시간이 가진 것과 같지만
커널과 교환한 것이죠
이전 그림에서는
이것이 주황색 상자였죠
제 슬라이드에서 주황색은 텐서플로우이고
파란색은 XLA을 의미합니다
일관성 있도록 말이죠
이 주황색 상자를
텐서플로우 커널로 교환했죠
XLA로 바꾸었습니다
이 커널의 일은 운영을 실제로
실행하는 대신 이 그래프를
그리기 위한 것입니다
텐서플로우 그래프를 가지고
XLA 그래프로 만들기 위해서이죠
예를 덧붙이면 더하기 노드를 누르고
뭔가를 해야 한다고 칩시다
커널을 찾아서 이러겠죠
텐서플로우 덧셈을 XLA 덧셈으로
바꾸는 법을 알지
이 특정 예시에서는 일 대 일 입니다
정말 간단한 사례였죠
크리스가 소프트맥스에 대해 말했죠
이건 합성 운영에
더 가깝다고 말이죠
내부에 많은 것들로
구성돼 있죠, 점이나 지수법
등으로 말이죠
이 그래프는

Indonesian: 
sama dengan yang kita punya
untuk waktu proses TensorFLow normal
namun mengeluarkan kernel.
Ingat, di gambar sebelumnya,
ini adalah kotak oranye.
Oranye artinya temanya TensorFlow
dan biru artinya XLA di semua slide saya.
Jadi kita keluarkan kotak oranye
dengan kernel TensorFlow
dan kita masukkan yang XLA.
Tugas kernel ini,
daripada mengeksekusi operasi
adalah membuat grafik ini.
Untuk mengambil grafik TensorFlow
dan mengubahnya jadi grafik XLA.
Contoh di sini untuk menambah,
kita tekan node tambah
dan bilang, oke, harus lakukan sesuatu.
Kita cari kernel, dia bilang, saya tahu
cara ubah TensorFlow
dan tambahkan ke XLA.
Di contoh ini, ini seperti satu ke satu.
Ini kasus yang sangat sederhana.
Chris sebutkan softmax,
bagaimana ini lebih ke operasi komposit.
Dibangun dari hal-hal
di dalamnya, seperti titik
dan eksponensiasi dan semacamnya.
Grafik di sini menunjukkan

Chinese: 
这跟我们普通的TensorFlow运行时间
是一样的
但是我们在这里不使用核心程序
请记住，在前面的图像中
有一个橙色的方框
哦，对了，橙色代表了TensorFlow
为了保持主题的一致性
在我所有的幻灯片中，蓝色代表XLA
所以我们换出那个橙色的盒子
用核心程序，TensorFlow的内核
我们换出XLA的核心程序
这个核心程序的工作，不是执行操作
而是创建这个图表
将TensorFlow图表转换为XLA图表
这是add节点的一个例子
我们遇到add节点
然后我们说，好吧，我们需要做一些事
我们查看核心程序
它说，太棒了
我知道如何将TensorFlow add转换成XLA add
在这个特定的例子中
这个是一对一的
这是一个非常简单的例子
因此克里斯提到了softmax
它是一个比较复杂的运算
它在内部创建一系列的运算
比如点和乘方
诸如此类的运算
所以在这里的这个图表

Japanese: 
標準の TensorFlow ランタイム用に
持っていたものと実質上同じです。
カーネルが一掃されました。
前のスライドでは、
オレンジ色のボックスでした。
ところで、スライドの中では
テーマに沿って話を進めるためにも
オレンジ色は TensorFlow を表し、
ブルーは XLA を表します。
カーネル、 TensorFlow カーネルが付いた
あのオレンジ色のボックスを一掃しました。
そして XLA の所でも一掃しました。
実質上オペレーションを実行する代わりに、
これらのカーネルの役割は
TensorFlow グラフを取得し、
それを XLA グラフに変換するために
このグラフを作ることになります。
add についての例を挙げると、
add ノードをヒットして
何かしなくてはいけないと言います。
カーネルを見て、
「素晴しい」と言います。
TensorFlow add を XLA add に
変換する方法を知っていると言います。
この特殊な例では、
１対１になります。
これは非常にシンプルなケースです。
クリスが softmax について
言及したように、
これは構築オペレーションです。
内部にはたくさんのものが詰まっています。
ピリオドやエクスポネンシエーションなどの
ようなものです。
このグラフが示しているのは、

English: 
is basically the
same thing that we
had for the normal
TensorFlow runtime,
but we swapped out the kernels.
So remember, in the
previous picture,
this was an orange box.
Oh, by the way, so orange
means sort of TensorFlow
to keep with the theme and
everything, and blue means
XLA in all my slides.
So we swapped out
that orange box,
right, with the kernels,
the TensorFlow kernels,
and we swapped in the XLA ones.
And the job of these kernels,
instead of actually executing
the operation, it's going to
be to create this graph, right?
To take the TensorFlow graph
and turn it into the XLA graph.
And so an example here for
add, well, we hit the add node
and we say, OK, we
need to do something.
We look up the
kernel and it says,
great, I know how to transform
the TensorFlow add into the XLA
add.
In this particular example,
it's sort of one to one.
This was a really simple case.
So Chris mentioned softmax,
how it's sort of this more
composite operation, right?
It's built up of
a bunch of stuff
inside, like dot
and exponentiation
and stuff like that.
And so this graph
here is showing

Spanish: 
que nosotros teníamos
para el tiempo de ejecución normal
de TensorFlow
pero cambiamos los núcleos.
Recuerden, en la imagen anterior
esto era una caja anaranjada.
Por cierto, lo naranja se refiere
a TensorFlow
en todas mis diapositivas y azul
se refiere a XLA en mis diapositivas.
Intercambiamos esa caja naranja
con los núcleos, los núcleos de TensorFlow
y los cambiamos por los de XLA.
Estos núcleos
en lugar de ejecutar realmente
la operación, crearán este gráfico
para tomar el gráfico TensorFlow
y convertirlo en el gráfico XLA.
Un ejemplo aquí para agregar,
iniciamos el nodo "añadir"
y necesitamos hacer algo.
Buscamos el núcleo y dice:
sé cómo transformar el TensorFlow "añadir"
en XLA "añadir".
En este ejemplo, es uno a uno.
Este fue un caso realmente simple.
Chris mencionó Softmax,
diciendo que es más o menos
una operación compuesta.
Compuesta de muchas cosas
adentro, como dot y exponenciación
y cosas de ese estilo.
Esta gráfica aquí está mostrando

Indonesian: 
softmax dan grafik TensorFlow
adalah satu operasi.
Dan kita mencari terjemahan kernel
dan mengubahnya jadi
berbagai operasi di grafik XLA.
Pada dasarnya, itulah semuanya.
Ini cara kita mengubah
grafik TensorFlow ke XLA.
Kita punya tautan di sini
yang menjelaskan
di mana semua kernel yang sebenarnya
melakukan terjemahan ini.
Di sinilah titik pertama kita
akan melihat orang keren ini bekerja.
Saya berharap itu adalah animasi GIF.
Itu akan lebih tepat sasaran.
Tapi saat kerja, sebenarnya,
kernel yang kita punya
tak ada di sini, 'kan?
Kami belum implementasi
tiap operasi TensorFlow.
Untuk beberapa dari mereka,
tempat ini adalah cukup sulit.
Itu sebabnya belum diimplementasikan.
Seperti yang Chris bilang,
beberapa operasi tidak menerjemahkan
dengan baik, karena sifat dinamik mereka.
Yang lain, kami belum mencobanya.
Inilah tempat di mana dukungan komunitas
akan sangat bermanfaat.
Kita telah membahas apa itu XLA

English: 
that softmax and the TensorFlow
graph is just one op.
And we look up the
translation kernel
and we turn that into
multiple ops in the XLA graph.
And that's basically all
there is to it, right?
This is how we transform
TensorFlow graphs into XLA.
We have a link
here that describes
where all the kernels
are that actually
perform this translation.
And here's the first
point where we're
going to see this
awesome men at work.
I kind of wish it was a
animated GIF, you know?
Because that'd be
more to the point.
But this men at work, basically,
the kernels that we have,
they're not all there, right?
Like, we haven't implemented
every TensorFlow op.
And this is a place
where for some of them,
they're actually
quite difficult.
And that's the reason we
haven't implemented them.
And maybe, as Chris
was mentioning,
some operations really just
don't translate that well,
because of their
very dynamic nature.
For other ones, we just haven't
gotten around to it, really.
And so this is a place where
actually community support
would be really useful.
OK, so we've sort of
covered what XLA is

Japanese: 
softmax と TensorFlow グラフは
１つの op だということです。
翻訳カーネルを調べて、
それを XLA グラフ内で
複合 op に変換します。
実質上、ここに全て挙げられています。
これが TensorFlow グラフを XLA に
変換する方法になります。
この翻訳を実質上実行する
カーネル全てがどこにあるかを提示する、
リンクがここにあります。
ここが、この作業中の素敵な男性を見ることの
できる最初のポイントになります。
GIF アニメーションだったら
よかったのですが。
その方がポイントを突いています。
しかしこの作業中の男性の
基本的に持っているカーネルは
ここに全てあるわけではありません。
あらゆる TensorFlow op を
実行したわけではありません。
この場所は、幾つかのカーネルにとって
困難な場所です。
だから、実行しなかったわけですが
クリスが言及したように、
非常にダイナミックな特性を持っているので
幾つかのオペレーションは充分に
翻訳していません。
他方では、それを周囲に
持ち得なかったと言えます。
ここはコミュニティのサポートが
実際にかなり役立つもととなる場所です。
XLA がどんなものかを知ることができ、

Korean: 
소프트맥스와 텐서플로우 그래프가
하나의 운영임을 보여줍니다
번역 커널을 찾아서
XLA 그래프에 다양한
운영으로 바꾸는 거죠
기본적으로 전부 다 있는 거죠
이것이 바로 텐서플로우 그래프를
XLA로 바꾸는 법입니다
여기 링크가 있습니다
실제로 이 번역을 실행하는
모든 커널이 있는 곳을 설명하죠
이 멋진 이들이 일하는 곳을
처음으로 보여주는 지점입니다
애니메이션으로 된 GIF였으면 좋았을텐데
그게 더 중점을 보여 주겠죠
이들이 작동하지만 우리가 가진 커널이
전부 있는 것은 아닙니다
모든 텐서플로우 운영을 실행하진 않았죠
따라서 일부분은
꽤 어려울 수도 있습니다
그래서 저희는 실행하지 않았죠
크리스가 말했듯이 어쩌면
일부 운영이 번역이
잘 되지 않을 수도 있죠
역동적인 속성 때문에 말이죠
다른 경우 저희가 실제로
작업을 못한 경우도 있습니다
바로 커뮤니티 지원이 정말
유용할 수 있는 시점이죠
그럼 XLA가 무엇인지 언급했고

Portuguese: 
Esse grafo mostra que SoftMax
e o grafo TensorFlow são uma só operação.
Buscamos o núcleo de tradução
e transformamos isso
em várias operações no grafo XLA.
E é basicamente isso.
É assim que transformamos
grafos TensorFlow em grafos XLA.
Aqui tem um link que descreve
onde estão os núcleos
que fazem a tradução.
E aqui é o primeiro ponto
em que veremos "homens trabalhando".
Gostaria que fosse apenas um GIF.
Seria mais apropriado.
Os nossos núcleos ainda
não estão tão bons.
Ainda não implementamos
todas as operações do TensorFlow.
Algumas delas são bem difíceis.
Por isso ainda não as implementamos.
Como o Chris mencionou,
talvez algumas operações
não possam ser traduzidas tão bem
dada a sua natureza dinâmica.
Outras, nós simplesmente
ainda não tivemos tempo.
Aqui o apoio da comunidade
seria muito útil.
Falamos sobre o que é XLA

Chinese: 
是用来显示softmax
和TensorFlow图表只是一个运算
我们查看翻译核心
然后将它转化为XLA图表中的多重运算
这基本上就是它进行的所有操作
这就是我们如何将TensorFlow图表
转化成XLA图表
我们在这里有一个链接
描述了所有的核心程序
是在哪里执行翻译的
首先，让我们来看看
这个很棒的员工是在哪里工作的
我希望这是一个GIF动画，你知道吗?
因为这会更加的切题
但这个人在工作，基本上
我们有的核心程序
不是全部
我们还没有实现每一个TensorFlow操作
它们中的一些
操作起来比较困难
这就是我们还没有实现的原因
也就，向克里斯提到的那样
一些操作不能被很好的翻译
因为他们的动态特性
其它的一些运算，我们还没有时间处理它
这就是社区支持
非常有用的地方
好了，我们已经提到了XLA是什么

Spanish: 
que Softmax y el gráfico TensorFlow
es solo una operación.
Y buscamos el núcleo de traducción
y lo convertimos en operaciones múltiples
en el gráfico XLA.
Es básicamente todo lo que hay que hacer.
Así transformamos los gráficos
de TensorFlow en XLA.
Aquí tenemos un enlace que describe
dónde están los núcleos
que ejecutaron esta traducción.
Este es el primer punto
donde los veremos hacer su trabajo.
Me gustaría que fuera un GIF animado.
Porque eso sería más acertado.
Pero estos trabajadores,
básicamente, los núcleos que tenemos
no están todos, no implementa
todas las operaciones de TensorFlow.
Y este es un lugar donde
para algunos de ellos
en realidad son difíciles.
Por esta razón no las implementamos.
Y como Chris mencionó
algunas operaciones
no se traducen muy bien
debido a su naturaleza muy dinámica.
Para otras, simplemente no hemos
llegado a ellas en realidad.
Aquí es donde la comunidad de apoyo
sería realmente útil.
Ya cubrimos un poco lo que es XLA

English: 
and we've covered how we
translate TensorFlow into XLA.
So the next two
points are going to be
about how we actually
use this cool compiler
inside TensorFlow.
And the first thing
we're going to talk about
is JIT, which is, like, the
just-in-time compilation.
And so in the theme of, like,
sort of graph transformations,
I'm going to describe JIT
as sort of this graph, how
the graph changes.
And so on the left, we have
a normal TensorFlow graph.
And in this red trapezoid,
we've identified three nodes.
And these three nodes
are going to be sort
of able to be compiled by XLA.
The other nodes in the graph are
not, for the purposes of this,
going to be compiled by XLA.
And there's many
reasons for that.
We said, sometimes operations
just aren't implemented.
Or other times we've chosen
the clustering that just
happens not to cluster them in.
And so this example, we've
chosen these particular
or these three nodes.
On the right, we see that
we've taken the graph

Indonesian: 
dan cara menerjemahkan TensorFlow ke XLA.
Dua poin berikutnya
tentang cara menggunakan
kompilator keren ini
di TensorFlow.
Hal pertama yang akan kita bicarakan
adalah JIT, yaitu kompilasi tepat waktu.
Dalam hal transformasi grafik,
saya akan jelaskan JIT
sebagai grafik ini,
bagaimana grafiknya berubah.
Di kiri, ada grafik TensorFlow normal.
Di trapesium merah ini,
ada tiga node teridentifikasi.
Tiga node ini akan bisa
dikompilasi oleh XLA.
Tiga node lain di grafik ini,
untuk tujuan ini,
tidak akan dikompilasi XLA.
Ada banyak alasan untuk itu.
Kadang operasi tidak diimplementasikan.
Di lain waktu kami memilih pengelompokan
yang kebetulan tak memasukkan mereka.
Contoh ini, telah kami pilih
dari tiga node tertentu.
Di kanan, terlihat kami sudah ambil grafik

Portuguese: 
e sobre como traduzir TensorFlow para XLA.
Os dois próximos tópicos
tratarão de como usar
esse compilador irado
dentro do TensorFlow.
A primeira coisa de que falaremos
é JIT, que é a compilação just-in-time.
No tópico de transformações de grafos,
vou descrever JIT como esse grafo,
como esse grafo muda.
À esquerda, temos
um grafo TensorFlow normal.
E nesse trapézio vermelho,
identificamos três nódulos.
Esses três nódulos
poderão ser compilados pelo XLA.
Os outros nódulos, para os nossos fins,
não serão compilados pelo XLA.
Existem várias razões.
Como disse, algumas operações
ainda não foram implementadas.
Ou escolhemos agrupamentos
que não as contêm.
Neste exemplo, escolhemos
estes três nódulos específicos.
À direita, é possível ver
que tomamos o grafo

Spanish: 
y vimos cómo traducir TensorFlow a XLA.
Los próximos dos puntos serán
sobre cómo utilizamos
este compilador dentro de TensorFlow.
Lo primero de lo que hablaremos
será de JIT, que es la compilación
justo a tiempo.
Hablando de transformaciones de gráficos
describiré a JIT como este gráfico
cómo cambia el gráfico.
A la izquierda tenemos
un gráfico TensorFlow normal.
En este trapecio rojo
identificamos tres nodos.
Y estos tres nodos podrán
ser compilados por XLA.
Los otros nodos del gráfico no serán,
a los efectos de esto
compilados por XLA.
Hay muchas razones para eso.
A veces las operaciones simplemente
no se implementan.
En otras ocasiones hemos
elegido la agrupación
que no los agrupa.
Aquí escogimos estos en particular
o estos tres nodos.
A la derecha, vemos que tomamos el gráfico

Japanese: 
TensorFlow を XLA に
変換する方法についても言及しました。
それでは次の２つのポイントで、
どのようにこのクールなコンパイラーを
TensorFlow 内部で使うかどうかを
見ていきたいと思います。
最初にお話するのは、
JIT についてです。
これはジャストインンタイム
コンピレーションのことです。
グラフ変換についてのテーマでは、
このグラフがどのように変化するかを通して
JIT について説明します。
左側には、標準のTensorFlow 
グラフがあります。
この赤色の台形の中には
３つのノードが確認できます。
これらの３つのノードは
XLA によってコンパイルされます。
この目的のため、グラフ内の他のノードは
XLA によってコンパイルされません。
それには多くの理由があります。
時には、オペレーションが実行されなかったり
その他の場合には、クラスターしないように
クラスターリングを選んだり
この例では、これらの３つの
特別なノードを選びました。
右側には、グラフを取り
そしてリライトしたものが見えます。

Chinese: 
我们已经讲了如何将TensorFlow翻译成XLA
接下来，我们要说的两点是
我们是如何在TensorFlow里
使用这个非常酷的编译器
我们要说的第一点是JIT
就像即时编译一样
所以在主题里，就像图像转换
我将把JIT描述为图像
以及图像是如何改变的
所以在左边，我们有一个
普通的TensorFlow图表
在这个红色的梯形框中
我们定义了三个节点
这当个节点将被排序
能够被XLA编译
图表的另一个节点不是为了
被XLA编译
有很多的原因
我们说过，有些操作没有被实施
或者其他时候我们选择集群
却没有将它们放到集群里
所以在这个例子里，我们选择了这些特定的
这三个节点
在右边，我们看到，我们读取了图表

Korean: 
텐서플로우를 XLA로
변역시키는 법도 다뤘습니다
다음 두 포인트는
텐서플로우 내부의
멋진 컴파일러를 실제로 어떻게
사용하는가이죠
먼저 언급할 내용은
JIT, 즉 저스트인타임
컴필레이션입니다
그래프 변환이라는 주제에서
JIT를 그래프가 어떻게 변하는지
이 그래프로 묘사하겠습니다
왼쪽에는 일반 텐서플로우 그래프가 있죠
이 빨간 사다리꼴에서
세 가지 노드를 식별했죠
이 세 노드가 XLA에 의해
컴파일될 수 있게 할 겁니다
이 그래프에서 다른 노드는
이 목적을 위해서는 XLA에 의해
컴파일되지 않을 겁니다
이 경우 많은 이유가 있습니다
저희는 때로 운영이
그냥 실행되지 않는다고 하죠
혹은 다른 경우 우연히
클러스터되지 않는 것을
클러스터링하게 선택했거나 말이죠
그럼 이 예시에서 저희는
이 세 가지 노드를 선택했죠
오른쪽에 그래프를 가지고

Korean: 
다시 적은 것이 보이시죠
이 밖에는 같은 노드가
여전히 있지만 안쪽에는
그 클러스터 혹은 그 서브그래프를
핑크 방울 안에 넣었죠
이제 텐서플로우 실행 시간이 어떻게
작동하는지 생각해보면 완전히 똑같습니다
각 노드를 만나고 이 오른쪽
그래프에서 나가서
이것이 나타내는 운영의 커널을 찾아
실행시키겠죠
이 핑크 방울을 누르게 되면
뭔가 특별한 일이 일어나겠죠?
이 서브그래프가
여전히 존재한다는 것을 알죠
그리고 컴파일 할 겁니다
이 그래프를 XLA 그래프로 전환시키고
이를 실제 머신 코드로 바꾸어
실행시키겠죠
캐싱이 발생하는 것도 이 시점이죠
같은 서브그래프를 다시 누르게 되면
그래서 같은 그래프를 여러 번 실행시키거나
혹은 심지어 프로그램 내에서
같은 서브그래프가 여러 번 나타난다면
컴필레이션 비용을 여러 번
지불할 필요가 없다는 거죠
한번만 컴파일하고 여러 번
실행하는 겁니다

English: 
and we've rewritten it, so that
the same nodes outside of it
are still there,
but on the inside,
we've taken that
cluster or that subgraph
and put it inside this
sort of pink bubble, OK?
And now when you think
about how TensorFlow,
like, the runtime works, it's
working exactly the same.
It's going off of
this right-hand graph,
where it's going
to visit each node,
and it's going to look up
the kernel for the operation
that it represents, and
it's going execute it.
When it hits this
pink bubble, that's
where some of the special
stuff happens, right?
We have inside of it the
notion that this subgraph still
exists.
And we're going to compile that.
We're going to transform that
graph into the XLA graph,
and transform that into
actual machine code,
and then execute that.
This is also where that
caching occurs, right,
where if you happen to hit
that same subgraph again,
so if you run the same
graph multiple times,
or within your program even, if
you have the same subgraph that
shows up multiple
times, we're not
going to pay the cost of
compilation multiple times.
We're going to just compile
that once and execute it
over and over again.

Spanish: 
y lo reescribimos
para que los mismos nodos fuera de él
sigan ahí, pero en el interior
tomamos este grupo o ese subgráfico
y lo pusimos dentro
de esta burbuja rosada.
Y ahora, cuando piensas en cómo funciona
el tiempo de ejecución de TensorFlow,
ves que funciona igual.
Sale de este gráfico de la derecha
en donde visitará cada nodo
y buscará el núcleo para la operación
que representa y lo ejecutará.
Al golpear esta burbuja rosa
es cuando suceden algunas cosas geniales.
Tenemos dentro de él la noción
de que este subgráfico todavía existe.
Y vamos a compilar eso.
Vamos a transformar ese gráfico
en el gráfico XLA
y a transformar eso
en código de máquina verdadero
y luego ejecutar eso.
Aquí también ocurre
el almacenamiento en caché
donde si vas al mismo subgráfico de nuevo
si ejecutas el mismo gráfico varias veces
o hasta dentro de tu programa,
si tienes el mismo subgráfico
que aparece varias veces
no pagaremos la compilación varias veces.
Compilaremos eso una vez
y lo ejecutaremos repetidamente.

Chinese: 
我们重写了它
因此相同的节点还在那里
但是在内部
我们选择了那个集群或子图
把它放进了这个粉红色的泡泡里
现在，当你想象TensorFlow
比如运行时间是如何工作的
它的工作原理完全相同
就像在右手边的图表中一样
它会访问每一个节点
它会从内核中查看所代表的操作
然后执行它
当它遇到这个粉红色泡泡时
就会有一些特殊的事发生
在里面，我们认为这个子图
仍然存在
我们会把它编译
我们将会把这个图表转成XLA图表
把它转成实际的机器代码
然后执行它
这也就是缓存发生的时刻
如果你碰巧在此遇到那个子图
如果你多次运行这个图表
或者在你的程序里
如果你有相同的子表
也显示了很多次
我们不需要多次编译它
我们只需要编译它一次
然后一次又一次的执行

Indonesian: 
dan menulis ulangnya,
jadi node yang sama di luar
masih di sana, tapi di dalam,
kami telah ambil kluster atau sub grafik
dan meletakkannya di dalam
balon merah muda ini.
Jika Anda memikirkan bagaimana TensorFlow
contohnya, kerja waktu proses,
cara kerjanya sama persis.
Dia menuju grafik kanan,
lalu mengunjungi tiap node
lalu mencari kernel untuk operasi
yang diwakilinya, lalu mengeksekusinya.
Saat dia sentuh balon merah muda,
hal istimewa akan terjadi.
Kami ada di dalam, berpendapat
sub grafik ini masih ada.
Kami akan mengompilasi itu.
Ubah grafik itu menjadi grafik XLA
dan mengubahnya
jadi kode mesin sebenarnya
lalu mengeksekusinya.
Ini juga di mana caching terjadi,
jika Anda mengenai
sub grafik yang sama lagi,
jika menjalankan grafik yang sama
atau dalam program,
jika Anda punya sub grafik sama
yang muncul beberapa kali,
kami tak akan membayar
biaya kompilasi berulang kali.
Kami hanya akan mengompilasi sekali
dan eksekusi berulang kali.

Portuguese: 
e o reescrevemos
para que os mesmos nódulos
que estão do lado de fora
ainda estejam aqui.
Mas dentro, aquele agrupamento,
ou aquele subgrafo,
foi colocado dentro desta bolha rosa.
Pensando no funcionamento do TensorFlow,
ou do tempo de execução,
está funcionando do mesmo jeito.
Está saindo deste grafo do lado direito,
em que visita cada nódulo,
procura o núcleo para a operação
representada por cada um
e as executa.
Quando chega na bolha rosa,
é aqui onde coisas especiais acontecem.
Dentro dela, temos a ideia
de que esse subgrafo ainda existe.
E vamos compilá-lo.
Este grafo será transformado no grafo XLA,
então será transformado
no código de máquina
e depois será executado.
Aqui é também onde ocorre o caching,
caso você passe pelo mesmo
subgrafo de novo.
Então se o mesmo grafo
for executado várias vezes,
ou mesmo dentro do programa,
se o subgrafo aparecer várias vezes,
não pagaremos o custo
de compilação várias vezes.
Será compilado apenas uma vez
e executado várias vezes.

Japanese: 
外側にあった同一のノードが
まだそこにあります。
そのクラスターもしくはサブグラフを取り、
ピンク色の円の中に入れます。
ランタイムが作動するように、
TensorFlow が作動する様子を見ると
同じように動きます。
この右側のグラフが作動します。
各々のノードを訪ね、その記号である
オペレーション用のカーネルを探し
それを実行します。
このピンク色の円をヒットする時、
そこで特別なことが起こります。
その内部に、このサブグラフが
まだ存在するという見解が出ます。
それをコンパイルし、
そのグラフを XLA グラフに変換し、
アクチュアルマシーンコードに
変換し、実行します。
これはまたキャッシュが起こる場所です。
もし同一のサブグラフを
もう１度ヒットしたり、
同一のグラフをプログラムの中で
複数回作動させたり、
複数回にわたって表示される
同一のサブグラフがある場合、
複数回にわたるコンピレーションのコストを
支払うわけではありません。
１度だけコンパイルして、
何度も実行することになるのです。

English: 
So in this picture,
we're going to show
some of the more
standard sort of ways
that you show up
in these graphs.
Like, the previous one
is kind of simplified.
Now, this one's obviously
also very simplified,
but the main point here
that we're trying to show
is that a single
TensorFlow graph
can have multiple such
clusters show up, right?
And in this example, we've
got two of them on the left.
We've got this blue
rectangle and we've
got that same sort
of red trapezoid.
So the clustering phase is
going to go and identify
which clusters are
going to be compiled.
And on the right side, we've
done the exact same thing.
We've turned those two things
into their respective little
bubbles.
And when the TensorFlow
executor gets to these nodes,
we're going to compile and
run them with the caching
and everything.
So in this slide, we're
going to talk a little bit
about one of the sort of
challenges that shows up.
You might think, well, that was
sort of pretty straightforward.
So here's a
particular challenge.

Japanese: 
このスライドでは、
これらのグラフ内で表示する
よりスタンダードな方法を
幾つか紹介します。
前のスライドは、簡易化したものです。
こちらもかなり簡易化されたものですが
皆さんにお見せしたい点は、
単一の TensorFlow グラフは、
表示されるこれらの複数のクラスターを
持つことができるということです。
この例だと、左側に２つあります。
ブルーの長方形と赤の台形のものです。
クラスターリングフェーズが進行し、
どのクラスターがコンパイルされるかを
特定します。
右側では、全く同じことが行なわれています。
これらの２つのものを
対応する小さな円の中に入れました。
TensorFlow エグゼキュターが
これらのノードを得ると、
それらをコンパイルし、キャッシングや
その他を通じて作動します。
このスライドでは、生じてくるチャレンジの
１つについてお話しします。
これはかなり簡単だと思われるでしょう。
ここに特別なチャレンジが存在します。

Indonesian: 
Dalam gambar ini, kami akan tunjukkan
beberapa cara standar
yang ditunjukkan di grafik.
Sebelumnya itu disederhanakan.
Yang ini juga disederhanakan
tapi yang ingin kami tunjukkan
adalah grafik TensorFlow tunggal
bisa memiliki beberapa
kluster yang muncul.
Di contoh ini, kami punya dua
di sebelah kiri.
Ada persegi panjang biru dan
trapesium merah.
Fase pengelompokan akan
mulai dan mengindentifikasi
kluster mana yang akan dikompilasi.
Di kanan, kita lakukan hal yang sama.
Kita telah ubah dua ini
menjadi balon lebih kecil.
Saat eksekutor TensorFlow
sampai di node ini, kompilasi
dan jalankan dengan lakukan cache
dan sebagainya.
Di slide ini, kita akan bicara sedikit
soal tantangan yang muncul.
Mungkin menurut Anda cukup mudah.
Ini tantangannya.

Chinese: 
所以在这个图片中
我们将向你展示一些标准的方式
一些你在这些图表中表现出来的方式
比如，之前的那个比较简单
现在，这个显然非常的简单
我们在这里想要表达的重点是
是一个简单的TensorFlow 图表
可以有很多的集群
在这个例子中，我们在左边有两个
我们有这个蓝色的矩形框
我们也有一个同样的红色梯形框
所以这个集群将会确定
哪个集群被编译
在右边，我们做了相同的事
我们将这两点转化为两个小泡
当TensorFlow执行器遇到这些节点后
我们将会编译并且执行它们
通过缓冲，等等
在这个幻灯片中，我们想要聊下
我们遇到的一个挑战
你可能会认为，这非常的直白
这就是一个特定的挑战

Spanish: 
En este cuadro vamos a mostrar
algunas de las formas más estándar
que muestran en estos gráficos.
Como el anterior está simplificado.
Ahora, este obviamente
también está muy simplificado
pero el punto principal
que intentamos mostrar
es que un solo gráfico TensorFlow
puede mostrar varios clusters.
Y en este ejemplo, tenemos
dos de ellos a la izquierda.
Tenemos este rectángulo azul
y tenemos ese mismo trapecio rojo.
La fase de agrupación va a ir
e identificará
qué clusters se van a compilar.
Y a la derecha
hicimos exactamente lo mismo.
Convertimos esos dos
en sus respectivas burbujas.
Y cuando el ejecutor TensorFlow
llega a estos nodos
compilaremos y los ejecutaremos
con el caché y todo.
En esta diapositiva,
vamos a hablar un poco
de uno de los desafíos que existen.
Podría pensarse
que era algo bastante sencillo.
Aquí un reto en especial.

Korean: 
이 그림에서 이 그래프에서 나타나는
일종의 일반적인 방식을
보여 드리겠습니다
이전 예시는 단순화된 것이었죠
이것도 분명히 아주 단순화된 것이지만
하지만 주요점은 하나의
텐서플로우 그래프가
이러한 클러스터를 보여줄 수 있다는 걸
보이려는 겁니다
그리고 이 예시에서
왼쪽에 두 가지가 있죠
이 파란색 사각형이 있고
같은 종류의 빨간색 사다리꼴이 있죠
클러스터를 하는 단계에는
어떤 클러스터가
컴파일될 것인지 식별하겠죠
오른쪽에서도 똑같이 했습니다
이 두 가지를 각각의 방울로 바꿨죠
텐서플로우 실행자가 이 노드를 가져오면
컴파일해서 캐싱으로 실행시킬 겁니다
이 슬라이드에서는
여기에서 나올 수 있는
일종의 문제에 대해 얘기해 보겠습니다
꽤 쉬웠다고 생각하실지도 모르겠습니다
여기 문제가 있습니다

Portuguese: 
Nesta imagem, nós vamos mostrar
algumas das maneiras comuns
de chegar a esses grafos.
O anterior foi um tanto simplificado.
Este também está simplificado,
mas o importante é
que um único grafo TensorFlow
pode fazer surgir vários aglomerados.
Neste exemplo,
temos dois deles à esquerda.
Este retângulo azul
e um trapézio vermelho.
A fase de clustering vai identificar
quais agrupamentos devem ser compilados.
À direita, fizemos a mesma coisa.
Transformamos aqueles dois
em suas respectivas bolhas.
Quando o executor do TensorFlow
chega nesses nódulos,
serão compilados e executados
com caching e tudo o mais.
Neste slide, falaremos um pouco
sobre um dos desafios.
Vocês podem pensar que até agora
foi tudo muito simples.
Aqui vai um desafio específico.

Spanish: 
No es algo muy difícil o parecido
pero a escala no es algo trivial.
En este en específico, mostramos
un gráfico donde escogimos
un agrupamiento que es bastante malo
de hecho, es un agrupamiento erróneo.
Ahora, puede que desees pensar más
sobre qué tiene de malo este agrupamiento.
Si escogemos este agrupamiento
¿qué podría salir mal?
El problema es evidente
en el lado derecho
donde creamos un ciclo
entre los nodos no JIT y los JIT.
Aquí el problema es que el motor
de ejecución no podrá determinar
cuál ejecutar primero.
¿Cómo ejecuto realmente este gráfico?
Y esto es obviamente algo
que debemos evitar mientras
hacemos el proceso JIT.
Este ejemplo en particular,
no es muy difícil, pero a medida
que llegamos a gráficos más grandes
esto se convierte en algo
más complicado y no trivial.
Es un ejemplo,
un sabor de las cosas concretas
que el nivel de JIT está realizando
ahora para ti.

Chinese: 
我是说，这并非非常的难
但是规模比较的大
对于这个挑战
我们显示了一个图表，我们选择了一个集群
它不巧是一个很坏的集群
现在，你可能会想一下
到底为什么这个集群不好呢？
如果我们碰巧选择了这个集群
会出现什么问题呢?
问题就在
右手边的幻灯片上
我们创造了一个在非JIT节点
和JIT节点之间的循环
这里的问题就是执行引擎
它没有办法决定
要先运行哪一个
要怎么执行这个图表
显然，当我们运行JIT程序时
需要避免这一点
在这个特定的例子里
这并非非常的困难
但我的意思是说
当我们读取一个很大的图表时
这就会变的比较有挑战
比较的有影响
所以这是一个例子
一个JIT为你执行的具体的例子

Japanese: 
とても難しいことではないのですが、
規模で言えば、平凡なものでもありません。
お見せしているこの特殊なグラフは、
かなり良くない形のクラスターリングを
抽出したところです。
本当に、悪いクラスターリングです。
一体このクラスターリングのどこが
良くないのだろう、
という問いが少なからず出てくると
思います。
もしこのクラスターリングを抽出すれば、
実際に何が上手く行かないのだろう。
その問題点は、右側の部分に表れています。
non JIT ノードと JIT ノード間に
サイクルを作った部分です。
ここで問題となるのは、
エグゼキューションエンジンに
定義する方法がなくなった場合、
どちらを先に作動させるのか、
という点です。
どのようにこのグラフを実行するのか、
という点です。
JIT プロセスを行っている時、
これは明らかに回避しなければなりません。
この特殊な例は、
非常に難しいものではありませんが
より大きなグラフを得るため、
これは多少骨の折れる、特殊なものです。
これは、JIT レベルが実際に実行する
具体的な例の１つです。

English: 
I mean, it's not, like,
super difficult or anything,
but it's kind of
non-trivial at scale.
So this particular
one, we're showing
a graph where we picked
a clustering that
happens to be pretty bad Yeah,
in fact, it's bad clustering.
Now, you might want to think
a little bit about, well,
what exactly about
this clustering is bad?
If we happened to pick
this clustering, like,
what would actually go wrong?
And so the problem
is evident sort of
on the right-hand
side, where we've
created a cycle between the
non-JITed nodes and the JITed
nodes.
And the issue here is that
just the execution engine,
it's going to have no way
to determine, like, well,
which one do I run first?
How do I actually
execute this graph?
And so this is
obviously something
that we need to avoid while
we're doing the JIT process.
This particular example, it's
not, like, super difficult,
but I mean, as we
get to larger graphs,
this actually becomes
a little bit more
challenging and non-trivial.
So this is an example, a
flavor of the concrete things
that the JIT level is
actually performing for you.

Korean: 
많이 어렵지는 않지만
스케일에서 사소하지는 않죠
이 문제를 보면
꽤 안 좋은 클러스팅을
뽑은 그래프를 보고 있습니다
그럼 이 클러스터링이 정확히
어떻게 나쁜 것인지에 생각해 보실까요?
이 클러스터링을 선택하게 된다면
무엇이 잘못 될까요?
오른쪽에서는 이 문제가
명백합니다
non-JIT 노드와 JIT 노드 사이의
사이클을 만들었죠
문제는 단순히 실행 엔진이
어떤 노드를 먼저 실행시킬까를
선택할 방법이 없다는 거죠
이 그래프를 실제로 어떻게 실행시킬까?
JIT 과정을 할 때에는
분명히 피해야 할 사항인거죠
이 특정 예시는 매우 어렵지는 않지만
더 큰 그래프를 만들수록
조금 더 어렵고 무시할 수 없게
되는 겁니다
JIT 레벨이 사실상 실행되고 있다는
구체적인 예시인 거죠

Indonesian: 
Maksud saya, tak terlalu sulit
tapi tidak terlalu sepele.
Yang ini, kami tunjukkan grafik
di mana pengelompokannya
cukup buruk, sebenarnya,
pengelompokannya buruk.
Sekarang pikirkan, kenapa
pengelompokan ini buruk?
Jika kita mengambil pengelompokan ini,
apa yang akan terjadi?
Masalahnya adalah bukti
di sebelah kanan, di mana
kami buat siklus
antara node non-JIT dan JIT.
Masalahnya di sini adalah
mesin eksekusi tak akan bisa menentukan
mana yang pertama dijalankan?
Bagaimana saya mengeksekusi grafik ini?
Pastinya ini yang kita perlu hindari
saat lakukan proses JIT.
Contoh ini, tidak terlalu sulit.
Maksud saya, semakin besar grafik
maka akan menjadi lebih menantang
dan tidak biasa.
Ini contoh, hal konkret
bahwa tingkat JIT
sebenarnya bekerja untuk Anda.

Portuguese: 
Não é super difícil, nem nada desse tipo,
mas não é algo trivial em escala.
Neste aqui, mostramos um grafo
em que escolhemos um agrupamento
que é bem ruim.
É, um agrupamento ruim.
Você pode se questionar
sobre o que especificamente
neste agrupamento é ruim.
Se escolhêssemos este agrupamento,
o que poderia dar errado?
O problema está evidente no lado direito,
onde criamos um ciclo
entre nódulos JIT e nódulos não-JIT.
O problema é que o motor de execução
não vai conseguir definir
o que executar primeiro.
Como executar este grafo?
Obviamente é algo que devemos evitar
ao fazer o processo JIT.
Neste exemplo, não é algo muito difícil.
Mas em grafos maiores,
torna-se um mais difícil e não trivial.
Nesse exemplo, temos
um gostinho das coisas concretas
que são realizadas a nível de JIT.

Indonesian: 
Untuk menyalakan kompilasi JIT,
ada dua cara utama.
Akan saya jelaskan yang pertama dulu.
Yaitu kotak biru di atas.
Namanya sesi Keseluruhan, oke?
Kami telah mencoba menyederhanakannya.
Jadi ini adalah, kami sungguh
mencoba menyederhanakannya
dan Anda dapat sepanjang ini.
Maksud saya, konsepnya sangat sederhana.
Tak masalah labelnya panjang, 'kan?
Konsepnya, yang Anda lakukan
adalah Anda punya konfigurasi
yang akan Anda berikan
untuk jalankan sesi Anda,
untuk membuat sesi Anda.
Anda perlu mengatur tanda di sini
untuk bilang, nyalakan JIT.
Ini dia.
Yang akan dilakukannya
adalah ambil seluruh grafik
dan itu akan menentukan
kluster grafik mana
yang bisa dikompilasi dan
dia akan menulis ulang grafik menjadi itu.
Lalu saat mengeksekusi,
tiap kita sentuh node
maka dia akan melakukan proses JIT
dan kompilasikan menjadi kode mesin.
Konsepnya di sini adalah
Anda menyalakan tanda ini

Spanish: 
Así que para activar la compilación JIT
ahora tenemos dos maneras principales.
Mostraré la primera.
Está en esta caja azul arriba.
Se llama "Sesión completa".
Y realmente tratamos
de hacerlo muy simple.
Y así que esto es, como dije
muy simple y luego tienes
esto muy largo.
Quiero decir
que el concepto es muy simple.
No importa la longitud,
como con la etiqueta.
En teoría, lo que haces
es tener esta configuración
que pasarás a tu sesión de ejecución
para crear tu sesión.
Solo tienes que establecer esta etiqueta
para decirle que inicie JIT.
Y eso es todo.
Lo que hará eso
es tomar tu gráfico entero
determinará cuáles agrupaciones
del gráfico pueden compilarse
e irá y reescribirá el gráfico en eso.
Y cuando ejecutas de verdad
cada vez que tocas ese nodo
realizará ese proceso JIT por ti
y compilará hasta llegar
al código de máquina.
Inicias esta etiqueta

Portuguese: 
Para ativar a compilação JIT,
temos duas formas hoje.
Vou explicar a primeira.
Esta na caixa azul, em cima.
Chama-se sessão completa, certo?
E tentamos facilitar ao máximo.
Eu disse que tentamos facilitar
e então temos esta coisa super longa.
Mas o conceito é bem simples.
Ignore a nomenclatura longa.
Conceitualmente,
o que você está fazendo
é tomar essa configuração e passar adiante
para executar a sessão,
para criar a sessão.
Tudo o que precisa fazer
é assinalar aqui para ativar o JIT.
E está feito.
Isso vai pegar todo o grafo
e determinar quais agrupamentos
do grafo podem ser compilados.
E vai reescrever o grafo desse modo.
E quando for executado,
toda vez que atingir esse nódulo
vai realizar o processo JIT
e compilar o código de máquina.

Korean: 
JIT 컴필레이션을 켜기 위해서는
현재 두 가지 주요 방법이 있습니다
첫 번째 방법을 먼저 설명하죠
그것은 상단에 있는 이 파란 상자에 있죠
이는 전체 세션이라고 불립니다
정말 간단하게 만들기 위해 노력했습니다
그러니까 저희는 간단하게 만든다고
만들었는데 이렇게 엄청 긴 결과가
나온거죠
하지만 컨셉은 실제로 간단합니다
이 긴 라벨은 신경쓰지 마시고
개념적으로 여러분은
세션을 만들고
운영하기 위해 패스할
컨피겨레이션을 가진 거죠
여러분이 해야 하는 일은
플래그를 다는 겁니다
JIT를 켜라고 하는 거죠
됐습니다
그래프 전체를 가지고
이 그래프의 어느 클러스터가 실제로
컴파일될 수 있는가를 결정해서
그래프를 그렇게
다시 쓰게 하는 거죠
그런 후 실제로 실행할 때
이 노드를 누를 때마다
JIT 과정을 실행시킬 것이고
머신코드로 컴파일하는 겁니다
컨셉은 이 플래그를 뒤집으면

English: 
So in order to turn on
the JIT compilation,
we've got two main
ways right now.
And so I'll walkthrough
through the first one.
That's in this blue
box on the top.
It's called Whole
session, right?
And we've really tried
to make it super simple.
And so what this is, ha,
I say, like, we really
try to make it super
simple and then you've got,
like, this super long.
OK but I mean, the concept
is actually super simple.
Never mind the long,
like, label, right?
Conceptually, what
you're doing is
you've got this
configuration that you're
going to pass into to
run your session, right,
to create your session.
And all you need to do is
set this one flag on it
to say, like, turn on the JIT.
And there you go.
What that's going
to do is it's going
to take your entire
graph, it's going
to determine which
clusters of the graph
can actually be
compiled, and it's
going to go and rewrite
the graph into that.
And then when you
actually execute,
it's going to, like, every
time we hit that node, it's
going to perform that
JIT process for you
and actually compile
down to machine code.
And so the concept here is
that you flip this one flag on

Chinese: 
所以要开启 JIT编译
我们现在主要有两种方法
所以我将介绍第一种
它在顶端的蓝色方框中
它叫做Whole session
我们真的想让它变的非常的简单
那么它是什么呢
我们真的想让它变的非常的简单
然后你有了这个非常长的程序
但是我的意思是说
概念其实非常的简单
没关系，标签很长
概念上来说，你所做的是
你有了这个配置
你想用它来运行你的程序
来创建你的程序
你所需要做的是设置这个标签
启动 JIT
就是这样
它所做的是
它会读取你整张图表
它会决定图表的哪个集群
实际上可以编译
它就会重写这个图表
当你实际执行时
每遇到一个节点
他就会为你运行JIT流程
然后编译成机器代码
所以这里的概念是，你做了这个标志

Japanese: 
JIT コンピレーションを作動するために
今、２つの主要な方法があります。
１つ目を手短に説明します、
上部のブルーボックスの中にあります。
これはホールセッションと呼びます。
これを非常にシンプルに表示しました。
ご理解いただけるよう、
非常にシンプルに表示しようと試みましたが
だいぶ長くなってしまいました。
コンセプトは実際、非常にシンプルです。
長いラベルについては
気にしないで下さい。
概念的には、セッションを作動し
セッションを作るためにパスする予定の
この環境設定を得たということです。
やらなければならないのは、
そこにフラグを付けるということです。
JIT を作動させるということです。
そして作動して下さい。
グラフ全部を取得し、
グラフのどのクラスターを
コンパイルするかを指定し、
前に進み、それにグラフをリライトします。
実際に実行した時、
ノードをヒットする度に起きるように
その JIT プロセスを実行し、
マシーンコード用にコンパイルします。
ここでのコンセプトは、
この１つのフラグを付けることによって

Japanese: 
自動的に恩恵を受けるということです。
魔法にかかったかのように
より迅速に進めることができます。
JIT コンピレーションを作動させる
第２の方法は、
これは多少、明白なものになります。
マニュアリースコープトと呼びます。
その根底にあるのは、
ここではプログラムを取得し
この１つのフラグをつける代わりに、
明白にプログラム内部にスコープを付け、
何がコンパイルされ、何がされなかったかを
手動でコントロールします。
その考えの１つとして、
特殊なモデルもしくはグラフによって
ある特定のエリアが算定もしくは、
このサブグラフをコンパイルするために
非常に価値のあるものに変わるのを
知ることになるでしょう。
それを遂行するための方法です。
完璧なコントロールを得ます。
この特殊な例の中で、この下の
add というオペレーションを見て下さい。
これは XLA によってコンパイルされる
唯一のものです。
これを非常にシンプルなものにしたい
と言いましたが、
期待するような
シンプルなものではないですね。
この１つのフラグを付ければ、
残り全てをやり遂げてくれる
というわけではありません。

Spanish: 
y obtendrás un beneficio automático.
Mágicamente todo es más rápido para ti.
La segunda forma en que podemos activar
la compilación JIT
es un poco más explícita.
Lo llamamos alcance manual.
La idea aquí es que tomes tu programa
y en lugar de solo iniciar esta etiqueta
colocarás explícitamente los alcances
dentro de tu programa
donde controlarás manualmente
qué se compila y qué no.
Una de las ideas es que
puedas saber dependiendo del modelo
o gráfico que tengas
qué áreas serán
muy valiosas para computar
o compilar este subgráfico
pero no este otro.
Así es cómo logras eso.
Tienes un control completo.
En este ejemplo tenemos
esta operación de adición aquí abajo
y es lo único que será compilado por XLA.
Dije que queríamos que fuera muy simple
pero no es tan simple como
nos gustaría, ¿verdad?
Como dije, solo inicias esta etiqueta
y esto hace casi todo lo demás.

Chinese: 
你就可以自动收益
一切就神奇的变快了
第二个方法是，我们可以启动JIT编译
这种方法更加的明确
你可以把它叫做手动范围
意思是你有了自己的程序
你不需要启动这个标记
你明确地设置你程序的范围
你可以手动控制什么被编译
什么不被编译
我们有的一个想法是
你可能知道由于特定的模型或图表
特定的区域
这可能对计算机非常的有价值
来编译这个子图
而不是其它的子图
这就是你可以完成的一种方式
你可以完全控制编译
在这个特殊的例子里
我们在这里有一个运算，就是添加
这是XLA编译的唯一一个运算
我们想让它变的非常的简单
但其实它没有我们想的那样简单？
我已经说过了
你刚刚打开了这个标签
它就会完成其余的所有事
理想情况下

English: 
and you get, like,
automatic benefit, right?
Things just get
magically faster for you.
So the second way that we
can actually turn on JIT
compilation.
This one's a little
bit more explicit.
We call it, like,
manually scoped, right?
And the idea here is that
here you take your program,
and instead of just
turning on this one flag,
you explicitly put scopes inside
of your program where you can
manually control exactly what
gets compiled and what doesn't.
And one of the ideas
here is that, well, you
might know due to the particular
model or graph that you have,
that certain areas,
it's going to be
very valuable to compute or to
compile this subgraph, but not
this other one.
And so this is how you
can accomplish that.
You get, like, complete control.
In this particular
example, we've
got, like, this one operation
down here, which is add,
and that's the only thing that's
going to be compiled by XLA.
So I said we wanted to make
this sort of super simple,
but it's not as simple
as we would like, right?
Like, I kind of said, well,
you just turn on this one flag
and it sort of
does all the rest.
Well, ideally, it's
like, why do you have

Indonesian: 
lalu memperoleh manfaat otomatis.
Secara ajaib akan lebih cepat untuk Anda.
Cara kedua yang bisa kita lakukan
untuk nyalakan kompilasi JIT.
Ini agak lebih eksplisit.
Kita sebut, dijangkau manual.
Idenya adalah Anda bawa program Anda
daripada cuma menyalakan tanda ini,
Anda secara eksplisit meletakkan jangkauan
di dalam program jadi Anda bisa
secara manual mengendalikan
mana yang dikompilasikan dan tidak.
Salah satu ide di sini, Anda mungkin tahu
karena model atau grafik tertentu
yang Anda punya
di area tertentu, ini akan jadi
sangat berharga untuk mengomputasi
atau kompilasi sub grafik ini
tapi bukan yang satu ini.
Ini cara bisa mencapainya.
Anda punya kendali penuh.
Di contoh ini, kami telah lakukan
operasi ini, yaitu tambah
dan itu hal yang akan dikompilasikan XLA.
Saya bilang kami ingin menyederhanakannya
tapi tidak sesederhana yang kita mau.
Anda cuma perlu menyalakan satu tanda ini
dan melakukan sisanya.

Korean: 
자동적으로 혜택을 얻게 된다는 거죠
신기하게도 더 빨라진 겁니다
JIT 컴플리션을 켜는 두 번째 방법을
보겠습니다
이는 조금 더 명백합니다
수동적으로 범주를 정한다고 부릅니다
프로그램을 가지고
이 플래그 하나를 켜는 대신에
무엇이 컴파일되고 되지 않을지를
정확히 수동으로 통제할 수 있는
프로그램 내에서
명백한 범주를 정하는 거죠
여러분이 가지고 있는 특정 모델이나
그래프 때문에 아실지도 모르겠지만
특정 영역은
이 서브그래프를 계산하거나
컴파일하는 데에 아주 귀중하지만
이것은 아닐 겁니다
어떻게 성취할 것인가에 대해
얘기해 보죠
완벽하게 통제할 수 있죠
이 특정 예시에서
이 운영 즉 덧셈이 여기 있죠
XLA에 의해 컴파일 되는
유일한 것입니다
제가 정말 간단하게 만들고
싶었다고 말씀드렸는데
원하는 만큼 간단하지는 않죠
이 플래그 하나를 켰는데 나머지 전부를
다 하는 것이라고 말했죠
이상적으로는 플래그는 애초에

Portuguese: 
O conceito é que você ativa uma flag
e recebe benefícios automáticos.
Tudo fica magicamente mais rápido.
A segunda maneira
de ligar a compilação JIT
é mais explícita.
Chamamos de "escopo manual".
A ideia é pegar o seu programa
e, em vez de ativar uma flag,
você explicitamente inclui
escopos dentro do programa
com os quais você pode controlar
o que será ou não compilado.
Uma das ideias é que talvez
você saiba devido ao modelo
ou grafo específico
que certas áreas serão muito importantes
no cálculo ou compilação
deste subgrafo, mas outras não.
É assim se realiza isso.
Você tem controle absoluto.
Neste exemplo, temos
a operação Add aqui embaixo.
E é a única coisa
que será compilada pelo XLA.
Eu disse que queria deixar tudo simples,
mas não está tão simples quanto queríamos.
Eu disse que só é preciso
ativar essa flag e ele faz todo o resto.

Japanese: 
理想を言えば、なぜフラグを
付けなければならないのかという事です。
これは自動でできないのかということです。
進行中の作業が多少残っている
という事実があります。
たくさんのアイディアがあります。
何かを作動させる時や、
どんなクラスターを作るかなど
利用してみたい様々な発見方法があります。
これらは私達が現在取り組んでいることです。
その間には、これらの２つの方法のように
実際に試したみたいものが存在します。
ここまでかなりスピードアップして
お伝えしてきました。
これまで XLA のことについて
お話ししてきました。
どのように TensorFlow を
XLA に変換させるか、
どのようにジャストインタイム
コンピレーションを行なうかについてです。
このフラッグを付けて、
自動的に物事が速く進むか
もしくは、グラフのサブポーションが
早くなったりなどです。
最後の部分では、アヘッドオブタイム
コンピレーションについてお話します。
グラフについてのテーマに沿いながら、
１枚のスライドを用いて、
アヘッドオブタイムコンピレーションとは
一体どんな意味を持つのかについて
説明したいと思います。
左側では、標準 TesorFlow グラフ
について話し始めましょう。

Portuguese: 
Mas por que precisar ativá-la?
Não deveria ser feito automaticamente?
E neste ponto o trabalho
ainda está em andamento.
Temos várias ideias
sobre heurísticas diferentes
que você pode usar sobre quando ativá-la,
que tipo de agrupamentos criar
e coisas desse tipo.
Estamos trabalhando nisso atualmente.
Nesse meio tempo, temos duas maneiras
para testarem por conta própria.
Dando um zoom aqui.
Falamos sobre XLA,
como transformamos
TensorFlow em XLA
e como fazer compilações just-in-time.
Você ativa essa flag
e tudo fica automaticamente mais rápido.
Ou partes do seu grafo
devem ficar mais rápidas.
Esta última parte trata
da compilação ahead-of-time.
Mantendo o tema dos grafos,
vou descrever em uma imagem
o que compilação ahead-of-time significa.
À esquerda, começamos
com o grafo normal do TensorFlow.

Chinese: 
你为什么还需要打开这个标签呢？
它不是应该自动打开吗？
这就是我们正在努力的一个方面
我们有很多的想法
喜欢不同的启发式
你可能会想使用他们来打开开关
创建什么样的集群
诸如此类的事
这就是我们现在
正在做的一些事
在此期间，有两种方法
可以让你试用
好的，让我们放大这里
好的，到目前为止，我们已经谈到XLA
我们如何将TensorFlow转成XLA
以及如何做即时翻译，对吧？
你可以开启标签
程序就会自动变快
或者部分图表就会变快
今天的最后一部分
是要讨论提前编译
保持图表的主题
我将要描述在一张图表里
提前编译
到底是什么意思呢？
在左边，我们从普通的TensorFlow图表开始

English: 
to turn the flag on at all?
Like, shouldn't it just be,
like, doing this automatically?
And this is the point where
there's a little bit of work
in progress.
Like, we have a lot
of ideas here, right,
like about different
heuristics that you
might want to use in terms
of when to turn the thing on,
what kinds of
clusters to create,
and things of that sort.
And so that's
something that we're
sort of working on right now.
In the interim, there's
sort of like these two ways
that you can sort of try
things out for yourself.
OK, we're, like, zooming
right along here.
OK, so so far, we've
talked about XLA,
how we transformed
TensorFlow into XLA,
and how we do the just-in-time
time compilation, right?
You sort of like flip this
flag and automatically things
should get faster or
subportions of your graph
should get faster.
This last part is
going to be about
ahead-of-time compilation.
And keeping in the
sort of graph motif,
I'm going to describe--
so the one picture
sense of, what does
ahead-of-time compilation
really mean, right?
And so on the left, we start
with that normal TensorFlow

Spanish: 
Idealmente ¿por qué deberías
iniciar la etiqueta?
¿No debería hacer esto automáticamente?
Y aquí es dónde hay
algo de trabajo en progreso.
Tenemos muchas ideas aquí
sobre diferentes heurísticas
que desearías usar en términos
de cuándo encenderla
qué tipos de clusters crear
y cosas de ese tipo.
Es algo en lo que estamos trabajando
en este momento.
Mientras hay dos formas que puedes probar
para hacer las cosas por ti mismo.
Estamos acercándonos aquí.
Hasta ahora hemos hablado de XLA
de cómo transformamos TensorFlow en XLA
y cómo compilamos justo a tiempo.
Todo debería ir más rápido 
o las subporciones
del gráfico deberían serlo al iniciar
esta etiqueta.
Lo último hablará
de la compilación por adelantado.
Y siguiendo con el tema de los gráficos
describiré esta única imagen
hace que preguntemos 
¿qué hace la compilación
por adelantado?
A la izquierda empezamos con el gráfico
común de TensorFlow.

Indonesian: 
Idealnya, kenapa
Anda harus menyalakan tanda?
Bukankah itu harusnya otomatis?
Di sinilah sedang dilakukan sedikit kerja.
Kami punya banyak ide di sini
seperti tentang heuristik berbeda
yang mungkin Anda ingin pakai
dalam kapan menyalakan sesuatu,
kluster apa
yang akan dibuat, dan hal semacamnya.
Dan itu yang kami kerjakan sekarang.
Sementara, ada dua cara
yang bisa Anda coba sendiri.
Oke, kita perbesar tepat di sini.
Sejauh ini, kita bicara soal XLA,
cara kita ubah TensorFlow ke XLA
dan cara melakukan
kompilasi waktu tepat waktu.
Anda cukup balik tanda ini
dan secara otomatis
harusnya lebih cepat
atau sub porsi grafik Anda
harusnya lebih cepat.
Bagian terakhir ini soal
kompilasi lebih cepat.
Menjaga motif grafik,
saya akan mendeskripsikan
dalam satu gambar, apa
artinya kompilasi lebih cepat.
Di sebelah kiri, kita mulai
dengan grafik TensorFlow normal.

Korean: 
왜 켜야할까요?
자동으로 되어야 하는 것 아닌가요?
저희가 작업하고 있는 시점이
바로 여기죠
저희는 여러 아이디어가 있습니다
언제 켜야하는가에 있어서
사용하고자 하는
여러 휴리스틱에 대한 아이디어죠
어떤 클러스터를 만들지
등에 대한 것이죠
그것이 저희가 현재
작업 중인 것입니다
그 사이에 여러분 각자가
시도해 볼 만한 방법이 이 두 가지이죠
좋습니다, 다음으로 넘어 가겠습니다
지금까지 XLA에 대해서 이야기했고
어떻게 텐서플로우를
XLA로 변환시키는가
또 어떻게 저스트인타임
컴필레이션을 하는가를 다뤘죠
이 플래그를 뒤집어서 자동으로
속도를 올리거나 그래프의 하위 부분이
더 빨라져야겠죠
이 마지막 부분은 어헤드오브타임
컴필레이션에 대한 겁니다
그래프 모티브를 계속 이어가면
그림으로 설명해 보겠습니다
어헤드오브타임 컴필레이션이
무슨 의미 일까요?
왼쪽에 있는 일반적인
텐서플로우 그래프로

Indonesian: 
Tidak seperti JIT, kita ambil
seluruh grafik sekarang
dan kita ubah ke grafik XLA.
Ingat, untuk JIT, kita mengambil
sub porsi grafik, seperti halnya
Anda menjalankan operasi
jika operasi tertentu tidak bisa
dikompilasi, itu tak masalah.
Kita tinggalkan itu,
kita akan eksekusi dengan normal
lalu kita kompilasi
hal yang bisa dikompilasi.
Di mode ini, keseluruhan grafik
harus bisa dikompilasi.
Anda dapat manfaatnya.
Karena jika Anda mengubah
seluruh hal ke dalam XLA
maka akhirnya, keluar biner ini,
seperti x86 atau ARM.
Anda bisa jalankan ini langsung
dari ponsel atau server Anda.
Dan teknik ini lumayan bagus.
Cara kita melakukan ini
adalah melalui sesuatu
bernama tfcompile.
Ini alat yang ditulis dalam C++.
Seperti alat pembungkus,
sama seperti GCC
atau Clang atau semacamnya.
Dia memulai seluruh kompilator.

Korean: 
시작하죠
JIT와는 다르게
이제 전체 그래프를 가지고
XLA 그래프로 변환시킵니다
JIT의 경우 그래프의 하위 부분을
가졌음을 기억하실 겁니다
특정 운영이 컴파일될 수 없어도
괜찮죠
이 부분은 그냥 빼고
정상적으로 실행할 겁니다
하지만 실제로 컴파일될 수
있는 것을 컴파일 하겠죠
이 모드에서는 전체 그래프가
컴파일될 수 있어야 합니다
하지만 이득도 있죠
일단 전체를 XLA로 변환시키면
결쿡에는 x85 혹은 ARM 같은
바이너리로 되죠
즉 여러분의 휴대기기나 서버에서
바로 실행할 수 있습니다
따라서 이것은 아주 강력한 기술이죠
이를 위해 저희는 tf컴파일이라는 것을
사용합니다
이는 C++로 쓰여진 도구로
일종의 래퍼 도구 입니다
GCC나 클랭 등과 같은 방식이죠
전체 컴파일러를 시작합니다

Portuguese: 
Diferente do JIT, pegamos o grafo inteiro
e o transformamos em um grafo XLA.
Lembre-se de que com JIT
tratamos de partes do grafo.
E se operações específicas
não puderem ser compiladas
não há problemas.
Elas ficam de fora,
executamos normalmente,
e compilamos o que é possível.
Neste modo, o grafo inteiro
precisa ser passível de compilação.
Mas há benefícios nisto.
Ao transformar a coisa toda em XLA,
no final ele emite um binário
como x86 ou ARM.
É possível executar diretamente
no celular ou no servidor.
Então essa técnica é muito poderosa.
Fazemos isso por meio
de algo chamado tfcompile.
Esta ferramenta é escrita em C++
e é como uma ferramenta wrapper,
parecida com GCC ou Clang.
Ela inicializa o compilador.

English: 
graph.
And unlike the JIT, we
take that entire graph now
and we transform that
into the XLA graph.
Like, remember, for the
JIT, we were taking, like,
subportions of the graph,
where as you're running, like,
if particular operations
couldn't be compiled,
that's fine.
We'll just leave those out,
we'll execute them as normal,
but then we'll compile the stuff
that actually can be compiled.
In this mode, the entire
graph needs to be compilable.
But you get a
benefit out of this.
Because once you transform
the entire thing into XLA,
then at the end, out spits
this binary, like x86 or ARM.
I mean, you can just
run this thing directly
on your mobile phone
or your server.
And so this is a pretty
powerful technique.
The way that we do this
is through something
called tfcompile.
This is a tool that's
written in C++,
which is really sort
of like a wrapper tool,
the same way that, like, a GCC
or, like, a Clang or something.
It kicks off, like, the
entire compiler, all right?

Spanish: 
Y a diferencia del JIT, tomamos
ese gráfico completo ahora
y lo transformamos en el gráfico XLA.
Recuerden que para JIT hablábamos
de subporciones del gráfico
mientras ejecutas.
Si las operaciones particulares
no son compiladas, está bien.
Dejaremos eso afuera,
ejecutaremos de manera normal
pero luego vamos a compilar las cosas
que realmente se pueden compilar.
En este modo, todo el gráfico
necesita ser compilable.
Sacas un beneficio de esto.
Porque una vez que transformas
todo esto en XLA
al final, muestra este binario,
como x86 o ARM.
Puedes ejecutar esto directamente
en tu teléfono móvil o en tu servidor.
Y esta es una técnica muy poderosa.
Hacemos esto usando
una técnica llamada tfcompile.
Es una herramienta que está escrita en C++
es una herramienta wrapper
así como GCC o como un Clang
o algo parecido.
Pone en marcha todo el compilador.

Japanese: 
JIT とは違い、グラフ全体を取って
XLA グラフに変換します。
JIT では、グラフのサブポーションを
取ったことを覚えていますか。
作動している時に、特殊なオペレーションは
コンパイルされませんでした。
それで良かったのです。
これらを省き、通常通りに遂行します。
基本的にコンパイルできるものは、
コンパイルします。
このやり方だと、グラフ全体がコンパイル
可能な状態にならなければいけません。
しかし、ここから利益を
受けることができます。
全体を XLA に変換すれば、
最後には、x86 や ARM のように
このバイナリが出ます。
直接、これを携帯電話かサーバーで
作動できます。
これはかなりパワフルな技術です。
tfcompile と呼ばれるものを使って
行なうやり方です。
これは C++ で書かれたツールです。
これはラッパーツールのようなものです。
GCC や Clang などのような
ものです。
それはコンパイラー全体を
開始するものです。

Chinese: 
跟JIT不同的是，我们现在有整张图表
我们将它转化为XLA图表
记得，我们讲过的JIT图表
比如，你运行的图表的一部分
如果有一个操作不能被编译
没有关系
我们就不管他们
我们会照常执行它们
然后我们会把可以编译的内容编译
在这个模型下，整张图表需要被编译
但是这样你有一个好处
因为当你将整张图表编译为XLA
最后，我们的二进制文件
比图x86或ARM
你可以直接在你手机上
服务器上运行
因此这是非常强大的技术
我们通过叫做tfcompile的技术
来实现它
这个工具使用C++写的
像一个包装工具
类似于GCC，Clang等等
它开始就像是一个编译器

Chinese: 
它工作的方式非常的简单
理论上就是，在左边
你开启你正常的TensorFlow图表
你给它一个配置文件
告诉它需要提供和获取是什么
所以提供和获取就是TensorFlow术语
来表达输入和输出
你把这个工具提供给编译器
在另一端输出，比如你的二进制文件
你运行平台的机器代码
和C++抬头
让你了解更多
我们在这里具体做什么
C++抬头概念上就是一个函数
我们已经转换了这张图表
我们已经确认了输入量是什么
以及输出量是什么
因此我们将整张图表转换为一个简单的函数
提供为输入参数
提取为输出参数
这很简单
我对此真的很兴奋
这是一种很酷的方式
不仅可以减少二进制文件的大小
但也是一种不同的部署方式

English: 
And it's pretty simple,
the way that it works.
The concept is that
on the left side,
you start with your
normal TensorFlow graph
and you give it a configuration
file that tells it
what the feeds and fetches are.
So feeds and fetches
are just like TensorFlow
terminology for what the inputs
are and what the outputs are.
You feed that into this
compiler, this tool,
and out at the other end
pops, like, your binary, like,
machine code for whatever
platform that you want to run
on and a C++ header.
To give you a little
bit more of an idea
of what exactly are
we doing, right?
That C++ header is conceptually
like a function, right?
We've turned that
graph and we've
identified what the
inputs are. identified
with the outputs are.
So we turn that entire
graph into a single function
where the feeds are
the input arguments
and the fetches are
the output arguments.
And so that's pretty
simple, right?
I'm actually pretty excited
about this, because this
is a pretty cool way to
think about things in terms
of not just reducing
binary sizes,
but also, like, different
ways of deployment, right?

Japanese: 
その動きは、きわめてシンプルです。
コンセプトは左側に書いてあります。
標準の TensorFlow グラフから始め、
フィードとフェッチが何かを伝える
環境設定ファイルを渡します。
フィードとフェッチは
TensorFlow の用語で、
何がインプットで、
何がアウトプットかを示すものです。
このコンパイラー、
ツールの中にフィードインし
他のエンドポップス、バイナリー、
作動したいプラットフォームのマシーンコード
そして C++ ヘッダーなどから
フィードアウトします。
一体に何をしているのかについて
もう少しお話したいと思います。
あの C++ ヘッダーは概念的に
１つの機能だと言えます。
あのグラフを作動し、インプットが何であるか
アウトプットが何かを特定しました。
そこでグラフ全体を
単一の機能に変換します。
そこではフィードはインプット引数であり、
フェッチはアウトプット引数です。
これはかなりシンプルです。
実際、私はとても感動しています。
バイナリーサイズを減らすという
考え方だけではなく、
発展させる異なる方法という観点からも、
非常に高度な考え方となります。

Korean: 
또한 작동 방식이 간단하죠
컨셉은 왼쪽에서
일반 텐서플로우 그래프로 시작하고
피드와 페치가 무엇인지 말해주는
컨피겨레이션을 주는 거죠
피드와 페치는 인풋과 아웃풋에 대한
텐서플로우의 용어같은 겁니다
이 컴파일러로 피드해 주면
반대쪽 끝에서 실행하고자 하는
어떠한 플랫폼이든
그에 맞는 바이너리 머신 코드와
C++ 헤더가 나오죠
저희가 정확히 어떤 일을 하는가를
좀더 설명해 드리겠습니다
그 C++ 헤더는 개념적으로 기능인거죠
그래프를 켜고
인풋과 아웃풋이 무엇인지
식별한 겁니다
따라서 이 그래프 전체를
하나의 기능으로 바꾼 거죠
피드가 인풋 아규먼트이고
페치는 결과 아규먼트인 셈이죠
아주 간단합니다
이건 정말 신나는 일입니다
바이너리 크기를 줄인다는 의미뿐 아니라
전개 방식도 다양할 수 있는
멋진 방식이니까 말이죠

Portuguese: 
A maneira como funciona é bem simples.
A ideia é que no lado esquerdo,
você começa com o grafo TensorFlow normal
e insere um arquivo de configuração
que informa onde estão os feeds e fetches.
Feeds e fetches fazem parte
da terminologia do TensorFlow
para designar entradas e saídas.
Você insere isto no compilador,
esta ferramenta,
e do outro lado sai o seu binário,
código para qualquer plataforma
em que você deseje trabalhar
e um cabeçalho do C++.
Para dar uma ideia melhor
do que estamos fazendo.
O cabeçalho C++ conceitualmente
é como uma função.
Pegamos o grafo
e identificamos entradas e saídas.
O grafo todo foi transformado
em uma única função
em que os feeds são
os argumentos de entrada
e os fetches são
os argumentos de saída.
E isso é bem simples, certo?
Estou animado com isso
porque é uma maneira muito legal
de pensar nas coisas
em termos de não só reduzir
o tamanho do binário,
mas também diferentes
maneiras de implantação.

Spanish: 
Y funciona de una forma bastante simple.
El concepto es que en el lado izquierdo
comienzas con tu gráfico TensorFlow normal
y le das un archivo
de configuración que le dice
cuáles son los feeds y fetches.
Los feeds y fetches son como terminología
TensorFlow para qué son inputs y outputs.
Ingresas esto en este compilador
y en el otro extremo obtienes tu binario,
un código
de máquina para cualquier plataforma
que ejecutes
y un header de C++.
Para darte una mejor idea
de qué hacemos exactamente.
Ese header de C++ es conceptualmente
como una función.
Convertimos ese gráfico
e identificamos cuáles son los inputs
y cuáles los outputs.
Convertimos ese gráfico 
en una sola función
donde los feeds son los argumentos input
y los fetches son los argumentos de output
y así que es bastante simple.
Estoy muy emocionado con esto
es una manera muy buena de pensar en cosas
y no solo reducir los tamaños binarios
sino también en diferentes
formas de implementación.

Indonesian: 
Cara kerjanya lumayan sederhana.
Konsepnya adalah di sebelah kiri,
Anda mulai
dengan grafik TensorFlow normal
dan beri konfigurasi file
yang memberi tahu
apa itu feed dan fetch.
Feed dan fetch itu terminologi TensorFlow
untuk input dan output.
Anda beri feed ke kompilator, alat ini
dan mengeluarkan biner,
seperti kode mesin
untuk platform yang ingin dijalankan
dan header C++.
Untuk memberi Anda sedikit ide
tentang sebenarnya apa yang kita lakukan.
Header C++ secara konsep seperti fungsi.
Kita ubah grafik itu dan
kita telah identifikasi
inputnya, identifikasi outputnya.
Jadi kita ubah seluruh grafik itu
menjadi satu fungsi
di mana feed itu argumen input
dan fetch adalah argumen output.
Itu lumayan sederhana, kan?
Saya lumayan semangat soal ini, karena itu
cara keren untuk berpikir dalam hal
bukan cuma mengurangi ukuran biner
tapi juga, cara penyebaran berbeda.

Indonesian: 
Kami punya cara keren mendeskripsikan
komputasi pembelajaran mesin
di TensorFlow.
Anda bisa bangun model
yang luar biasa kompleks dan rumit ini.
Semua ini diubah jadi grafik
untuk TensorFlow ini.
Anda bisa feed seluruh grafik
ke tfcompile.
Dan keluarannya, fungsi tunggal
yang Anda panggil
dengan input dan output Anda.
Dan itu sangat keren.
Beberapa yang masih kami kerjakan.
Salah satunya adalah
biner yang sedang kita dukung
back end satu-satunya,
adalah untuk CPU.
Untuk kedua stasiun kerja,
seperti x86 atau seluler
seperti ARM tapi belum GPU.
Tak ada alasan teknis 
kenapa belum lakukan ini.
Hanya saja waktu kami terbatas.
Dan kami belum melakukannya,
tapi itu hal yang sungguh
kami ingin lakukan nanti.
Hal keren lain untuk ke depannya
seperti yang saya bilang
hanyalah ikatan bahasa
yang kami dukung
sekarang adalah C++.

Chinese: 
我们把它当作一种很花哨的方式
来描述在TensorFlow中的机器学习
你可以建造这些极其复杂的
复杂的模型
这些都会转换成TensorFlow图表
你可以把整张图表提供给tfcompile
在另一端输出
就像一个你可以调用的单一函数
有你的输入和输出
这真的是非常酷
在这里我们还有一些剩余的工作
其中的一个是我们现在支持的
唯一的二进制文件
唯一的后端，是CPU
所以对于工作站
比如 x86或是移动设备
比如ARM，但是还不支持GPU
我们之所以还没有这么做
并没有技术上的问题
只是因为我们时间有限
因此我们还没有做
但这绝对是我们今后努力的方向
实际上我已经提到的
另一个很酷的未来发展方向
我们现在支持的唯一的计算机语言
是C++

English: 
We've got this, like, fancy
way to describe machine
learning computations
in TensorFlow, right?
And you can build these
extraordinarily complex
and, like, intricate models.
All of that turns into
this graph for TensorFlow.
And you can feed that entire
graph into this tfcompile.
And out at the other
end pops, like,
a single function that
you can call, right,
with your inputs
and your outputs.
And that's actually pretty cool.
Some of the remaining pieces of
work here, right, that we have.
One of them is that the only
binaries that we currently
support, the only
back end, is for CPU.
And so both for workstations,
like x86, or for mobile,
like ARM but not GPU yet.
And there's no technical reason
why we haven't done this.
It's just we have limited time.
And so we haven't done it yet,
but that's definitely something
that we want to
do moving forward.
Another cool future direction
actually is I've mentioned,
well, the only sort of language
binding that we support right
now is C++.

Japanese: 
TensorFlow 内のマシーン
ラーニング算定を説明する巧みな方法です。
これらの並外れて複雑な、入り込んだ
モデルを構築することができます。
その全ては TensorFlow 用のグラフに
変換されます。
このグラフ全体をこの tfcompile に
フィードできます。
そしてインプットとアウトプットを使って
呼び出す単一機能のような、
別のエンドポップから
フィードアウトすることができます。
これはかなり高度な方法です。
今、困難な仕事が幾つか残されています。
その１つは、現在私達がサポートしている
バイナリーだけが
つまりバックエンドだけが
CPU に対応します。
これらは x86 のような
ワークステーション用か、
ARM のようなモバイル用で、
GPU 用ではありません。
まだ終了していない理由は、
技術的なものではなく
単に限られた時間しかないため、
まだ終了していないというだけです。
しかし、先に進めて行きたいと
考えているプロジェクトです。
もう１つの素晴しい将来の方向性として、
現在サポートしている結合言語は
C++ です。

Portuguese: 
Temos esta maneira rebuscada de descrever
cálculos de aprendizagem
de máquina no TensorFlow, certo?
E você pode criar modelos
extraordinariamente complexos.
Tudo isso vira um grafo no TensorFlow.
E você pode inserir
o grafo inteiro no tfcompile.
E do outro lado sai uma única função
que você pode chamar.
Com entradas e saídas.
Isso é muito legal.
Algumas partes que ainda
demandam trabalho:
os únicos binários
que comportamos atualmente,
o único back-end, é para CPU.
Ambos para estações de trabalho, como x86
ou para móvel, como ARM,
mas ainda não para GPU.
Não há motivo técnico para
que não tenhamos feito ainda.
Temos um tempo limitado.
Então não fizemos ainda,
mas com certeza é algo
que queremos no futuro.
Outro objetivo futuro é que mencionei
que a única linguagem de associação
que comportamos atualmente é C++.

Spanish: 
Tenemos una manera elegante
de describir los cálculos
del aprendizaje automático en TensorFlow.
Puedes construir estos modelos
extraordinarios y complicados.
Todo eso se convierte
en este gráfico para TensorFlow.
Puedes alimentar
todo este gráfico en este tfcompile.
Y en el otro extremo aparece
una sola función que puedes llamar
con tus inputs y outputs.
Es realmente genial.
Algunas de las piezas remanentes
de trabajo que tenemos.
Una es que los únicos binarios 
que respaldamos en la actualidad
el único backend es para CPU.
Ambas para estaciones de trabajo x86 
o para móviles
como ARM pero todavía no para GPU.
No hay razón técnica
por la que no hemos hecho esto.
Solo tenemos tiempo limitado.
No lo hemos hecho
aún pero eso es definitivamente algo
que queremos desarrollar.
Como mencioné ahora
el único tipo de lenguaje
de vinculación que respaldamos
ahora mismo es C++.

Korean: 
텐서플로우에서의 머신 러닝 계산을
멋지게 설명하는 방법이겠죠
또한 이러한 놀라울 정도로
복잡한 모델을 만들 수 있습니다
이 모든 것이 텐서플로우를 위한
이 그래프로 바뀌는 거죠
그리고 그 그래프 전체를 이 tf컴파일로
피드할 수 있죠
그리고 반대쪽 끝에서 나오는 거죠
인풋과 아웃풋으로 불러 올 수 있는
단일한 기능인거죠
정말 멋집니다
저희가 하는 일 중 나머지를 보겠습니다
그중 하나는 저희가 현재
지원하는 유일한 바이너리
유일한 백엔드는 CPU를 위한 겁니다
x86와 같은 작업공간이나
ARM 같은 휴대기기를 지원하지만
GPU는 아직 안 되죠
이를 하지 않은 기술적 이유는 없습니다
시간이 부족했을 뿐이죠
아직 하지 않았지만 분명 앞으로
하고 싶은 일입니다
앞으로의 또 다른 멋진 방향은
사실 제가 언급했습니다
저희가 지원하고 있는
유일한 언어 바인딩은
C++이죠

Chinese: 
或者从技术上讲，我猜还有C
无论哪种方式,你可以通过标题文件
调用这些函数
没有理由，从概念上讲
我们不能添加一个包装器
让你可以通过你编程的语言
调用这个函数
基本上,一切支持绑定到C
在一定程度上
所以你可以用Python和SWIG
或者你可以使用，在这个例子里
像 Java和 JNI
如果你喜欢Go
你可以使用Go和cgo
有很多不同的方式
你可以简化部署
通过使用编译器
因此在接下来的几张幻灯片中
我们将要讨论一些准确的细节
这个tfcompile是如何工作的
我要讲的第一部分
是一个小的配置文件
我们已经说了什么是提供
什么是获取
这是由Google protobuf表达的
如果你对这还没有很熟悉
文件本身是protobuf的文本版本
它看起来像JSON
它实际上非常的复杂

Portuguese: 
Tecnicamente, C também.
De todo modo, você pode
chamar essa função
com esse arquivo de cabeçalho.
Não há motivo para não poder adicionar
um wrapper fino que permitisse
chamar essa função
por meio da linguagem de programação
de sua preferência.
Tudo comporta enlace para C,
até certo ponto.
Você pode usar, então, Python e SWIG
ou, como neste exemplo, Java e JNI.
Ou, se você gostar de Go,
pode usá-lo com cgo.
Há muitas formas diferentes
de simplificar a implantação
usando um compilador.
Os próximos slides tratam dos detalhes
sobre como o tfcompile funciona.
A primeira parte de que vou falar
é que tive um arquivo de configuração
em que dizia quais são
os feeds e os fetches.
Isto está expresso por meio
de protobuf da Google.
Se vocês não conhecem, este arquivo aqui
é a versão de texto do protobuf.
Parece um pouco com JSON.
Não é muito complicado.

Japanese: 
もしくは、技術的には
C 言語と呼ばれるものです。
いずれにしても、このヘッダーファイルを
通じてこの機能を呼び出すことが可能です。
選択したプログラミング言語を通じて、
この機能を呼び出すことが可能な
薄いラッパーを追加できなかった理由は
概念的に見つかりません。
基本的には、全てが C を幾つかの
エクステントに結合するサポートをします。
Python や SWIG、
またこの例で行くと
Java や JNI を
使うことができます。
Go が好きであれば、
Go や cgo を使うことができます。
コンパイラーを使って、
発展ストーリーを簡易化できる
多くの異なる方法が存在します。
次のスライドでは、この tfcompile が
実際にどのように作動するのか
その詳細についてお話ししたいと思います。
最初にお話したいのは、
フィードとフェッチが何かを説明した
少数の環境設定ファイルについてです。
これは Google protobuf 内で
表現されました。
これに精通していなければ、
ファイル自体が protobuf の
テキストバージョンになっています。
JSON のように見えます。
これはそれほど複雑ではありません。

Spanish: 
Técnicamente diría que C también.
Puedes llamar a esta función
a través del archivo header.
No hay razón para que no agreguemos
un wrapper que permita
llamar a esta función 
a través de tu lenguaje
de programación elegido.
Básicamente todo soporta vinculando
a C hasta cierto punto.
Podrías usar Python y SWIG
o podrías usar,
como en este ejemplo, Java y JNI.
O si te gusta Go entonces usar Go y cgo.
Hay muchas maneras
podrías simplificar tu implementación
usando un compilador.
Las próximas diapositivas hablarán
un poco sobre los detalles de cómo
funciona tfcompile.
Lo primero que diré es que
tenía un pequeño archivo de configuración
donde dijimos cuáles son los feeds
y cuáles son los fetches.
Esto se expresa en una especie 
de protobuf de Google.
Si no estás familiarizado con esto,
el archivo
en este momento
es una versión de texto de protobuf.
Algo como JSON.
En realidad, no es muy complicado.

English: 
Or actually, technically,
C as well, I guess.
Either way, you can
call this function
through this header file.
There's no reason
why, conceptually, we
couldn't add a thin
wrapper that allows
you to call this function
now through your programming
language of choice.
Like, basically, everything
supports binding to C
to some extent.
And so you could use,
like, Python and SWIG
or you could use, like, well,
in this example, like, Java
and JNI.
Or if you like Go, right,
you could use Go and cgo.
Like, there's many different
ways where, like, you
could actually simplify
your deployment
story using a compiler.
So the next few slides
are going to talk
a little bit about the
details through exactly
how this tfcompile thing works.
The first part I'm
going to talk about
is, you know, I had a
little configuration
file where we said, what are the
feeds and what are the fetches?
And so this is expressed
in sort of Google protobuf.
So if you're not familiar
with this, the file
itself right now is the text
version of the protobuf.
It looks kind of like JSON.
It's not very
complicated, actually.

Korean: 
사실 엄격히 말하면
제 생각에 C도 있죠
어쨌거나 이 헤더 파일을 통해
이 기능을 불러올 수 있죠
개념적으로 여러분이 선택하는
프로그래밍 언어를 통해
이 기능을 불러 오도록 하는
얇은 래퍼를 더하지 않을
이유는 없습니다
기본적으로 모두가
C로의 바인딩을 어느 정도 지원하죠
따라서 파이썬이나 SWIG
혹은 이 예시에서는 자바나 JNI 등도
사용할 수 있죠
혹은 Go를 좋아하시면
Go와 cgo를 사용할 수 있죠
컴파일러를 사용해서
배치를 실제로 단순화할 수 있는
다양한 방법이 있습니다
다음 슬라이드 몇 장은 정확히
어떻게 tf컴파일이 작동하는지
좀더 자세히 설명하겠습니다
첫 번째 부분은
피드가 무엇이고 페치가 무엇인지에 대해
이야기할 때 작은
컨피겨레이션 파일이 있었죠?
이것은 Google
프로토버프에서 표현됩니다
익숙하시지 않다면
지금 이 파일 자체가
프로토버프의 텍스트 버전입니다
JSON 같아 보이죠
사실 별로 복잡하지 않습니다

Indonesian: 
Atau secara teknis, C juga.
Anda bisa panggil fungsi ini
melalui file header juga.
Tak ada alasan kenapa,
kami tak bisa tambahkan pembungkus tipis
agar Anda bisa memanggil fungsi ini
melalui bahasa pemrograman
yang Anda pilih.
Semua mendukung C secara meluas.
Anda bisa pakai Python dan SWIG
atau Anda bisa pakai,
di contoh ini, Java dan JNI.
Jika Anda suka Go,
Anda bisa pakai Go dan cgo.
Ada banyak cara berbeda,
Anda bisa menyederhanakan
cerita penyebaran menggunakan kompilator.
Slide selanjutnya akan bahas detail
tentang bagaimana cara kerja tfcompile.
Bagian pertama untuk dibicarakan
adalah saya punya file konfigurasi kecil
di mana kami bilang, apa feed-nya
dan apa fetch-nya?
Dan ini diekspresikan
dalam Google protobuf.
Jika Anda tidak familier dengan ini,
filenya sendiri sekarang
adalah versi teks protobuf.
Terlihat seperti JSON.
Tidak terlalu rumit, sebenarnya.

Chinese: 
因此上面的部分有两个提供
请记住，你已经确定了图表的输入
因此，在这个非常简单的例子中
我们有x和y作为我们这张图表的输入
我们告诉编译器具体的形状是什么
这是一个很好的要点，需要再次强调
克里斯提到TensorFlow
非常的灵活
可以让你非常容易并快速的完成所有的任务
但对编译器来说
如果可以专业化，就更好了
这是你可以得到的一个好处
如果你可以根据你的具体尺寸专业化
所以在这里，你添入图表中的任何输入
你可以准确的告诉它
我们要用的准确的尺寸
类似的，有了提供
我们在这里也有获取
对于获取，你基本上确定
你要用哪个节点作为
你生成的函数输出
在这个例子中，你不需要在指明形状
事实上，你不能因为给出的输入形状

Spanish: 
Esta parte superior tiene dos feeds.
Recuerda, estamos identificando 
los inputs en el gráfico.
En este ejemplo simple
tenemos que X e Y son los inputs
en este gráfico.
Y le decimos al compilador
exactamente cuáles son las formas.
Este es un buen punto para volver
a enfatizar.
Chris mencionó que TensorFlow
tiene muchísima flexibilidad
y te permite hacer
cosas muy rápido y fácil.
Para los compiladores
es mejor si se puede especializar.
Ese es uno de los beneficios
que obtienes, si te especializas sabiendo
los tamaños exactos.
Para cualquiera de los inputs
que entran en tu gráfico,
le dices con exactitud
los tamaños exactos que vamos a utilizar.
Así como para el feed,
tenemos el fetch aquí.
Y para ellos solo identificamos
qué nodo o nodos deseas
como outputs de la función
que vas a generar.
En este caso, no es necesario
especificar la forma.
De hecho, no se puede, 
al dar las formas de inputs

Japanese: 
この上部には２つのフィードがあります。
グラフ内にインプットがあることを
確認して下さい。
この特殊で簡単な例の中では、
x と y がこのグラフ内で
インプットになります。
そしてコンパイラーにどのような
シェイプなのかを正確に伝えます。
ここは再び強調したいポイントです。
クリスが言及したように、
TensorFlow にはこの並外れた
柔軟性が備わっており、非常に容易に
そして迅速に作業することができます。
しかしコンパイラーに対しては、
特定することができれば良策です。
正確なサイズに基づいて、
特定することができれば
恩恵を受けることができます。
グラフ内に入ってくるインプットについては、
使用する予定の正確なサイズを伝えます。
同様に、フィードと同様に
フェッチがあります。
フェッチについては、
生成した機能のアウトプットとして
ノードもしくは複数のノードを
基本的に特定します。
このケースにおいては、シェイプをこれ以上
特定する必要はありません。
事実、特定できません。
なぜなら、インプットシェイプを
与えることによって

Portuguese: 
A parte superior tem dois feeds.
Lembre que estamos
identificando as entradas no grafo.
Neste exemplo simples,
temos "x" e "y"
que são as entradas no grafo.
E informamos ao compilador
os formatos exatamente.
É importante enfatizar, certo?
Como o Chris mencionou, o TensorFlow
tem uma flexibilidade extrema
e permite fazer as coisas
fácil e rapidamente.
Mas para os compiladores,
é melhor se especialização for possível.
Este é um dos benefícios.
Se puder especializar
com base nos tamanhos exatos.
Para qualquer entrada inserida no grafo,
informa-se exatamente
os tamanhos que serão usados.
Semelhante ao feed, temos o fetch.
Para o fetch, identifica-se quais nódulos
serão as saídas da função que será gerada.
Neste caso, não é necessário
especificar o formato.
Na verdade, não é possível,
porque com os formatos das entradas

Korean: 
이 상단 부분은 두 개의 피드가 있죠
인풋을 그래프로 식별하고
있다는 사실 기억하시죠?
이 단순한 예시에서는
이 그래프에서 x와 y가
인풋이 되었습니다
그리고 우리가 컴파일러에게
어떤 모양인지 정확히 말해 줄 겁니다
다시 강조하기 좋은 시점이죠
크리스가 텐서플로우는
굉장히 융통성 있다고
언급했었죠
정말 쉽고 빨리 일 처리를
할 수 있게 하죠
하지만 컴파일러의 경우
특별화할 수 있다면 훨씬 좋죠
여러분이 얻는 혜택인거죠
여러분이 가진 정확한 크기에
기초해서 특별화할 수
있다면 말이죠
그래프로 오는 어떠한 인풋의 경우에도
정확히 말해 주셔야 합니다
우리가 사용할 크기는
정확히 이 크기다, 하고 말이죠
피드의 경우도 마찬가지로
여기 페치가 있죠
페치의 경우 기본적으로 어떤 노드
혹은 여러분이 만들어 낼
기능의 아웃풋으로써
원하는 노드를 식별하면 됩니다
이 경우 더이상 모양을
구체화할 필요는 없죠
사실 그렇게 할 수 없죠
인풋 모양을 정한다면

English: 
So this top part
has, like, two feeds.
And remember, we're identifying
the inputs into the graph,
right?
So in this particular
simple example,
we've got, like, x and y happen
to be our inputs in this graph.
And we tell the compiler
exactly what the shapes are.
This is a good point
to reemphasize, right?
Like, Chris had mentioned
sort of TensorFlow
has this extreme
flexibility, where it really
allows you to do stuff
very easily and quickly.
But for compilers, it's much
better if you can specialize,
right?
That's one of the
benefits that you
get, if you can specialize
based on the exact sizes
that you have.
And so here for
any of the inputs
that come into your graph,
you tell it exactly,
like, here's the exact sizes
that we're going to use.
Similarly, for as the feeds,
we've got the fetch here.
And for the fetch, you
basically just identify
which node or nodes you want
as outputs of the function
that you're going to generate.
In this case, you don't have
to specify the shape anymore.
In fact, you can't, just
because given the input shapes,

Indonesian: 
Bagian atas ini punya dua feed.
Ingat, kita mengidentifikasi
input ke grafik.
Dalam contoh sederhana ini,
kita punya x dan y
yang jadi input grafik ini.
Dan beri tahu kompilator
tepatnya, apa bentuknya.
Ini hal bagus untuk ditegaskan lagi.
Chris bilang TensorFlow punya
fleksibilitas ekstrim ini
yang memungkinkan Anda melakukan hal
dengan mudah dan cepat.
Tapi kompilator akan lebih baik
jika Anda bisa mengkhususkannya.
Itu manfaat yang Anda dapat
jika bisa mengkhususkan
berdasarkan ukuran tepat
yang Anda punya.
Jadi untuk input apa pun
yang masuk ke grafik Anda,
beri tahu tepatnya
ukuran tepat yang akan digunakan.
Sama dengan feed,
kita punya fetch di sini.
Untuk fetch, Anda hanya perlu identifikasi
mana node yang dijadikan output
dari fungsi yang ingin Anda hasilkan.
Di kasus ini, Anda tak perlu
menyebutkan ukuran.
Sebenarnya tak bisa,
karena dari ukuran input

Chinese: 
我们可以推断出输出形状是什么
通过所有的图表
所以这基本上
运行这个编译器时
是唯一你需要的配置文件
我们要说的下一步是
你如何能够调用的指令
我现在有了这个配置文件
我有了我的图表
那我要如何开始呢？
我在这里要使用的例子是
当你使用Bazel
基本上通过Bazel
我们创建了一个Bazel宏模块
它就像是糖衣语法
用来启动整个程序
我们介绍了这个概念称为tf_library
它非常的简单
你基本上只是给予了它三部分信息
这个我们刚刚已经说过了
第一部分是图表
你把图表变成protobuf形式
第二部分提供和获取
这是一个配置文件
就是我们刚刚展示的内容
非常简单 这是提供 那是获取
这是提供的大小
第三个信息是C++分类名

Spanish: 
ya podemos inferir
cuál es la forma del output
a través del gráfico.
Esta es básicamente la única pieza
de configuración
que necesitarás para ejecutar
este compilador.
El siguiente paso se trata
de cómo convocarlo.
Tengo este archivo de configuración.
Tengo mi gráfica.
¿Cómo lo inicio?
El ejemplo que presentaré aquí
es cuando se utiliza Bazel.
A través de Bazel
creamos un macro de construcción Bazel
que es como azúcar sintética
para iniciar el proceso.
Introdujimos esta noción
llamada tf_library
y es bastante simple.
Solo le darás tres piezas básicas
de información y se trata
de las que ya hemos mencionado.
El primero es el gráfico.
Le das el gráfico en forma protobuf.
La segunda pieza son los feeds y fetches.
Es un archivo de configuración.
Eso fue lo que acabo de mostrar.
Es simple, aquí están los feeds
y aquí los fetches
y este es el tamaño de ellos.
La tercera pieza es el nombre 
de la clase C++.

Korean: 
그래프까지 아웃풋에서 모양이 무엇인지
추론할 수 있기 때문이죠
따라서 이 컴파일러를
실제로 실행하기 위해
필요한 유일한
컨피겨레이션인 겁니다
다음으로 언급할 내용은
실제로 어떻게 호출하는가 입니다
이 컨피겨레이션 파일이 있죠
그래프도 있죠
어떻게 시작할까요?
여기서 제가 제시할 예시는
Bazel을 사용할 경우입니다
기본적으로 Bazel을 통해서
Bazel 빌드 매크로를 만들었죠
이 전체를 시작하기 위한
합성 설탕 같은 겁니다
tf_라이브러리라는
개념을 소개한 적 있죠
아주 간단합니다
기본적으로 세 가지 주요 정보를 줍니다
이미 말씀 드린 것들이죠
첫 번째는 그래프이죠
그래프를 프로토버프 형태로 주는 겁니다
두 번째는 피드와 패치입니다
이건 컨피겨레이션 파일이죠
제가 보여 드리고 싶었던 것입니다
간단하죠. 여기는 피드
저기는 패치가 있고
여기는 피드 크기가 있죠
여기 세 번째는
C++ 클래스 이름이 있죠

English: 
we can sort of infer what
the shape is at the output
all the way through the graph.
And so this is
basically the only sort
of piece of
configuration that you're
going to need to actually
run this compiler.
The next step is going
to talk about, well,
how do you actually
invoke the thing, right?
So I've got this
configuration file.
I've got my graph.
How do I kick it off?
And so the example I'm
going to present here
is when you use Bazel.
So basically,
through Bazel, we've
created a Bazel
build macro, which
is just like syntactic sugar
to kick off the whole thing.
We've introduced this one
notion called tf_library
and it's pretty simple.
You're basically just giving
it, like, three main pieces
of information and it's the
ones we've just already talked
about.
The first one is
the graph, right?
You sort of give it the
graph in protobuf form.
The second one is the
feeds and fetches.
This is a configuration file.
That was that thing
that I just showed.
You know, simple, like, here's
the feeds, here's the fetches,
here's the size of the feeds.
And the third thing here is
the C++ class name, right?

Indonesian: 
kita bisa simpulkan berapa ukuran output
sepanjang grafik.
Pada dasarnya, inilah
satu-satunya konfigurasi
yang akan Anda butuhkan
untuk menjalankan kompilator ini.
Langkah selanjutnya akan bicarakan
cara memanggil sesuatu.
Saya punya file konfigurasi ini.
Saya punya grafik.
Bagaimana cara mulainya?
Contoh yang akan saya tampilkan di sini
adalah saat Anda menggunakan Bazel.
Melalui Bazel, kami telah membuat Bazel
berukuran makro, yang mana
merupakan sintaksis
untuk memulai semuanya.
Kami telah perkenalkan gagasan
yang disebut tf_library
dan itu cukup sederhana.
Anda sebenarnya memberikan
tiga bagian utama
dari informasi dan itu
yang telah kita bicarakan.
Yang pertama adalah grafik.
Memberikan grafik dalam bentuk protobuf.
Kedua adalah feed dan fetch.
Ini file konfigurasi.
Itu hal yang baru saya perlihatkan.
Sederhana. Ini feed, ini fetch.
Ini ukuran feed.
Yang ketiga adalah nama kelas C++.

Portuguese: 
inferimos qual será o formato
da saída ao final do grafo.
Essa é a única configuração necessária
para executar o compilador.
No próximo passo, falaremos sobre
como é possível invocar.
Tenho este arquivo de configuração.
Tenho meu grafo.
Como eu inicio?
No exemplo que vou apresentar,
é usando a Bazel.
Por meio da Bazel, criamos um macro,
que é como o açúcar sintático
para dar o pontapé inicial.
Introduzimos uma noção chamada
tf_library e é bem simples.
Você basicamente dá
três informações principais
que são as quais já mencionamos.
A primeira é o grafo, certo?
Você informa o grafo em profobuf.
A segunda são os feeds e fetches.
É um arquivo de configuração,
aquele que acabei de mostrar.
Algo simples,
"aqui estão os feeds e fetches
e os tamanhos dos feeds".
A terceira é o nome da classe no C++.

Japanese: 
全てのグラフを通じて、アウトプット時に
どのシェイプかを推測できるからです。
これは、このコンパイラーを
作動させるために必要な
環境設定の一部になります。
次のステップでは、どのように呼び出しを
実行するかをお話しします。
この環境設定ファイルを手に入れ、
グラフも手に入れました。
どのように始めればいいのでしょうか。
ここで紹介したいのは、
Bazel を使用する時についてです。
基本的には、Bazel を通じて
Bazel ビルドマクロを作りました。
あらゆることを開始するための、
シンタックの砂糖みたいなものです。
tf_library と呼ばれる、
この１つの概念を導入しました。
それはかなりシンプルなもので、
基本的に３つの主要な情報を与えました。
それらについては既にお話しました。
１番目はグラフです。
グラフを protobuf フォームに
与えました。
２番目はフィードとフェッチです。
これは環境設定ファイルであり、
すでにお見せしました。
シンプルで、ここにフィードがあり、フェッチがあり、
フィードのサイズがあります。
３番目は、C++ クラスネームです。

Korean: 
이는 C++ 헤더에서 만들어질
클래스 이름으로 계산을 호출할 수 있게
해주는 겁니다
주목할 점은 오픈 소스 세상에서
저도 이런 경험을 하죠
Bazel을 사용하는
사람들이 별로 없다는 겁니다
실제로 Bazel을 사용하지 않는다고
전부 다 잃어버리는 건 아닙니다
tf컴파일 도구는 명령라인에서
실행할 수 있는 겁니다
기본적으로 제가 방금 설명한
이 컨피겨레이션 옵션은
도구로 패스할 수 있는
플래그인 겁니다
게다가 아웃풋 오브젝트 라인의 위치와
아웃풋 파일을 어디로
가게 하고 싶은가를
여러분이 지정할 수 있습니다
이게 다입니다
여러분이 가진 어떠한 빌드 시스템으로도
쉽게 통합되도록
만들고자 노력했습니다
한 가지 덧붙이자면
커뮤니티의 도움이 많이
필요한 곳이기도 합니다
사람들이 가지고 있는 빌드 환경이
너무 다양하니까 말이죠
Make나 CMake 등
이러한 것들이 많습니다
이 통합으로 실제로 더하기에

Indonesian: 
Ini nama kelas yang akan dihasilkan
untuk Anda
di header C++, yang memungkinkan
Anda memanggil komputasi.
Hal yang perlu diingat,
di dunia sumber terbuka
maksud saya, saya juga mengalaminya.
Tak banyak orang pakai Bazel.
Jika Anda tidak memakai Bazel,
tak ada ruginya, 'kan?
Contohnya alat tfcompile
bisa Anda jalankan di baris perintah.
Pada dasarnya, opsi konfigurasi
yang baru saya jelaskan adalah tanda
yang Anda serahkan pada alat.
Anda juga bisa beri tahu
di mana Anda ingin file objek output
dan ke mana output akan pergi.
Itu saja.
Kami mencoba mempermudah integrasinya
ke dalam sistem pembangunan
yang Anda punya.
Penting diperhatikan bahwa
ini tempat di mana akan bagus
jika ada banyak bantuan komunitas,
karena ada jumlah mencengangkan
berbagai lingkungan pembangunan
yang dimiliki orang, seperti Make, CMake.
Ada banyak hal ini.
Harusnya cukup sederhana
menambahkan dalam integrasi itu.

Portuguese: 
É o nome da classe
que será gerada no cabeçalho C++
e que possibilitará invocar a computação.
Uma coisa a se notar
é que no mundo dos códigos abertos,
eu também sinto isso,
poucas pessoas usam Bazel.
Se vocês não usam Bazel,
nem tudo está perdido.
A ferramenta tfcompile
é algo que pode ser executado
na linha de comando.
E as opções de configuração que mencionei
são as flags que você informa
à ferramenta.
Além disso, você pode informar
onde deseja o arquivo objeto de saída
e para onde deseja que o cabeçalho vá.
E isso é tudo.
Tentamos fazer com que isso
fosse facilmente integrado
a qualquer sistema de criação.
Este é outro ponto
em que a ajuda da comunidade
seria muito boa, porque há
uma quantidade enorme
de ambientes de criação,
como Make e CMake.
Tem um monte dessas coisas.
Então seria relativamente fácil
adicionar essa integração.

Chinese: 
所以这是在C++标题中为你生成的分类名
它会为你调用运算
现在要注意的一点是
在开源的世界中
我也要体验它
并没有很多人使用Bazel
所以如果你不用Bazel
也不会丢失所有的信息
比如tfcompile工具
就是你可以运行的命令栏
基本上，这些配置选项
比如我刚刚描述的
添加到工具上的标签
除此以外，你可以告诉它
我想把我的输出文件放在哪
我想要把输出文件储存在哪
就是这样
因此，我试图把这个简单的集成为
你有的构建系统
只是要注意
这是另一个需要社群帮助的地方
因为人们使用的构建环境
真的是各种各样
比如Make，CMake
有很多诸如此类的东西
因此把它添加到集成中

English: 
And so this is the class name
that will be generated for you
in that C++ header, which
will allow you to invoke
the computation.
Now, one thing to note, I know,
like, in the open source world,
I mean, I experience
this, too, right?
Like, not that many
people use Bazel.
And so if you don't actually use
Bazel, all is not lost, right?
Like the tfcompile
tool is just something
you can run the command line.
And basically, like, these
configuration options
that I just described
are the flags
that you pass into the tool.
And in addition, you
can tell it where
do I want my output
object file and where
do I want my output file to go.
And that's about it.
So we tried to make this
sort of easily integratable
into whatever build
system you have.
Just a note on that,
it's like, this
is another place where
lots of community help
would be great, because
there's, like, an astounding
number of different build
environments that people have,
like Make, CMake.
There's, like, a whole
bunch of these things.
So it should be relatively
simple to actually add

Spanish: 
Este es el nombre de clase 
que se generará para ti
en ese header de C++,
que te permitirá invocar el cálculo.
Algo que recordar
en el mundo de código abierto
que yo también experimento
es que no mucha gente usa Bazel.
Y si no usas Bazel, no todo está perdido.
Como la herramienta tfcompile, 
es para ejecutar la línea de comando.
Y al igual que estas opciones 
de configuración
que describí son las etiquetas
que pasas a la herramienta.
Además puedes decir dónde quieres
tu archivo de objetos output
y para dónde quieres que vayan.
Y eso es todo.
Intentamos hacer algo 
fácilmente integrable
a cualquier sistema de construcción.
Una nota de esto
es que este es otro lugar
donde mucha ayuda de la comunidad
sería genial 
porque hay un número sorprendente
de diferentes entornos de construcción
como Make o CMake.
Hay muchísimos de estos.
Entonces debería ser relativamente fácil
añadir en esa integración.

Japanese: 
これは C++ ヘッダー内に生成される
クラスネームで、
これで算定を呼び出すことができます。
１つお伝えしたいのは、
オープンスペース世界で
私も経験がありますが
多くの方が Bazel を使っている
わけではありません。
Bazel を使わなくても、
損失にはなりません。
tfcompile ツールが、コマンド行を
動かすものであることと同じです。
説明したこれらの環境設定オプションは、
ツール内にパスするフラッグです。
加えて、アウトプットオブジェクトファイルを
どこに置きたいか
またアウトプットフィルをどこに送りたいかを
指示することができます。
それだけです。
これを簡単にどのようなビルドシステムにも
統合可能なものに変えようとしています。
これは、多くのコミュニティヘルプが
貴重なものとなる別の場所です。
Make や CMake のような著しい数の
異なるビルド動作環境があるからです。
これらの集合体が存在します。
そのインテグレーション内の add に対して、
相対的にシンプルである必要があります。

Spanish: 
Aquí es como si hubiera mucho código.
Sé que están perplejos.
Intentaré describirlo
de una manera directa.
Aquí tratamos de describir
la manera sencilla para invocar
el cálculo que acabamos de describir.
Es código C++, porque esa es la clase 
del lenguaje que nosotros
soportamos en este momento.
En la parte superior incluyes
el header generado.
Esto es lo que se generó automáticamente
para que invoques el cálculo.
En esta línea instanciamos
esta clase, este TestMatMul.
Esa fue la clase
que se describió, definida
dentro del header generado.
Ahora tenemos esta variable MatMul.
Si miras las diapositivas
Matmul, esa instancia
es lo que utilizaremos durante esto.
En el siguiente paso configuramos
los argumentos para ejecutar este cálculo.
Este cálculo particular lo vamos a asumir
como una multiplicación de matrices.
Todo este código solo es una forma...

Chinese: 
应该是相对简单的
好了，这里有很多的代码
并且我知道，人们的眼界也很高
因此我想要以一种直白的方式
来描述它
所以我们想再这里描述的是
你可以使用的简单的方法
来调用我们刚刚描述的运算
这是C++代码
这是我们目前支持的程序语言
在顶端，可以包括
你的生产标题
这是为你自动生成的
来调用运算
在这一栏中，我们实例化这个TestMatMul
这是我们描述的类别
在生成的标题中定义
我们已经获取了这个MatMul变量
所以如果你看幻灯片
基本上，matmul，在这个例子中
是我们一直要用的
下一步就是要设置的是
实际运行的参数
这个特定的运算
假设是一个矩阵乘法
因此，所有的编码都很花哨

Japanese: 
ここには大量のコードがあり、
人々の目はかすんでいるようです。
率直な方法で、これを説明したいと思います。
ここで説明したいことは、
今説明した、算定を呼び出す
簡単な方法についてです。
これは C++ コードです、これは現在
サポートしている言語の１つです。
上部では、生成されたヘッダーを
取り込みます。
これは算定を呼び出すために
自動的に生成されたものになります。
この行では、このクラス、
つまりこの TestMatMul を例示します。
それは、説明され生成されたヘッダー内で
定義されたクラスとなります。
今、この matmul バリアブルがあります。
スライドを通して見ると、
基本的には、matmul、
そのインスタンスは
私達が至る所で使おうとしているものです。
次のステップは、実際にこの算定を
作動させる引数をセットします。
これから遂行しようとする
特殊な算定は、配列乗算になります。
このコード全ては、まさに高度であり

English: 
in that integration.
OK, so here it's sort of like
there's a whole bunch of code.
And I know, like, people's
eyes are sort of glazing over
and stuff.
So I'm going to, like, just
try to describe this in sort
of like a straightforward way.
And so what we're
trying to describe here
is, like, the simple way
that you can actually
invoke the computation
that we've just described.
This is C++ code, because that's
sort of the language that we
currently support.
And at the top, you
sort of include,
well, your generated header.
This is the thing that was
automatically generated for you
to invoke the computation.
And on this line, we instantiate
this class, this TestMatMul.
That was the class that's
described, defined inside
of that generated header.
And note, we've got this
MatMul variable now.
So if you look
through the slide,
basically, matmul,
that instance is, like,
what we're going
to use throughout.
The next step is a to set up
the arguments to actually run
this computation.
This particular computation
we're going to assume
is, like, a matrix
multiplication.
And so all of this code is
really just a fancy-- you know,

Indonesian: 
Terlihat banyak kode di sini.
Mata Anda mungkin menjadi
berkaca-kaca membacanya.
Saya akan coba mendeskripsikannya
secara sederhana.
Yang kami coba jelaskan di sini
cara sederhana Anda bisa memanggil
komputasi yang baru kita jelaskan.
Ini kode C++, karena itu bahasa
yang kami dukung saat ini.
Yang penting, Anda memasukkan
header yang dihasilkan Anda.
Ini hal yang secara otomatis
dihasilkan untuk Anda
untuk memicu komputasi.
Di baris ini, kami beri contoh
kelas ini, TestMatMul.
Itu adalah kelas yang dideskripsikan,
didefinisi
di dalam header yang dihasilkan.
Kami juga punya variabel matmul sekarang.
Jika Anda lihat slidenya,
secara singkatnya
matmul adalah apa yang akan
kita pakai seterusnya.
Selanjutnya mengatur argumen
untuk menjalankan komputasi ini.
Komputasi ini kita asumsikan
seperti perkalian matriks.

Korean: 
상대적으로 쉬울 겁니다
여기 코드가 아주 많이 있죠
사람들의 눈이 피곤해 지는 것이 보이죠
복잡하지 않은 방식으로
설명해 보겠습니다
여기에서 설명하고자 하는 것은
우리가 방금 설명한 계산을
실제로 호출할 수 있는
간단한 방법입니다
이것은 C++ 코드입니다
저희가 현재 지원하는
언어이니까 말이죠
상단에는 생성된 헤더를
포함하고 있죠
계산을 호출하기 위해 자동으로
만들어진 겁니다
이 라인에서는 이 TestMatMul을
예시로 보이고 있습니다
생성된 헤더의 내부에서
설명되고 정의 내려진
클래스입니다
이제 MatMul 변수가 있죠
슬라이드를 훑어 보시면
기본적으로 matmul을
계속해서 사용할 겁니다
다음 단계는 이 계산을 실제로
실행하기 위한 아규먼트를
설정하는 겁니다
저희가 가정할 이 특정 계산은
행렬 곱셈입니다
이 모든 코드가 그냥
멋있는 척 하는 겁니다

Portuguese: 
Aqui temos um monte de código.
Sei que vocês devem estar ficando tontos,
então vou tentar descrever
de um jeito simples.
O que tentamos descrever aqui
é um jeito simples de invocar
a computação que acabamos de descrever.
Esse código é em C++,
porque é a linguagem que comportamos.
No topo, está inserido o cabeçalho gerado.
É a coisa que foi gerada automaticamente
para se poder invocar a computação.
Nesta linha, instanciamos
esta classe, o TestMatMul.
É a classe descrita e definida
dentro do cabeçalho gerado.
Note que agora temos uma variável MatMul.
Se olharem o slide,
a instância matmul será usada
daqui em diante.
O próximo passo é estabelecer
os argumentos para executar a computação.
Para esta computação,
vamos supor que seja
uma multiplicação matricial.
Todo esse código é apenas
uma maneira rebuscada,

Indonesian: 
Semua kode ini hanyalah fantasi,
beginilah di C++.
Anda bilang argumen pertama saya
adalah angka 1 hingga 6
dan argumen kedua adalah 7 sampai 12.
Anda panggil ini dengan matmul.Run.
Ini memicu komputasi apa pun
yang Anda punya di grafik Anda.
Pada akhirnya, Anda bisa ambil hasil
dari objek matmul.
Semoga ini memberi Anda gambaran
seberapa sederhana hal ini.
Anda bisa ambil model kompleks apa pun
yang Anda punya dan masukkan ke fungsi
yang bisa Anda panggil.
Untuk meringkas, kita telah bahas
subdirektori kompilator
di bawah TensorFlow, yaitu XLA.
Ini kompilator, c ke XLA, yang mana
melakukan transformasi TensorFlow ke XLA.
JIT, yaitu tepat waktu
dan AOT, yaitu lebih cepat.
Sekarang saya akan presentasikan
beberapa hasil.
Hal yang perlu diingat adalah
ketika Megan bicara

Chinese: 
这就是如何在C++中
你说我的第一个参数是数字1到6
我的第二个参数是数字7到12
然后你把它叫做matmul.Run
基本上，这可以调用
你图表中的任何计算
最后，你可以提取
matmul对象的结果
希望这个示例让你知道
这是多么简单
你可以使用任何复杂的模型
把它简化为一个函数
你可以调用的函数
让我们回顾一下
我们已经描述了TensorFlow下的
编译器子目录，也就是XLA
这是一个编译器，将c转化为XLA
它让TensorFlow转化为XLA
JIT，是即时编译
以及AOT，是提前编译
现在我要展示一些结果
在这里需要注意的是
当梅根说到一些很酷的

Korean: 
C++에서 첫 아규먼트는
숫자 1에서 6까지이고
두 번째는 숫자 7에서 12라고
하는 거죠
matmul.Run이라고
불리는 것을 불러 오겠습니다
기본적으로 그래프에 있는
계산이 무엇이든
호출해 오는 것이죠
결국에는 matmul 오브젝트의 결과를
가져 올 수 있는 겁니다
이를 통해 이것이 얼마나 간단한가를
여러분들이 알 수 있길 바랍니다
어떠한 애매모호한
복잡한 모델이 있더라도
그저 불러올 수 있는 기능으로
요약되는 것이죠
따라서 요약컨대 텐서플로우 하의
컴파일러 서브디렉토리를
언급했죠, 이는 XLA가 있고
컴파일러이죠
그리고 tf에서 XLA가 있죠
텐서플로우를 XLA로 변형시키죠
JIT, 즉 저스트인타임
AOT, 즉 어헤드오브타임을 언급했죠
그럼 이제 결과물을 보여 드리죠
주목할 점은
메건이 저희가 이룬 멋진

Spanish: 
es cómo en C++, 
dices que tu primer argumento
serán los números 1 al 6
y el segundo argumento
del 7 al 12.
Luego invocas a esto llamado matmul.Run.
Básicamente eso invoca cualquier cálculo
que tenías en tu gráfico.
Y al final, puedes sacar los resultados
del objeto matmul.
Espero que esto te dé una idea
de lo simple que realmente es.
Puedes tomar cualquier modelo
arbitrariamente complejo
que tengas y llevarlo a una función
que puedas invocar.
Para recapitular, ya hablamos
del subdirectorio de compilación
bajo TensorFlow, que tiene XLA
este es el compilador, c a XLA
que hace la conversión de TensorFlow a XLA
JIT que es justo a tiempo
y AOT que es por adelantado.
Ahora voy a presentar algunos resultados.
Algo que recordar es que cuando
Megan habló de los resultados

Portuguese: 
é assim em C++,
de dizer que o primeiro argumento
serão os números de um a seis
e o segundo, os números de 7 a 12.
E então chamamos isso, o matmul.Run.
Isso invoca qualquer computação
que exista no seu grafo.
No final, você pode pegar
os resultados do objeto MatMul.
Espero que isso dê uma ideia
de como é simples.
É possível pegar qualquer modelo
arbitrariamente complexo
e reduzir a uma função
que pode ser chamada.
Recapitulando, falamos
do subdiretório do compilador
no TensorFlow que tem XLA,
este é o compilador,
TF para XLA, que transforma
TensorFlow em XLA.
O JIT, que é o just-in-time,
e o AOT, ahead-of-time.
Agora vou apresentar alguns resultados.
Uma coisa a se notar
é que quando Megan falava

Japanese: 
これは C++ 内で
最初の引数は1 から 6 とし、
２番目の引数は 7 から12 にすると
指示しています。
これを matmul.Run. と呼びます。
基本的には、グラフ内のいかなる算定も
呼び出します。
最後に、matmul オブジェクトから
結果を取り出すことができます。
願わくば、それが実際にシンプルであるという
印象を与えます。
持っているどんな恣意的な
複合モデルでも取ることが可能であり、
呼び出すことのできる機能に
要約することができます。
要約するために、
XLA を持つ TensorFlow 下の
サブダイレクトリコンパイラーを
カバーしました。
c to XLA というコンパイラーは、
TensorFlow を XLA 用に変換します。
ジャストインタイムである JIT、
アヘッドオブタイムである AOT も
含まれます。
幾つかの結果を紹介します。
ここで注目して頂きたいのが、

English: 
this is how in C++, you say
that my first argument is going
to be the numbers 1 to 6 and my
second argument's going to be
the numbers 7 to 12.
And then you call this one
thing called matmul.Run.
And basically, that's
invoking whatever computation
you had in your graph.
And at the end, you can
grab the results out
of the matmul object.
And so hopefully this gives
you a sense for, like, kind
of how simple it really is.
You can take whatever
arbitrarily complex model
that you have and boil
it down to a function
that you can just call.
And so to recap, we've
covered sort of the compiler
subdirectory under TensorFlow,
which has XLA, right,
this is the compiler,
c to XLA, which
does the TensorFlow
to XLA transformation,
the JIT, which is
the just-in-time,
and AOT, which is ahead-of-time.
And so now I'm going to
present some results.
So one thing to note
here is that when
Megan was talking
about some of the cool,

Portuguese: 
de alguns resultados maravilhosos
de desempenho que tivemos,
nada disso incluía o XLA.
O primeiro slide
que mostrarei trata do JIT.
Ao usar JIT para modelos diferentes
executados em GPU,
qual é o ganho de velocidade?
A maneira de ler isto,
cada linha representa
um modelo específico que executamos.
Os números do gráfico descrevem
a aceleração ou a desaceleração.
Para cada linha,
executamos o modelo específico
de duas maneiras.
Executamos uma vez
usando TensorFlow normalmente.
E uma outra com o XLA habilitado,
com o JIT habilitado.
A flag do JIT vai compilar
e, espera-se, acelerar as coisas.
O que se vê é que tudo em verde
são números positivos.
A ideia por trás deste slide
é que "mais rápido é melhor".
O conjunto de modelos aqui,
nós ligamos para eles.

Chinese: 
非常棒的我们有的性能结果
实际上没有包括 XLA，对吗？
所以我要展示的第一张幻灯片是关于JIT的
当你使用JIT在GPU上运行不同的模型时
速度是什么呢？
我们阅读的方式是
每一行都是我们运行的特定模型
以及图像上数字的描述
加速和减速是多少？
所以从本质上说，每一行
我们有两种方式运行这种特殊的模型
我们已经使用正常的TensorFlow运行过一次
我们现在在激活XLA后，再运行一次
并使用 JIT标签
JIT标签将会编译所有信息
让一切变的更快
所以你在这里看到的是
基本上所有的绿色，都是正数
所以这张幻灯片的重点是
越快越好
我们这里有的模型集合
是我们真正关心的事

Korean: 
성능 결과에 대해 이야기했을 때
그중 어떠한 것도
XLA를 포함하진 않았죠
첫 슬라이드는 JIT에 관한 것 입니다
GPU에서 실행되는 다른 모델을 위한
JIT 사용 시 가속도는 뭘까요?
이것을 읽는 방법은 각 열이
저희가 실행한 특정 모델인 겁니다
차트에 있는 숫자는 가속인지
감소인지를 나타내죠
본질적으로 각 열의 경우
이 특정 모델을
두 방식으로 실행했습니다
일반 텐서플로우만을
사용해서 한번 실행했습니다
그리고 XLA과 JIT 플래그를
가능하도록 한 후
또 한번 실행했죠
JIT 플래그는 컴파일하게 해주고
속도를 빠르게 해 주길 바라는 거죠
여기에서 보고 계시는 것은
기본적으로 모든 녹색은 양수입니다
이 슬라이드의 요점은 더 빠른 것이
더 낫다는 거죠
그리고 여기 있는 모델 컬렉션은
저희가 실제로 정말 좋아하는 모델입니다

English: 
you know, the awesome
performance results
that we've had, none of that was
actually including XLA, right?
So the first slide I'm
going to show is on JIT.
And when you use JIT for
different models running
on GPU, what is the speed up?
And so the way to read
this is that each row is
one particular model
that we've run.
And the numbers on the chart
are describing, well, what's
the speed up or slow down?
So in essence, for
each row, we've
run this particular
model two ways.
We've run it once using
just normal TensorFlow.
And we've run it another
time with XLA enabled,
with that JIT flag enabled.
And the JIT flag is
going to compile things
down and hopefully
make things faster.
And so what you're
seeing here is
that basically all of the green
stuff is positive numbers.
And so kind of the whole point
in this slide is, well, faster
is better.
And the collection of models
that we actually have here
are sort of things that
we actually do care about.

Indonesian: 
soal hasil kinerja yang keren
dan luar biasa
yang kita punya, tak ada
yang termasuk untuk XLA.
Slide pertama yang akan saya tunjukkan
adalah tentang JIT.
Saat Anda gunakan JIT
untuk model berbeda yang dijalankan
pada GPU, berapa percepatannya?
Cara membacanya adalah tiap baris mewakili
satu model tertentu yang kita jalankan.
Angka pada grafik mendeskripsikan
berapa percepatan atau perlambatan.
Intinya, tiap baris, kita telah jalankan
model ini dengan dua cara.
Kita telah jalankan
dengan TensorFlow normal.
Kita juga telah jalankan
dengan mengaktifkan XLA
dan dengan aktifkan tanda JIT.
Tanda JIT akan mengompilasi semua
dengan harapan membuatnya lebih cepat.
Yang Anda lihat di sini sebenarnya
adalah semua yang berwarna hijau
adalah nomor positif.
Inti slidenya adalah,
lebih cepat lebih baik.
Koleksi model yang kami punya di sini
adalah hal yang paling kami pedulikan.

Spanish: 
impresionantes de rendimiento
que tuvimos, 
nada de eso estaba incluyendo XLA.
La primera diapositiva
que mostraré está en JIT.
Y cuando se utiliza JIT 
para diferentes modelos en ejecución
en GPU, ¿cuál es la rapidez?
La manera de entender
esto es que cada fila
es un modelo particular
que hemos ejecutado.
Y los números en la tabla describen
si aumenta la velocidad
o si disminuye.
Así que en esencia, para cada fila
ejecutamos este modelo 
en particular de dos maneras.
Ya lo ejecutamos una vez usando
TensorFlow normal.
Y lo hemos ejecutado
otra vez con XLA habilitado
con ese indicador JIT habilitado.
La etiqueta JIT compilará
y con suerte hará
las cosas con más rapidez.
Lo que ves aquí
es que todo lo verde 
son números positivos.
Lo principal en esta diapositiva es que
más rápido es mejor.
Y la colección de modelos que tenemos aquí
son cosas que realmente nos importan.

Japanese: 
メガンが、素晴しい並外れた
パフォーマンス結果について話しましたが
そこに XLA は全く含まれて
いませんでした。
最初にお見せするスライドは、
JIT についてです。
GPU を作動する異なるモデル用に
JIT を使っている時、
高速化はどうでしょうか。
これを読み取る方法として、各々の行は
作動する１つの特殊なモデルとなっています。
チャート上の数字は、スピードアップもしくは
スローダウンについて説明しています。
本質的に、各々の行に対して
この特殊なモデルを２方向で作動しています。
一度、標準 TensorFlow を使って
作動させました。
別の機会には、動作可能な XLA、
JIT フラッグを使って作動させました。
JIT フラッグはコンパイルを始め、
願わくば迅速化を実現します。
ここでご覧になっているのは、
基本的に緑色のものは、全て正数です。
このスライドが示しているのは、
より早い方が良策だということです。
ここにあるモデルの集合については、

English: 
It's not just arbitrary things.
The first couple of
examples are for GMT.
That's the neural
machine translation.
So it's one of these
stacked LSTM-type models.
Next down the list, we've got
Inception, AlexNet, like, some
of the image processing models.
One of the reasons
why we see speed ups
here are due to the
things that Chris actually
mentioned, right?
We get this fusion
of operations.
Like, element and
wise operations
get automatically
fused together.
And so if the long pole
basically in your computation
is streaming through
all of the data,
well, that's going
to help a lot, right?
You've got that these
tiny operations,
like, you want to add things,
you want to multiply things,
you can fuse them all together.
Also, there's sort of different
paralyzation and buffer
allocation strategies that
we have that can actually
provide additional speed up.
Another thing we want
to point out here
is that it's not
just for inference
or not just for training.
It's actually for both.
And so here the pink
boxes are highlighting

Chinese: 
这不仅仅是任意的东西
第一个例子是GMT
也就是神经机器翻译
那是一个堆叠的LSTM形模型
下一个是Inception，AlexNet
一些图像处理模型
我们想要加速的一个原因
正如克里斯提到的那样
我们融合了这些操作
比如，元素和运算
把它们自动的融合在一起
如果在你计算中的长杆
是加载所有的数据
这真的很有帮助
你有了这些小的运算
比如，你想要添加、乘以一些事
你可以把它们融合在一起
这里有很多的停滞
和缓冲配置策略
可以创造额外的加速
我们在这里还想指出
这不仅仅是为了推理
或仅仅为了训练
我们两者都要做的
在这里的这个粉红色方框
标注了训练的例子

Indonesian: 
Bukan cuma semaunya saja.
Beberapa contoh pertama adalah untuk GMT.
Ini adalah terjemahan neural machine.
Ini salah satu model LSTM tersusun.
Selanjutnya, kita punya Inception,
AlexNet, beberapa model pemroses gambar.
Salah satu alasan kenapa kita lihat
ada percepatan di sini
adalah karena hal
yang sudah disebut Chris tadi.
Kita punya operasi fusi ini.
Operasi elemen dan wise tergabung
secara otomatis.
Jika patokan panjang di komputasi Anda
mengalir di semua data,
itu sangat membantu.
Anda punya operasi kecil ini,
Anda ingin tambahkan
atau mengalikan sesuatu
maka Anda bisa gabungkan semuanya.
Ada strategi alokasi paralisasi
dan buffer berbeda yang kita punya
dan bisa sediakan tambahan percepatan.
Hal lain yang ingin kami tekankan
yaitu bukan hanya untuk penggabungan
atau hanya untuk latihan.
Namun keduanya.
Ada kotak merah muda menyoroti

Portuguese: 
Não são apenas arbitrários.
Os primeiros exemplos são para GMT.
É a máquina neural de tradução.
É um dos modelos tipo LSTM empilhados.
Em seguida, na lista,
temos Inception, AlexNet,
alguns modelos de processamento de imagem.
Algumas das razões da aceleração
já foram mencionadas pelo Chris.
Temos uma fusão de operações.
Operações de elementos
são automaticamente fundidas.
Se o maior atraso na sua computação
é percorrer todos os dados,
isto vai ajudar bastante.
Estas pequenas operações,
como adicionar ou multiplicar coisas,
podem ser fundidas.
Há também estratégias
de alocação de paralisação e buffer
que proporcionam ainda mais aceleração.
Isso não serve apenas para inferência
ou apenas para treinamento.
Serve para ambos.
As caixas rosas estão destacando
os exemplos de treinamento

Korean: 
임의적인 것이 아닙니다
첫 예시는 GMT를 위한 겁니다
인공신경망 머신 번역이죠
LSTM 유형의 모델 중 하나입니다
다음은 인셉션, AlexNet 등과
이미지 처리 모델이 있죠
여기서 가속화가 있는 이유 중 하나는
크리스가 사실 이미 말했던 이유
때문이죠
저희는 이 퓨전 운영이 있습니다
엘리먼트와 와이즈 운영은
자동으로 퓨전되는 거죠
따라서 계산에서 중요한 문제가
모든 데이터를 통해 스트리밍되면
도움이 많이 되는 거죠
작은 운영이 있다면
예컨대 덧셈이나 곱셈을 하고 싶다면
모두 퓨전시킬 수 있습니다
또한 더욱 가속화시켜 줄
다양한 무력화와 버퍼 할당 전략이
있습니다
여기서 언급하고 싶은 점은
추론만을 위한이나 훈련만을 위한 것이
아니라는 점이죠
둘 다를 위한 것입니다
여기 핑크 상자는 저희가
실제로 훈련을 실행한

Japanese: 
私達が実際に配慮していることであり、
恣意的なものではありません。
１番目の例は、GMT についてです。
これはニューラルマシーン翻訳です。
束ねられたこれらの
LSTM タイプモデルの１つです。
リストの下には、
イメージプロセシングモデルである
Interception AlexNet があります。
ここで高速化を目にする１つの理由に、
クリスが言及したことが、
実は関係しています。
エレメントと回転の早いオペレーションが
自動的に融合したような、
このオペレーションの融合を
得たからです。
基本的に算定内の長いポールが
データ全てをストリーミングしたら、
非常に大きな助けとなります。
これらの小さなオペレーションがあり、
追加したり、乗算したい場合
これらをすべて融合することができます。
また異なるパラリゼーションや
バッファ割当戦略があります。
これらは実際、
付加的な高速化に寄与します。
ここで強調しておきたいもう１つの点は、
インフェレンスのためだけではなく、
またトレーニングのためだけでもありません。
その両方のためです。
ここではピンク色のボックスは、
トレーニングサンプルや

Spanish: 
No son solo cosas arbitrarias.
El primer par de ejemplos son para GMT.
Esa es la traducción automática neuronal.
Es uno de estos modelos 
de tipo LSTM apilados.
Seguido en la lista también tenemos
Inception, AlexNet
como algunos modelos 
de procesamiento de imagen.
Una de las razones 
por las que vemos las aceleraciones
aquí se debe a las cosas 
de las que habló Chris.
Una fusión de operaciones.
Operaciones y elementos
inteligentes se fusionan.
Entonces si el polo en tu cálculo
está transmitiendo
a través de toda la información
eso ayudará bastante.
Tienes pequeñas operaciones
en las que quieres agregar cosas,
multiplicar cosas
y puedes fusionarlas todas.
Hay diferentes estrategias de paralización
y asignación que tenemos que pueden
proporcionar una velocidad adicional.
Algo más que queremos señalar
es que no es solo para la inferencia
o como prueba.
En realidad es para ambos.
Las cajas rosadas están resaltando

Portuguese: 
ou os modelos
em que executamos o treinamento.
Tanto a progressão
como a propagação regressiva.
Isso é muito legal.
Uma observação é que parece,
pelo menos nesta imagem,
que muitos dos de treinamento
estão mais abaixo na lista.
Não estão melhorando tanto
o desempenho ou, em alguns casos,
houve uma mudança negativa.
Negativo quer dizer que estão piores.
Que não estamos tão bem.
No lado do treinamento,
um dos motivos para isso
é que treinar grafos, em geral,
é um pouco mais complicado.
Imagine grafos de inferência
que só funcionam progressivamente.
Acrescentando treinamento,
terá propagação regressiva.
Precisa computar os gradientes.
E isso torna o grafo maior
e mais complicado.
Esse é um dos motivos
por que os números estão mais baixos
no lado do treinamento,
mas certamente é algo
em que vamos trabalhar.
Melhorar esses números o máximo possível
é algo em que estamos
trabalhando ativamente.
No próximo slide...
No caso do slide anterior,
se vissem aquilo
em um artigo científico,

Korean: 
훈련 예시나 모형을
강조하고 있습니다
둘 다 앞뒤로 나아가는 [청취불가]
정말 멋집니다
하나 주목할 점은
적어도 이 그림에서는 많은 훈련이
목록의 하단 쪽에 있다는 거죠
성능 향상을 그다지 많이 보이진 않죠
어쩌면 심지어 일부 경우에
성능 감소일 수도 있죠
음수는 실제로 더 나빠졌다는 의미죠
이전만큼 좋지 않다는 거죠
훈련 측면에서는 그 이유가
일반적으로 훈련 그래프는
조금 더 복잡하죠
추론 그래프는 전진 패스만
있있다고 생각하시면 됩니다
하지만 훈련을 더하면
배경이 생기는 거죠
변화도를 계산해야 할 겁니다
이는 그래프 전체를 더 크고
복잡하게 만들죠
이것이 바로 훈련 측면에서의
숫자가 조금 더 낮은 이유이지만
분명 해결하고 싶은
문제이죠
이 모든 숫자를 가능한 한 많이
향상시키려는 노력이
저희가 현재 하고 있는 일입니다
다음 슬라이드는
사실 이전 슬라이드를 보면
학술지에서 보신다면

Japanese: 
作動させたトレーニングモデルを
強調するものです。
両方とも、フォワードパスそして
バックプロップです。
これはかなり高度なことです。
ここで気がついたことは、
少なくともこのスライド上では、
たくさんのトレーニングはリスト上の
下の方に表示されています。
多くのパフォーマンス改善を得ておらず、
幾つかのケースではネガティブな
パフォーマンス改善がみられたのでしょう。
ネガティブとは、ここでは
悪いことを意味します。
良くありません。
トレーニングの側面で言えば、
この理由の１つとして
一般的に、トレーニンググラフは
多少複雑になっています。
インフェレンスグラフは
フォワードパスしか持っておらず、
トレーニングを追加すれば、
バックプロップを得ることになります。
勾配を算定する必要があります。
それによって、グラフ全体が大きくなり
より複雑となります。
これが理由で、いくつかの数字は
トレーニングサイド用に
多少低くなっているのです。
しかし、これは私達が取り組みたい事柄です。
できる限り、これらの数字全てを改善するのは
現在私達が活発に取り組んでいることです。
次のスライドでは、それでは
事実、前のスライドでは
アカデミックペーパーのようなものを
目にしたと思いますが、

English: 
the training examples
or the models
where we actually ran training.
So both the forward pass
and back [INAUDIBLE].
And this is actually
pretty cool.
One observation, though,
here is that, well, it
seems, at least on this picture,
that lots of the training ones
are sort of lower down
on the list, right?
They're not getting as much
of a performance improvement
or maybe, even in some cases,
maybe a negative performance
improvement.
So negative here means
that we actually are worse.
We're not as good.
And so on the training
side, one reason for this,
it's basically, you know,
training graphs, in general,
are a little bit
more complicated.
You can think about,
like, inference graphs
as only having the forward pass.
But once you add
training, you're
going to have, like, backprop.
You're going to have to
compute the gradients.
And so that makes
the entire graph
larger and more complicated.
And that's one of
the reasons why
sort of like some of the
numbers are a little bit lower
for the training side, but
it's definitely something
that we want to work on.
And so trying to improve all of
these numbers as much as we can
is something that we're
actively working on right now.
So the next slide.
So actually, with
that previous slide,
if you saw that in an
academic paper or something,

Spanish: 
los ejemplos de prueba
o en los que ejecutamos la prueba.
Tanto el pase adelantado como el contexto.
De verdad es muy bueno.
Sin embargo, una observación, aquí parece
al menos en esta imagen,
que muchos de los probados
están más abajo en la lista.
No tienen una mejora en el rendimiento
o en algunos casos
tal vez un rendimiento negativo
Lo negativo aquí significa que empeoramos.
No somos tan buenos.
Y sucesivamente en el lado
de entrenamiento, se debe
básicamente a que los gráficos de prueba
son un poco más complicados.
Piensas en gráficos de inferencia
que solo tienen el pase.
Cuando añades la prueba
tendrá contexto.
Y calcularás los gradientes.
Haciendo el gráfico más
grande y más complicado.
Es una de las razones
por las que los números son más bajos
en el lado de prueba, pero es algo
en que queremos trabajar.
Mejorar todos estos números
tanto como podamos
es algo en lo que trabajamos
activamente ahora mismo.
Siguiente diapositiva.
Con la diapositiva anterior
si veías eso en un ensayo académico

Chinese: 
或者我们运行训练的模型
两者都可以快进或后退
这真的是非常的棒
在这里的一个观察是
至少在这张图片中，许多的训练
都在这个清单上
他们没有得到很多的性能改进
或者是，在一些例子中
有任何负面的性能改进
负面在这里的意思是，我们变的更糟
我们没有像以前那么好
所以在训练方面，一个原因是
基本上，训练图表
一般来说会比较复杂
你可以想象推理图表
只有向前推理
一旦你添加了训练
你必须要有向后推理
你必须要计算梯度
这让整张图表都变的
更大，更复杂
这就解释了
为什么训练中所使用的数字
跟我们工作使用的数字
不一样
改善所有的数字
正是我们现在努力的一个方向
下一张幻灯片中
实际上，是之前的幻灯片
如果你在学术期刊上看见过

Indonesian: 
contoh latihan atau model
di mana bisa jalankan latihan.
Untuk maju dan mundur..
Dan ini sangat keren.
Satu observasi, adalah
setidaknya pada gambar ini
banyak latihan dipindahkan
ke bawah daftar.
Mereka tak dapat banyak
peningkatan kinerja
atau mungkin peningkatan kinerja negatif.
Negatif di sini artinya
malah jadi lebih buruk.
Kami tidak bagus.
Di sisi latihan, satu alasan untuk ini
adalah, grafik latihan,
secara umum, lebih rumit.
Contohnya grafik interferensi
hanya lewat ke depan.
Setelah ada latihan
akan ada arah mundur.
Anda harus hitung gradiennya.
Itu membuat seluruh grafik
lebih besar dan rumit.
Itu salah satu alasan kenapa
beberapa angka lebih rendah
untuk sisi latihan, tapi tentu saja
ingin kami kerjakan.
Coba tingkatkan semua angka semampunya
adalah hal yang sedang
kami kerjakan sekarang.
Slide selanjutnya.
Dengan slide sebelumnya,
jika Anda lihat

Spanish: 
no te importaría.
No le creerías a este tipo.
Porque simplemente se ve 
demasiado positivo.
Aquí tomé una colección
de micro referencias.
Como información,
estos números son reales.
Estos números en realidad...
los tomé, ayer de los puntos 
de referencia reales
que hemos sacado constantemente.
Solo tomé una foto
de los de ayer
y los incluí en este cuadro.
De nuevo tenemos
el mismo diseño de gráfico.
Lo verde a la derecha
son números positivos.
Aceleraciones, son buenas.
A la izquierda,
están los números negativos.
Lo malo.
Vemos algunas mejoras
de velocidad muy buenas.
Hay una parte muy grande 
que muestra mejoras
de hasta el 50%.
Y aquí abajo hay espacio para mejorar.
Hablé un poco de las cosas
que podríamos intentar mejorar.
Otra cosa que notamos aquí abajo...
No puedes leer la fuente
porque es pequeñita
pero muchos de los modelos
o muchas micro referencias que ejecutamos
son para celdas ya fusionadas.
Estas son cosas en las que aprovechamos

Chinese: 
你会觉得
我不相信这个人，对吧？
因为它看起来太积极的
所以在这里，我们有了一个微基准测试的集合
还要注意的一件事是
这些数字都是真实的
这些数字事实上都是
我昨天摘录的
我们不断的运行这些基准
我只是简单回顾一下昨天的内容
把它们运用到图表上
所以，同样的
这是相同的图表布局
右边的绿色的数字都是正数
这些的加快的数字
非常好
红色的数字是负数
这不是很好
因此我们看到了一些加速
这一共加速了
大约50%
在这下面还有提升的空间
我们说了一些
我们想要改进的地方
我们在这下面还要注意的一点是
你无法阅读字体
因为太小了，但这下面的很多模型
以及我们运行的许多微基准测试
像是预制的细胞
所以这是我们利用

Korean: 
뭐든 간에
이 사람 안 믿어, 하시겠죠
너무 좋아 보이니까 말이죠
그래서 마이크로벤치마크를 모아 봤습니다
또 언급하고 싶은 것은
이 숫자들은 실제입니다
이 숫자들은 전부 실제로
저희가 실행하고 있는 실제 벤치마크에서
제가 어제 가져온 것입니다
어제 스냅샷으로 찍은 것을
이 차트에 집어 넣은 겁니다
그럼 여기 같은 그래프 레이아웃이 있죠
오른쪽의 녹색 부분이 양수이고
가속화된 것이죠
좋습니다
왼쪽의 빨간 부분은 음수입니다
안 좋은 거죠
꽤 괜찮은 가속화를 보고 있죠
여기 크고 굵직한 덩어리는 50%까지
올라간 경우이죠
그리고 여기 밑쪽은
향상시켜야 할 여지가 있죠
저희가 향상시켜야 할 부분이 대해
약간 말했었죠
여기 밑에서 또 주목할 부분은
글자가 작아서 잘 안 보이겠지만
여기 밑 쪽의 많은 모델들
혹은 저희가 실행 중인
많은 마이크로벤치마크는
미리 퓨전된 셀 같은 것입니다
이는 우리가 현존하는 컴파일러나

Japanese: 
決してそうだとは思っていませんが
よりポジティブな見方で言ってみました。
ここでは、マイクロベンチマークの集合を
取り出しました。
もう１つ注目して頂きたいのが、
これらの数字は実際のものです。
これらの数字は、昨日私が取り出したものです。
コンスタントに作動しているアクチュアル
ベンチマークから取り出したものです。
昨日、表示されていたものを写し、
このチャートに載せました。
ここには同一のグラフレイアウトがあります。
右側に緑色のものがあり、
それは正数で高速化を示しています。
良いですね。
左側にある赤いものは、
負数で、よくありません。
かなりの高速化が見られ、
しっかりした実体を示しています。
50 パーセントに到達しています。
下の方には、まだ改善すべき空間があります。
改善してみたいことについて、
先程少しお話ししました。
もう１つ気がついた点がありますが、
フォントが小さいので読めませんが
下の方にあるモデルの多く、もしくは
作動しているマイクロベンチマークの多くは
prefused cell 用です。

Portuguese: 
não dariam muita atenção,
diriam que não acreditam em mim, certo?
Porque parece muito positivo.
Então fiz um conjunto de microbenchmarks.
Notem também que estes são números reais.
Eu os peguei ontem dos benchmarks reais
que executamos regularmente.
Peguei um instantâneo de ontem
e coloquei neste grafo.
É mesmo layout do grafo.
Os dados em verde à direita
são números positivos.
Esses sofreram aceleração.
Isso é bom.
Os vermelhos à esquerda
são números negativos.
Isso é meio ruim.
Temos algumas acelerações muito boas.
Tem uma boa parte aqui
em que se chega a 50%.
Aqui embaixo, temos espaço para melhorar.
Falei um pouco sobre
o que queremos fazer para melhorar.
Outra coisa que notamos embaixo,
vocês não podem ler
porque a fonte é pequena,
é que vários modelos, ou vários
microbenchmarks que executamos
são para células pré-fundidas.
Nessas situações,

Indonesian: 
di laporan akademik,
Anda akan, ya, terserah saja.
Tak akan percaya orang ini, kan?
Karena terlihat terlalu positif.
Saya ambil satu koleksi microbenchmark.
Satu hal yang perlu diingat,
angka ini sungguhan.
Semua angka ini sebenarnya--
Saya ambil, kemarin
di patokan sesungguhnya
yang sedang kita jalankan secara konstan.
Saya ambil cuplikan apa pun
kemarin dan masukkan di grafik ini.
Di sini adalah tampilan grafik yang sama.
Hal hijau di kanan, nomor positif.
Percepatan. Bagus.
Hal merah di kiri, nomor negatif.
Itu buruk.
Kita punya percepatan bagus.
Ada bagian besar di sini di mana dia naik
sebesar 50%.
Dan di bawah ada ruang untuk peningkatan.
Saya bicara soal beberapa hal
yang ingin kami lakukan
untuk meningkatkannya.
Hal lain yang kita sadari di sini adalah--
Tak bisa baca fontnya, karena kecil--
tapi banyak model di sini
atau microbenchmark yang kita jalankan
seperti sel pra gabungan.
Di sinilah kami manfaatkan

English: 
you'd be like,
yeah, whatever, man.
I don't believe this guy, right?
Because it's like, it just
looks like too positive.
And so here I've taken a
collection of microbenchmarks.
Oh, another thing to note,
actually, these numbers
are for real.
These numbers are all actually--
I grabbed them, like, yesterday
off of the actual benchmarks
that we've been running,
like, constantly.
And so I just grabbed
a snapshot of whatever
yesterday was and, like,
plopped them onto this chart.
And so here, again, it's
the same graph layout.
The green stuff on the right,
you know, positive numbers.
Those are speed ups.
That's good.
And the red stuff on the
left, negative numbers.
That's kind of bad.
And so we see some
pretty good speed ups.
There's a big, hefty chunk
here where things get up
to as much as 50%.
And down here there's,
like, room to improve.
I talked a little bit
about some of the things
that we might want
to do to improve.
Another thing that we've
noticed down here is that--
you can't read the
font, because it's
tiny-- but then lots
of the models down here
or lots of the microbenchmarks
that we're running
are for sort of
like prefused cells.
So these are things
where we take advantage

Korean: 
현존하는 고속 퓨전 커널의 실행을
이용할 수 있는 부분이죠
텐서플로우 운영이 이를 할 경우
텐서플로우 자체가
멋진 일을 해내는 거죠
이 고속 커널을 시작하게 하지만
XLA 측면은 현재 그리
잘 하지 못 하기 때문이죠
저희의 위치를 솔직히 말씀드리면
이곳이 바로 저희가
있는 곳이지만
향상시키려고 노력 중이죠
이 슬라이드는 제가 여러분께
마케팅을 하려는 게 아님을 보여 주죠
저 사실 마케팅 수업에서 C+를 받았죠
이전 슬라이드 두 장은 GPU였죠
이 슬라이드는 CPU이죠
JIT에 대해서 말이죠
다시 한번, 가속화와
녹색은 좋다는 의미입니다
감속과 빨간색은 나쁘다는 의미죠
따라서 이 부분은 좋지 않죠
이를 설명하는 간단한 방법은
일하는 사람 상징이 있죠
이 배후에 대해 좀더 자세히
설명해 드리죠

English: 
of existing compilers or
existing implementations
of fast-fused kernels.
And so when the TensorFlow
op comes in that does that,
TensorFlow by itself
does a really good job,
because it's kicking
off this fast kernel,
but the XLA side doesn't really
do a good job of that right
now.
And so just to be, like, sort
of honest about where we are,
that's kind of where
we are, but we're
trying to improve the thing.
So this slide really
proves to you that I'm not,
like, in marketing or
something like that.
Yeah, I actually got
a C-plus in marketing.
So the previous two
slides were GPU, right?
And so this slide's, like, CPU.
Again, on the JIT, right?
And again, speed ups and
green are supposed to be good.
And slowdowns and red
are supposed to be bad.
And so this is, like, not good.
And so the simple
way to describe this
is that, yeah, we've got the
men at work thing, you know?
I can give you a
little bit more detail
behind that, though, right?

Indonesian: 
kompilator atau implementasi yang ada
dari kernel gabungan yang cepat.
Saat operasi TensorFlow datang melakukan,
TensorFlow sendiri bekerja bagus
karena dia memulai kernel cepat ini
tapi sisi XLA tidak bekerja bagus
sekarang.
Jujur saja, begini kondisi kami
tapi kami coba meningkatkannya.
Ini membuktikan bahwa saya bukan
di pemasaran atau semacamnya.
Ya, saya dapat C-plus di marketing.
Dua slide sebelumnya itu GPU, 'kan?
Dan slide ini, CPU.
Dan juga, di JIT.
Tetap sama, percepatan
dan hijau seharusnya bagus.
Perlambatan dan merah seharusnya buruk.
Dan ini, tidak bagus.
Cara sederhana untuk mendeskripsikan ini
adalah, tampilan 'sedang dikerjakan' ini.
Saya bisa jelaskan lebih detail.

Spanish: 
los compiladores existentes 
o implementaciones existentes
de núcleos de fusión rápida.
Cuando llega la operación de TensorFlow
que hace eso por su cuenta
TensorFlow hace un muy buen trabajo
porque inicia este núcleo rápido
pero el lado de XLA no hace realmente
un buen trabajo ahora mismo.
Y siendo honestos con nuestro avance
hasta ahí llegamos
pero intentamos mejorar.
Esta diapositiva demuestra
que no estoy en mercadeo o algo así.
Sí, en realidad reprobé mercadeo.
Las dos anteriores eran GPU.
Entonces esta es de CPU.
Otra vez en JIT.
Las aceleraciones y lo de verde es bueno.
Y la desaceleración y el rojo son malos.
Y por lo tanto esto no es bueno.
La manera simple de describir esto
es que sí, trabajamos en esto.
Puedo darte más detalles de esto.

Portuguese: 
aproveitamos compiladores que já existem,
ou implementações já existentes
de núcleos de rápida fusão.
Quando a operação
do TensorFlow realiza isso,
o próprio TensorFlow faz um bom trabalho
porque está iniciando o núcleo rápido,
mas o lado do XLA não faz
um bom trabalho atualmente.
Sendo honesto sobre onde estamos,
onde estamos tentando melhorar.
Este slide comprova
que eu não sou do marketing.
É, eu tirei 5 em marketing.
Os dois slides anteriores
trataram de GPU, certo?
Este trata de CPU.
De novo, em relação ao JIT, certo?
Novamente, aceleração em verde
representam coisas boas.
Desaceleração e vermelho
representam coisas ruins.
Então isso não é bom.
A forma mais simples de descrever isso
é com aquele "homens trabalhando", sabe?
Porém posso dar mais detalhes, certo?

Chinese: 
现有的编译器
或是快速融合核心的方法
所以当TensorFlow操作加进来后
TensorFlow自己可以做得很好
因为它可以启动快速核心
但是XLA端现在做的还不够好
所以我们想跟大家坦诚
我们做了什么
我们还有哪些地方需要改进
这张幻灯片向你证明了
我们不是在做市场推销
我的市场营销课得了C+
所以前面的两张幻灯片是GPU
所以这张幻灯片是CPU
还有JIT,对吧?
再一次的，加速还有绿色的数字是好的
减速和红色的数字是不好的
所以这个是不好的
用于一个简单的方法来描述这一点
我们有一个男人正在工作
我们告诉你幕后的
很多细节

Japanese: 
これらは、既存のコンパイラーもしくは
既存する fast-fused カーネル実行から
利益を得るものとなります。
TensorFlow op がそこで
実行した場合、
TensorFlow 自体が
かなり良い仕事をします。
このファーストカーネルを開始するからです。
しかし、XLA サイドは現在
良い仕事をしていません。
改善を進めようとしている現時点では、
本当のことです。
このスライド、
これを見れば、私がマーケティングなどに
携わっていない事が分かると思います。
実際に、マーケティングで
C-plus を得ました。
前の２つのスライドでは、
GPU についてお話ししました。
このスライドは CPU のこと、
そして再び JIT についてお話しします。
高速化は緑色で良いものとして、
低速化は赤で悪いものとして考えます。
これは良くないものです。
これを説明する簡単な方法は、
作業中の男性のマークです。
その背景にある詳細について
少しお話ししましょう。

Chinese: 
最简单的一个原因是
我们没有无限的工作人员在做这件事
因此我们必须优先化
我们喜欢实际的人
我们会想
如果你使用TensorFlow
并且你想使用这个编译器
你可能就会想让它变的更快
如果你想让它变的更快
然后你可能已经在使用GPU
所以我们要着重的第一点
是要改善GPU的性能
因为你从中获益更多
其中的一个具体原因
为什么这些基准实际上更糟
是因为现在，TensorFlow 已经
弃用了很多的操作
如果你有多重的操作，你可以平行的运行它们
这是在单一平行运行的基础上
比如所，你有一个大的matmul
我们做一些很炫的改编
尽可能的弃用一些操作
在 XLA方面，我们有独立的后端
用于顺序操作和平行操作
但我们并没有花过多的时间
所以在这里有很多唾手可得的东西

Indonesian: 
Salah satu alasan sederhana
karena kami tak punya cukup orang
dan kami harus memprioritaskannya.
Kita orang yang praktis.
Kita berpikir, jika pakai TensorFlow
dan ingin gunakan kompilator ini
mungkin Anda ingin membuatnya lebih cepat.
Jika ingin lebih cepat
maka Anda sekarang telah gunakan GPU.
Pertama kita akan fokus
untuk meningkatkan kinerja GPU
karena Anda bisa dapatkan
banyak manfaat dari sana.
Salah satu alasan konkret
kenapa-- banyak
patokan ini sebenarnya lebih buruk
adalah saat ini, TensorFlow
telah melumpuhkan
banyak operasi.
Jika punya berbagai operasi,
itu bisa dijalankan secara paralel.
Ini lebih penting selain operasi
paralelisme tunggal, di mana
Anda punya matmul besar
dan kami lakukan penyusunan keren
untuk memparalelkan itu
sebaik mungkin.
Di sisi XLA, kita punya back end terpisah
untuk sekuensial dan paralel, tapi cuma
belum habiskan banyak waktu untuk itu.
Banyak hal belum selesai,
dan saya pikir

Japanese: 
簡単な理由の１つとして、
それに従事する人が無限にいないからです。
ですから、それを優先しなくてはいけません。
私達は実践的な人と言えます。
TensorFlow を使っていて、
このコンパイラーを使用したければ
おそらく、高速化も図りたいでしょう。
高速化を望めば、おそらく
すでに GPU ユーズを使っているでしょう。
最初に取り組むことは、
GPU パフォーマンスを
改善することです。
そこから最大の利益を得ることが
できるからです。
この特殊な、これらのベンチマークの大部分が
良くない具体的な理由の１つとして
一般に TensorFlow がすでに多くの
オペレーションを麻痺させるからです。
複数のオペレーションがあれば、
並行して作動させます。
これはシングル op パラリズム内の
上部にあります。
そこには大きな matmul があり、
可能な限り、それを麻痺させるため
手のこんだタイル張りを行ないます。
XLA サイドでは、シーケンシャルと
パラレル用の単独のバックエンドがあります。
それに費やす時間があまりありません。
ローハンギングフルーツが多数あり、

Korean: 
간단한 이유 중 하나는
이 작업을 하는 사람들이
무한대가 아니라
우선순위화 해야 한다는 겁니다
그리고 저희는 실용적입니다
이런 생각을 한 거죠
텐서플로우를 사용하고 있다면
이 컴파일러를 사용하고 싶고
이를 더 빨리 만들고
싶을 것이라고 말이죠
이를 더 빠르게 만들고 싶다면
아마 지금 이미 GPU를 사용하고 있겠죠
따라서 저희가 초점을 둔 첫 번째 일은
GPU 성능을 향상시키는 것이죠
가장 많은 이득을
얻을 수 있으니까 말이죠
이 벤치마크 중 상당수가
실제로 더 안 좋은
구체적인 이유 중 하나는
현재 텐서플로우는 이미 많은 운영을
병렬화시켰기 때문이죠
다양한 운영이 있다면
병렬적으로 운영할 수 있겠죠
이것이 단일 병렬 운영 내의
최고점에 있죠
큰 matmul이 있고
멋진 타일링이 있으며 가능한 한 많이
병렬화시키고 싶다고 칩시다
XLA 측면에서는
차례로 하는 것과 병렬화된 것이
각각의 백엔드를 가지고 있지만
많은 시간을 투자하지 않았죠
따라서 쉬운 목표가 많습니다

English: 
Like, one of the
simple reasons is
because we don't have
unlimited people working on it
and so we have to prioritize.
And we're kind of like
practical people, right?
We kind of thought,
well, I mean,
if you're using TensorFlow and
you want to use this compiler,
then you probably want
to make things faster.
And if you want to make
things faster, then
probably you're using GPUs
use right now already.
And so the first thing
we're going to focus on
is, like, improving
GPU performance,
because you can get, like,
the most benefit out of that.
One of the concrete reasons
why this particular-- many
of these benchmarks
are actually worse
is that currently,
TensorFlow already paralyzes
much of the operations, right?
If you have multiple operations,
they can run in parallel.
This is on top of the within
single op parallelism,
where, let's say,
you have a big matmul
and we do fancy tiling and
stuff to parallelize that as
much as possible.
On the XLA side, we do
have separate back ends
for sequential and
parallel, but we simply
haven't put very
much time into it.
And so there's a lot
of low-hanging fruit

Portuguese: 
Uma das razões mais simples
é que não contamos
com um número ilimitado de pessoas
trabalhando nisso,
então temos que eleger prioridades.
E somos pessoas práticas, certo?
Pensamos que se você usa o TensorFlow
e quiser usar o compilador,
você quer deixar as coisas mais rápidas.
Se você quer rapidez,
então provavelmente já usa GPUs.
Então a primeira coisa
em que nos concentramos
é melhorar o desempenho da GPU,
porque você é mais beneficiado assim.
Uma das das razões concretas
por que muitos
desses benchmarks estão piores
é que atualmente TensorFlow já
faz em paralelo muitas das operações.
Múltiplas operações podem ser
executadas em paralelo.
Além do paralelismo interno
de operações únicas,
em que há um grande MatMul
e fazemos um tiling elaborado
para executar em paralelo
sempre que possível.
No lado XLA, temos back-ends separados
para sequenciais e para paralelas,
mas não pudemos dedicar
tanto tempo a isso.
Então há muitas coisas "mamão com açúcar",

Spanish: 
Una de las razones
es que no tenemos
gente ilimitada trabajando en esto
y tenemos que priorizar.
Somos personas prácticas.
Pensamos
si usas TensorFlow 
y quieres usar este compilador
entonces seguro quieres hacerlo
más rápido.
Y si quieres más velocidad, entonces
puede que ya estés usando GPUs.
Lo primero en lo que nos centraremos
es en mejorar el rendimiento GPU
porque obtendrás
mejores beneficios con eso.
Una de las razones concretas
por las que estos puntos de referencia
empeoraron
es que actualmente, TensorFlow ya paraliza
muchas de las operaciones.
Si tienes varias operaciones,
puede ejecutar en paralelo.
Está en la parte superior
del paralelismo de una sola operación
donde tienes un gran matmul
y hacemos cosas elegantes y paralelizamos
tanto como sea posible.
En el lado XLA, tenemos
extremos posteriores separados
por secuenciales y paralelos,
pero simplemente
no hemos pasado mucho tiempo ahí.
Entonces hay muchas cosas a la mano

Japanese: 
これらの数字をより簡単に、そしてかなり
ダイナミックに改善できると思います。
ここはまた、興味があれば
コミュニティ参加という観点から
多くの可能性のある場所で、
オープンソースとなっています。
パフォーマンスという観点でお話しする
スライドの困難な部分です。
１つまだ話していないことがあります。
より小さいバイナリーについてです。
コンピレーションを使う方法は
非常に多くあると話してきました。
JIT やアヘッドオブタイムがあります。
これはアヘッドオブタイムです。
ここで注目したいのは、
モバイル上では、バイナリーサイズが
大きな違いをもたらすということです。
ユーザーはアプリケーション用に
多くのメガバイトがダウンロードされるのを
座って待っていたくはありません。
コンパイラーを使うことによって、
かなりのバイナリーサイズの軽減を
行なうことが可能です。
特殊な例として、
束ねられた LSTM があります。
それは 3 デイープ、60  ワイドです。
シーケンスで 60 ワイド、3 デイープの
LSTM セルがあります。
Android ARM 用に
コンパイルされます。
リアルアプリケーションのようなものです。

Indonesian: 
kami bisa tingkatkan angka ini
dengan mudah dan dramatis.
Ini akan jadi area di mana,
jika Anda tertarik, pastinya
untuk keterlibatan komunitas,
ada banyak hal untuk dilakukan.
Semuanya sumber terbuka.
Itu adalah slide yang buruk
untuk mengakhiri soal kinerja.
Satu hal yang belum kami bicarakan
adalah biner yang lebih kecil.
Saya sebutkan, ada banyak cara
Anda bisa manfaatkan kompilasi.
Anda bisa lakukan JIT, atau lebih cepat.
Ini untuk lebih cepat.
Dan hal spesifik yang kami coba targetkan
itu di seluler, seperti ukuran biner
akan membuat perbedaan.
Pengguna tak ingin duduk dan menunggu
untuk mendownload megabyte besar
ke aplikasi Anda.
Dengan kompilator, kita bisa dapatkan
reduksi ukuran biner yang signifikan.
Contoh yang kami punya di sini
adalah untuk LSTM tersusun.
Yang satu ini ukurannya
sedalam 3 dan lebar 60.
Anda punya sel LSTM dengan lebar 60
dan kedalaman 3.
Ini dikompilasi untuk Android ARM.
Ini aplikasi sungguhan.

Portuguese: 
cujos números podemos melhorar
fácil e dramaticamente.
Essa área também seria,
se vocês tiverem interesse,
com envolvimento da comunidade,
há muita coisa a se fazer.
E tudo é em código aberto.
Seria meio chato terminar nesse slide
em termos de desempenho.
Uma coisa de que não falamos
foram binários menores.
Mencionei que há muitas maneiras
de usar a compilação.
É possível usar JIT ou ahead-of-time.
Isto se aplica a ahead-of-time, certo?
O nosso foco específico aqui
é que para móvel o tamanho do binário
faz uma grande diferença.
Os usuários não querem esperar
pelo download de muitos megabytes
no seu aplicativo.
Então usando o compilador,
é possível conseguir
reduções significativas
no tamanho do binário.
Este exemplo se aplica
à LSTM empilhada.
Este aqui tem 3 de profundidade
e 60 de largura.
Temos células LSTM
de 60 de largura em sequência
e três de profundidade.
E foi compilada para Android ARM.
Isto é um aplicativo real.

Chinese: 
我们可以非常简单，显著的
改善这些数字
这也会是一个领域
如果你感兴趣的话
可以参与到社区参与
有很多需要你帮忙的地方
所以这些信息都在开源资源中
这是一张蹩脚的幻灯片
在总结性能
当我们还没有提到
是小的二进制文件
我说过，有很多的方法
你可以使用编译
你可以做即时或提前编译
这是用于提前编译的
我们在这里努力的具体目标
是在移动端，二进制文件大小
实际上有很大的差异
你的用户不会希望坐在那里等待
下载你的应用
通过使用编译器
我们可以显著的减少二进制文件的大小
我们在这里用的具体的例子是LSTM
这个例子恰巧是
深度为3，宽度为60
所以你有LSTM细胞
深度为3，宽度为60
这是为Android ARM编译的
这是一个真正的应用程序

Korean: 
제 생각에 여기 이 숫자는
아주 쉽고 드라마틱하게
향상시킬 수 있죠
따라서 관심이 있으시다면
커뮤니티 참여가 분명히 가능한
영역입니다
많은 일이 있죠
그리고 모두 오픈소스이죠
성능에 있어서는 어쩌면 부끄러운
마지막 슬라이드일 수도 있습니다
하지만 저희가 언급하지 않은 하나는
더 작은 바이너리입니다
컴필레이션을 사용할 수 있는 방법이
많다는 얘기는 언급했죠
JIT나 어헤드오브타임을 할 수 있죠
이는 어헤드오브타임을 위한 겁니다
여기에서 목표로 잡을 특정한 것은
휴대기기에서 바이너리 크기가 사실
큰 차이를 만들죠
여러분의 앱에서 많은 메가바이트가
다운로드되길 앉아서 기다리길 원하는
사용자는 없죠
따라서 컴파일러를 사용해서
상당한 바이너리
크기 감소를 볼 수 있습니다
특정 예시는 스택된 LSTM입니다
이 특정 예시는 깊이 3에
너피 60입니다
LSTM 셀을 시퀀스에서
너비 60으로 하고
깊이는 3인 거죠
안드로이드 ARM에서 컴파일 되죠
실제 앱인 거죠

Spanish: 
aquí donde creo que podemos mejorar 
bastante estos números
fácil y radicalmente.
Esta sería un área
que si te interesa, tiene muchas cosas
en términos de participación
comunitaria.
Y todo está en código abierto.
Sería muy triste terminar 
con esta diapositiva
en términos de rendimiento.
Algo de lo que no hemos hablado
es de los binarios más pequeños.
Mencioné que hay muchas formas
para usar la compilación.
Puedes hacer JIT o por adelantado.
Esto es por adelantado, ¿no?
Lo que intentamos es que en móviles
el tamaño binario sí hace
una gran diferencia.
Tus usuarios no quieren esperar
que se descarguen muchísimos megabytes
para tu aplicación.
Y así usando el compilador, podemos
tener reducciones significativas
del tamaño binario.
El ejemplo particular que tenemos
aquí es para un LSTM apilado.
Este tiene 60 de ancho
y tres de profundidad.
Tienes células LSTM de 60 de ancho 
en secuencia
y luego tres profundas.
Y se compila para Android ARM.
Esto es como una verdadera aplicación.

English: 
here, actually, where I think we
can improve these numbers quite
easily and quite dramatically.
So this would also
be an area where,
if you're interested, then,
like, there's definitely
in terms of community
involvement,
there's lots of stuff here.
And it's all in open source.
So that would be kind
of a lame sort of slide
to end on in terms
of performance.
But one thing we haven't
really talked about
is smaller binaries, right?
I mentioned, like,
there's many ways that you
can use the compilation.
You can do, like, a
JIT or ahead-of-time.
This is for
ahead-of-time, right?
And the specific thing
we're trying to target here
is that on mobile,
like, binary size
actually makes a big difference.
Like, your users don't want
to sit around and wait for,
like, many, many
megabytes to be downloaded
for your application.
And so using the
compiler, we can actually
get significant sort of
binary size reductions.
The particular example we have
here is for a stacked LSTM.
This particular one
happens to be, like,
three deep and 60 wide.
So you've got LSTM cells sort
of like 60 wide in sequence
and then three deep.
And it's compiled
for Android ARM.
And this is, like,
a real application.

English: 
The original binary
size was 2.6 megabytes.
And that breaks down to a 1
megabyte for the TensorFlow
runtime, with only the
ops that we actually need,
and then 1.6 megabytes
for the graph.
And when we compile that down,
we end up with 600 kilobytes,
right?
And so that was what
Chris was talking
about in terms of, like,
a four times reduction.
272 kilobytes of that is code
and 330 kilobytes is weights.
So I'm going to
focus in on that 272.
Because even four times,
that's sort of not enough.
I want to make it bigger, right?
So I want to point out,
this picture down here,
which is sort of like you can't
really read anything on it,
it's basically a tree map
of all of the binary size
usage broken down by
what's actually using it.
And so on this box here, this
is the actual generated code
that we created.
It's only 88 kilobytes.
So the next box that we
have is Eigen. And so this
is 76 kilobytes.
This is a good point
to also mention that,
so you might
wonder, well, what's
Eigen doing in this
picture, right?

Japanese: 
オリジナルのバイナリーサイズは
2.6 メガバイトでした。
それが 必要な op を残し、
TensorFlow ランタイム用に
１メガバイトにブレークダウンし、
グラフ用に 1.6 メガバイトとなりました。
コンパイルすると、
600 キロバイトになります。
４倍減少したという、
クリスが話していたこととつながります。
272 キロバイトはコードで、
330 キロバイトはウェイトです。
その 272 について注目します。
４倍とはいえ、充分ではありません
もう少し大きくしたいです。
この下にあるスライドは、
何も読み取ることができません。
基本的には、実際に何を使っているかによって
分類したバイナリーサイズユサージを
全て表示している３つのマップです。
このボックスには、私達が作った
アクチュアル生成コードがあります。
88 キロバイトだけです。
次のボックスは、Eigen です。
これは 76 キロバイトです。
ここで言及したい点は、
このスライドの中で Eigen が一体
何をしているのかということです。

Spanish: 
El tamaño binario original
era 2.6 megabytes.
Y se descompone en un megabyte 
para el tiempo de ejecución
TensorFlow con las operaciones 
que realmente necesitamos
y luego 1,6 megabytes para el gráfico.
Y cuando compila eso,
terminamos con 600 kilobytes.
Eso era lo que Chris decía
en términos de reducción de tiempo.
272 kilobytes de eso es código
y 330 kilobytes es el peso.
Así que me voy a centrar en esos 272.
Porque incluso cuatro veces
no es suficiente.
Quiero hacerlo más grande.
Quiero señalar esta imagen aquí abajo
que no puedes leer nada en ella
es un mapa de árbol
de todo el uso del tamaño binario
desglosado en lo que realmente 
lo está utilizando.
Aquí en esta caja está el verdadero 
código generado
que creamos.
Solo son 88 kilobytes.
La siguiente caja que tenemos es Eigen
esto tiene 76 kilobytes.
Es un buen punto 
para mencionar también eso
te podrías estar preguntando
¿qué hace Eigen en la imagen?

Portuguese: 
O binário original tinha 2,6 megabytes.
Que representa 1 MB
do tempo de execução do TensorFlow,
com apenas as operações que precisamos,
e 1,6 MB do grafo.
Compilando, temos 600 kB.
Era disso que o Chris falava,
uma redução de quatro vezes no tamanho.
Aqui, 272 kB são o código
e 330 kB são pesos.
Vou me concentrar nos 272.
Porque quatro vezes
ainda não é o bastante.
Queremos mais, certo?
Quero ressaltar que esta imagem,
em que vocês não conseguem ler nada,
é um mapa em árvore do tamanho do binário
segmentado pelo que de fato o está usando.
Nesta caixa aqui está
o código gerado que criamos.
Tem apenas 88 kB.
A caixa seguinte é a Eigen que tem 76 kB.
É um bom momento para mencionar,
bem, vocês devem estar se perguntando
o que a Eigen está fazendo aqui.
Eigen, se vocês não sabem,

Korean: 
원래의 바이너리 크기는
2.6 메가바이트입니다
이는 텐서플로우 실행 시간에서
1 메가바이트로 줄고
실제로 필요한 운영만 하는 거죠
그래프는 1.6 메가바이트가 됩니다
이를 컴파일하면
600 킬로바이트까지로 감소하죠
크리스가 4배 감소에 대해
말한 점이 바로 이 부분입니다
272 킬로바이트는 코드
330킬로바이트는 무게이죠
이 272에 초점을 두겠습니다
4배라 하더라도 부족하기 때문이죠
더 크게 만들고 싶죠
이 밑에 있는 그림은
아무것도 읽을 수가 없긴 하지만
기본적으로 모든 바이너리 크기에 대한
나무 지도입니다
실제로 이를 사용하는 것이
무엇인지 보여주죠
이 상자에는 저희가 만든
실제 생성된 코드이죠
88킬로바이트 뿐입니다
다음 상자는 아이건으로
76킬로바이트 입니다
또한 언급하고 싶은 점은
이 그림에서 아이건이
왜 있는지 궁금하시겠죠

Chinese: 
最初的二进制文件大小是2.6兆字节
现在使用TensorFlow
运行时间将到了1兆字节
只使用我们需要的操作
图表只有1.6兆字节大小
我们用编译，最后得到的文件为600千字节
所以这就是克里斯之前说的
减少了四倍大小
272千字节的代码 　
330千字节的文件大小
让我们来自习研究一下这个272
虽然我们已经将文件减少了四倍
但这还不够
我还想要更近一步的改善
所以我想要指出
下面的这张照片
你并不能从它上面读取任何的信息
它基本上是一个树形图
它显示了我们现在正在使用的二进制文件大小
所以在这里的这个矩形框中
这是我们实际生成的代码
只有88千字节
下一个矩形框显示的是本征
只有76千字节
在这里我们还要提起
你可能会想知道
本征在这张图像上是做什么

Indonesian: 
Ukuran awal biner adalah 2,6 megabyte.
Dibagi jadi 1 megabyte untuk waktu proses
TensorFlow, dengan hanya
satu operasi yang kita perlukan
lalu 1,6 megabyte untuk grafik.
Saat kita mengompilasinya,
kita berakhir dengan 600 kilobyte.
Inilah yang Chris bicarakan
dalam hal, empat kali reduksi.
272 kilobyte dari itu adalah kode
dan 330 kilobyte adalah berat.
Saya akan fokus pada 272 itu.
Karena meskipun empat kali,
itu masih kurang.
Saya ingin lebih besar.
Saya ingin tekankan untuk gambar ini,
mungkin Anda tak bisa baca apa pun.
Pada dasarnya peta pohon
dari semua penggunaan ukuran biner
yang dipisahkan oleh
apa yang menggunakannya.
Di kotak ini, ini sebenarnya
hasil kode yang kita buat.
Hanya 88 kilobyte.
Kotak selanjutnya yang kita punya
adalah Eigen.
Ini 76 kilobyte.
Ini poin bagus untuk juga beri tahu bahwa
Anda mungkin berpikir, apa
yang Eigen lakukan di sini?

Korean: 
아이건은 특별화 된
선형 대수학 라이브러리 같은
C++에서 템플릿화 된 것입니다
matmul을 상당히 빨리
할 수 있게 해주죠
타일링 등을 크기에 따라 해줍니다
XLA에서는 스스로
이 모든 것을 그저 실행시킬
기회가 있을 뿐 아니라
이미 현존하는 괜찮은
실행이 있다면 그냥 이용하면 되는 거죠
따라서 이 특정 경우에는
LCM 셀 안에 있는 행렬 곱셈을 위한
단일-스레드 아이건을
이용하는 거죠
이는 76 킬로바이트이죠
사실 오른쪽에 대부분은
표준 안드로이드 라이브러리가
사용하고 있죠
이는 108 킬로바이트 정도죠
이는 정말 원하면
훨씬 더 작게
만들 수 있다고 믿는 일의
스냅샷입니다
하지만 272나 600 킬로바이트도
좋은 출발점이죠
벌써 4배 정도 감소된 거죠
요약컨대 텐서플로우 그래프가
어떻게 XLA를 통해
컴파일 되는가를 다뤘죠
저스트인타임과 어헤드오브타임
컴필레이션 모두가 있죠

English: 
Like, Eigen, if you don't
know, is a C++ templated sort
of specialized linear
algebra sort of library.
So it let's you do, like,
matmuls really fast.
Does that sort of tiling and
stuff depending on your sizes.
In XLA, we have the opportunity
to not just implement
all these things
on our own, right?
But if we have good
implementations
that already exist, we can
just take advantage of it.
And so in this
particular case, we've
taken advantage for
single-threaded Eigen
for the matrix
multiplications that
happen inside the LCM cells.
So that takes up 76 kilobytes.
And actually, on the
right, the majority
is taken up by standard
Android libraries.
This is, like, 108 kilobytes.
So this is just a
snapshot of sort
of like the we believe
we can actually
make things much smaller
even if we really wanted to.
But 272 or 600 kilobytes
even is a pretty good start.
It's, like, a four
times reduction already.
And so to summarize,
we've talked
about how so TensorFlow
graphs are compiled via XLA.
We have both just-in-time and
ahead-of-time compilation.

Indonesian: 
Eigen, jika Anda tidak tahu,
adalah template C++
aljabar linear khusus, seperti pustaka.
Jadi dia membiarkan Anda melakukan
matmul sangat cepat.
Menyusun dan sebagainya
yang bergantung pada ukuran.
Di XLA, kita punya kesempatan
bukan hanya mengimplementasi
semua hal ini sendiri.
Jika sudah punya implementasi bagus,
kita bisa memanfaatkannya.
Di kasus ini, kami manfaatkan
Eigen thread tunggal
untuk perkalian matriks
yang terjadi di dalam sel LCM.
Itu membutuhkan 76 kilobyte.
Sebenarnya, di kanan, mayoritas diambil
oleh pustaka Android standar.
Ini sekitar 108 kilobyte.
Ini hanya cuplikan
dari hal yang kita percayai
kita bisa buat lebih kecil jika
kita menginginkannya.
Tapi 272 atau 600 kilobyte,
awal yang lumayan bagus.
Yaitu empat kali reduksi.
Merangkum, kita sudah bicara
soal cara grafik TensorFlow
dikompilasi lewat XLA.
Kita punya kompilasi
tepat waktu dan lebih cepat.

Spanish: 
Eigen, por si no sabes, 
es como una plantilla de C++
de una biblioteca especializada
de álgebra lineal.
Te deja hacer matmuls con mucha rapidez.
Hace ese tipo de mosaicos 
dependiendo de tus tamaños.
En XLA, podemos no solo implementar
todo esto por nuestra cuenta.
Si tenemos implementaciones
buenas que ya existen, podemos aplicarlas.
En este caso en particular
usamos Eigen para un solo hilo
para las multiplicaciones matrices
que ocurren dentro de las células LCM.
Así que ocupa 76 kilobytes.
En realidad, la mayoría de la derecha está
ocupada por bibliotecas estándar 
de Android.
Como unos 108 kilobytes.
Es solo una muestra
de que nosotros creemos
que podemos disminuir las cosas
mucho más si es lo que queremos.
Pero 272 o 600 kilobytes 
es un buen comienzo.
Ya es una reducción.
Y para resumir, hemos hablado
de cómo se compilan los gráficos 
TensorFlow mediante XLA.
Tenemos compilaciones
justo a tiempo y adelantadas.

Portuguese: 
é uma biblioteca em C++
especializada em álgebra linear.
Então permite que se faça
matmuls muito rápido.
E faz tiling dependendo dos tamanhos.
Em XLA, temos a oportunidade
de não apenas implementar
todas essas coisas por conta própria.
Mas se já houver boas implementações,
podemos aproveitá-las.
Neste caso específico,
aproveitamos a linha única
de execução da Eigen
para as multiplicações matriciais
que ocorrem dentro das células LCM.
Isso ocupa 76 kB.
À direita, a maior parte é ocupada
por bibliotecas padrão do Android.
Isto é 108 kB.
Isto é apenas uma ideia
de como acreditamos
que poderíamos deixar tudo
ainda menor, se quiséssemos.
Mas 272 kB ou 600 kB é um bom começo.
O tamanho já é quatro vezes menor.
Em suma,
falamos sobre como grafos
do TensorFlow são compilados via XLA.
Temos duas compilações,
just-in-time e ahead-of-time.

Japanese: 
Eigen とは、特殊化した
一次代数ライブラリーの
テンプレート化した C++ です。
非常に速い matmuls のようです。
タイル張りをし、
サイズに合わせるようなものです。
XLA には、自分達で全てを
実行しないという選択もあります。
既存の素晴しい実行があるため、
そこから利益を得ます。
この特殊なケースでは、
LCM セル内部で起こる配列乗算のため
シングルスレッド Eigen 用に
使いました。
それは 76 キロバイトになります。
右側では、大部分は標準 Android 
ライブラリから得ています。
それは 108 キロバイトになります。
これはスナップショットで、
より小さくできると信じているものを
表示してあります。
心から実現したいと思っています。
しかし 272 や 600 キロバイトは
かなりよい出だしだと言えます。
すでに４倍の軽減を行なっています。
要約すると、TensorFlow グラフが
XLA を通して、どのように
コンパイルされるかを話しました。
ジャストインタイムとアヘッドオブタイム
両方のコンピレーションがあり、

Chinese: 
事实上，如果你不知道的话
它是一个以C++ 为模版的
特殊的线性代数图书库
它可以让你快速的使用matmuls
会根据你的尺寸调整
在XLA中，我们可以选择
不自己运行这些程序
如果我们很好的运行现有的程序
我们就可以使用它
所以在这个例子中
我们使用单一本征
使用矩阵乘法
在LCM细胞内
这占用了76千字节的内存
事实上，在右边
大部分信息都由安卓图书库占用
大约占有108千字节
这只是一个快照
我们相信我们可以
让所有的程序变的更小
272或是600千字节是一个很好的开始
已经减少了四倍
总结来说
我们谈到了TensorFlow图表是如何通过XLA编译的
我们有即时和提前编译

Japanese: 
これらはかなり高度で、
様々な使用ケースで役に立ちます。
幾つかのリアルモデルは、すでにより速く、
より小さくなっています。
非常に素晴しいことです。
最後に話したのは、
進行中の作業についてです。
これらを改善するために努力し続けます。
これらのベンチマークナンバー全てのように。
より良くするために日常ベースで
作業を進めていきます。
それではスピーチを終わります。

Korean: 
둘다 아주 멋지고
상이한 사용 사례를 다루죠
일부 실제 모델은
이미 더 빠르거나 용량이 더 작죠
모두 정말 멋집니다
그리고 마지막으로
진행중인 작업이 있습니다
계속해서 향상시키려고 노력 중이죠
이 모든 벤치마크 숫자의 경우
더 발전하기 위해
매일 작업하고 있는 것들이죠
그럼 이것으로 마치겠습니다

Spanish: 
Ambos son bastante útiles
y tienen diferentes usos.
Algunos modelos reales
ya son más rápidos o más pequeños.
Así que todo está muy bien.
Lo último es el trabajo en curso.
Continuamente intentamos 
mejorar esas cosas.
Como en todos esos números
de referencia en los que trabajamos 
a diario
para intentar mejorar las cosas.
Y eso fue todo.

Chinese: 
它们都非常的酷，可以运用在不同的例子中
一些模型，一些真实的模型
已经变的更快更小
所以这真的很棒
所以最后一件事就是正在进行的工作
我们不断的改进这些功能
所以的这些基准数据
我们每天都在努力
想要把一切变的最好
所以，这就是今天的全部内容

Indonesian: 
Keduanya keren dan menyediakan
penggunaan berbeda.
Beberapa model nyata
sudah lebih cepat atau lebih kecil.
Jadi sangat bagus.
Terakhir, yang sedang dikerjakan.
Kami terus coba meningkatkan ini semua.
Seperti angka tolak ukur itu,
kami berusaha setiap hari
untuk meningkatkannya.
Sampai di sini, sekian.

English: 
And so they're both pretty cool
and serve different use cases.
And some models,
some real models,
are actually already
faster or smaller.
So it's all really neat.
And oh, yeah, the last thing is
that work in progress, right?
Like, we're continually trying
to improve these things.
Like, all those
benchmark numbers,
we're working on that
on sort of a daily basis
to try to make things better.
And so with that,
that's the talk.
[MUSIC PLAYING]

Portuguese: 
Ambas são bem legais
e atendem diferentes casos de uso.
Alguns modelos reais já estão
mais rápidos ou menores.
Então é bem bacana.
A última coisa é aquele
"estamos trabalhando", certo?
Estamos continuamente tentando melhorar.
Aqueles números dos benchmarks,
trabalhamos neles diariamente
e tentamos melhorá-los.
Com isso, termino a conferência.
