
Chinese: 
嗨，我是 Jonathan
在座的朋友可能很多都在
使用信息构建
或正在各种产品中
做着选择
我想告诉你TensorFlow应适合您的需求
这遥控器...
好了，谢谢
首先，我先谈一下对于系统来说
从培训到服务的所有步骤
通常都涉及到这三个步骤
一般来说 
原始数据在训练时都不太好用
所以必须对数据进行处理
之后，你对它进行培训
然后提出你的模型
所以对于数据准备来说

Japanese: 
[TensorFlow開発者会議2017]
こんにちは ジョナサンです
皆さんの多くはもう組織内で
多くのインフラを実行しているか
他の様々なインフラを実行したいと
思ってることでしょう
TensorFlowはそこに
適しているというお話をします
リモコンはー
ありがとう
まず訓練からモデルの実稼働までの
全段階について話そうと思います
通常この３段階になります
大抵持っている生データは
まだ訓練に適しません
それで何らかのデータ準備が
必要です
その後 訓練をして
モデルを提供します
データ準備には

Portuguese: 
Olá, sou Jonathan.
Muitos de vocês provavelmente
já rodam infraestrutura
nas suas organizações,
ou querem rodar várias outras peças
de infraestrutura.
Vou contar a vocês sobre
como o TensorFlow se encaixa nisso.
Então, o botão...
Obrigado.
Primeiro, vou falar sobre todas as etapas,
de treinar a servir um modelo em produção.
E, tipicamente, envolve essas três etapas.
Em geral, dados brutos não são bons
para treinamento,
então você precisa
fazer uma preparação de dados.
Depois disso, você faz o treinamento
e então serve seu modelo.

English: 
JONATHAN HSEU: Hi, I'm Jonathan.
A lot of you are probably
running a lot of infrastructure
already in your
organization or you
want to think about running
various other pieces
of infrastructure.
And I'm going tell you about
TensorFlow fits into that.
So, the clicker--
[SIDE CONVERSATION]
OK, thank you.
So first, I'm going to talk
about all the steps you
go from training to serving
a model in production.
And it typically involves
these three steps.
Usually, the raw data that you
have isn't good for training
yet, so you have to do some
form of data preparation.
After that, you do training
and then you serve your model.
So, for data preparation,
there are three essential steps

Indonesian: 
Hai, saya Jonathan.
Banyak dari Anda memakai infrastruktur
dalam organisasi Anda
atau ingin menjalankan
bagian lain infrastruktur.
Saya akan cerita tentang bagaimana
TensorFlow dipakai untuk itu.
Jadi, clickernya--
Baik, terima kasih.
Pertama, saya akan jelaskan
semua langkah yang Anda lakukan
dari pelatihan sampai menyajikan
sebuah model dalam produksi.
Dan biasanya melibatkan tiga langkah ini.
Biasanya, data mentah Anda
belum cocok untuk pelatihan
jadi Anda perlu mempersiapkan data.
Lalu, Anda jalankan pelatihan, 
lalu menyajikan model.

Korean: 
안녕하세요, 저는 조나단입니다
여기 계신 많은 분들께서는
이미 속해 계신 단체에서
여러가지 인프라를 사용해 보셨거나
다른 인프라들을
사용해 보고 싶어하고 계실 것이라
생각됩니다
오늘은 텐서플로가 어떻게 사용될 수
있는가에 대해 말씀드리겠습니다
클리커가...
감사합니다
우선, 연습부터 모델 생산까지의
단계들에 대해
말씀 드리도록 하겠습니다
대게 3가지 단계로 이루어져 있는데요
보통 가공 전 데이터는
연습하기에 적합하지 않습니다
어느 정도의 데이터 준비 작업을
하셔야 하는데요
그 이후에 연습을 거쳐
모델을 만드실 수 있게 될 것입니다
데이터를 준비하는 것에는

Spanish: 
Hola, soy Jonathan.
Muchos de ustedes tal vez ya ejecutan
mucha infraestructura en su organización
o quieren pensar en ejecutar otras
diversas piezas de infraestructura.
Y les voy a contar que TensorFlow
encaja en eso.
Entonces, el puntero...
Bien, gracias.
Así que, primero, voy a hablar
sobre todos los pasos
que van del entrenamiento a ejercer
un modelo en producción.
Y normalmente implica estos tres pasos.
Por lo general, los datos puros que tienes
no son buenos aún para la formación
así que tienes que formar
la preparación de los datos.
Después de eso, haces entrenamiento
y entonces ejerces tu modelo.
Para la preparación de datos
hay tres pasos esenciales

Japanese: 
3つの必須な段階があります
データを様々なソースから
インポートします
これはHiveやMySQLなどですね
通常 データに
何らかの前処理を実行します
集計を計算したり結合を行います
その後TensorFlowでサポート
されているファイル形式で
ファイルをエクスポートします
それについて後に説明しましょう
多くの皆さんはこのプロセスを行うための
次の３つを使用してきました
SPARC、Hadoop の MapReduceか
Apache Beamですね
現在
これらでうまくいきます
視覚的な例として私たちにはー
MySQLからデータを供給しています
それがユーザーデータだとします
Hiveにデータがあります
例がWebインプレッションや
ウェブクリックだとします
地域ごとのユーザーデータのように
そのデータを合わせ
集計を計算しますね
特に埋め込みを使用している場合は
しばしば語彙生成を行います
語彙生成は本質的に
単語からIDへマップし
IDマップを埋め込み層へ
埋め込みを意味します

Spanish: 
que están involucrados en ella.
Así que importarás los datos
de diversas fuentes.
Podría ser de Hive,
MySQL y así sucesivamente.
Normalmente, realizarás algún tipo
de pre-procesamiento en los datos.
Ellos calcularán agregados o harán uniones
y luego exportarás el archivo
en el formato admitido
por TensorFlow y eso lo explicaré luego.
Por lo general, mucha gente ha estado
usando estas tres cosas
para hacer este proceso...
SPARC, Hadoop, MapReduce o Apache Beam.
Y con todos funciona bien en este momento.
Como ejemplo visual, tenemos...
Te llenas de datos de MySQL.
Digamos que son datos del usuario
y tienes datos en Hive.
Un ejemplo podrían ser las impresiones web
o los clics en la web.
Quieres unir esos datos,
calcular agregados
como los datos de usuario por región.
A menudo, generarás vocabulario
particularmente si usas
incrustaciones.
El generar vocabulario,
esencialmente, significa
mapear palabras a IDs y mapear IDs
a una capa de incrustación...
Y después de eso, típicamente tendrás

English: 
that are involved
in data preparation.
So you'll import the data
from various sources.
This might be Hive,
MySQL, and so on.
You'll typically perform
some sort of pre-processing
on the data.
They'll compute
aggregates or do joins
and then you'll export the file
in the file format supported
by TensorFlow and I'll
explain that a bit later.
So, a lot of people have been
using typically these three
things for doing this process--
SPARC, Hadoop, MapReduce,
or Apache Beam.
And it works well with
all these at the moment.
And as a visual
example, we have--
you're feeding in
data from MySQL.
Say it's user data.
And you have data in Hive.
An example might be web
impressions or web clicks.
You want to join that
data, compute aggregates
like user data per region.
Often, you'll do vocabulary
generation, particularly
if you're using embeddings.
Vocabulary generation
essentially
means, like, mapping from
words to IDs and the IDs map
to an embedding
layer-- embedding.
And then after that,
you'll typically

Chinese: 
涉及三个基本步骤
你输入的数据来自不同的地方
这可能是Hive
MySQL等等
你通常会对数据
进行某种预处理
它们将计算聚合或执行连接
然后以TensorFlow支持的文件格式导出文件
稍后我会做解释
所以，很多人一直在用
SPARC，HadoopMapReduce
或者Apache Beam
这些编程模型来完成这个过程
目前它们的效果都很好
如图所示
你在输入来自MySQL的数据
例如用户数据
在Hive中也有数据
例子可能是网络印象或网路点击
你想执行数据链接或计算聚合
例如每个区域的用户数据
通常你会做词汇生成
特别是你使用嵌入式
词汇生成基本上就是
从单词到身份的映射
再将ID映射到嵌入层 - 嵌入
之后

Korean: 
3가지 단계가 있습니다
여러가지 출처들에서
데이터를 불러오실 것입니다
하이브나 마이에스큐엘
같은 곳에서 말이죠
대체로 데이터에
전처리가 필요하실 겁니다
데이터에 대한 집계 통계를
계산 한다거나 연결한 후
텐서 플로에서 지원하는
파일 형태로 내보내실 것입니다
이것에 대해서는 추후에 조금 더
설명해 드리도록 하겠습니다
많은 분들께서 이 단계를 위해
사용하시는 프로그램들에는
SPARC, 하둡, 맵리듀스
혹은 아파체 빔 등이 있습니다
현재로써는 모든 프로그램들이
잘 작동하고 있습니다
그리고 시각적인 사례로
마이 에스큐엘에서 처리한
피드 데이터를 보도록 하겠습니다
이것이 여러분들의
데이터라고 생각해 봅시다
하이브에 데이터를 가지고 계시다고
보는 것이죠
예를 들자면 웹 임프레션이나
클릭 같은 것들이요
그 데이터들을 연결하시거나
집계 통계를 내셔야 합니다
한 지역당 한 유저의
데이터들이라던가 이런 식으로요
가끔 단어를 만들어
내셔야할 때도 있습니다
특히 삽입을 사용하신다면요
단어를 만든다는 것이 무슨 말이냐하면
단어에서 아이디로 그리고 그 아이디들로
삽입 층을 만듧니다
그 후에는 주로

Indonesian: 
Jadi, untuk persiapan data,
ada tiga langkah penting.
Jadi Anda akan mengimpor data
dari bebagai sumber.
Mungkin dari Hive, MySQL, dan sebagainya.
Anda akan lakukan sejenis pra-proses data.
Yaitu menghitung agregat atau
melakukan penggabungan
lalu Anda akan ekspor file
dalam format file yang didukung
oleh TensorFlow dan saya akan
menjelaskannya nanti.
Jadi banyak yang sudah menggunakan
tiga hal khusus ini
untuk melakukan proses ini--
SPARC, Hadoop, MapReduce,
atau Apache Beam.
Dan bekerja baik dengannya saat ini.
Sebagai contoh visual, kami punya--
Anda mengumpan data dari MySQL.
Katakanlah itu data pengguna.
Dan Anda memiliki data dalam Hive.
Satu contoh mungkin tayangan web
atau klik web.
Anda mau gabungkan data, 
menghitung agregat
seperti data pengguna per wilayah.
Anda akan sering melakukan 
vocabulary generation
khususnya jika Anda gunakan penyematan.
Vocabulary generation,
artinya, contohnya, penyematan dari
kata ke ID dan ID dipetakan
pada sebuah lapisan penyematan--
penyematan.
Dan setelah itu, biasanya Anda punya

Portuguese: 
Para preparação de dados,
há três etapas essenciais envolvidas.
Você importará os dados de várias fontes.
Pode ser do Hive, MySQL, e outros.
Você normalmente faz
um pré-processamento nos dados.
Eles computarão agregados
ou farão ligações
e então você exportará o arquivo
no formato suportado
pelo TensorFlow, explicarei mais a seguir.
Então, muitas pessoas têm utilizado
tipicamente essas três coisas
para fazer este processo,
SPARC, Hadoop, MapReduce ou Apache Beam.
E funciona bem com todos neste momento.
Como exemplo visual, nós temos...
Você alimenta dados do MySQL,
digamos, dados de usuário.
E você tem dados no Hive.
Um exemplo pode ser impressões
ou cliques na web.
Você vai unir esses dados,
computar agregados
como dados de usuário por região.
Muitas vezes, você gerará vocabulário,
particularmente se utiliza embutidos.
Geração de vocabulários
significa mapeamento de palavras
para IDs, e do mapa de IDs
para uma camada embutida.

Portuguese: 
E depois, você normalmente
fará um teste de treinamento dividido.
E depois deste processo,
você terá um formato de arquivo
que o TensorFlow compreende.
E por que você vai querer isso?
O formato do arquivo de entrada
utilizado com TensorFlow
é, na verdade, importante.
Por exemplo, imagine que você está
treinando inception em GPUs P100.
Você quer manter o P100 saturado.
Uma das coisas mais importantes
para que isso funcione bem,
é trabalhar no pipeline de entrada.
Isso envolve trabalhar com pistas.
Existem tutoriais
no website do TensorFlow.
Mas, neste caso, falarei
sobre formatos de arquivos.
Alguns formatos de arquivos são
mais rápidos do que outros.
Nós otimizamos o caminho
para trabalhar com buffer de protocolo
tf.Example e tf.SequenceExample.
SequenceExample é normalmente utilizado
quando você treina com RNNs,
e TFRecords é um formato específico
de arquivo do TensorFlow
que utilizamos nele.
E este é, sem dúvida, o mais rápido.
Utilizamos internamente
e otimizamos este caminho muito bem.

Chinese: 
你将会把训练测试分开
在此过程之后
就可输出TensorFlow 识别的文件格式
为什么要做这些呢？
输入的文件格式
实际上对TensorFlow很重要
举个例子
假设你在P100 GPU上
开始做培训
你想保持P100色彩饱和度
其实最重要的是
保持输入技术
工作状态良好
这涉及到如何使用线索
在TensorFlow网站上有有关教程
但是在这个例子中
我将谈论文件格式
一些文件格式化时快过另一些
我们特别优化了
使用tf.Example和tf.SequenceExample
协议缓区的路径
SequenceExample
通常在训练RNNs时使用
tf.Records是与TensorFlow一起使用的
特定文件格式
这是迄今为止最快的
我们内部在使用它
路径已很好地优化了
另外 TensorFlow本来就支持

Indonesian: 
satu pemisahan tes pelatihan.
Dan setelah proses ini, 
Anda akan keluarkan satu format file
yang dimengerti TensorFlow.
Dan mengapa Anda melakukan hal ini?
Jadi format input file yang mereka
gunakan dengan TensorFlow
sesungguhnya cukup penting.
Contohnya, anggaplah
Anda sedang melatih Inception
pada P100 GPU.
Anda ingin menjaga kejenuhan P100.
Satu hal paling penting
untuk dilakukan agar berhasil
yaitu bekerja pada kerangka input Anda.
Hal itu melibatkan sinyal.
Ada tutorial di situs web TensorFlow.
Tapi khusus kasus ini,
saya akan membahas format file.
Beberapa format file lebih cepat
dibanding lainnya.
Kami khususnya telah mengoptimalkan jalur
untuk bekerja dengan buffer protokol
tf.Example dan tf.SequenceExample.
SequenceExample biasanya digunakan
saat Anda berlatih dengan RNN
dan TFRecords adalah format
file khusus TensorFlow
yang kami gunakan dengan TensorFlow.
Dan sejauh ini, ini yang tercepat.
Kami gunakan secara internal, 
optimalkan jalur ini
dengan cukup baik.
Tambahan, TensorFlow aslinya

Spanish: 
un segmento de prueba de entrenamiento.
Y después de este proceso,
imprimirás a un formato de archivo
que TensorFlow entiende.
¿Y por qué tal vez quieres hacer esto?
El formato de archivo de entrada
que utilizan con TensorFlow
realmente importa mucho.
Por ejemplo, supongamos que inicias
la formación en GPUs P100.
Quieres mantener el P100 saturado.
En realidad, una de las cosas
más importantes
que puedes hacer para que funcione bien
es trabajar en tu fuente
de información de entrada.
Y eso implica trabajar con señales.
Hay tutoriales en el sitio web
de TensorFlow.
Pero en este caso específico,
hablaré de los formatos de archivo.
Algunos formatos de archivo
son más rápidos que otros.
Hemos optimizado el camino
para trabajar con búferes de protocolos
tf.Example y tf.SequenceExample.
SequenceExample normalmente se usa
cuando entrenas
con RNNs y tf.Records.
Es un formato de archivo específico
de TensorFlow
y lo usamos con él.
Y este es el más rápido de todos.
Lo usamos internamente y hemos
optimizado este camino muy bien.
Adicionalmente,
TensorFlow también nativamente

Korean: 
트레이닝과 테스트 셋으로 나누고
이 단계 이후에는
텐서플로가 이해 할 수 있는
파일 포멧으로 변환 하시면 됩니다
왜 이 단계를 거쳐야 할까요?
텐서플로에 사용하는 입력 파일의
포멧은 꽤나 중요합니다
예를 들어 당신의 첫 훈련을
P100 GPU들로 한다고 칩시다
당신은 P100를
포화시켜두셔야 할 겁니다
잘 실행 시키기위해
가장 중요한 것은
입력 통로에 신경을 쓰는 것입니다
신호를 사용하는 것을 포함하죠
텐서플로 웹 사이트의
튜토리얼 영상에서 확인하실 수 있습니다
하지만 특별히 이 케이스에서는
파일 포멧에 대해
이야기 해보도록 하겠습니다
어떤 파일 형식은
다른 것들보다 빠릅니다
저희는 tf. 이그잼플과
tf.시퀀스 이그잼플
버퍼 프로토콜들의 사용을 가장 적합하게
만들어 두었습니다
시퀀스이그잼플은 보통 RNN과
tf.레코드로 훈련하실 때 사용하시는
텐서플로와 호환되는
특정한 파일입니다
이게 가장 빠른 형식의 파일이구요
내부적으로도 사용중이고
저희가 꽤나 잘 최적화 시켜 놓았습니다

English: 
have a training test split.
And after this process,
you'll output to a file format
that TensorFlow understands.
And why might you
want to do this?
So, the input file format
they use with TensorFlow
actually matters quite a bit.
So, one example is, suppose
you're training inception
on P100 GPUs.
You want to keep
the P100 saturated.
Actually, one of the
most important things
you can do to make
that work well
is work on your input pipeline.
And that involves
working with cues.
There are tutorials on
the TensorFlow website.
But specifically in this case,
I'll talk about file formats.
Some file formats are
faster than others.
We have specifically
optimized the path
for working with tf.Example
and tf.SequenceExample protocol
buffers.
SequenceExample
is typically used
when you're training
with RNNs and tf.Records
is a TensorFlow
specific file format
that we use with TensorFlow.
And this is by far the fastest.
We use this internally and
we've optimized this path
pretty well.
Additionally,
TensorFlow also natively

Japanese: 
その後は通常
訓練テストを分割します
この処理のあと
TensorFlowが理解できる
ファイル形式に出力します
なぜこうするのでしょう？
TensorFlowで使う入力ファイル形式が
実は重要です
ひとつの例として
P100 GPUでInceptionを
訓練しているとします
P100を飽和状態に保つ必要があります
それをうまく行うために
最も重要なことの 1つは
入力パイプラインで作業することです
それにはキュー作業も入ります
TensorFlowのウェブサイトに
チュートリアルがあります
ですが 具体的にこのケースでは
ファイル形式について話しましょう
一部のファイル形式は
他の形式より高速です
私たちは具体的に
tf.Exampleと tf.SequenceExampleの
プロトコルバッファで作業する
パスを最適化しました
SequenceExampleは通常
RNNで訓練しているとき
使用されます
tf.RecordはTensorFlowで使う
TensorFlow固有のファイル形式です
そしてこれははるかに速いです
これを内部的に使用し
このパスをかなり最適化しました
さらに
TensorFlowはまたネイティブに

English: 
has ops to support reading from
various file formats like CSV,
JSON, fixed record length files.
We have upcoming
support for Avro.
So you can use those.
Those are a little slower,
but since they're native ops,
they actually work pretty well.
More commonly,
people, if you, like,
read examples of
TensorFlow code on the web,
people will be feeding
data directly in Python.
And this is by far
the most common.
It's the easiest
to experiment with.
It also has the
most flexibility,
meaning that you can use
any file format that Python
natively can understand and
then convert it to numpy arrays,
which can be fed as
tensors in TensorFlow.
It's also useful for settings
like reinforcement learning.
But it's also the
slowest option.
So if you're running
experiments, this makes sense.
But if you're trying to
productionize a pipeline
and you care about
training speed,
then you might want to consider
switching to the first option.
OK, I'd like to mention
actually why it's a bit slower.

Indonesian: 
punya ops untuk mendukung pembacaan
dari berbagai jenis format file
seperti CSV, JSON, file
dengan panjang rekaman tetap.
Akan ada dukungan mendatang untuk Avro.
Itu bisa digunakan.
Ops itu agak lambat, tapi karena Ops asli,
akan bekerja dengan baik.
Umumnya, jika orang yang suka
membaca contoh kode TensorFlow
di web, akan mengumpan data 
secara langsung di Python.
Dan sejauh ini, hal itu yang paling umum.
Paling mudah untuk dilakukan.
Juga yang paling fleksibel, artinya
Anda dapat menggunakan
format file apa saja yang dapat dimengerti
Python dan mengubahnya
ke susunan numpy, yang dapat diumpan
jadi tensor di TensorFlow.
Berguna bagi pengaturan 
seperti penguatan belajar.
Tapi itu juga opsi paling lambat.
Jadi jika Anda lakukan
eksperimen, ini masuk akal.
Tapi jika Anda coba memproduksi saluran
dan peduli akan kecepatan pelatihan,
lalu Anda mungkin ingin
mempertimbangkan beralih ke opsi pertama.
Saya ingin menjelaskan
mengapa itu sedikit lambat.

Spanish: 
tiene ops para ayudar a leer
varios formatos de archivo como CSV
JSON, archivos de registro
de longitud fija.
Tendremos soporte para Avro.
Así que puedes usarlos.
Son un poco más lentos,
pero ya que son ops nativos
realmente funcionan bastante bien.
Más comúnmente, si quieren,
lean ejemplos de código de
TensorFlow en la web,
las personas llenarán
datos directamente en Python.
Y esto es lo más común.
Es lo más fácil de experimentar.
También tiene más flexibilidad,
lo que significa que puedes utilizar
cualquier formato de archivo que Python
nativamente puede entender
y luego convertirlo en arreglos numpy
que pueden llenarse
como tensores en TensorFlow.
También es útil para los ajustes
como el aprendizaje de refuerzo.
Pero también es la opción más lenta.
Así que si ejecutas experimentos,
esto tiene sentido.
Pero si intentas producir
una fuente de información
y te importa la velocidad de entrenamiento
Entonces es posible que desees considerar
cambiarte a la primera opción.
Bien, me gustaría mencionar
por qué es un poco más lento.
Hay dos cosas que están involucradas...

Portuguese: 
Além disso, o TensorFlow
tem também ops nativos
para suportar a leitura
de vários formatos de arquivos
como CSV, JSON,
arquivos de comprimento fixo.
Teremos, em breve, suporte para Avro,
então, você pode utilizá-los.
Esses são mais lentos,
mas como são ops nativos,
funcionam muito bem.
Mais comumente, se vocês, por exemplo,
leem exemplos do código
do TensorFlow na internet,
as pessoas alimentam
dados diretamente em Python.
E isto é, sem dúvida, o mais comum.
É a forma mais fácil de experimentar.
Também tem mais flexibilidade,
o que significa que você pode utilizar
qualquer formato de arquivo que o Python
compreende nativamente
e então converter para matrizes NumPy,
que são alimentadas
como tensores no TensorFlow.
Também é útil para aprendizado de reforço,
mas também é a opção mais lenta.
Então, se você roda experimentos,
isso faz sentido.
Mas se você quiser produzir uma pipeline
e se preocupa com velocidade,
você pode querer considerar
mudar para a primeira opção.
Eu gostaria de mencionar
o porquê de ele ser mais lento.

Chinese: 
从各种文件格式
（如CSV，JSON，固定记录长度文件）
读取的数据
我们还将支持Avro
你们可以使用
它们有点慢
但由于是本机操作
实际上性能良好
更常见的是 如果你喜欢
可以在网络上阅读TensorFlow编程的例子
人们直接在Python中输入数据
这是到目前为止最常见的
也是最简单
和最灵活的
你可以使用Python
本身可以识别的文件格式
然后 将其转换为Numpy数组
在TensorFlow中作为张量输入
它对设置也很有用
像强化学习
但这也是最慢的选择
如果你只是测试
这样还行
如果你想应用到实际设计应用中
或者你在意训练速度
那么你应考虑回到第一个选择
好了，我想提一下
它为什么有点慢

Korean: 
또한 텐서플로는 원래
다양한 파일 형식을 지원하는 작업을
보유하고 있습니다
CSV나 JSON이라는
고정 길이 형식 파일도 지원하고 있구요
Avro도 조만간 지원이
가능해질 예정입니다
이런 것들을 사용할 수 있습니다
약간 느리기는 해도 익숙한 것들이라
잘 실행 될 것 입니다
좀 더 흔하게는 웹사이트의
텐서플로 코드 예시 같은 것을
바로 파이톤에 입력하실 수도 있습니다
이 방법이 가장 흔한 방법이지요
가장 쉬운 방법이기도 하구요
가장 융통성있기도 하구요
무슨 뜻이냐 하면
어떤 파일 형식을 사용하시던
파이톤이 알아서 사용 가능한
집합체로 바꿔줍니다
그것은 텐서플로에 텐서로
입력 될 수 있지요
강화 학습을 하는 상황에도
아주 유용합니다
하지만 가장 느린 방법이죠
만약 실험을 하시는 것이라면
사용하셔도 좋습니다
하지만 파이프라인을 만드시는 것이라
훈련 속도에 신경을 쓰셔야 한다면
처음 방법으로 하시는 것이
좋으실 것입니다
왜 느린지에 대해 설명드리자면
2가지가 연관 되어있기 때문 입니다

Japanese: 
CSV JSON 固定長レコードファイルのような
様々なファイル形式の読み取りを
サポートするオペレーションがあります
Avroには今後のサポートを
用意しています
あなたはそれらを使えます
少し遅いですが
ネイティブopなので
実際にはかなりうまく動作します
より一般的には
Web上のTensorFlowコードの
例を読む場合
Pythonで直接データを入力します
これははるかに一般的で
実験するのが一番簡単です
それはまた 最も柔軟性があり
つまりPythonがネイティブに理解できる
ファイル形式を使用できて
Numpy配列に変換できます
そしてTensorFlowでテンソル として
供給できます
また 強化学習などの設定にも役立ちます
ですが それは最も遅い選択肢でもあります
実験を行っている場合は
これは当然ですが
パイプラインを生成しようとして
訓練の速度を気にする場合
最初の選択肢に切り替えるといいでしょう
なぜ少し遅いのか話しましょう
関係する２つのことがあります

Indonesian: 
Ada dua hal yang terlibat--
membaca dari format file khusus
dalam Python sendiri
mungkin tidak terlalu cepat.
Anda punya bagian itu.
Sekarang saat konversi dari 
susunan pi baru ke tensor
TensorFlow, ada salinan terlibat
dan itu menunjukkan biaya tambahan.
Saya rekomendasikan TFRecords Support.
Kuharap sekarang, Anda jadi yakin.
Dan sebaik apa kerjanya?
Jadi Apache Beam, sampai 
beberapa minggu lalu
sebenarnya memiliki dukungan
awal untuk format file ini.
Tapi kebanyakan Anda
tidak menjalankan Apache Beam
dan akan menjalankan fungsi
Hadoop MapReduce dan SPARC.
Anda hanya ingin gunakan itu.
Jika Anda masuk ke repositori
ekosistem dalam organisasi
GitHub TensorFlow, kami punya kode
yang bekerja dengan TF Records.
Perhatikan bahwa saya tidak sebut
buffer protokol.
Buffer protokol punya dukungan awal
untuk banyak bahasa yang akan digunakan.
Baik, karena Anda telah mengekspor data
pelatihan ini, Anda ingin mulai latihan.
Ada dua cara umum 
untuk melakukan pelatihan.

Korean: 
파이톤이 특정한 파일 형식을
읽는 것 자체가
빠르지만은 않을 수도 있구요
그 이유가 하나 있고
그리고 새로운 파이 집합체를
텐서플로우의 텐서로
호환 할 때 복사를 해야 하는데
이것이 간접비를 생성합니다
그래서 제가 tf.레코드서포트를
추천 드렸던 것입니다
이 모든 정보들이 알아듣기
쉬우셨기를 바랍니다
그럼 얼마나 잘 실행되나요?
몇 주 전부터 아파치 빔에서
이 파일 포맷을 지원하기 시작했습니다
아파치 빔을 잘 사용하시지 않으시고
하둡 맵리듀스 SPARC같은
프로그램들을
사용하고 계실 것입니다
아마 쭉 그것을 사용하고 싶으실 거구요
텐서 플로의 생태계 보고에 들어가시면
깃허브 라고 하는데요
TF기록들을 위한 코드들이 있습니다
프로토콜 버퍼에 대해서
전혀 말씀드리지 않았는데요
프토콜 버퍼들은 여러분이 쓰시는
다양한 언어로 지원이 되고 있습니다
이제 이 트레이닝 데이터를 내보내셨다면
트레이닝이 하고싶으실 것입니다
2가지 흔한 방법들이 있는데요
하나는 여러분의 컴퓨터나 노트북에

Portuguese: 
Existem duas coisas envolvidas:
a leitura de formatos de arquivo
específicos no Python
pode não ser muito rápida.
Então, existe essa parte.
E então, ao converter de matrizes NumPy
para tensores TensorFlow,
existe uma cópia envolvida
que induz a uma sobrecarga adicional.
Então, eu recomendo suporte a TFRecords.
Espero que agora você esteja convencido.
E quão bem funciona?
O Apache Beam, há cerca de duas semanas,
tem suporte nativo
para este formato de arquivo.
Mas muitos de vocês
não estão rodando Apache Beam
e já estão rodando trabalhos
Hadoop MapReduce e SPARC.
E vocês querem usar isso.
Então, se você for
ao repositório de ecossistema
na organização GitHub do TensorFlow,
temos códigos para rodar
com registros TF lá.
Vejam que eu não mencionei
buffers de protocolo.
Buffers de protocolo têm suporte nativo
para muitas linguagens
que vocês utilizarão.
Agora que já exportaram
esses dados de treinamento,
vocês querem treinar.
Existem duas formas de fazer treinamento.

Japanese: 
Pythonで特定のファイル形式から
読み込むこと自体が
あまり速くないでしょう
新しい pi 配列から
TensorFlowテンソルに変換するとき
コピーが含まれ
オーバーヘッドを付加します
ですからtf.RecordSupportを
勧めました
現時点で納得なさったでしょうか
それがどれくらいうまく
機能するかと言うと
数週間前の時点でApache Beamは
このファイル形式をネイティブに
サポートしています
ですがApache Beamを実行する
人は多くなくて
もうHadoop MapReduceと
SPARCを実行していて
それを使いたいでしょう
GitHubのTensorFlowの
エコシステムリポジトリ に行くと
そこにTFRecordsで作業する
コードがあります
プロトコルバッファのことは
全く言ってなかったのですが
プロトコルバッファは
皆さんが使用する多くの言語に
ネイティブサポートがあります
このトレーニングデータを
エクスポートしたら
訓練を始めます
訓練には２つの一般的な方法があります

Chinese: 
这里涉及到两件事
读取Python中某些特殊文件格式
可能不会太快
这是第一点
然后转换Numpy数组到TensorFlow张力
涉及到另一个副本
增加了额外的工作
所以我在这里推荐tf.RecordSupport
希望在这点上我说服了你
它的工作效果如何呢？
几周前，Apache Beam
实际上已经支持这种文件格式
但是很多人不用Apache Beam
而是用SPARC
或Hadoop MapReduce
你就像用它们
如果你去TensorFlow生态系统的知识库
在那儿有GitHub
记载的TFRecords
请注意 我没有提过协议缓冲区
实际上是协议缓冲支持
很多你即将用到的语言
好了，现在你可以输出培训数据了
你想进行训练
这里有两种常见的训练方式

English: 
There are two things
that are involved--
reading from specific
file formats in Python
itself may not be too fast.
So you have that part.
And then when converting from
new pi arrays to TensorFlow
tensors, there is
a copy involved
and that induces
additional overhead.
So I've recommended
tf.RecordSupport.
Hopefully at this
point, you're convinced.
And how well does it work?
So, Apache beam, as
of a few weeks ago,
actually has native support
for this file format.
But a lot of you aren't
running Apache Beam
and you'll be running
Hadoop MapReduce and SPARC
jobs already.
And you just want to use that.
So if you go to the ecosystem
repository in the TensorFlow
GitHub organization, we have
code to work with TF records
there.
Note that I didn't mention
protocol buffers at all.
Protocol buffers actually
has native support
for a lot of languages
you would be using.
OK, so now that you've
exported this training data,
you want to go to training.
There are two common
ways of doing training.

Spanish: 
leer formatos de archivo
específicos en Python mismo
tal vez no sea muy rápido.
Así que tienes esa parte.
Y luego al convertir
de nuevas matrices pi a tensores
de TensorFlow, hay una copia involucrada
que induce sobrecarga adicional.
Así que he recomendado tf.RecordSupport.
Espero que en este punto,
estés convencido.
¿Y qué tan bien funciona?
Apache Beam, desde hace unas semanas,
tiene soporte nativo
para este formato de archivo.
Pero muchos de ustedes
aún no ejecutan Apache Beam
y ya ejecutan trabajos
de Hadoop MapReduce y SPARC
y solo quieres usar eso.
Así que, si vas al repositorio
del ecosistema en la organización
de TensorFlow GitHub, tenemos código
para trabajar ahí con los registros TF.
Ten en cuenta que no mencioné
los búferes de protocolo en absoluto.
Los búferes de protocolo
tienen soporte nativo
para muchos de los lenguajes que usas.
Ya que has exportado
estos datos de entrenamiento
vas a querer ir al entrenamiento.
Hay dos formas comunes de hacerlo.

Spanish: 
Una es decir que tienes una GPU
en tu ordenador de escritorio o portátil,
quieres hacer entrenamiento local.
Esto funciona bien para los casos
de depuración o al trabajar
con conjuntos de datos de orden pequeño.
Pero como Megan mencionó
en la charla de introducción,
el entrenamiento distribuido...
como, 64 GPUs
tienes una velocidad de 58x
en las imágenes procesadas por segundo
si ejecutas un comienzo distribuido
con 64 GPUs versus un GPU.
Así que entrenas mucho más rápido.
Y para mucha gente en tu organización
esta podría ser
la diferencia de tomar un mes
en entrenar un modelo
frente a tomar un día.
Y el bucle de retroalimentación
es bastante importante
para hacer que el aprendizaje automático
funcione bien en tu organización.
Entonces, existen
dos componentes esenciales
si quieres empezar con entrenamiento
distribuido en tu organización.
Derek habló acerca
de los gestores de clúster.
Conocemos organizaciones
que las han estado usando todas
para hacer una muy buena distribución
en TensorFlow.
Así que recomendamos cualquiera de estas.
Con Hadoop, quiero decir Hadoop Harn.

Korean: 
GPU를 가지고 계시다는
가정하에 부분적
훈련을 하고 싶을 때
사용 할 수 있습니다
특정한 경우에 자주 사용 되는데요
디버깅이나 작은 양의 데이터들을
사용하시는 경우가 해당됩니다
메간이 시작할때 말했듯이
64 GPU같은 분배된 트레이닝에서는
이미지를 프로세스 하는데
초당 58배속의 능률증가를
얻으실 수 있습니다
1GPU가 아니라 64 GPU의
분산된 시작으로
실행하셨으면 말입니다
즉, 연수가 훨씬 빨라지겠지요
여러분들의 기관에 있는 많은 사람들은
한 모델당 한달의 연수 기간을 갖느냐와
하루만에 연수를 끝낼 수 있는가의
차이 일 것입니다
피드백 루프도 꽤나 중요합니다
당신의 기관에서 기계 학습이
잘 진행되려면 말이죠
여러분의 단체에서 분산 훈련을
시작하기에 앞서
2가지 중요한 요소들이 있는데요
데릭이 말했듯이
클러스터 관리 자들이 중요합니다
이 모든 것들을 사용해서
텐서플로의 분산처리가
잘 실행되도록 노력하는 단체들이
많이 있을텐데요
여기 추천하는 것들이 있습니다

Japanese: 
１つはデスクトップやラップトップに
GPUがある場合
ローカルの訓練をします
これはデバッグや小さなオーダーの
データセットで作業するー
特定のケースでうまく機能します
しかしメーガンが
基調講演で話したように
分散訓練
例えば64 GPUの場合
１GPUに対して64GPUで
分散起動で実行するので
実際に1秒で処理される画像で
スピードが58倍になります
ですから訓練がずっと速いです
あなたの職場の 多くの人にとって
これはモデルの訓練にかかる時間が
１カ月と１日の違いです
職場で機械学習がうまく機能するには
フィードバックループが非常に重要です
ですから組織で分散訓練を
始める場合
必須コンポーネントが２つあります
デレクはCluster Managerについて
話していました
分散されたTensorFlowを
うまく機能させるため
このすべてを使用している
組織もあります
だから私たちはこれらの
いずれかをお勧めします

Chinese: 
比如在桌面或笔记本电脑上
你有一个GPU
你想做局部训练
这对于具体的工作
像调试或处理少量数据集等很有效
正如 Megan 在介绍中提到的
分布式培训 - 像64 GPU
如果你以分布式启动 64个GPU
而不是一个GPU时
每秒处理的图像速度便提高了58倍
所以你训练便会更快
对于很多人来说
这可能意味着
过去一个月的训练
相对于现在的一天
反馈回路
在机器学习的实践中非常重要
如果你想在公司
进行分布式培训
有两点必不可少
Derek讲到过集群管理器
我们知道已经使用这些产品的公司
TensorFlow都运行得很好
所以我推荐其中的任何一种

Indonesian: 
Satu, Anda harus punya GPU
di komputer atau laptop.
Anda mau lakukan pelatihan lokal.
Tugas ini bagus untuk kasus
khusus debugging atau bekerja
dengan perintah data set sedikit.
Seperti yang Megan sebutkan di awal
mendistribusikan pelatihan--
seperti 64 GPU
sebenarnya Anda dapat 58x kecepatan
untuk gambar diproses per detiknya
jika Anda jalankan pada distribusi dimulai
dengan 64 GPU versus satu GPU.
Anda berlatih lebih cepat.
Dan untuk banyak orang di organisasi Anda,
ini berarti perbedaan
memakan waktu sebulan
untuk melatih sebuah model
versus satu hari.
Dan simpai umpan balik sangat penting
untuk membuat pembelajaran mesin
bekerja dengan baik di organisasimu.
Jadi, ada dua komponen penting
jika Anda mau mulai dengan pelatihan
distribusi dalam organisasi Anda.
Derek membicarakan
tentang Cluster Manager.
Kami tahu organisasi
yang menggunakan semua ini
untuk membuat distribusi 
TensorFlow bekerja dengan baik.
Jadi kami rekomendasikan
salah satu dari ini.

Portuguese: 
Uma é tendo um GPU
no seu computador ou laptop.
Você quer fazer treinamento local.
Isso funciona bem para os casos
específicos de debugging
com pequenos conjuntos de dados.
Mas, como Megan mencionou
na palestra de introdução,
treinamento distribuído,
como, por exemplo, 64 GPUs,
você tem uma aceleração de 58x
em imagens processadas por segundo
se você rodar
em configurações distribuídas
com 64 GPUs contra um GPU,
então, você treina muito mais rápido.
E para muitas pessoas na sua organização,
essa pode ser a diferença
entre levar um mês
para treinar um modelo ou levar um dia.
E o ciclo de feedback é bem importante
para que o aprendizado de máquina
funcione bem na sua organização.
Então, existem dois componentes essenciais
para poder começar com treinamento
distribuído na sua organização.
Derek falou sobre
Gerenciadores de Cluster.
Conhecemos organizações
que têm utilizado todos estes
para fazer um TensorFlow distribuído
funcionar bem.
Então, recomendamos qualquer um desses.

English: 
One is say you have a GPU
on your desktop or laptop.
You want to do local training.
This works well for the specific
cases of debugging or working
with small order data sets.
But as Megan mentioned
in the intro talk,
distributed training--
like, 64 GPUs,
you actually get a 58x speed up
in images processed per second
if you run on
distributed starting
with 64 GPUs versus one GPU.
So you train much faster.
And for a lot of people
in your organization,
this could mean the
difference of taking a month
to train a model
versus taking a day.
And the feedback loop
is pretty important
to make machine learning work
well in your organization.
So, there are two
essential components
if you want to start
with distributed
training in your organization.
Derek was talking
about cluster managers.
We know organizations that
have been using all of these
to make a distributed
TensorFlow work well.
So we'd recommend any of these.

Indonesian: 
Hadoop di sini maksudnya Hadoop Yarn.
Dan jadi kami sebenarnya 
punya contoh konfigurasi
untuk Kubernetes dan Mesos, khususnya
dalam repositori ekosistem.
Jika Anda sudah menjalankannya,
Anda bisa memulai
secara cepat dengan cara itu.
Sebagai tambahan dari Cluster Manager,
Anda juga dapat menjalankan
penyimpanan terdistribusi.
Derek membahas sedikit tentang ini
tapi inilah yang kami gunakan.
Kami menambah dukungan
HDFS dalam TensorFlow 11.
TensorFlow punya dukungan awal
untuk membaca dari Google Cloud Storage
dan jika Anda jalankan
layanan cloud Amazon
lalu pengguna melaporkan ia 
bekerja baik dengan Amazon EFS.
Alasan Anda menjalankan
penyimpanan terdistribusi
biasanya karena dua alasan--
untuk data input, jadi tiap pekerja
bisa membaca dari sumber tunggal
dan untuk output model Anda--
jadi, untuk checkpoint dalam 
model ekspor itu sendiri.
Jadi, Container hanyalah sebuah opsi
tapi sangat direkomendasikan.
Jadi, Container mengisolasikan 
pekerja Anda dari lingkungan mereka.

Korean: 
Hadoop, 그러니까
Hadoop Yarn을 통해서
Kubernetes와 Mesos 를 위한
예시 배열들을 보유하고 있습니다
특별히 생태계의 보고에 대한 것들을요
이미 그 것들을 진행하고 계시다면
좀 더 빨리 시작하실 수 있습니다
하지만 클러스터 관리자 외에도
분산 스토리지를 실행하셔야합니다
데릭이 조금 설명 했었지만
이것 들이 저희가 사용하는 것들입니다
저희는 텐서플로 11에
HDFS 지원을 더했습니다
텐서플로는 또 원래
구글 클라우드 저장소를 지원합니다
아마존의 클라우드 서비스를 사용하신다면
사용자들의 보고에 따르면
아마존의 EFS와도 호환 된다고 합니다
분산 스토리지를 사용하시는 이유는
2가지가 있는데
각 유저가 하나의 출처에서
읽어 드릴 수 있게 하기위해서고
산출량 때문이기도 합니다
내보내진 모델의 검문소인 것이지요
저장소는 선택적인 것이지만
강력히 추천합니다
저장소는 일하는 사람들을
주변에서부터 고립시키죠

English: 
By Hadoop here, I
mean Hadoop Yarn.
And so we actually have
configuration examples
for Kubernetes and
Mesos specifically
in the ecosystem repository.
So if you're already running
that, then you can get
started pretty quickly that way.
But in addition to
a Cluster Manager,
you should also be running
distributed storage.
Derek was talking about
this a little bit,
but these are the ones
that we work with.
We added HDFS support
in TensorFlow 11.
TensorFlow also
has native support
for reading from
Google Cloud Storage,
and if you're running on
Amazon's cloud service,
then users have reported it
working well with Amazon EFS.
So, the reason you would want
to run distributed storage
is mostly for two reasons--
for your input
data so each worker
can read from a single source
and for output for your model--
so, for checkpoints in
the exported model itself.
So, containers are
completely optional
but highly recommended.
So, containers isolate your
workers from their environment.

Portuguese: 
Por Hadoop aqui,
quero dizer Hadoop Yarn.
Na verdade temos exemplos
de configuração
para Kubernetes e Mesos, especificamente,
no repositório do ecossistema.
Se você já roda isso, então poderá
começar rapidamente desta forma.
Mas, além de um Gerenciador de Cluster,
você deverá também rodar
armazenamento distribuído.
Derek falou um pouco sobre isso,
mas estes são os que utilizamos.
Adicionamos suporte HDFS
no TensorFlow 0.11.
TensorFlow também tem suporte nativo
para leitura do Google Cloud Storage,
e se quiser rodar
no serviço de nuvem da Amazon,
há usuários que reportaram
que ele trabalha bem com Amazon EFS.
Você pode querer rodar armazenamento
distribuído por dois motivos.
Para que seus dados de entrada
possam ler de uma única fonte
e para saída no seu modelo,
ou seja, para checkpoints
no modelo exportado.
Containers são completamente opcionais,
mas altamente recomendados.
Os containers isolam
seus trabalhadores do seu ambiente.

Chinese: 
Hadoop，我是说Hadoop Yarn
实际上，我们在生态系统库中
有Kubernetes和Mesos
专门的配置示范
所以如果你们已经在使用它们
那么就可以很快开始
但除了集群管理器之外
你也应该运行分布式存储
Derek 谈到一些
而这些是我们的合作伙伴
在TensorFlow 1.1
我们添加了HDFS支持
TensorFlow也支持Google云端存储
和Amazon的云服务
用户反馈在Amazon EFS也好用
你想运行分布式存储
主要有两个原因
一是为了输入的数据
从而每个人都可以从单一的来源读取数据
第二为的是模型--
输出模型本身的检测点
所以容器完全可有可无
但强烈推荐
容器把工作人员从环境中隔离出来

Spanish: 
Y tenemos ejemplos de configuración
de Kubernetes y Mesos, específicamente,
en el repositorio del ecosistema.
Así que si ya estás ejecutando
eso, entonces puedes
empezar bastante rápido de esa manera.
Pero además de un administrador
de clústeres
también deberías ejecutar
el almacenamiento distribuido.
Derek habló un poco de esto,
pero estos son los únicos
con los que trabajamos.
Hemos añadido soporte HDFS
en TensorFlow 11.
TensorFlow también tiene soporte nativo
para leer de Google Cloud Storage,
y si lo ejecutas
en el servicio de nube de Amazon,
pues los usuarios han reportado
un buen funcionamiento con Amazon EFS.
La razón por la que querrías
ejecutar el almacenamiento distribuido
es principalmente por dos razones...
para la entrada de tus datos,
para que cada trabajador
pueda leer de una sola fuente
y para la salida de tu modelo...
y para los puntos
del propio modelo exportado.
Por lo tanto, los contenedores
son completamente opcionales
pero muy recomendables.
Por lo tanto, los contenedores aíslan
a los trabajadores de su entorno.

Japanese: 
ここのHadoopは
Hadoop Yarnの意味です
エコシステムリポジトリに
特にKubernetesとMesosの
設定例があります
すでに
それを実行している場合は
早く始められます
Cluster Manager に加えて
分散ストレージ も実行する必要があります
デレクはこれについて
少し話していましたが
これらは私たちが扱うものです
TensorFlow.11でHDFSサポートを
追加しました
TensorFlowには
Google Cloud Storage から読み込む
サポートもあります
Amazonのクラウドサービスを
利用 している場合
ユーザーはAmazon EFSで
うまく機能していると報告しています
分散ストレージを実行する理由は
主に2つあります
あなたの入力データでは
workerが単一ソースから読み込めて
モデルの出力には
エクスポートされたモデル自体の
チェックポイントについては読み込めます
コンテナは完全にオプションですが
是非お勧めです
したがってコンテナは
worker を環境から隔離します

English: 
And one reason this is useful
is because certain jobs
might have certain
version dependencies that
might differ from other jobs.
And a specific example
here is eventually,
we'll release TensorFlow 2.0.
Senseful uses
semantic versioning,
and at 2.0, we may make some
backwards incompatible changes.
And suppose you want to
upgrade to TensorFlow
2.0 in your organization.
Then the containers
make it much easier
to do gradual updates
because you don't have
to update every job at once.
You can just update jobs.
You can pin the jobs to a
particular TensorFlow version
and update each one one by one.
So, getting started with
containers makes sense.
Docker is supported in
both Mesos and Kubernetes
and we recommend that.
So, as a refresh for what
Derek was talking about,
I'm going to show you what
distributed trading code looks
like as a refresh of
what Derek mentioned
and what configuration involves.
So, there are essentially two
types of jobs that you have--

Chinese: 
这点之所以重要是因为
有些工作与不同的版本之间有依赖关系
但有些没有
举个具体的例子，就是最终
我们会发布TensorFlow 2.0
有用的语义版本
在2.0，我们可能做一些
前后不兼容的更改
假设你们公司想要
升级到TensorFlow 2.0
容器使其逐步更新更容易
因为你不必
一次更新每个内容
你只需更新需要的
可以将需求固定到
某个TensorFlow版本
然后逐一更新
所以，一开始就选择容器是明智的
Docker支持Mesos和Kubernetes
所以我们推荐它
先回顾一下Derek 讲过的内容
先看一下 Derek 提过的
分布式交易代码是什么样子
涉及什么配置
基本上有两种工作类型--

Japanese: 
これが有用な理由の1つは
特定のジョブが
他の仕事と異なる特定の
バージョン依存性を
持つ可能性があるからです
ここの具体的な例は
最終的にはTensorFlow 2.0をリリースしますが
TensorFlowは
セマンティックバージョニングを使用し
2.0では 後方互換性のない
変更を行う可能性があります
あなたの職場でTensorFlow2.0に
アップグレードしたいとすると
コンテナが徐々の更新を
はるかに簡単にします
すべてのジョブを一度に
更新しなくて済むからです
ジョブの更新だけでいいのです
特定のTensorFlowバージョンに 
ジョブを固定し
それぞれを1つずつ更新できます
ですから コンテナを使い始めることは
理にかなっています
DockerはMesosとKubernetesの
両方でサポートされています
それをお勧めします
だからデレクが話していたことを
復習するために
分散トレーニングで
コードがどのようなものか
デレクが話したことに基づいて
またどのような構成が含まれているか
お見せします
本質的に2種類の仕事があります

Korean: 
이것이 유용한 이유는 어떤 일들은
다른 직업과 다른 의존이
필요할 수도 있습니다
예를 들어
저희가 곧 텐서플로 2.0을
낼 것입니다
의미 있는 사용과 의미론적인 버전으로요
그리고 2.0에서
뒤로는 양립할 수 없는
변화를 만들것입니다
그리고 여러분들이 텐서플로 2.0으로
업그레이드 하고 싶어지셨다고
가정해봅시다
그럴 경우에는 저장소가
천천히 업데이트 하실 수 있게 해줍니다
모든 작업들을 한번에 업데이트
하실 필요가 없기 때문이죠
작업들을 편리하게
업데이트 하실 수 있습니다
특정한 작업들을 텐서플로 버전에
고정 해 놓고
하나씩 업데이트 하시면 됩니다
그러니까 저장소로 시작하는 것이
앞뒤가 맞는거죠
Mesos와 Kubernetes에서는
Dockers를 지원합니다
그리고 저희는 그걸 추천하지요
데릭이 말하던 것을 상기시켜보자면
분산된 거래 코드가 어떻게 생겼는지
보여드리도록 하겠습니다
또 데릭이 말했던
어떤 구성이 관련되어
있는가에 대해서도요
두 가지 기본 작업은

Portuguese: 
Uma razão pela qual isso é útil
é porque certos trabalhos
podem ter certas dependências de versões
diferentes de outros trabalhos.
Um exemplo específico
aqui é que, eventualmente,
vamos lançar o TensorFlow 2.0.
O TensorFlow utiliza
versionamento semântico,
e no 2.0 podemos fazer algumas
mudanças retrógradas incompatíveis.
Supomos que você queira um upgrade
para TensorFlow 2.0 na sua organização.
Então, os containers
deixarão muito mais fácil
fazer atualizações graduais porque
não é preciso atualizar tudo de uma vez.
Você pode apenas atualizar trabalhos.
Pode associar trabalhos
a uma versão específica do TensorFlow
e atualizar uma por uma.
Então, começar com containers faz sentido.
O Docker é suportado
em ambos Mesos e Kubernetes
e nós o recomendamos.
Então, como lembrete do que
Derek falou a respeito,
vou mostrar como o código
de troca distribuída se parece
como um lembrete do que Derek mencionou
e quais configurações são envolvidas.
Existem, essencialmente, dois
tipos de trabalhos que você pode ter:

Spanish: 
Y una razón por la que esto es útil
es porque ciertos trabajos
podría tener ciertas dependencias
en la versión
que pueden diferir de otros trabajos.
Y un ejemplo específico aquí
es que finalmente
lanzaremos TensorFlow 2.0.
Una versión semántica con usos sensibles
y en 2.0, podemos echar para atrás
algunos cambios incompatibles.
Y supongamos que quieres actualizar
a TensorFlow 2.0 en tu organización.
Entonces los contenedores
la ponen más fácil
al hacer actualizaciones graduales
porque no tienes
que actualizar cada trabajo
de inmediato.
Puedes actualizar los trabajos.
Puedes asignar los trabajos a una versión
de TensorFlow en particular
y actualizarlos uno por uno.
Por lo tanto, empezar
con contenedores tiene sentido.
Docker es compatible
con Mesos y Kubernetes
y lo recomendamos.
Así pues, para refrescar lo que Derek
estaba hablando
te mostraré como luce
el código de comercio distribuido
para que refresques lo que Derek mencionó
y la configuración que implica.
Por lo tanto, hay esencialmente
dos tipos de trabajos...

Indonesian: 
Dan satu alasan ini berguna
karena pekerjaan tertentu
mungkin punya versi ketergantungan
yang berbeda dari tugas lain.
Dan contoh khusus di sini, nantinya
kami akan merilis TensorFlow 2.0.
Senseful menggunakan versi semantik
dan di 2.0, kami membuat beberapa
perubahan inkompatibel mundur.
Anggap Anda mau upgrade ke TensorFlow 2.0
di organisasi Anda.
Lalu Container mempermudahnya
untuk update bertahap
karena Anda tidak harus
update setiap tugas sekaligus
Anda bisa hanya update tugas.
Anda dapat mempin pekerjaan 
ke versi TensorFlow khusus
dan mengupdate satu demi satu.
Jadi, masuk akal
untuk mulai dengan Container.
Docker mendukung Mesos dan Kubernetes
dan kami merekomendasikannya.
Sebagai penyegar tentang
yang dikatakan Derek
saya akan menunjukkan
seperti apa kode trading terdistribusi
sebagai penyegar tentang
apa yang Derek katakan.
dan konfigurasi apa yang terlibat.
Jadi, ada dua tipe
pekerjaan yang Anda miliki--

Indonesian: 
server parameter dan pekerja.
Dan Derek menyebutkan bahwa
pengaturan yang paling umum
dan pengaturan yang kami rekomendasikan
adalah di antara replikasi grafik.
Dalam hal itu, pekerja
benar-benar mengoperasikan
dengan mandiri.
Jadi pekerja tidak perlu
berbicara satu sama lain
atau bahkan saling mengenal
satu sama lain.
Mereka hanya berkomunikasi 
dengan server parameter.
Dan untuk itu, Derek sudah menunjukkannya
tapi dengan berbagai slide.
Ini kode yang terlibat jika
Anda menggunakan TensorFlow inti.
Dengan level API lebih tinggi,
banyak yang hilang
dan jadi sederet kode yang lebih sedikit.
Tapi pada dasarnya, Cluster Manager
menyebutkan semua server
parameter lain dan pekerja
yang harus dikomunikasikan pekerja ini.
Anda memulai satu server.
Jika Anda server parameter,
berhenti di situ.
Tapi jika Anda pekerja, Anda perlu
menetapkan variabel ke server parameter
dan menentukan perangkat pekerja
sehingga grafik ini dimiliki
oleh pekerja tertentu ini.
Konfigurasi bergantung
pada Cluster Manager

Portuguese: 
servidores de parâmetros e trabalhadores.
E Derek mencionou
que a configuração mais comum
e a que recomendamos
está entre a replicação gráfica.
Neste caso, trabalhadores operam
independentemente.
Os trabalhadores não precisam
conversar uns com os outros
ou sabem muito sobre os outros.
Eles apenas se comunicam
com os servidores de parâmetros.
E, para isso, Derek nos apresentou
através de vários slides.
Este é o código envolvido
quando você utiliza núcleo TensorFlow.
Com APIs de nível mais alto,
muito disso sai
e transforma-se
em poucas linhas de código.
Mas, em essência,
seu Gerenciador de Cluster
especifica todos os outros servidores
de parâmetros e trabalhadores
com os quais este deve se comunicar.
Você inicia um servidor.
Se for servidor de parâmetro,
você para por aí.
Mas se for trabalhador,
você precisa atribuir variáveis
para servidores de parâmetros
e definir o dispositivo do trabalhador
para que este gráfico pertença
a este trabalhador em particular.
A configuração realmente depende
de qual Gerenciador de Cluster

Chinese: 
参数服务器和工作人员
德里克提到最常见的设置
和我们推荐的设置
差别在于图型复制
在这种情况下工作人员
完全独立运作
所以工作人员不必相互交谈
甚至彼此认识
他们只与参数服务器沟通
为此，Derek实际上显示了
多个幻灯片
如果你正在使用核心TensorFlow
这是相关代码
随着使用更高级别的API
很多代码行都可以省略
但实质上
你的Cluster Manager指定
所有参数服务器和工作者
这个工作人员一定要与之交流
你启动一个服务器
如果是一个参数服务器
可以停在那儿了
但如果你是工作者
那么你需要分配变量到参数服务器
设定工作设备
从而使某个图
属于某个特定的工作人员
所以配置取决于

Korean: 
매개 변수와 일하는 사람들입니다
데릭이 말했듯이 가장 흔한 구성은
그리고 저희가 추천하는 구성은
그래프 복제 입니다
이 상황에서는 완전 각자 일하게
되는 것이지요
일하는 사람들이 서로에게
이야기 할 필요가 없거나
알 필요도 없습니다
매개변수 서버를 통해서만 소통 하지요
데릭이 이 것을 몇 개의
슬라이드를 통해 보여주었는데요
텐서플로를 사용하실 때
필요한 코드 입니다
고급 API들을 사용하시면
이런 것들은 훨씬 적은 코드로
해결하실 수 있습니다
하지만 기본적으로
당신의 클러스터 관리자는
다른 모든 매개 변수 서버들과
이 사람이 소통해야 할
다른 일하는 사람들을 명시해 줍니다
서버를 시작합니다
매개 변수 서버라면
여기서 완료하시면 됩니다
만약 일하는 사람이라면
매개 변수 서버에 변수를
할당해야 합니다
그리고 그 사람에게 맞는 그래프를 위해
장치를 조정해야합니다
배열은 클러스터 관리자와
어떤 분산 스토리지를

Spanish: 
servidores de parámetros y trabajadores.
Y Derek mencionó
que la configuración más común
y la configuración que recomendamos
está entre la replicación del gráfico.
Y en ese caso,
los trabajadores en general operan
independientemente.
Así que los trabajadores
no necesariamente hablan entre sí
y tampoco se conocen.
Sólo se comunican
con los servidores de los parámetros.
Y para eso, Derek realmente mostró esto
pero a través de múltiples diapositivas.
Este es el código involucrado si usas
el núcleo de TensorFlow.
Con el nivel superior de APIs,
mucho de esto
se va y se convierte
en menos líneas de código.
Pero en esencia,
tu administrador de clústeres
especifica todos los demás servidores
de parámetros y los trabajadores
con los que este trabajador
debe comunicarse.
Inicias un servidor.
Si eres un servidor de parámetros,
pues detente allí.
Pero si eres un trabajador,
entonces necesitas
asignar variables a los servidores
de parámetros
y configurar el dispositivo del trabajador
para que este gráfico pertenezca
a este trabajador en particular.
Por lo tanto, la configuración realmente
depende de qué gestor de clúster

English: 
parameter servers and workers.
And Derek mentioned that
the most common setup
and the setup that we recommend
is between graph replication.
And in that case, workers
operate completely
independently.
So the workers don't
necessarily talk to each other
or even know about each other.
They only communicate with
the parameter servers.
And for that, Derek
actually showed this but
across multiple slides.
This is the code involved if
you're using core TensorFlow.
With the higher level
APIs, a lot of this
goes away and becomes
much fewer lines of code.
But in essence,
your Cluster Manager
specifies all the other
parameter servers and workers
that this worker must
communicate with.
You start a server.
If you're a parameter
server, you just stop there.
But if you're a
worker, then you need
to assign variables
to parameter servers
and set the worker device
so that this graph belongs
on this particular worker.
So, configuration really
depends on which cluster manager

Japanese: 
パラメータサーバーとワーカーです
そしてデレクは
最も一般的なセットアップで
推奨するセットアップは
グラフ複製の間にあると言いました
このケースでは
ワーカーは全く独立して働きます
ワーカー同士は必ずしも
お互いに話す必要はなく
相手を知らなくてもよく
パラメータサーバとのみ通信します
デレクは複数のスライドで
これを説明しました
コアのTensorFlowを使用する場合は
これがコードです
より高いレベルのAPIでは
コードの行数 がずっと少なくなります
ですが本質的に
あなたのCluster Managerが
このワーカーが
通信しなければならないー
他のすべてのパラメータサーバーと
ワーカーを指定します
サーバーを起動して
パラメータサーバーの場合は
そこでただ停止します
しかしワーカーの場合は
パラメーターサーバーに
変数を割り当てて
このグラフがこの特定のワーカーに
属するように
ワーカーデバイスを
設定する必要があります
したがって構成は実際には
どのCluster Managerと

Indonesian: 
dan sistem penyimpanan 
terdistribusi yang Anda pilih.
Kami punya contoh lagi, dalam dimensi
repositori, repositori ekosistem itu.
Kami tambahkan lebih banyak
dan silakan berkontribusi
apa pun yang bekerja baik
di infrastruktur yang ada.
Tambahan, saya katakan
bahwa baru-baru ini Yahoo membuat kode
dijalankan di SPARC jadi sumber terbuka.
Kenapa ini berguna?
Karena Anda pikir SPARC
seperti sebuah framework pemrosesan data.
Kenapa itu berguna
untuk dijalankan di SPARC
dibanding Cluster Manager?
Jadi SPARC sebenarnya didukung
untuk dijalankan
di Mesos, Yarn, atau secara mandiri
dan Anda sudah menjalankan 
SPARC di organisasi Anda.
Sebenarnya ini mungkin
cara termudah untuk memulai.
Dan pastinya, sulit menjalankan 
TensorFlow terdistribusi
di Hadoop Yarn.
Pastinya, akan lebih mudah
jika Anda menjalankan SPARC 
terpisah dari Yarn daripada mencoba
menjalankan TensorFlow
terdistribusi secara langsung.
Saya rekomendasikan ini
dalam kasus tertentu
saat Anda sudah menjalankan SPARC.

Korean: 
고르느냐에 따라 달라집니다
예시가 있지요, 지난번과 같이
생태계의 보고 입니다
저희는 계속 더해가니 주저 마시고
언제든지 여러분의 인프라에서
잘 작동 했던 것들로
추천 해주시기 바랍니다
그리고, 최근 야후도 SPARC를
실행 할 수 있는
오픈 소스 코드를 제공하고 있습니다
왜 유용하냐구요?
여러분들 께서는 SPARC가
데이터를 처리하는 틀이라고
생각하실지 모르겠습니다
왜 SPARC에서 실행하는 것이
클러스터 매니저에서 보다 유용할까요?
SPARC는 Mesos, Yarn
또는 스탠드 알론 방식을
지원합니다, 그리고 많은 분들께서
이미 SPARC를 사용하고 계실 겁니다
아마 이것이 시작하시기에
가장 쉬운 방법일 것입니다
텐서플로의 분산처리를
Hadoop Yarn에서
실행하시는 것은 어려우실 겁니다
그리고 확실히 SPARC를
Yarn과 함께 시작하시는 편이
텐서플로의 분산처리를 Yarn에
바로 실행하시는 것보다 쉬울 겁니다
그래서 저는 이 것을
SPARC를 이미 실행중인 경우에
추천합니다

Spanish: 
y sistema de almacenamiento
distribuido hayas elegido.
Tenemos ejemplos, repito,
en esa dimensión del repositorio
ese repositorio del ecosistema.
Y estamos agregando más y siéntete libre
de aportar todo lo que sabes
para que funcione bien
en tu infraestructura.
Además, me gustaría mencionar
que Yahoo! ha abierto recientemente
el código fuente para ejecutar en SPARC.
¿Y por qué es esto útil?
Porque quizás pienses que SPARC
es como una estructura de
procesamiento de datos.
¿Por qué sería útil ejecutar en SPARC
en lugar de un gestor de clúster?
Porque SPARC realmente tiene soporte
para correr en Mesos, Yarn
o en modo autónomo
y muchos de ustedes ya estarán
ejecutando SPARC en su organización.
Y esta podría ser la forma
más fácil de empezar.
Y por supuesto, es difícil ejecutar
TensorFlow distribuido en Hadoop Yarn.
Y por supuesto,
es mucho más fácil comenzar
si estás ejecutando SPARC
en el nivel superior de Yarn
que tratar de ejecutar TensorFlow
distribuido en Yarn directamente.
Así que te recomiendo
esto en casos específicos
donde ya estés ejecutando SPARC.

Japanese: 
どの分散ストレージシステムを
選択したかによります
そのエコシステムリポジトリの
ディメンションには
諸例がありますが
私たちはもっと多くを加えて
あなたの既存のインフラで
うまく行くとあなたがご存じのことに
自由に貢献してください
また Yahoo!が最近SPARCで
実行するソースコードを公開しました
これが有用なのは
SPARCがデータ処理
フレームワークのようなのに
なぜCluster Managerではなく
SPARCで 実行するのが
便利なのかと
思われているからです
SPARCは実際にMesosやYarn
スタンドアロンモードで
実行するサポートがあり
皆さんの多くはもう職場で
SPARCを実行しています
これが実際始めるには
最も簡単な方法かもしれません
また確かに 分散されたTensorFlowを
Hadoop Yarnで実行するのは難しいです
Yarn上でSPARCを実行することは
分散TensorFlowをYarnに
直接 実行しようとするより
開始はずっと簡単です
だから私はこれを
すでにSPARCを実行しているー
特定のケースでお勧めします

English: 
and which distributed
storage system you chose.
We have examples, again, in
that repository dimension,
that ecosystem repository.
And we're adding
more and feel free
to contribute any that you know
that work well in your existing
infrastructure.
Additionally, I'd
like to mention
that Yahoo! recently open
sourced code to run on SPARC.
And why is this useful?
Because you might
think that SPARC
is like a data
processing framework.
Why would it be useful to run
on SPARC rather than a Cluster
Manager?
So, SPARC actually has support
for running on Mesos, Yarn
or in standalone
mode, and a lot of you
will already be running
SPARC in your organization.
And this actually might be the
easiest way to get started.
And for sure, it's difficult
to run distributed TensorFlow
on Hadoop Yarn.
And for sure, it's
much easier to get
started if you're running
SPARC on top of Yarn
than to try to run distributed
TensorFlow on Yarn directly.
So I'd recommend this
in specific cases
where you're already
running SPARC.

Portuguese: 
e qual armazenamento
distribuído você escolheu.
Temos exemplos nessa
dimensão de repositório,
esse repositório de ecossistema.
E adicionamos mais.
Sintam-se livres para contribuir
com o que sabem que funciona bem
na sua infraestrutura existente.
Também gostaria de mencionar
que a Yahoo!, recentemente,
criou código aberto para rodar em SPARC.
E por que é útil?
Você pode pensar no SPARC
como um framework
de processamento de dados.
Por que seria útil rodar no SPARC
ao invés de um Gerenciador de Cluster?
Então, o SPARC tem suporte
para rodar em Mesos, Yarn
ou em modo autônomo,
e muitos de vocês já estão rodando
SPARC nas organizações.
Então, esta pode ser
a maneira mais fácil de começar.
Com certeza, é difícil rodar
TensorFlow distribuído no Hadoop Yarn.
E, com certeza, é muito mais fácil começar
se você rodar SPARC acima do Yarn
ao invés de rodar TensorFlow
distribuído diretamente no Yarn.
Eu recomendaria isso em casos específicos
quando você já está rodando SPARC.

Chinese: 
选择了哪个集群管理器
和分发存储系统
我们有很多例子
还是在生态系统
知识库里的知识空间中
请随意添加
在现有构架中
运行良好的方法
另外，我想提一下
雅虎最近开放了
在SPARC上运行的源代码
为什么这很有用？
因为你可能认为SPARC
就像一个数据处理框架
为什么在SPARC运行有用
而不在群集管理器上？
SPARC实际上支持
在Mesos，Yarn
或独立模式下运行
你们很多已经在运行SPARC
这实际上可能是
最简单的入门方式
在HadoopYarn上
运行分布式TensorFlow确实很难
在SPARC上运行Yarn
比直接在分布式TensorFlow上
容易得多
如果你已经在运行SPARC了
在具体情况下我建议这个

Japanese: 
ダンデライオンは
TensorBoardについて話しました
分散型トレーニングでこれを
どう使うのかと疑問に思うでしょうね
分散型トレーニングでは通常
分散ストレージ上に指定した
ディレクトリに行くー
サマリーとイベントを 出力します
TensorBoardを実行するために
必要なことは
TensorBoardコマンドを実行し
その分散ストレージディレクトリに
向けるだけです
見ることができるローカルの
HTTPサーバーで開始されます
誤差を見ることができ
埋め込みビジュアライザで
その仕組みがどのように
機能しているか調べられます
例えばここで多くのステップを
スキップしたとか
ハイパーパラメータの
チューニングをする必要があるなど
しかしあなたはすでに
そのすべてが済んでいて
自分のモデルに満足しているとします
それをエクスポートし
実稼働に提供したいですね
現在それを行う2つの
一般的な方法がありますが
長期的にはそれは1つになります
お勧めはSaveModelです
これは今後TensorFlowの
標準ファイル形式になります
SaveModelが他より優れている点は
モデルを稼働に提供するのに必要な
すべてのアセットが含まれていることです

Korean: 
Dandelion이 텐서 보드에
대해 말했듯이요
어떻게 분산 훈련에 사용할 수 있을까?
생각하셨을 것입니다
보통 분산 훈련 때는
결과물로 이미 분산 스토리지에
지정해둔 요약본이나
이벤트 디렉토리를 받으실 겁니다
텐서보드를 실행 하시려면
텐서보드 명령을 실행하시고
분산 저장 디렉토리만 선택하시면 됩니다
그냥 보실 수 있는 부분적인
HTTP 서버를 시작 하시면 되구요
무엇을 잃으셨는지 보실 수도 있고
삽입 비쥬얼라이저 사용법을
익히실 수도 있습니다
제가 단계를 많이 뛰어 넘었는데요
예를들어 여러분이 하이퍼 매개변수를
조율하셔야 한다거나 하는데
이미 다 하시고
지금 모델에 만족하신다면
내보내셔서 생산하고 싶으시겠지요
현재로써는 2가지 방법이있습니다
하지만 미래에는 하나가 되겠지요
저희는 SaveModel을
강력하게 추천합니다
텐서플로의 기본 형식이
될 것입니다
다른 것들은 뛰어 넘는 이것의 장점은
여러분께서 모델을 생산할 때
필요한 모든 것을
포함하고 있다는 것입니다

Indonesian: 
Dandelion berbicara tentang TensorBoard.
Anda mungkin heran, bagaimana memakainya
dengan pelatihan terdistribusi.
Dengan pelatihan terdistribusi,
Anda punya output yang meringkas
dan event yang pergi ke direktori
yang Anda tentukan
di penyimpanan terdistribusi.
Yang Anda perlukan untuk jalankan
TensorBoard adalah jalankan
perintah TensorBoard, arahkan
ke direktori penyimpanan terdistribusi.
Mulai dalam server HTTP secara lokal
yang Anda bisa lihat.
Bisa dilihat kerugian Anda.
Anda lewati visualizer terpasang
dan bagaimana benda itu bekerja.
Saya lewatkan banyak tahap di sini.
JIka Anda perlu melakukan penalaan
parameter hiper, dan lainnya.
Tapi anggap Anda sudah 
melakukan semuanya
dan puas dengan model Anda.
Anda mau ekspor
dan menyajikan di produksi.
Saat ini, kami punya
dua cara umum mengerjakannya
tapi dalam jangka panjang, akan jadi satu.
Rekomendasi kami
adalah memakai SavedModel.
Itu akan jadi standar format file
untuk TensorFlow ke depannya.
Dan keuntungan dengan 
SavedModel dibanding yang lain
yaitu memasukkan semua aset
yang Anda perlukan
untuk menyajikan model dalam produksi.

Portuguese: 
E Dandelion falou sobre TensorBoard.
Vocês devem se perguntar: "como utilizar
com treinamento distribuído?"
Com treinamento distribuído
você tem saídas que são resumos e eventos
que vão a um diretório especificado
por você no armazenamento distribuído.
Tudo o que você precisa para rodá-lo,
é acionar o comando
e apontá-lo ao diretório
de armazenamento distribuído.
Ele vai iniciar em servidor HTTP local
que você poderá ver.
Poderá ver suas perdas.
Poderá analisar o visualizador embutido
e como isso funciona.
Então, pulei muitas etapas aqui.
Supomos que você precise fazer ajuste
do hiperparâmetro e mais.
Mas que você já fez isso
e está feliz com seu modelo.
Você quer exportá-lo
e servi-lo em produção.
Agora, temos duas maneiras de fazer isso,
mas, a longo prazo, será apenas uma.
Nós recomendamos
que você utilize SaveModel.
Este será o formato de arquivo padrão
para TensorFlow daqui para frente.
E a vantagem do SaveModel sobre os outros
é que ele inclui todos os recursos
para servir seu modelo em produção.

Spanish: 
Y Dandelion habló de TensorBoard.
Te preguntarás, ¿cómo usas
esto con el entrenamiento distribuido?
Con el entrenamiento distribuido,
normalmente
tienes salidas que son los resúmenes
y los eventos
que van a un directorio que especificaste
en el almacenamiento distribuido.
Todo lo que necesitas hacer
para ejecutar TensorBoard es ejecutar
el comando de TensorBoard y dirigirlo
a ese directorio de
almacenamiento distribuido.
Comenzará en el servidor HTTP
de manera local en donde lo puedes ver.
Puedes ver tus pérdidas.
Puedes pasar por el visualizador
de incrustación
y ver cómo funciona esa cosa.
Así que, como, he omitido
un montón de pasos aquí.
Supongo que necesitas hacer
un gran ajuste de parámetros y eso.
Pero supongamos que ya hiciste todo eso
y eres feliz con tu modelo.
Quieres exportarlo
y entregarlo a producción.
Así que actualmente, tenemos
dos maneras comunes de hacerlo
pero a largo plazo, será sólo una.
Recomendamos que uses SaveModel.
Va a ser el formato de archivo estándar
para TensorFlow más adelante.
Y la ventaja de SaveModel
con respecto a los demás
es que incluye todos los bienes
que necesitas para entregar
tu modelo en producción.

Chinese: 
Dandelion 提到过 TensorBoard
你可能会想，
如何在分布式培训中使用这个？
分布式培训，通常你有输出
摘要和事件进入目录
它们会被指定到
分布式存储上
所有你需要在TensorBoard上做的就是
运行TensorBoard命令
并将其指向分布式存储目录
你会看到
它会在局部HTTP服务器开始
你可以看到你的损失
你可以通过嵌入视觉效果器
看看这些东西如何运作
我在这里跳过了很多步骤
假设你需要做
超级参数调整等
但假设你已经完成所有这一切
你对你的模型感到满意
你想投放到实际工作中
目前我们有两种方法
但长远来讲只用一种
我们强烈推荐你用SaveModel
它将是TensorFlow的
标准文件格式
SaveModel的优势在于
它包括了模型在实际工作中
所需的所有功能
我提到过词汇

English: 
And Dandelion talked
about TensorBoard.
You might wonder, how do you use
this with distributed training?
So, with distributed
training, typically, you
have output which are
summaries and events that
go to a directory
that you specified
on distributed storage.
All you need to do
to run TensorBoard
is run the TensorBoard
command and point it
to that distributed
storage directory.
It will start in
HTTP server locally
that you can just look at.
You can look at your losses.
You can go through the
embedding visualizer
and how that stuff works.
So, like, I've skipped
a lot of steps here.
Like, suppose you
need to do hyper
parameter tuning and so on.
But suppose you're already
done with all of that
and you're happy
with your model.
You want to export it and
serve it in production.
So currently, we have two
common ways of doing that,
but in the long
term, it will be one.
We highly recommend
you go with SaveModel.
It's going to be the standard
file format for TensorFlow
going forward.
And the advantage to
SaveModel over everything else
is that it includes
all the assets
you need to serve your
model in production.
I mentioned that
vocabularies are

Indonesian: 
Saya sebutkan kosa kata
adalah sangat umum
untuk penyematan dan Anda gunakan
kosa kata khusus saat pelatihan.
Anda pastikan gunakan kata
yang sama persis dan waktu penyajian.
Termasuk semua file untuk Anda.
Jadi keuntungan lain dengan SavedModel
adalah sekelompok grafik dan
Anda dapat menentukan
yang mana yang Anda gunakan
untuk kegunaan khusus.
GraphDef sekarang sangat umum
dalam penggunaan tertentu
khususnya dalam seluler.
Jadi, dalam contoh seluler, 
Anda biasanya
membekukan variabel-variabel 
Anda ke dalam konstan
di grafik TensorFlow.
Keuntungan dengan GraphDef sekarang
adalah bahwa GraphDef 
sebenarnya buffer protokol
yang mengakses seperti file tunggal.
Anda hanya mendistribusikan file tunggal.
Itu lebih mudah disebarkan.
Tapi keuntungan itu hilang.
Seperti baru-baru ini, Anda juga
dapat membekukan satu SavedModel.
Jadi saya harap, Anda dapat
mengeksploitasi SavedModel.
Anda ingin menyajikannya.
Noah-- bahasan berikutnya 
hanya mendalami

Japanese: 
語彙が埋め込みには
かなり一般的だと言いましたが
トレーニング時に特定の語彙を使用し
提供時に全く同じ語彙を
使うようにします
それにはそれらのすべての
ファイルが含まれています
SaveModelのもう1つの利点は
それが多くのグラフであり
特定の用途にどのグラフを使用するか
指定できます
GraphDefは現在
特定の用途で 特にモバイル上で
かなり一般的です
モバイルの例では通常
変数を定数に固定して
TensorFlowグラフに表示します
今GraphDefの利点は
GraphDefは1つのファイルのように
アクセスするー
プロトコルバッファなことです
単一のファイルを
分散するだけで済み
展開がずっと簡単です
しかしその利点は消えます
最近ではSaveModelを
フリーズすることもできます
だからうまくいけば
SaveModelをエクスポートして
それを提供したいです
TensorFlow Servingについては
ノアがこの後の講演で詳しく述べるので

Spanish: 
Mencioné que los vocabularios
son bastante comunes
para las incrustaciones
y usas un vocabulario específico
en el tiempo de entrenamiento.
Querrás asegurarte de usar
el mismo vocabulario
y el tiempo de servicio.
Incluye todos esos archivos para ti.
Otra ventaja de SaveModel
es que tiene un montón de gráficos
y puedes especificar cuál deseas
usar para un caso particular.
GraphDef ahora mismo es bastante
común en usos particulares
particularmente en el móvil.
En el ejemplo del móvil, típicamente
colocas tus variables a constantes
en tu gráfico de TensorFlow.
La ventaja de GraphDef ahora mismo
es que GraphDef es realmente
un búfer de protocolo
que accesa como un archivo único.
Así que solo tienes que distribuir
un solo archivo.
Es mucho más fácil de implementar.
Pero esa ventaja desaparece.
Desde hace poco, también puedes
detener un SaveModel.
Así que espero que hayas
explotado el SaveModel.
Quieres ejercerlo.
Noah... la siguiente charla
en realidad trata mucho más

Portuguese: 
Eu mencionei que vocabulários
são muito comuns para embutidos
e você utiliza vocabulário específico
durante o treinamento.
Você quer garantir o mesmo
vocabulário e tempo de serviço.
Ele inclui esses arquivos para você.
A outra vantagem do SaveModel
é um conjunto de gráficos,
e você pode especificar qual quer utilizar
para um caso de uso em particular.
O GraphDef é comum em usos particulares,
especialmente em dispositivos móveis.
No exemplo móvel, você normalmente
congela suas variáveis em constantes
no gráfico do TensorFlow.
A vantagem do GraphDef neste momento
é que ele é, na verdade,
um buffer de protocolo
que acessa como um único arquivo,
e você só precisa distribuir ele.
É muito mais fácil de aplicar.
Mas essa vantagem está indo embora.
Recentemente, você também
pode congelar um SaveModel.
Então, você exportou para SaveModel,
e agora quer servi-lo.
Noah, na próxima palestra,
falará muito mais
sobre TensorFlow Serving,

Chinese: 
它是很常见的嵌入
你需要在训练时使用特定的词汇
你要确保使用完全相同的词汇
和服务时间
它包括所有所需的文件
SaveModel的另一个优点是它全是图形
对于特定例子
你可以指定
要使用哪个
GraphDef现在很流行
常见于特殊用途
特别是在手机上
在手机示例中
通常将变量冻结到
TensorFlow图中的常量中
GraphDef的优点是
GraphDef实际上是一个协议缓冲区
可以像文件一样访问
所以你只需要分布单个文件
这很容易
但这个优势正在消失
最近，你可以还可以冻结SaveModel
所以希望你已经采用SaveModel
你要利用它
诺亚在随后的讲座上

English: 
pretty common for embeddings and
you use a specific vocabulary
at training time.
You want to make sure to use
the exact same vocabulary
and serving time.
It includes all
those files for you.
So the other
advantage to SaveModel
is it's a bunch
of graphs and you
can specify which one you want
to use for a particular use
case.
GraphDef right now is pretty
common in particular uses,
particularly on mobile.
So, in the mobile
example, you typically
freeze your variables
into constants
in your TensorFlow graph.
The advantage to
GraphDef right now
is that GraphDef is actually
a protocol buffer which
accesses like a single file.
So you only have to
distribute a single file.
That's much easier to deploy.
But that advantage
is going away.
As of recently, you can
also freeze a SaveModel.
So hopefully, you've
exploited the SaveModel.
You want to serve it.
Noah-- the subsequent talk is
actually going go much more

Korean: 
제가 이미 말씀 드렸지만 삽입에는
단어들이 꽤 자주 사용됩니다
그리고 훈련 때는
특정한 것을 사용하지요
여러분은 정확히 그 단어를
사용하셨는지와
시간을 확인하셔야 하는데
이 것은 모든 파일들을 포함합니다
Save Model의 다른 장점은
여러가지 그래프들 중에서
이번 케이스에 사용하고 싶으신 것을
고를 수 있다는 것입니다
GraphDef도 꽤나 자주 사용되는데요
특정한 곳에만 사용됩니다
특히 휴대폰에서요
휴대폰 예시에서는
변수들을 텐서플로 그래프의
정수로 고정시키는 것을
보도록 하겠습니다
GraphDef의 장점은
프로토콜 버퍼라는 것입니다
파일 한 개처럼 통용되지요
파일 하나만 나누시면 됩니다
효율적으로 사용하기 쉬우시겠죠
하지만 이 장점은 사라지고 있습니다
SaveModel도 고정이 가능해졌기
때문이지요.
SaveModel을 살펴보시면 좋겠습니다
아마 사용하고 싶어지실 수도 있습니다
노아가 다음에 할 이야기는
텐서플로에 기여 하는 것에 대해
더 깊이 이야기 할 것이기 때문에

Indonesian: 
TensorFlow Serving dan
saya hanya akan membicarakan
dua hal teratas di sini.
TensorFlow Serving dan 
In-process TensorFlow.
Ini dua opsi untuk menyajikan
model TensorFlow
setelah Anda mengekspolitasinya, 
tapi mereka benar-benar berbeda.
TensorFlow Serving, dalam mode khas
berjalan sebagai layanan berbeda
yang Anda buat RPC untuknya.
Jadi, mengapa Anda memilih
salah satu dibanding yang lain?
Jadi, Noah akan menjelaskan lebih lanjut
tapi menyajikan model sebenarnya
punya banyak nuansa tersembunyi
yang mungkin tidak Anda sadari
saat Anda memikirkannya.
Jika Anda alokasikan
satu model sekali saja
maka masuk akal untuk pakai
In-process TensorFlow.
Tapi jika Anda berpikir tentang--
seperti, anggap Anda punya pekerjaan
melatih data baru tiap hari dan
ingin menyajikan model baru tiap hari.
Bagaimana Anda mulai menyajikan
model baru itu?
Anda bisa memikirkannya.
Ada dua cara dasar yang mungkin terjadi.
Dalam server, Anda bisa menghapus
model lama yang terhapus

Chinese: 
会更多地探讨TensorFlow服务
我只讨论这里的前两项--
TensorFlow服务和
TensorFlow运行
它们都可以服务TensorFlow模型
但在选择之后它们完全不同
在其典型模式下TensorFlow服务
作为RPC单独的服务运行
你为什么要选择这个而不是那个呢？
Noah会做详解
你可能不知道
实际服务模式有很多隐藏的细微差别
如果你只是做一个模型完事
只需使用
TensorFlow就可以
但如果你想--
假设你每天训练新数据
你想每天
为新的模型服务
你怎么为这个新模式服务呢？
你可以考虑一下
有两个基本的方式可能发生
在您的服务器中

Spanish: 
de la implementación de TensorFlow
y voy a hablar
de los dos primeros aquí...
la implementación de TensorFlow
y TensorFlow en proceso.
Por lo tanto, estas son ambas opciones
para implementar tu modelo de TensorFlow
después de haberlo explotado,
pero son muy diferentes.
La implementación de TensorFlow,
en su modo típico
funciona como un servicio separado
en el que haces RPCs.
Entonces, ¿por qué elegir
uno sobre el otro?
Noah va a indagar bastante en esto
pero entregar un modelo en realidad tiene
un montón de matices ocultos
y tal vez no seas consciente de ellos
cuando pienses en eso.
Por lo tanto, si estás aplicando
un modelo único
entonces tiene sentido sólo utilizar
TensorFlow en proceso.
Pero si piensas que...
supongámos que tienes un trabajo
donde entrenas todos los días
nuevos datos y deseas
implementar un nuevo modelo
todos los días.
¿Como podrías empezar
a implementar ese nuevo modelo?
Puedes pensar en eso.
Hay como dos básicas maneras
que podrían suceder.
En tu servidor, puedes
descargar completamente

Japanese: 
私が話すのは
ここの上２つについてだけ
TensorFlow Servingと
in-process TensorFlowですね
この2つとも
エクスポート後に
あなたのTensorFlowモデルを
提供するオプションですが
それらは全く異なっています
TensorFlow Servingは典型的なモードでは
RPCを実行する別のサービスとして
実行されます
ではなぜあなたは
一方を選ぶでしょうか？
ノアはずっと詳しく話しますが
実際にモデルを提供することには
ただ考えているときは気付かないような
隠れた微妙さがたくさんあります
モデルを単体として
適用するだけなら
in-process TensorFlowを
使用するのが当然です
しかし もし考えているのがー
例えば
毎日新しいデータを訓練し
毎日新しいモデルを提供する場合
どのように新しいモデルの
提供を始めますか？
考えてみると
有り得る基本的な方法が２つあります
サーバーで古いモデルを
完全にアンロードすることができます

Korean: 
저는 제일 중요한
두 가지만 말하겠습니다
텐서플로우에 기여하는 것과 공정
두가지 다 개발 이후 텐서플로에
기여 하실 때의 두가지 옵션입니다
하지만 두 가지는 꽤 다르지요
텐서플로에 기여하는 것은 보통 모드에서
RPC생산과는 다른 서비스로 실행됩니다
어떤 것이 어떨 때 더 좋을까요?
노아가 더 말하겠지만
모델을 서빙한다는 것은
더 깊은 뉘앙스가 있습니다
그냥 생각하실 때는 아마도
잘 모르실 수도 있는데요
일 회성으로 적용하시는 것이라면
in-process 텐서플로를
사용하시는 것이 좋을 것입니다
하지만 생각해보세요
매일 새로운 데이터로
트레이닝 하는 작업이 있는데
매일 새로운 모델을 만들어야 한다고
생각해 봅시다
어떻게 새로운 모델을
제공 하시겠습니까?
생각해 보시면
일어날 수 있는 일들이 2가지 있습니다
서버에서 낡은 모델을
완전히 내려버릴 수도 있습니다

English: 
into TensorFlow serving and
I'm only going to talk about
the top two here--
TensorFlow serving and
in process TensorFlow.
So, these are both options
for serving your TensorFlow
model after you've exploited it,
but they are quite different.
TensorFlow serving,
in its typical mode,
runs as a separate service
that you make RPCs to.
So, why might you choose
one over the other?
So, Noah's going to go
much more in depth here,
but serving a model actually
has a lot of hidden nuance
that you might not be aware of
when you just think about it.
So, if you're just applying
a model as a one off,
then it might make sense to
just use in-process TensorFlow.
Flow
But if you think about--
like, suppose you
have a job that
trains every day on
new data and you want
to serve a new model every day.
How might you start
serving that new model?
You can think about it.
There's like two basic
ways that might happen.
In your server, you can
unload the completely unload

Portuguese: 
eu vou apenas falar
sobre os dois primeiros aqui.
O TensorFlow Serving e in-process.
Ambas são opções para servir
seu modelo TensorFlow após exportá-lo,
mas são um pouco diferentes.
TensorFlow Serving, em modo típico,
roda como um serviço separado
para o qual você faz RPCs.
Então, por que você vai escolher
um ao invés do outro?
Noah falará com muito mais detalhes aqui,
mas servir um modelo, de fato,
tem muitas nuances escondidas
que você pode não saber
quando pensa sobre isso.
Se estiver aplicando
um modelo de uma só vez,
pode fazer sentido utilizar
apenas TensorFlow in-process.
Mas se você pensar, por exemplo,
vamos supor que você tenha um trabalho
que treina novos dados todos os dias,
e você quer servir
um modelo novo todos os dias.
Como você poderá começar
a servir esse novo modelo?
Podem pensar a respeito.
Existe duas maneiras básicas
para isso acontecer.
No seu servidor, pode descarregar
completamente o modelo antigo,

Indonesian: 
dan menunggunya sampai selesai,
menunggu
semua permintaan diselesaikan
dan memuat model baru.
Memorinya efisien karena Anda hanya punya
satu model termuat di satu waktu.
Anda bisa muat model baru simultan
saat ia berjalan dan gandakan
penggunaan memori.
TF Serving menawarkan itu 
sebagai sebuah opsi konfigurasi.
Tambahan, untuk efisiensi, 
secara khusus
jika Anda menyajikan di GPU, 
Anda ingin batch input Anda.
Ini juga bermanfaat pada GPU,
khususnya jika Anda menyajikan di GPU
Anda ingin ada satu batch benar-benar
memanfaatkan GPU Anda.
Anda bisa bayangkan, ada beberapa nuansa
bagaimana Anda mau batch, khususnya
dalam pengaturan laten rendah.
Jadi, TF Serving menangani hal itu.
Juga, jika Anda menyajikan 
beberapa model
isolasi di antara model-model itu--
mereka bersaing 
untuk sumber perangkat keras
dan ada beberapa kesulitan
dalam mengisolasikan model.
Khusunya dengan intensif.
Anda harus memikirkan thread mana--
seperti, cara ukur thread pools,
dan sebagainya.
Anda tidak harus memikirkan itu
jika Anda dalam TensorFlow Serving.

English: 
the old model and then
wait for that to finish,
wait for all requests to
finish, and load your new model.
This is memory efficient
because you only
have one model loaded
at a single time.
Or, you can simultaneously
load the new model
while it's running and
double your memory usage.
tf.Serving offers that as
a configuration option.
Additionally, for
efficiency, particularly
if you're serving on GPUs,
you want to batch your inputs.
This also has some
benefit on CPUs,
but particularly if
you're serving on GPUs,
you want a batch to
fully utilize your GPUs.
As you can imagine,
there's some nuance
to how you want to
batch, particularly
in low latency settings.
So, tf.Serving handles that.
Also, if you're serving
multiple models,
isolation between those models--
they're going to contend
for hardware resources
and there's some difficulties
in isolating between them.
It's particularly intensiveful.
You have to think
about which threads--
like, how to size
thread pools and so on.
You don't have to think
about that if you're
on TensorFlow serving at all.

Spanish: 
el viejo modelo y luego esperar
a que este termine
esperar a que todas las solicitudes
terminen y cargar tu nuevo modelo.
Esto es eficiente en la memoria
porque sólo tienes un modelo
cargado una sola vez.
O puedes simultáneamente
cargar el nuevo modelo
mientras se está ejecutando
y doblar el uso de tu memoria.
tf.Serving lo ofrece
como una opción de configuración.
Además, para la eficiencia,
particularmente
si estás ejerciendo en GPUs,
desearás agrupar tus entradas.
Esto también tiene beneficio en los CPUs
pero particularmente
si estás ejerciendo en GPUs
querrás un lote para utilizar
plenamente tus GPUs.
Como puedes imaginar, hay algo de matiz
de cómo quieres agrupar, particularmente
en configuraciones de baja latencia.
Por lo tanto, tf.Serving maneja eso.
Además, si estás implementando
múltiples modelos
con aislamiento entre esos modelos...
ellos van a confrontarse
por recursos del equipo
y hay algunas dificultades
para aislarse entre ellos.
Es particularmente intenso.
Tienes que pensar sobre qué hilos...
cómo colocarle tamaño
a los conjuntos de hilos y eso.
No tienes que pensar sobre si estás
en la implementación de TensorFlow
en lo absoluto.

Japanese: 
それが完了するのを待って
すべての要求が完了するのを待ち
新しいモデルをロードします
これはメモリ効率がよいです
なぜなら一度に1つのモデルだけ
ロードしているからです
あるいは実行中に新しいモデルを
同時に読み込めば
メモリ使用量を2倍にできます
tf.Servingは設定オプションとして
これを提供します
さらに効率化のために
特にGPUで作業している場合は
入力をバッチ処理する必要があります
これは
CPUにもいくつかの利点がありますが
特にGPUで提供している場合は
バッチによりGPUを完全に
利用することができます
ご想像のように
特に低遅延設定で
どうバッチ処理するか微妙な点があります
tf.Servingはそれを処理します
また 複数のモデルを扱っている場合は
それらのモデル間の隔離は
ハードウェアリソース を争います
それらを隔離するには
いくつかの困難があります
特にTensorFlowでは
考える必要があるのは
どのスレッド
スレッドプールの サイズを
設定する方法などですが
TensorFlow Servingでは
考える必要はありません

Chinese: 
您可以完全卸载旧的模型
等待所有请求后完成
加载新的模型
这样内存效率高
因为在同一时间
只有一个模型在加载
或者 在卸载时
同时加载新模型
但会加倍内存的使用
作为配置选项
tf.Serving提供这种功能
另外，为了提高效率
特别是如果是在GPU上服务
需要批量输入
这对CPU有好处
但在GPU上服务更好
批量会充分利用GPU
可以想象
批处理有一些细微差别
特别是在低延迟设置中
所以，tf.Serving可以处理
另外，如果你在为多种模型服务
隔离那些模型
他们将对硬件资源进行争夺
隔离他们就比较难
它们特别集中
你必须考虑那些线程
大小如何，线程池等
如果你用TensorFlow服务
你就不必考虑这些

Portuguese: 
e então esperar isso terminar,
que as solicitações terminem,
e carregar o novo modelo.
Isso é eficiente à memória porque
só há um modelo carregado por vez.
Ou, ao mesmo tempo,
pode carregar o novo modelo
enquanto está rodando
e dobrar o uso de memória.
O TF Serving oferece isso
como opção de configuração.
Em adição, para a eficiência,
particularmente,
se você servir em GPUs,
pode querer suas entradas em lotes.
Isso também tem alguns
benefícios em CPUs,
mas, particularmente,
se você estiver servindo em GPUs,
vai querer um lote que utilize
completamente seus GPUs.
Como podem imaginar,
existem algumas nuances
sobre como lotear, especialmente
em configurações de baixa latência.
Então, o TF Serving lida com isso.
Se estiver servindo modelos múltiplos,
o isolamento entre esses modelos...
Eles vão disputar recursos de hardware
e há algumas dificuldades
no isolamento entre eles.
É específico no TensorFlow.
Você precisa pensar sobre quais threads,
por exemplo, como mensurar
thread pools e mais.
Você não precisa pensar sobre isso
se estiver no TensorFlow Serving.

Korean: 
그리고 그 것이 끝나기를 기다리고
모든 요청들이 끝나도록 기다리고
새로운 모델을 실으실 수 있습니다
이것은 효율적인데 왜냐하면
한번에 한 모델만 불러오시면
되기 때문입니다
아니면 실행과 동시에
새 모델을 불러오는
메모리 사용을 두 배로
늘리실 수도 있구요
tf.Serving은 그것을 배열 옵션으로
가지고 있습니다
또한, 효율성을 위해
특히나 GPU에서 작업하신다면
입력들을 함께 묶으실 수 있습니다
CPU에게도 이득이지요
하지만 GPU에서 작업중이시라면
GPU를 잘 활용하기위해
묶으실 수 있습니다
상상해 보시면 뉘앙스가 있습니다
어떻게 묶고 싶으신지
특히 저지연 세팅에서요
tf.Serving이 그것을 다룹니다
여러가지 모델을 사용하신다면
그 모델들 간의 고립...
하드웨어 자료들을 위해
겨루게 될 것입니다
그것들을 격리하는데
문제가 있을 수 있지요
많은 주의가 필요합니다
어떤 맥락들...
즉, 어떻게 맥락들을
정해야 하는가 따위지요
텐서플로를 사용하신다면
그런것을 생각하지 않으셔도 됩니다

English: 
So, that's the next talk.
Now that I've explained all
the benefits, you're like, OK,
then why not just use
that all the time?
Why should I use in
process TensorFlow at all?
So, in process TensorFlow is
actually the standard mode
for certain things,
specifically if you're
running on a mobile device.
Pete actually went over this.
Basically, you have a TensorFlow
session and you run it.
If you're running
batch inference-- like,
if you already have a TensorFlow
model, you have a ton of data
and you want to run inference
over that data using Beam
or SPARC, then it's
much better to just use
in process TensorFlow than
to start another tf.Serving
service.
There's the specific case
of very strict latency
requirements where
you don't want
to do the RPCs back and forth
with TensorFlow serving,
but this is a very rare case.
Usually, the latency
involved there is very small.
Operationally speaking,
it's much easier
to run one service
than to run two.
So if you want to
simplify your deployments,
that's also a reason to do this.
But regardless of
which one you choose,

Chinese: 
那将是下一次讨论的内容
既然我已经解释了所用的好处
为什么不一直使用呢？
为什么还要使用
过程TensorFlow呢？
在过程TensorFlow是
某些东西的标准模式
特别是在移动设备上运行
皮特其实已经讲到过
你会有机会运行TensorFlow
如果你正在运行批次推理--
如果你已经有了TensorFlow模型
你想使用Beam或SPARC对该数据进行推理
那就只是使用TensorFlow过程
而不要启动
另一个tf.Serving服务
这有个具体的例子
有非常严格的延迟要求
你不想在TensorFlow服务中来回做RPC
但这是非常罕见的情况
通常，延迟涉及得非常少
操作上讲，
运行一个服务比两个
要容易得多
如果你想简化部署
那便是原因
但不管你选择哪个

Japanese: 
それは次の課題に行きましょう
メリットをすべて説明したので
いつもこれを使えばよいと
思うかもしれません
in-process TensorFlowを
使用する必要がないと思われるでしょう
in-process TensorFlowは
実は特定のものについては標準モードです
特にモバイルデバイス上では
ピートが話しましたが
基本的にTensorFlow セッションがあり
それを実行します
バッチ推論を実行している場合
既にTensorFlowモデルをお持ちの場合は
大量のデータがあります
BeamまたはSPARCをを使用して
そのデータについて推論を実行します
するとin-process TensorFlowを使う方が
別のtf.servingサービスを
始めるよりもずっと良いです
TensorFlow ServingでRPCを
繰り返し実行したくない
非常に厳密な待ち時間要件の 
特定のケースがあります
これは非常にまれなケースです
通常そこに含まれるレイテンシは
非常に小さいです
運用上は2つを実行するよりも
1つのサービスを実行する方が
はるかに簡単です
したがってデプロイを
簡素化したい場合は
それもこれを行う理由です
しかしどちらを選んでも

Indonesian: 
Jadi, itu topik berikutnya.
Sudah dijelaskan semua keuntungan,
Anda berpikir, bagus
lalu mengapa tidak terus menggunakannya?
Mengapa saya gunakan
In-process TensorFlow saja?
Jadi, In-process TensorFlow
sebenarnya mode standar
untuk hal tertentu, khususnya
jika Anda menjalankan perangkat seluler.
Pete sebenarnya membahas ini.
Pada dasarnya, Anda punya sesi
TensorFlow dan menjalankannya.
Jika Anda jalankan batch inference--
seperti,
jika sudah punya model
TensorFlow, punya banyak data
dan mau jalankan inferensi 
pada data dengan Beam
atau SPARC, lalu lebih baik menggunakan
In-process TensorFlow dibanding memulai
layanan TF Serving lain.
Ada kasus spesifik syarat laten
yang ketat dimana Anda tidak ingin
melakukan RPC berulang kali
dengan TensorFlow Serving
tapi itu jarang terjadi.
Biasanya, laten yang terlibat
sangat sedikit.
Dengan kata lain, lebih mudah
menjalankan satu layanan
dibanding dua layanan.
Jadi jika Anda ingin
menyederhanakan sebaran Anda
yang juga satu alasan untuk melakukannya.

Spanish: 
De eso trata la próxima charla.
Ya que he explicado
todos los beneficios, te preguntarás
entonces, ¿por qué no usar
eso todo el tiempo?
¿Por qué debo usar TensorFlow
|en proceso siempre?
TensorFlow en proceso
es realmente el modo estándar
para ciertas cosas,
específicamente si estás
ejecutando en un dispositivo móvil.
En realidad, Pete repasó esto.
Básicamente, tienes una sesión
de TensorFlow y la ejecutas.
Si estás ejecutando
la inferencia por lotes...
como si ya tuvieras un modelo de
TensorFlow, tienes una tonelada de datos
y deseas ejecutar la inferencia
en esos datos utilizando Beam
o SPARC, entonces es mucho mejor usar
TensorFlow en proceso que iniciar
otro servicio de tf.Serving.
Está el caso específico de una latencia
muy estricta donde no quieres
hacer los RPCs de ida y vuelta
con el servicio de TensorFlow
pero este es un caso muy raro.
Por lo general, la latencia
involucrada es muy pequeña.
Operacionalmente hablando,
es mucho más fácil
ejecutar un servicio, que ejecutar dos.
Así que si quieres
simplificar tus implementaciones
también hay una razón para hacer esto.
Pero independientemente de cuál elijas

Portuguese: 
Essa será a próxima palestra.
Agora que já expliquei os benefícios,
vocês devem pensar:
"Então por que não utilizamos
isso o tempo todo?
Por que eu deveria utilizar
o TensorFlow in-process?"
O TensorFlow in-process é,
na verdade, o modo padrão
para certas coisas, especialmente se você
estiver rodando em dispositivo móvel.
O Pete falou sobre isso.
Basicamente, você tem uma sessão
TensorFlow e roda ela.
Ao rodar inferência em lote,
se já tiver um modelo TensorFlow,
terá uma tonelada de dados
e vai querer rodar inferência neles,
utilizando Beam ou SPARC, então será
muito melhor apenas utilizar
TensorFlow in-process do que
iniciar outro serviço de TF Serving.
Existe o caso específico de requisitos
de latência muito estritos,
onde você não vai querer fazer
repetidos RPCs com TensorFlow Serving,
mas é um caso muito raro.
Geralmente, a latência envolvida
aqui é muito baixa.
Em termos de operação, é muito mais fácil
rodar um serviço do que dois.
Então, se você quiser
simplificar o desenvolvimento,
esta também é uma razão para fazer isso.
Mas, independentemente de qual escolher,

Korean: 
다음 이야기로 넘어가지요
제가 모든 혜택들을 설명 드렸습니다
항상 그걸 사용하면 안되나? 하고
생각하실 수도 있지요
아직 제조 과정에 있는 텐서플로를
왜 사용해야하지?
제조 과정에 있는 텐서플로는
표준 모형입니다
어떤 특정한 것들을 위한
특히나 모바일 기계에서
사용할 수 있는 것이죠
피트가 설명드렸지요
텐서플로우 세션을 가지고 실행합니다
묶음을 실행하신다면, 예를들어
이미 텐서플로 모델이 있으시고
어마어마한 양의 데이타가 있는데
Beam이나 SPARC를 사용해서
추론 하고싶으시다면
그냥 개발중인 텐서플로우를
사용하시는 것이
다른 tf.Serving 서비스를
사용하는 것보다 낫습니다
이 구체적 사례에는
아주 엄격하게 숨겨진
요건들이 있는데요
RPCs와 텐서플로를 번갈아
사용하고 싶지 않으실 겁니다
이것은 아주 드문 경우지만요
보통 잠재된 것은 아주 작습니다
사용 면에서는 한가지 서비스를
사용하시는 것이
두가지를 사용하시는 것보다
훨씬 쉽습니다
전개를 단순화시키고 싶으시다면
이것을 하실 이유가 되는 것이지요

Portuguese: 
as primeiras duas etapas entre eles
são praticamente as mesmas.
Você exporta seu modelo
de estado, torna-o acessível,
aí você escreve o código
para fazer inferência.
Vou mostrar como é em alguns instantes.
Para TensorFlow in-process,
você tem a etapa adicional
de vincular à biblioteca compartilhada
do TensorFlow,
que nós distribuímos.
Vocês podem ver isso nas nossas
instruções Go and Java
e pode simplesmente baixá-las lá,
ou podem construí-las.
Aqui está o exemplo Go
de como se parece uma inferência.
Na verdade, não há muito código.
E, se vocês forem ao repositório
Go no GitHub,
poderão ver códigos de inception reais
que funcionam no Go.
Isso envolve, primeiro,
o carregamento do modelo salvo.
Você passa o diretório
onde está o modelo salvo.
Como mencionei antes, modelos salvos
envolvem múltiplos gráficos TensorFlow.
Após a especificação do diretório,
há uma lista de conjuntos de tags
que você pode utilizar para especificar
qual gráfico TensorFlow quer carregar.
Ao executar seu modelo, vocês
estão provavelmente familiarizados

English: 
the first two steps between
them is practically the same.
You want to export your state
model, make it accessible,
and then you have to write
the code to do inference.
And I'll show you what that
looks like in a moment.
For in process TensorFlow,
you have the additional step
of linking to the TensorFlow
shared library, which
we actually distribute.
And you can see that in our
Go and Java instructions
and you can just
download it right there,
or you can build it yourself.
So, here's the Go example of
what inference looks like.
It's actually not
too much code at all.
And actually, if you go to
the Go repository on GitHub,
you can actually see
real inception code
that works in Go.
So, what it involves is first
loading your saved model.
You pass the directory
that the save model is in.
As I mentioned before,
save models involve
multiple TensorFlow graphs.
So, after you specify
the directory,
there is a list of--
set of tags that you
can use to specify
which TensorFlow
graph you want to load.
When you execute your
model, all of you

Japanese: 
それらの最初の2つの
ステップは実質的に同じです
保存されたモデルをエクスポートして
アクセス可能にし
その後推論を行うためのコードを
記述しなければなりません
それがどう見えるか
ちょっとお見せしましょう
in-process TensorFlowでは
TensorFlow共有ライブラリにリンクする
ステップが１つ追加されます
それを実際に配布されています
またGoとJavaの説明書に
それがあるので
そこでダウンロードしてもいいですし
自分で構築してもいいです
ここに推論がどう見えるか
Goの例があります
実際コードは多くありません
そして実際に
GitHubのGoリポジトリに行くと
Goで動作する実際のinceptionコードを
見ることができます
ここでは まず保存されたモデルを
最初にロードします
その保存モデルが入っている
ディレクトリを渡します
前に述べたように
SaveModelには
複数のTensorFlowグラフが
含まれています
したがってディレクトリを指定した後で
どのTensorFlowのグラフを
ロードしたいかを
特定するに使用できる
タグのセットのリストがあります
あなたのモデルを実行するとき

Spanish: 
los dos primeros pasos entre ellos
son prácticamente los mismos.
Deseas exportar tu modelo expuesto,
hacerlo accesible
y luego tienes que escribir
el código para hacer inferencia.
Te mostraré como se ve en un momento.
Para TensorFlow en proceso,
tienes el paso adicional
de enlazar con la biblioteca
compartida de TensorFlow
que actualmente distribuimos.
Y puedes verlo en nuestras instrucciones
de Go y Java
y puedes descargarlo allí mismo
o puedes construirlo tú mismo.
Así que aquí está el ejemplo de Go
de cómo se ve la inferencia.
En realidad no hay mucho código.
Y si vas al repositorio de Go en GitHub
puedes ver código de inicio real
que funciona en Go.
Entonces, lo que implica es primero cargar
tu modelo guardado.
Pasas el directorio donde está
el modelo guardado.
Como he mencionado antes,
los modelos guardados envuelven
múltiples gráficos de TensorFlow.
Luego que especifiques el directorio
hay una lista de...
un conjunto de etiquetas
que puedes usar para especificar
cuál gráfico de TensorFlow deseas cargar.
Cuando ejecutes tu modelo, todos ustedes

Indonesian: 
Apa pun yang Anda pilih, dua langkah
pertama untuk keduanya hampir sama.
Anda ingin ekspor model Anda,
buatlah bisa diakses
dan Anda harus menulis kode
untuk inferensi.
Saya akan tunjukkan contohnya sesaat lagi.
Untuk In-process TensorFlow, 
Anda punya tahap tambahan
menghubungi pustaka bersama TensorFlow
yang sebenarnya kami distribusikan.
Dan Anda dapat lihat
dalam instruksi Go dan Java
dan Anda bisa download di sana
atau Anda dapat membuatnya sendiri.
Ini contoh Go dari inferensi.
Kodenya tidak banyak.
Dan sebenarnya, jika Anda 
masuk ke repositori Go di GitHub
Anda bisa melihat kode Inception
yang sebenarnya
bekerja dalam Go.
Ini melibatkan, pertama, muatlah
model tersimpan Anda.
Anda melewati direktori
di mana modelnya tersimpan.
Seperti bahasan sebelumnya,
SavedModel melibatkan
berbagai grafik TensorFlow.
Jadi, setelah Anda menentukan direktori
ada daftar serangkaian tag
yang Anda dapat gunakan
untuk menentukan grafik TensorFlow
yang ingin Anda muat.
Saat Anda eksekusi model, kemungkinan

Chinese: 
它们之间前两个步骤几乎是一样的
你想输出模型的状态，使其可访问
然后你必须写代码去做推断
我会等一下展示给你们
对于过程TensorFlow
有额外的步骤
就是连接到TensorFlow共享库
是由我们发布的
你可以看到我们的Go和Java指令
你可以在那里下载
或者自己构建
这是Go推论的例子
其实代码并不多
实际上，如果你去GitHub上Go知识库
你可以看到真正的代码
它们可以在Go中运行
第一加载你保存的模型
你通过有保存模式的目录
如前所述，保存模型涉及多个
TensorFlow图
指定目录后
有一组可用于指定标签的列表
可以加载某个
TensorFlow图
当运行你的模型

Korean: 
무엇을 고르시던지
처음 두 단계는 거의 같습니다
상태 모델을 내보내시고
접근을 가능하게 하신 후
추론을 위한 코드를 적으시면 됩니다
조금 뒤에 보여드리겠습니다
개발 중인 텐서플로우를 위해
여러분은 저희가 제공해드린
텐서플로의 공유 라이버리와 연결하시는
추가단계를 거치셔야 합니다
저희 Go와 Java설명에서
보실 수 있습니다
여기서 다운하실 수도 있고요
직접 만드실 수도 있습니다
추론이 어떤 것인지 보여주는
Go예시가 있습니다
그렇게 코드가 많지 않습니다
그리고 GitHub에서
Go의 보관소에 가시면
Go에서 실제로 사용되는
시작 코드를 확인하실 수 있습니다
우선, 저장된 모델을 불러오시고
디렉토리를 통과합니다
지난번에 말했듯이 저장된 모델은
여러개의 텐서플로 그래프를 포함합니다
디렉토리를 명시하신 후에
사용하실 수 있는 태그들의
목록이 있습니다
이 태그들은 어떤 텐서플로 그래프를
불러올지 명시해줍니다
모델을 실행하실 때, 아마 여러분들이

English: 
are probably already familiar
with TensorFlow sessions
if you've ever used
TensorFlow at all.
It's essentially the same
thing as the Python API
but in another language.
You take a tensor.
Here, we have a batch of images.
And you run your TensorFlow
model using that tensor.
And as output, you
get probabilities
for each classification for
each image in the batch.
And you do something with it.
So I showed Go there.
Jeff mentioned that we support
a ton of different languages.
These languages are all on our
TensorFlow GitHub repository.
So you can actually just
go to the TensorFlow GitHub
repository and start
using any of these.
All of these
languages can actually
be used to build and
execute TensorFlow graphs,
But a common question is, can
any language besides Python
be used for training?
And the answer is a bit nuanced,
but the short of it is no.
And the reason is because a
lot of the supporting libraries

Portuguese: 
com as sessões do TensorFlow,
se já o tiverem utilizado.
É, essencialmente, a mesma
coisa que o API do Python
mas em outra linguagem.
Você pega um tensor.
Aqui, temos um lote de imagens.
E você roda o modelo TensorFlow
utilizando aquele tensor.
Como saída, você terá probabilidades
para cada classificação
de cada imagem do lote.
E você faz alguma coisa isso.
Eu mostrei o Go ali.
Jeff mencionou que damos suporte
a várias linguagens diferentes.
Essas linguagens estão no nosso
repositório GitHub do TensorFlow.
Vocês podem ir ao repositório
GitHub do TensorFlow
e começar a utilizar qualquer um desses.
Todas essas linguagens
podem ser utilizadas
para construir e executar
gráficos TensorFlow.
Uma pergunta comum é:
"Alguma linguagem além de Python
pode ser utilizada para treinamento?"
E a resposta tem algumas nuances,
mas em resumo é "não".
O motivo disso é porque
muitas das bibliotecas de suporte

Indonesian: 
Anda sudah terbiasa 
dengan sesi TensorFlow
jika Anda pernah menggunakan TensorFlow.
Itu sama pentingnya dengan API Python
tapi dengan bahasa yang berbeda.
Anda ambil tensor.
Di sini kami punya sekelompok gambar.
Dan Anda menjalankan model
TensorFlow dengan tensor itu.
Dan sebagai output, Anda 
dapat kemungkinan
untuk masing-masing klasifikasi 
untuk tiap gambar dalam kelompok itu.
Dan Anda melakukan sesuatu dengannya.
Jadi saya tunjukkan Go di sana.
Jeff mengatakan bahwa kami 
mendukung beribu-ribu bahasa.
Semua bahasa ada 
di repositori GitHub TensorFlow.
Anda bisa pergi ke repositori
GitHub TensorFlow
dan mulai menggunakan salah satunya.
Semua bahasa ini dapat digunakan
untuk membuat dan 
menjalankan grafik TensorFlow.
Pertanyaan umum, dapatkah bahasa
selain Python digunakan untuk pelatihan?
Dan jawabannya sedikit nuansa,
tapi singkatnya tidak.
Dan alasannya karena 
banyak pustaka pendukung

Korean: 
이미 텐서플로를 사용해보셨다면
텐서플로 세션에 익숙하실 겁니다
Phyton API와 거의 같다고
보시면 됩니다
언어가 다를 뿐이지요
텐서를 가집니다
이미지 묶음들이 있습니다
그리고 그 텐서를 사용해서
텐서플로 모델을 실행합니다
그리고 여러가지 가능성을 가지게 되지요
각 이미지 묶음의
각 유형들에 대한 가능성을요
그리고 그것으로 무언가 하시면 됩니다
제가 Go를 보여드렸구요
제프가 저희가 여러가지 언어를
지원한다고 말씀드렸습니다
이 언어들은 텐서플로
Github저장소에 있습니다
텐서플로 Github저장소에 가셔서
사용하시면 됩니다
모든 언어들이 사실은
텐서플로 그래프를 만들고
실행 하는데 사용됩니다
하지만 흔히들 묻기를 Python이외의
언어들이 훈련하는데
사용될 수 있냐는 것입니다
답은 약간 아니다쪽에 가깝습니다
이유인 즉, 많은 지원중인 라이버리들이

Chinese: 
如果你曾经使用过TensorFlow
大概已经很熟悉TensorFlow
基本上与Python API是一样的
但是用另一种语言
你拿出一个张量
这里就有一批图像
你在运行TensorFlow时
使用该张量的模型作为输出
你获得每个分类批次中
的每个图像概率
你做一些处理
我在那里演示了 Go
杰夫提到我们支持
许许多多不同的语言
这些语言都在我们的
TensorFlow GitHub知识库中
你可以到TensorFlow GitHub知识库
开始使用它们
所有这些语言
实际上可以用来构建和执行TensorFlow图
但一个常见的问题是
Python以外的任何语言能用于培训吗？
答案有点微妙
简短的答案是‘不行’
原因是很多支持

Japanese: 
これまでにTensorFlow を
使ったことがある皆さんは
既にTensorFlowセッションに
精通しているでしょうが
Python API と本質的に同じですが
言語が違います
あなたはテンソルを取ります
ここでは一連の画像があります
そしてそのテンソルを使って
TensorFlow モデルを実行します
出力として
バッチ内の各画像の各分類について
確率を得ます
それで何かをします
そこにGoを示しました
ジェフは私たちが多種多様な
言語をサポートしていると述べました
これらの言語はすべて
TensorFlow GitHubリポジトリにあります
実際にTensorFlow
GitHubリポジトリにアクセスして
これらのどれでも使い始められます
これらの言語はすべて実際に
TensorFlowグラフの 作成と実行に
使えますが
Python以外の言語を
トレーニングに使用できるかと
いう質問がよくあります
答えは少し微妙ですが
簡単にはノーです
その理由はトレーニングライブラリ

Spanish: 
probablemente ya estén familiarizados
con las sesiones de TensorFlow
si alguna vez has usado TensorFlow.
Esencialmente es lo mismo
que la API de Python
pero en otro lenguaje.
Tomas un tensor.
Aquí, tenemos un lote de imágenes.
Y ejecutas tu modelo de TensorFlow
utilizando ese tensor.
Y como salida, recibes probabilidades
de cada clasificación
para cada imagen en el lote.
Y haces algo con eso.
Allí mostré Go.
Jeff mencionó que soportamos
una tonelada de lenguajes diferentes.
Estos lenguajes están en nuestro
repositorio de TensorFlow en GitHub
Así que en realidad puedes ir allá
e iniciar utilizando cualquiera de estos.
Todos estos lenguajes se pueden
usar para construir
y ejecutar gráficos de TensorFlow
pero una pregunta común es, ¿puede
cualquier lenguaje además de Python
ser usado para la formación?
Y la respuesta está un poco matizada,
pero la versión corta es, no.
Y la razón es porque muchas
de las bibliotecas de soporte

Spanish: 
como las bibliotecas de formación,
las APIs de alto nivel, los optimizadores
la biblioteca RNN, todas ellas sólo
están disponibles en Python
en este momento.
Así que personalmente,
te recomiendo que solo
hagas entrenamiento en Python,
pero puedes hacer inferencia en cualquiera
de estos otros lenguajes.
Las instrucciones para usar
la biblioteca compartida
están en los readmes que están
asociados con cada lenguaje.
Así que puedes descargarlo
o construirlo tú mismo.
No voy a entrar muy a fondo en esto.
Así que, como resumen...
estos son los pasos básicos.
Probablemente ya estés ejecutando
infraestructura con esto.
El punto que quiero enfatizar aquí
es que, especialmente si tienes
un montón de datos
en tu organización, realmente deberías
pensar en cómo hacer
que el comercio distribuido funcione bien
y lo que debes ejecutar para lograr eso.
Como dijo Megan, hay alrededor
de una velocidad de 58x
cuando se ejecuta en 64 GPUs
y te puedes imaginar
qué tipo de efecto eso tendrá
en los ingenieros que trabajan
con TensorFlow
en la formación de modelos de TensorFlow.
Y gracias.

English: 
like the training libraries,
the high level APIs, optimizers,
the RNN library, all of those
are only available in Python
at the moment.
So I would personally
recommend that you only
do training in Python, but
you can do inference in any
of these other languages.
The instructions for
using the shared library
are in the readmes that are
associated with each language.
So you can either download
it or build it yourself.
I won't go into too
much detail here.
So, as a summary--
so, these are the basic steps.
You're probably running
infrastructure already
around it.
The point I want
to emphasize here
is that, especially if
you have a lot of data
in your organization,
you really should
be thinking about how to make
distributed trading work well
and what you should
be running to do that.
As Megan said, there's
like a 58x speed
up when running
on 64 GPUs and you
can imagine what
kind of effect that
would have on the engineers
working with TensorFlow,
in training TensorFlow models.
And thank you.

Indonesian: 
seperti pustaka pelatihan, API
level tinggi, pengoptimalan, pustaka RNN
hanya tersedia di Python pada saat ini.
Jadi secara pribadi, saya merekomendasikan
Anda hanya lakukan pelatihan 
di Python, tapi Anda dapat lakukan
inferensi dalam apa pun bahasa yang lain.
Instruksi menggunakan pustaka bersama
ada dalam berkas informasi
yang diasosiasikan dengan tiap bahasa.
Jadi Anda dapat download
atau membuatnya sendiri.
Saya tidak ingin terlalu rinci di sini.
Jadi, sebagai ringkasan--
Jadi, ini adalah langkah dasar.
Anda mungkin sudah menjalankan
infrastruktur seperti itu.
Yang mau ditekankan di sini
bahwa, khususnya jika
Anda punya banyak data
dalam organisasi, Anda bisa pikirkan
cara membuat distribusi trading
bekerja dengan baik
dan apa yang dapat Anda 
jalankan untuk melakukannya.
Seperti Megan katakan, ada 58x percepatan
saat berjalan pada 64 GPU dan
Anda dapat bayangkan akibatnya
pada insinyur yang bekerja di TensorFlow
dalam melatih model TensorFlow.
Terima kasih.

Korean: 
예를 들어 트레이닝 라이버리
고급 API들, 최적화기
RNN 라이버리 같은 것들이
Python으로만
사용 가능하기 때문입니다
현재로써는요
개인적으로는 Python을
사용해서 훈련하시기를
추천합니다, 하지만 다른 언어들을
추론해보셔도 좋습니다
공유 라이버리를
사용하는 것에 대한 설명은
각 언어에 연관된
리드미 파일들에 있습니다
다운받으시거나 만드실 수 있습니다
너무 깊이 들어가지는 않겠습니다
요약하자면
이것이 기본 스텝입니다
이미 인프라를 운영하고
계실 것입니다
강조하고 싶은 것은
여러분들의 단체에 데이터가 많으시다면
정말로 분산된
영업을 생각해보셔야 한다는 것입니다
그리고 그것을 위해
어떻게 운영할지에 대해서요
메간이 말했듯이 그것은 64 GPU에
실행하시면 58배속이고
텐서플로에서 일하는
엔지니어들에게 미치는 영향을
생각해 보실 수 있을겁니다
텐서플로 모델로 트레이닝
하는 것에 대해서요
감사합니다

Japanese: 
高度なAPI オプティマイザ
RNNライブラリのような
多くのサポートライブラリが
利用可能なのは現時点では
すべてPythonでのみだからです
だから個人的にお勧めするのは
Pythonでのみのトレーニングですが
推論はこれらの他の言語の
どれでもできます
共有ライブラリを使用する説明書は
各言語に関連するリードミーにあります
それをダウンロードするか
自分で構築することができます
ここでは
あまり詳しく説明しません
まとめとして
これらは基本的なステップです
あなたは既にその周りにインフラを
実行している可能性があります
ここで強調 したい点は
特にあなたの職場で
たくさんのデータがある場合
分散トレーニングをいかにうまくするか
それをするために何を実行するか
本当に考えるべきです
メーガンが言ったように
64GPU上で実行している場合
58倍のスピードがあります
TensorFlowを使って
TensorFlowモデルの訓練で
作業するエンジニアの方に
どれほど影響があるか
想像できるでしょう
ご視聴ありがとうございました

Chinese: 
像培训库，高级API，优化器，RNN库等等
所有这些
现在只能在Python中使用
所以我个人建议你
仅在Python中进行培训
但可以用其他任何语言
进行推理
使用相关语言的共享库说明
都在readmes里面
所以你可以下载或自己建立
我不在这里再多讲了
作为一个总结
这些都是基本步骤
你可能已经使用
信息构架
我想强调的一点是
特别是如果你公司里有很多数据
你真的应该考虑
如何使分布式交易运作好
应该怎么做才能达到这一点
就像梅根说的那样
在64 GPU上运行时
可以达到58x的速度
你可以想象
当工程师使用TensorFlow时
或培训TensorFlow模型时
会有什么深远影响
谢谢大家

Portuguese: 
como as de treinamento,
os APIs de alto nível, otimizadores,
a biblioteca RNN, todas essas
só estão disponíveis em Python.
Então, eu recomendo pessoalmente
que você faça o treinamento
apenas em Python,
mas pode fazer inferência
em qualquer uma dessas linguagens.
As instruções para utilizar
biblioteca compartilhada
estão nas instruções do "leia-me"
associados a cada linguagem.
Vocês podem tanto baixá-los
como construí-los.
Não vou entrar em muitos detalhes aqui.
Então, em resumo,
essas são as etapas básicas.
Vocês provavelmente já estão
rodando infraestrutura nisso.
O ponto que gostaria de enfatizar
é que, especialmente, se você
tem muitos dados na sua organização,
realmente deve pensar sobre como fazer
a troca distribuída funcionar bem,
e o que você deveria rodar para isso.
Como Megan falou,
existe uma aceleração de 58x
quando você roda em 64 GPUs,
você pode imaginar que tipo de efeito
isso teria nos engenheiros
trabalhando com TensorFlow,
ao treinar modelos TensorFlow.

English: 
[MUSIC PLAYING]

Portuguese: 
Obrigado.
