
Korean: 
안녕하세요, 여러분
전 노아 피델이고
오늘 전 텐서플로우 서빙을 통해
생산에서 모델을 어떻게
서브할 수 있는가에 대해
발표하겠습니다
그럼 우측 하단에 있는
이미지로 시작하겠습니다
이것은 소프트웨어
엔지니어링이 산업으로써
얼마나 발달되고 진보되었는가를
보여주기 위한 것입니다
머신 러닝은 아직 초기 단계에 있죠
따라서 소프트웨어 엔지니어링으로 해온
모든 멋진 일들과
모두 이해할 수 있게 된 최고의 실례들
예컨대 소스 컨트롤이나 연속 빌드 등을
생각해보면 어쩌면
너무 당연하게 받아들이고
있는지도 모르겠습니다
머신 러닝의 경우 심지어
이 중 일부가 무엇인지도 모르죠
이는 텐서플로우 서빙으로 할 수 있는
많은 것들의 원동력을 주고 있습니다
그럼 이야기 몇 가지로 시작하죠
지난 10년 동안 민간 항공사를
이용해 보신 분 있을까요?
좋습니다, 우리 중 절반은 깨어 있고
아마도 나머지 절반도
그렇겠죠
약 12년 전으로 돌아가 보면
저는 전 세계 대부분의
민간 항공기가 사용하는
비행 계획 소프트웨어
시스템을 작업하고 있었죠
비행기가 어딘가로 가기 위해
얼마의 연료가 필요한가 등의
여러분께 중요한 내용을 다루었죠

Chinese: 
[音乐]
NOAH FIEDEL: 大家好
我是Noah Fidel 今天想和你们分享一下
怎么将TensorFlow服务器
用在你的模型上
我们要从右下角的图看起
这个向你展示的是 在这个行业中
软件工程已经非常成熟和高级
用机器来学习还处于起步阶段
想想看 我们已经
习惯了用软件工程来做一些事
也对其有一定的了解
比如来源控制和持续开发
我们确实已经不能没有这些系统
而机器学习呢
我们还没有对其有很深入的了解
正因如此
我们想大力开发TensorFlow服务器
从几个故事说起吧--
谁在过去的10年中做过飞机呢?
好吧 看来只有一半的人是醒着的
另一半没举手的人肯定也应该举
12年前
我在建立一个计划飞机航班的软件系统
这个系统会被世界各大航空公司运用
里面包括一些你可能关心的信息
比如一架载人飞行的班机需要多少油

Indonesian: 
Hai, semua.
Saya Noah Fiedel dan saya akan berbagi
cara melayani model di produksi
dengan TensorFlow Serving.
Kita akan mulai dengan gambar
di sebelah kanan bawah,
yang menunjukkan bahwa,
sebagai sebuah industri,
teknik perangkat lunak
sangat matang dan maju
sedangkan pembelajaran mesin
masih sangat baru.
Jika kita pikirkan segala yang hebat
yang biasa digunakan
pada rekayasa perangkat lunak dan
praktik terbaik yang kita telah pahami,
hal seperti source control
dan continuous build yang kita sepelekan,
pada pembelajaran mesin,
masih ada yang belum diketahui.
Itu sangat memotivasi
pekerjaan kita pada TensorFlow Serving.
Dimulai dengan beberapa kisah--
siapa yang pernah naik penerbangan
komersial 10 tahun terakhir ini?
Baik, separuh orang di sini masih sadar
dan setengah lainnya
mungkin pernah naik juga.
Kembali ke 12 tahun lalu,
saya mengerjakan sistem perangkat lunak
perencanaan penerbangan
untuk berbagai penerbangan
komersial di dunia.
Termasuk hal yang Anda tahu
seperti berapa bahan bakar yang dibutuhkan
untuk terbang ke suatu tempat.

Spanish: 
Hola a todos.
Soy Noah Fidel,
y hoy voy a compartir con ustedes
cómo pueden servir sus modelos
en producción con TensorFlow Serving.
Comenzaremos con esa imagen
en la parte inferior derecha
y en verdad esto muestra cómo, 
como industria
la ingeniería de software
es bastante madura y avanzada.
Y el aprendizaje automático
está en sus primeros días.
Si piensas
en todas las grandes cosas
a las que estamos acostumbrados
con la ingeniería de software
y las mejores prácticas
que hemos llegado a comprender
como el control del código fuente
y las compilaciones continuas
que damos por sentadas.
Del aprendizaje automático, aún no
sabemos cuáles son esas cosas
y eso motiva mucho
lo que hacemos con TensorFlow Serving.
Empezando con algunas historias...
¿Quién ha tomado una aerolínea comercial
en los últimos 10 años?
Bien, la mitad de nosotros
está despierta
y la otra mitad
probablemente ha volado también.
Hace unos 12 años
yo trabajaba en un sistema
que hacía el software
de planificación de vuelos
para la mayoría de los vuelos
comerciales del mundo.
Esto incluye cosas que quizás te importen
como cuánto combustible tomar
en tu avión para llegar a algún sitio.

Japanese: 
皆さんこんにちは
私はノア・フィデル
そして今日は
TensorFlow Serving を使って
あなたのモデルをどのように
本番稼働に利用できるかをお見せします
まず始めに右下の画像からですが
これはソフトウェアエンジニアリングが
業界として
結構先進的で発達してあるというのを
お見せするものです
そして機械学習が
まだ初歩的な物であるというのもです
なのでソフトウェアエンジニアリングで
お馴染みの継続的インテグレーションや
ソースコントロールなどといった良き物を
当たり前の事と思うかもしれません
しかし機械学習では
そういうのが何なのか
まだ分からないままであり、
それが TensorFlow Serving を
作った理由の１つです
手始めに幾つかの例え話をー
ここ１０年間の間に
民間航空会社を使った人はいますか
半分の人は起きてるようですね
後 半分の人達も多分使ってるでしょう
１２年前に遡りますが
私は世界中の民間飛行の
殆どのフライトプランを組み合わせる
ソフトウェアのシステムを開発中でした
どこかに行くために必要な飛行機の燃料など
知っておきたい事なども含まれていました

Portuguese: 
Olá, pessoal.
Eu sou Noah Fidel 
e hoje vou lhes apresentar
como servir seus modelos em produção
com o TensorFlow Serving.
Vamos começar com a imagem
na parte inferior direita,
e é só para ilustrar como, na indústria,
a engenharia de software está
bem madura e avançada,
e o aprendizado de máquina
está bem no início.
Se pensar em tudo de bom
que nos acostumamos,
a engenharia de software
e melhores práticas,
que compreendemos,
coisas como controle de fonte
e configuração contínua,
talvez desconsideremos.
E aprendizado de máquina.
ainda nem sabemos o que são essas coisas,
e isso motiva o que fazemos 
com o TensorFlow Serving.
Então comecemos com algumas histórias.
Quem aqui viajou por uma companhia aérea 
comercial nos últimos 10 anos?
Ok, metade de nós está acordada
e a outra metade
provavelmente viajou também.
Voltando uns 12 anos atrás,
eu trabalhava em um sistema
de software de planejamento de voo
para muitas companhias aéreas 
comerciais mundiais.
Ele incluía coisas importantes como:
"Quanto combustível pôr no avião
para chegar a um destino?"

English: 
[MUSIC PLAYING]
NOAH FIEDEL: Hi, everybody.
I'm Noah Fidel, and I'm
going to share with you today
how you can serve your
models in production
with TensorFlow Serving.
So we're going to start with
that image on the bottom right,
and really this is just
showing how, as an industry,
software engineering is
quite mature and advanced.
And machine learning is still
early on in the early days.
So if you think about all
the great things we're
used to with soft engineering
and best practices
that we've all
come to understand,
things like source control
and continuous builds,
we might take for granted.
And machine learning,
we don't even
know what some of
those things are yet,
and that motivates a lot of what
we do with TensorFlow Serving.
So starting with a few stories--
who has taken a commercial
airline in the last 10 years?
OK, so half of us are awake
and the other half probably
have as well.
So going back
about 12 years ago,
I was working on a system
that did the flight planning
software for the majority of the
world's commercial air flights.
This included things
you might care about
like how much fuel to take on
your plane to get somewhere.

Korean: 
제가 참여했을 때에는
소스 컨트롤이 없었고
제가 떠날 때는 있었죠
전 이 일을 도와주고 있었죠
그 당시 다들 소스 컨트롤을
이해하고 있었지만
최고의 실례가 있다고 해서
모든 사람들이 사용하는 것은 아니었죠
텐서플로우 서빙과 연관됩니다
여러분 모두가 사용할 수 있는
최고의 실례를 만들고
자동으로 사용할 정도로
쉽게 만들고 싶은 거죠
2010년에 저는 휴대 기기 앱에서
사진을 공유하는
작은 스타트업 기업에 있었죠
정말 좋았습니다
엔지니어링도 정말 좋았고
최고의 실행을 위해 최선을 다했으며
소스 코드와 연속 빌드 등도 있었죠
어느 날 얼굴 탐지와
자동 자르기 기능을 위해
머신 러닝 모델을 추가하기로 했고
정말 좋았습니다
저희도 사용자도
투자자들도 정말 좋아했죠
하지만 머신 러닝에서 오는
연속 빌드가 없었습니다
그 당시 툴은 실행 환경에서
모델로의 무게를
확인할 정도로 즉각적이었죠
하지만 모델로
재훈련시킬 수는 없잖아요?
지금은 잘 이해되는 최고의 실례이죠
그렇게 할 수 있어야죠
이제 2017년 오늘에 이르렀죠
정말 좋은 도구가 많지만
이제 막 시작했고 
머신 러닝에서 갈 길이

Indonesian: 
Tak ada source control
saat saya bergabung,
tapi ada saat saya keluar.
Saya membantu membuatnya
walau source control cukup lazim saat itu,
hanya karena ada praktik terbaik,
bukan berarti semua orang
sudah menggunakannya.
Itulah TensorFlow Serving.
Kami ingin membuat praktik terbaik
yang bisa digunakan
dan mempermudahnya sehingga
Anda langsung paham.
Tahun 2010, saya bekerja
di perusahaan rintisan
membuat pembagian foto
pada aplikasi seluler.
Sangat hebat.
Tekniknya hebat, kami berusaha
melakukan praktik terbaik,
ada source control,
continuous build, dan sebagainya.
Suatu hari kami menambah
model pembelajaran mesin
untuk deteksi wajah dan auto crop
dan sangat bagus.
Kami menyukainya, begitu pula
pengguna dan investor kami.
Tapi kami tidak punya continuous build
dari pembelajaran mesin.
Saat itu, peralatannya cukup khusus
sehingga kami periksa bobot modelnya
pada lingkungan eksekusi,
tapi modelnya tak bisa dilatih ulang, kan?
Saat ini, itulah praktik terbaiknya.
Anda harus bisa melakukannya.
Jadi di sinilah kita, di tahun 2017.
Ada banyak sekali alat,
tapi sebenarnya kita baru saja mulai

Chinese: 
我开始参与软件制作的时候
它并没有来源控制
我离开的时候才有
我一直在帮助实现这个功能
也觉得很有动力
因为即使在当时
人们已经能理解源头控制这个概念
但不代表大家都在使用这个功能
综合这些
我想到了开发TensorFlow
我们希望开发一个最好的系统
容易上手
让大家都能随意使用
在2010年 我在一家小的新兴公司
开发分享照片的应用
这个经历特别好
我们很享受开发应用的过程
并且试着做到最好
我们运用了源头控制和持续开发等功能
有一天我们决定加一个机器学习的模型
包括面部识别和自动剪切的功能
很成功
我们特别高兴 用户特别享受
我们的投资方也很欢喜
但是我们没有机器学习的持续开发
那时候的工具并不是点对点的应用
我们试着做好这个系统
并且试着实际应用
但是没法进行大的改动
但是现在我们知道
什么是最好的开发方式
怎么才能做好软件
到现在我们进入2017年
有了很多好的工具
但是我们才刚刚起步
从机器学习开始

Portuguese: 
Eu não tinha controle de fonte ao entrar.
Eu tive quando saí.
E estava ajudando a fazê-lo,
mas isso dá motivação,
embora o controle de fonte
já fosse algo conhecido,
só porque temos uma melhor prática,
não significa que todos já usam.
E isso ocorre com o TensorFlow Serving.
Queremos fazer as melhores práticas
que todos usem
e torná-las tão fáceis
que possam obtê-las por padrão.
Então, em 2010, eu estava
em uma pequena startup
fazendo compartilhamento de fotos
em apps de celulares.
Foi muito legal. Tivemos ótima engenharia.
Tentamos as melhores práticas.
Tivemos controle de fonte
e configurações contínuas...
e decidimos pôr um modelo
de aprendizado automático
para detectar rostos
e fazer recorte automático
e foi muito legal.
Nós amamos, nossos usuários também,
e nossos investidores ainda mais.
Mas não tínhamos configuração contínua
do aprendizado de máquina.
Mas, na época,
as ferramentas eram bem ad hoc
que analisamos os pesos para o modelo
no ambiente de execução,
mas não podia treinar
o modelo de novo, certo?
Hoje, é uma melhor prática conhecida.
Você quer poder fazê-lo.
Então, aqui estamos em 2017.
Temos muitas ferramentas ótimas,
mas, na verdade, estamos começando

English: 
It didn't have source
control when I joined.
It did when I left.
And I was helping do
that, but this kind
of motivates that even
though source control was
an understood thing of the time,
just because we have a best
practice doesn't mean
everybody uses it yet.
And that's something
with TensorFlow Serving.
We want to make best
practices that you all
can use and make them easy
enough that you got them
kind of by default.
So in 2010, I was at a small
startup doing photo sharing
on mobile apps.
It was really great.
We had some great
engineering, we
tried to do all
the best practices,
we had source control and
continuous builds, and so on.
And one day we decided to
add a machine-learned model
to do face detection
and auto cropping,
and it was really great.
We loved it, our users loved it,
our investors really loved it,
but we had no continuous
build from machine learning.
And at the time, the tools
are kind of ad hoc enough
that we checked in the weights
to the model in the execution
environment, but you couldn't
retrain them model, right?
And now it's a kind of
understood best practice.
You want to be able to do that.
So here we are today in 2017.
We have lots and lots of great
tools, but really, you know,
we're getting started,
and we have a long way

Spanish: 
No tenía control
del código fuente cuando entré.
Sí lo tenía cuando me fui.
Y yo estaba ayudando a hacer eso
pero esto implica que
a pesar de que
el control del código fuente
era conocido,
sólo porque tenemos una mejor práctica
no significa que
todo el mundo ya lo utiliza .
Y eso es importante
con TensorFlow Serving.
Queremos crear las mejores prácticas
que ustedes puedan usar
y hacerlo lo suficientemente fácil
para que las tengan
por defecto.
En 2010,
yo estaba en una pequeña startup
haciendo aplicaciones móviles
para compartir fotos.
Fue realmente bueno.
Tuvimos una gran ingeniería
tratamos de hacer
las mejores prácticas
teníamos el control de código fuente
y compilaciones continuas, y demás.
Un día decidimos añadir
un modelo de aprendizaje automático
para hacer detección
y recorte automático de rostros
y fue genial.
Nos encantó,
a nuestros usuarios les encantó
a nuestros inversores
realmente les encantó
pero no teníamos compilaciones continuas
de aprendizaje automático.
Y en ese momento, las herramientas eran
lo suficientemente ad hoc
que comprobábamos los pesos del modelo
en el entorno de ejecución,
pero no se puede
reciclar el modelo, ¿verdad?
Ahora se entiende
como una de las mejores prácticas.
Todos quieren poder hacer eso.
Así que aquí estamos hoy en el 2017.
Tenemos muchas y grandes herramientas,
pero, ya saben
estamos empezando,
y tenemos un largo camino por recorrer

Japanese: 
私が加わったころには
ソースコントロールがありませんでした
私が去るころにはありました
導入するのに手を貸していましたが
つまりこのようにー
この時もソースコントロールという物が
あったにも関わらず
最適手法があるからといって
誰もが使うわけではありません
そしてそれが TensorFlow Serving の
狙いでもあります
誰もが使えるベストプラクティスを作って
最初から使えるように簡単にしたいわけです
2010年のころ私は
小さなスタートアップ企業で
モバイルアプリの写真共有機能を
デザインしていました
とても優れていました
ソースコントロールや
継続的インテグレーションなどといった
ベストプラクティスなどを
すべて取り込んでいました
ある日 顔領域検出や
自動クロッピングのために
機械学習モデルを
導入しようということになりました
ユーザー、投資者、そして自分たちも
皆 乗り気でしたが
機械学習からは継続的インテグレーションが
ありませんでした
そしてその頃はツールも
機能が限定されたものだったので
実行環境の中のモデルへのウェイトを
確かめても
モデル自体を再トレーニングする事は
できませんでした
今はそれが
ベストプラクティスと知られています
それができるようになりたいわけです
そして 2017 年という現在に至ります
色々と良いツールがありますが
まだまだ始まったばかりで

Korean: 
아주 멉니다
바라건데 우리 모두가
머신 러닝을 둘러 싼 훌륭한 생태계와
최고의 실례를 만들 수 있고
공유할 수 있길 바랍니다
오늘 발표의 아젠다를 보겠습니다
첫 번째 질문인 텐서플로우 서빙이
무엇인가에 답하기 위해
실제로 무엇을 서빙하는지
소개할 것입니다
이게 무엇인지
여러분 중 일부는 아시겠죠
어쩌면 기본일지도 모르겠습니다
하지만 아직 잘 모르시는 분들을 위해
머신 러닝을 제품으로
전개하고 싶으시다면
이 개념과 익숙해지는 편이
좋을 겁니다
서빙은 머신 러닝 모델을 훈련 시킨 후
어떻게 응용하는가 입니다
아주 간단하고 쉬운 것 같죠
하지만 예상 밖의 혹은
새로운 속성들이 있죠
또 다른 관점으로 보겠습니다
모든 분들이 이 슬라이드
왼쪽에 있는 주황색 상자가
익숙하시길 바랍니다
데이터가 있죠
텐서플로우에서 모델을 훈련하기 위해
이 데이터를 사용할 겁니다
그러면 이 모델이 있고 오른쪽에
앱이 있죠
여러분의 앱에서 비디오를 추천한다고
가정하겠습니다
이 모델이 여러분의 앱 내부에서
사용 가능하도록 만들어야겠죠

Spanish: 
en el aprendizaje automático.
Y esperemos
que todos juntos podamos construir
un gran ecosistema alrededor
del aprendizaje automático
y las mejores prácticas,
y así sucesivamente, y compartirlos.
Así que aquí está
la agenda para la charla de hoy.
Para responder a la primera pregunta
¿qué es TensorFlow Serving?
En realidad, voy a presentar
para lo que está sirviendo.
Algunas quizá ya saben lo que es.
Esto podría ser, lo básico para ustedes
pero para aquellos
que no están familiarizados
si alguna vez desean implementar
su aprendizaje automático en la producción
querrán familiarizarse
con estos conceptos.
Serving es cómo se aplica
un modelo de aprendizaje automático
después de haberlo entrenado.
Parece bastante simple y directo.
Pero tiene algunos atributos
que pueden ser inesperados
o nuevos para ustedes.
Teniendo otra opinión al respecto.
Todos estarás familiarizados
con las cajas naranjas
en el lado izquierdo de la diapositiva.
Así que tienes algunos datos.
Vas a usar eso
para entrenar un modelo en TensorFlow.
Y entonces tienes ese modelo,
y tienes tu app a la derecha.
Digamos que estás mostrando
recomendaciones en video
a los usuarios de tu app.
De alguna manera,
necesitas conseguir que el modelo
sea utilizable dentro de tu app.

Indonesian: 
dan masih jauh dari pembelajaran mesin.
Semoga kita bersama-sama
bisa membangun ekosistem yang bagus
untuk pembelajaran mesin, praktik terbaik,
dan sebagainya, dan menyebarkannya.
Ini agenda untuk ceramah hari ini.
Menjawab pertanyaan pertama,
apa itu TensorFlow Serving?
Saya akan memjelaskan tentang Serving.
Mungkin ada yang sudah tahu.
Ini mungkin hal yang dasar bagi Anda
tapi bagi yang belum tahu,
jika Anda ingin meluncurkan
pembelajaran mesin ke produksi,
Anda harus tahu konsep ini.
Jadi, Serving adalah bagaimana Anda
menerapkan model pembelajaran mesin
setelah Anda melatihnya.
Kedengarannya sederhana dan mudah.
Tapi ada beberapa atribut yang mungkin
tidak disangka atau baru bagi Anda.
Dan, dari sudut pandang yang berbeda,
saya harap semuanya paham
tentang kotak oranye
di sebelah kiri tampilan.
Ada beberapa data,
Anda akan memakainya
untuk melatih model di TensorFlow.
Lalu modelnya siap dan
aplikasi ada di sebelah kanan.
Misalnya Anda menunjukkan
rekomendasi video
pada pengguna aplikasi Anda.
Apapun caranya Anda perlu mengusahakan
agar modelnya bisa dipakai pada aplikasi.

Portuguese: 
e temos muito a fazer
com o aprendizado de máquina.
E espero que todos juntos
possamos construir um ecossistema
do aprendizado de máquina
e as melhores práticas e compartilhá-los.
Aqui está a agenda da palestra de hoje.
Respondendo a primeira questão,
"O que é TensorFlow Serving?",
vou apresentar o que é serving.
Muitos devem saber o que é.
Deve ser algo básico para vocês.
Mas os que não estão familiarizados ainda,
se deseja implantar
seu aprendizado de máquina
em produção,
desejará se familiarizar
com esses conceitos.
Serving é como você usa
um modelo de aprendizado de máquina
após tê-lo treinado.
Parece bem simples e claro.
Mas há uns atributos que podem ser
novos ou inesperados para você.
E dando uma outra olhada nisto.
Espero que todos conheçam
as caixas laranjas
no lado esquerdo do slide.
Você tem alguns dados.
Vai usá-los para treinar
um modelo no TensorFlow.
E você tem esse modelo
e o seu aplicativo à direita.
Digamos que mostre recomendações de vídeos
para usuários em seu aplicativo.
Você precisa obter esse modelo
de forma que seja funcional
em seu aplicativo.

English: 
to go from machine learning.
And hopefully,
all of us together
can build a great ecosystem
around machine learning
and best practices, and
so on, and share those.
So here's the agenda
for today's talk.
To answer the first question,
what is TensorFlow Serving?
I'm actually going to
introduce what is serving.
So some of you probably
know what it is.
This might be, kind
of, the basics for you,
but for those who
aren't familiar with it
yet, if you ever want to
deploy your machine learning
into production, you'll
want to become familiar
with these concepts.
So serving is how you apply
a machine learning model
after you've trained it.
Seems pretty simple
and straightforward.
It has some attributes
though that might
be unexpected or new to you.
And, you know, taking
another view on this.
Hopefully, everybody is
familiar with the orange boxes
on the left side of the slide.
So you have some data.
You're going to use that to
train a model in TensorFlow.
And then you have that model,
and you have your application
on the right.
Let's say you're showing
video recommendations
to users in your application.
Somehow you need to
get that model such
that it's usable inside
your application.

Japanese: 
機械学習からは先が長いです
これから 皆さんと一緒に機械学習を基にした
素晴らしい環境を作り上げ
それのベストプラクティスなどを
共有できればと思います
これが今日お話する課題です
TensorFlow Serving とは何かの質問を
答えるために
まず Serving とは何かを
紹介します
既に知っている方もいるでしょう
知っていれば基本かもしれませんが
まだ知らないという方は
いつか機械学習を本番の稼働に
実装したい場合は
こういった概念を知っておいた方が
いいでしょう
では Serving とは
訓練した後の機械学習モデルを
どうやって適用するかのことです
結構シンプルに思えますね
ですが 予想外の属性や新しい属性が
あるかもしれません
そしてもう１つの見方をしてみると
スライドの左側にあるオレンジ色の図形に
馴染みがあると思います
データがあります
それを使って TensorFlow のモデルを
訓練します
そしてそのモデルがあって
右側にアプリケーションがあります
例えば自分のアプリで
ユーザーにビデオ推薦を見せるとします
そして自分のアプリで使えるように
そのモデルをどうにかしなければいけません

Chinese: 
我们还有很长的路要走
希望我们能携手
在机器学习的基础上
建立一个好的可持续的系统
知道怎样是最好的方式
并且和大家分享
接下来我们进入今天的讲座
第一个问题是 TensorFlow服务器是什么?
我想先讲讲什么是服务器
你们中有的人可能已经知道了
肯定是基础知识
我给不熟悉的人讲一下
如果你想将机器学习
运用到制作中 你必须
熟悉这些概念
研发服务器就是完善一个模型
然后将其运用到机器学习的系统中
听上去很简单很直接
但是它有些新的属性
你可能没想到 或者不熟悉
我们可以从另一个角度来看
我希望你们已经对橙色盒子很熟悉了
就是幻灯片左边的部分
从一些数据开始
你想在TensorFlow里用这些数据
来完善你的模型
你的模型在这里 你的应用系统
在右边
假设在你的应用中
你想加入让用户推荐视频的功能
你得完善你的模型
这样这个功能就能在应用里实现

English: 
So the most common way to do
this is using an RPC server.
And TensorFlow serving can
be used both as an RPC server
and as a set of libraries inside
your app on embedded devices
or in mobile.
So a key attribute
for serving is
that it's online
and low latency,
and this differs quite
a bit from training
and other big data
pipelines you might run.
Your users don't want to
wait for the recommendations.
They're not going
to wait a minute.
They're probably not
going to wait 10 seconds.
You really need to be fast
and consistently fast.
Another thing that's, you know,
different from many big data
tools out there is that
you'll have many models
in a single process.
So let's say you had a
great production model,
it's serving great
recommendations to your users,
and then you have a new
experiment you want to run.
The most common
pattern that people do
is they want to load, say,
a second experimental model
in their server alongside
their main production model.
So it's really common.
Another thing is an
emerging best practice
that we're seeing a
lot inside Google,
and we want to bring
more to industry--
is that you'll
have many versions
of your model over time.
So the data that you
trained on last week

Japanese: 
一般的な方法が
RPC サーバーを使う事です
そして TensorFlow Serving は
RPC サーバーとして使えるし
またアプリの中のライブラリのセットとして
内蔵された機器やモバイルで使えます
なので Serving の主属性は
オンラインで低遅延であり
これは訓練や実行するかもしれない
他の大きなパイプラインデータとは
大きく違います
ユーザーは推薦なんかを
待ちたくありません
１分も待ったりしません
１０秒さえも待ったりしないでしょう
常に迅速であることが必要です
そして大型データツールと他に違う事は
１つのプロセスで
いくつものモデルがあるという事です
例えば良い製作モデルがあるとして
ユーザーに良い推薦を出していて
新しい実験を実行してみたいとします。
１番よくあるパターンとして
２つ目の実験モデルをメインの製作モデルと
隣り合わせでサーバーにロードさせます
とてもよくあることです
もう１つは Google の中でよく見かける
ベストプラクティスですが
そして我々は
この業界にもっとあってほしいものですが
時間が経つにつれ
複数のモデルを持つことです
先週訓練の元にしたデータが

Indonesian: 
Cara umum yang dipakai
adalah memakai server RPC.
Dan TensorFlow Serving bisa dipakai
baik sebagai server RPC
dan sebagai pustaka dalam aplikasi
di perangkat tertanam atau di ponsel.
Jadi atribut kunci untuk serving adalah
online dan latensi rendah.
Ini cukup berbeda dari pelatihan
dan saluran data besar lain
yang Anda jalankan.
Pengguna tidak mau menunggu
rekomendasi Anda.
Mereka tak mau menunggu lagi.
Apalagi menunggu 10 detik.
Anda perlu cepat dan terus seperti itu.
Hal lain yang berbeda
dari alat data besar lainnya di luar sana
adalah akan ada banyak model
dalam satu proses.
Jika ada model produksi hebat,
ia akan melayani rekomendasi hebat
pada pengguna Anda,
dan akan ada eksperimen baru
yang ingin dijalankan.
Pola yang amat umum dilakukan,
mereka ingin memuat, contohnya,
model eksperimen kedua dalam server
bersama dengan model produksi utama.
Jadi sangat umum terjadi.
Hal lain adalah praktik terbaik
yang banyak bermunculan di Google,
dan kami ingin membawa lebih
ke industri ini--
adalah Anda akan punya
berbagai versi model seiring waktu.
Jadi, data yang dilatih minggu lalu

Korean: 
이렇게 하는 가장 흔한 방법은
RPC 서버를 사용하는 겁니다
텐서플로우는 임베드 기기
혹은 휴대기기 상의
앱 내부에서 RPC 서버와
라이브러리 세트 둘 다로
사용될 수 있습니다
따라서 서빙의 주요 속성은
온라인과 낮은 지연 속도인 거죠
그리고 이는 훈련이나 여러분이
실행할지도 모르는
다른 큰 데이터 파이프라인과
상당히 다릅니다
사용자들은 추천을 위해 기다리지 않죠
1분도 기다리지 않죠
10초도 기다리지 않을 겁니다
정말 빠르고 계속해서 빨라야 합니다
많은 다른 큰 데이터 툴과의
또 다른 차이점은
단일 과정에서 많은 모델이
있을 것이라는 점이죠
훌륭한 생산 모델이 있다고 가정해 보죠
사용자에게 훌륭한 추천사항을 제공하고
이제 여러분은 새로운 실험을
실행하고 싶은 거죠
이 분들이 하는 가장 흔한 패턴은
예컨대 주요 생산 모델과 함께 서버에서
두 번째 실험 모델을 로딩하고 싶어하죠
정말 흔한 방식이죠
또 다른 방식은 Google 내부에서
최근에 자주 보는 최고 실례로
산업으로 더 많이 가져 오고
싶은 방법이기도 하죠
바로 시간이 지나면서
많은 버전의 모델을 가지는 거죠
지난 주에 훈련시킨 데이터는

Spanish: 
La forma más común de hacerlo
es utilizando un servidor RPC.
Y el servidor de TensorFlow
puede utilizarse como servidor RPC
y como un conjunto
de bibliotecas dentro de la app
en dispositivos incrustados
o en dispositivos móviles.
Un atributo clave para el serving
es que esté en línea y tenga baja latencia
y esto difiere bastante del entrenamiento
y otras procesos de big data que ejecutes.
Tus usuarios
no quieren esperar las recomendaciones.
No esperarán un minuto.
Probablemente no esperarán ni 10 segundos.
Necesitas ser realmente rápido,
constantemente rápido.
Otra cosa que es diferente
de muchas herramientas
de datos grandes por ahí
es que tendrás
muchos modelos en un solo proceso.
Digamos que tienen
un gran modelo de producción
que sirve grandes
recomendaciones a tus usuarios
y quieres ejecutar un nuevo experimento.
El patrón más común
que la gente sigue es que quieren cargar
digamos, un segundo modelo
experimental en su servidor
junto con su modelo
de producción principal.
Es muy común.
Otra buena práctica emergente
que estamos viendo mucho dentro de Google
y queremos traer más a la industria
es que tendrás muchas versiones
de tu modelo con el tiempo.
Por lo tanto, los datos que entrenaste
la semana pasada

Portuguese: 
Então a forma mais comum de fazê-lo
é usando um servidor RPC.
E o TensorFlow Serving pode ser usado
como um servidor RPC
ou como um conjunto
de bibliotecas no seu app,
em dispositivos incorporados
ou em celulares.
Um atributo chave para o serving
é que é on-line e com baixa latência,
e isso se diferencia bastante
de treinamento
e outros encadeamentos
de grandes dados que possa rodar.
Seus usuários não querem esperar
pelas recomendações.
Não vão esperar um minuto.
Talvez nem dez segundos.
Você precisa ser rápido
e consistentemente rápido.
Outra coisa que difere de muitas
ferramentas de grandes dados
é que você terá muitos modelos
em um único processo.
Digamos que tenha
ótimo modelo de produção,
servindo ótimas recomendações
aos seus usuários,
e tenha um novo experimento
que queira fazer.
O padrão comum feito pelas pessoas
é que querem carregar
um segundo modelo experimental
no servidor delas,
junto ao modelo principal de produção.
Isto é muito comum.
Outra coisa que é 
uma melhor prática crescente,
que temos visto muito no Google,
e que queremos trazer mais
para a indústria.
É que você terá muitas versões
de seu modelo com o tempo.
Os dados que treinou na semana passada

Chinese: 
最常用的方法就是运用RPC服务器
TensorFlow服务器
既可以被当成RPC服务器来用
也可以被当成嵌入设备应用或移动中的
资源
所以服务器的一个关键属性就是
一直在线并且容易找到
这和你可能用到的其他大的数据结构
很不同
你的用户不会想花时间
等着去推荐东西
他们不会花一分钟来等
可能连10秒都不愿意等
所以你的系统必须快 而且稳定
另一个这个和其他大数据工具不同的地方
在于这个系统
在一个单一的过程中
能提供很多种模型
假如你有一个很好的制作模型
给你的用户提供很不错的推荐方式
然后你有一个新模式想要进行试验
通常来讲
人们会上传一个实验模型
传到主制作模型上
这是通常的做法
另一个要提到的
是一种正在新兴的新方式
我们在谷歌系统中常常见到
并且希望大力开发--
就是花时间
来积累多种模型
你上周完善过的数据

Korean: 
어제 모은 데이터와 큰 연관이
없을 수도 있는 거죠
따라서 모델을 계속해서 훈련시키고
계속 전개시키는 겁니다
마지막으로
여기 마지막 포인트를 말씀드리죠
미니 배치를 아시는 분 있을까요?
좋아요
꽤 많죠
미니 배치는 훈련 시간에
여러 예시를 가지고
어쩌면 대기 시켜며
그래프를 통해 함께 실행하는 거죠
더 많은 처리량과 더 높은 효율성을
얻기 위해서 말이죠
이건 정말 멋집니다
모델이 더 빨리 더 많은 훈련 데이터를
처리하게 해 주는 거죠
문제는 어떻게 생산 설정에서
이를 할 수 있는가이죠
모든 요구가 동시에 들어오지 않고
적당한 지연속도를
유지하고 싶을 때 말이죠
이를 위해 라이브러리와
바이너리 수준 모두에서
사용할 수 있는 좋은 도구가 있습니다
그럼 텐서플로우 서빙이
무엇인가로 넘어가죠
융통성 있고 머신 모델을 위한
고성능 서빙 시스템으로
생산 환경을 위해 설계됐습니다
텐서플로우 서빙은 세 가지
주요 기둥이 있습니다
첫 번째는 C++ 라이브러리로

English: 
might not be as relevant to the
data you gathered yesterday,
and so you want to
continually train your models
and continually deploy them.
Last but not least,
I'm just going
mention the last bullet here.
Is anybody familiar
with mini-batching?
OK.
Just a f-- oh, a good number.
So mini-batching is where
you take a bunch of examples
at training time,
maybe cue them up,
and then you run them
through your graph
together to get more throughput
and higher efficiency.
And this is really great.
It lets you train models
more quickly, process a lot
more training data, and
so the challenge here
is how can you do that in
a production setting where
all of your requests
arrive asynchronously
and you want to keep a
nice bound on latency.
And we have some good tools,
both at the library level
and binaries for you to do that.
All right, so moving on to
what is TensorFlow Serving.
So it's a flexible,
high-performance serving system
for machine models, and it's
designed for your production
environments.
TensorFlow Serving has
three major pillars.
The first are C++ libraries.

Portuguese: 
podem não ser tão relevantes
para os dados colhidos ontem.
E você quer treinar seus modelos
e implantá-los, continuamente.
Por último, mas muito importante,
eu só vou mencionar o último ponto aqui.
Alguém aqui está familiarizado
com mini-batching?
Ok. Só um pou...
ah, um bom número.
Mini-batching é quando você pega
um monte de exemplos
no tempo de treinamento,
talvez os ponha em ordem
e os executa no seu gráfico, em conjunto
para ter mais taxa de transferência
e frequência mais alta.
E é muito legal.
Deixa treinar modelos mais rapidamente,
processar mais dados de treinamento.
E o desafio aqui
é como fazer isso
em um ambiente de produção
onde todos os pedidos
chegam assincronamente
e quer manter um bom limite de latência.
E temos boas ferramentas,
em nível de biblioteca
e binários para você fazer isso.
Bem, vamos falar sobre o que é
o TensorFlow Serving.
Ele é um sistema de serviço flexível,
de alto desempenho
para modelos de aprendizado de máquina
e para ambientes de produção.
O TensorFlow Serving
tem três pilares principais:
o primeiro são as bibliotecas C++.

Indonesian: 
mungkin tidak relevan dengan data
yang Anda kumpulkan kemarin
dan Anda ingin terus melatih model Anda
dan terus meluncurkannya.
Terakhir, saya hanya akan
sebutkan poin terakhir.
Apakah ada yang tahu mini-batching?
Oke, cukup banyak.
Mini-batching adalah di mana
Anda mengambil beberapa contoh
saat pelatihan,
mungkin mengisyaratkannya,
lalu menjalankannya pada grafik bersamaan
agar mendapat efisiensi
yang lebih tinggi dan menyeluruh.
Ini sangat hebat.
Anda bisa melatih model lebih cepat,
memproses lebih banyak data pelatihan
dan tantangannya, bagaimana
melakukannya dalam aturan produksi
di mana semua permintaan
muncul secara asinkronus
dan Anda harus jaga agar latensi tetap.
Ada beberapa alat bagus
baik di tingkat pustaka
maupun biner.
Baiklah, kita lanjut ke penjelasan
TensorFlow Serving.
Jadi, ia adalah sistem layanan
kinerja tinggi dan fleksibel
untuk model mesin dan didesain
untuk lingkungan produksi.
TensorFlow Serving memiliki
tiga pilar utama.
Yang pertama adalah pustaka C++.

Spanish: 
podrían no ser tan relevantes
para los datos que recopilaste ayer
por lo que debes entrenar
y desplegar continuamente tus modelos.
Por último,
voy a mencionar el último punto aquí.
¿Alguien está familiarizado
con el mini-batching?
De acuerdo.
Sólo unos cuan... Ah, un buen número.
Mini-batching
es donde se toma un montón de ejemplos
cuando entrenas,
tal vez les das una señal de entrada,
y luego los ejecutas juntos
a través de tu gráfico
para obtener
más rendimiento y mayor eficiencia.
Y esto es realmente genial.
Te permite
entrenar modelos más rápidamente,
y procesar
muchos más datos de entrenamiento
el desafío aquí
es cómo puedes hacerlo
en un entorno de producción
en el que todas tus solicitudes
llegan de forma asíncrona y deseas
mantener un buen límite de latencia.
Y tenemos buenas herramientas,
tanto en el nivel de biblioteca
como en binarios para que puedas hacerlo.
Pasando a lo que es TensorFlow Serving.
Es un sistema de servidor flexible
y de alto rendimiento
para modelos de máquinas, y está diseñado
para tus entornos de producción.
TensorFlow Serving
tiene tres pilares principales.
El primero son las bibliotecas C ++.
Esas son las que usamos internamente
para construir nuestros binarios

Japanese: 
昨日集めたデータと比べて
関連性が少ないかもしれないので
常にモデルを訓練しながら
常に展開したいわけです
そして最後にもう１つだけ
言っておきたいことがあります
皆さん ミニバッチ法というのを
ご存知でしょうか
オーケー
結構いますね
ミニバッチ法とは訓練のときに
複数の例を選んで
一緒にグラフを通して実行し、
もっと効率よく情報量を処理するわけです
これは素晴らしいことです
モデルをもっと早く訓練することができ
もっと沢山の訓練データを処理します
ここでの難関はそれらのリクエストが
同時に入ってくる実際の稼働環境で
どうやって対応するか そして
遅延のバウンドをどう維持するかです
そのために
ライブラリとバイナリのレベルで
便利なツールがあります
では TensorFlow Serving とは
何なのかについてお話しします
機械モデルのための
柔軟な高性能 Serving システムであり
開発者の製作環境向けに
デザインされています
TensorFlow Serving には
３つの支点があります
１つ目は C++ ライブラリです

Chinese: 
可能与你昨天积累的数据完全没关系
所以你要继续完善你的模型
继续最大化使用它们
最后, 我想提一下
最后的一点
有谁对mini-batching很熟悉的吗?
好
只有几个-- 哦 不错
mini-batching就是你在完善数据的时候
积累一些例子，然后将它们排列好
然后你在图表中进行分析
将它们以更高效的方式进行排列
这种方式很赞
因为你可以更快地完善更多模型
处理更多数据，但是有挑战性的是
你用怎样的处理方式来确保
所有的数据都能异步实现
确保数据的潜在性
我们有很多很好的工具来进行支持
有资源性工具和其他工具
好了 接下来我们来说说TensorFlow服务器
这个是一个灵活高效的服务系统
用于机器模型
而且是为你的制作环境
设计而成
TensorFlow服务器有三大脊柱
第一个是C++数据系统

Chinese: 
也是我们内部建立二进制代码的基础
这些都是开放性资源
并且处在系统的低级
包括怎样保存和恢复TensorFlow模型
和怎样陆续上传新的模型
我们的二进制代码包括了
所有我们目前了解到的制作方式
还有一些新兴的方式
这些方式我们还不确定它们是否有效
我们会进行标注然后进行尝试
另外还有Docker存储器和教程
有代码实验室
让你对我们的二级代码进行调整
更好地将其运用在
Kubernetes之类的平台上
最终要说到的是
我们在谷歌云端机器学习系统上有服务器
也有内部处理系统
好了 接下来
我们可以了解一下资源库
我们的代码平台完全是从新生成的
意思是假如你有一个当前的系统
可能你在运用一个遗下的
或者自制的机器学习系统
想要使用TensorFlow服务器
但是在过度阶段
你可能想把这个和自己的遗留系统
结合起来
我们的代码平台
允许你结合任何C++阶段

Spanish: 
y son todos de código abierto.
Y tienen niveles muy bajos.
Incluyen cosas como cómo guardar
y restaurar un modelo de TensorFlow
así como cómo cargar
nuevas versiones de modelos con el tiempo.
Tenemos binarios que incorporan
las mejores prácticas
que hemos aprendido
hasta ahora fuera de lo común,
y para los emergentes
que no estamos seguros
si es una mejor práctica todavía
márcalos para activarlos y probarlos.
También tenemos contenedores de Docker,
tutoriales, y laboratorios de código
que te permiten escalar automáticamente
nuestros binarios en Kubernetes
y así sucesivamente.
Finalmente, tenemos
un servicio alojado con Google Cloud ML
así como una versión interna de eso.
Vamos a sumergirnos
en nuestras bibliotecas.
Nuestra plataforma central
es completamente genérica
y lo que eso significa es que,
digamos que tienes un sistema actual.
Tal vez tienes el servidor
en un sistema heredado
o en uno de aprendizaje
automático construido en casa.
y deseas adoptar TensorFlow
pero durante algún período
de transición es posible
que desees mezclarlo
con tu sistema heredado.
Nuestra plataforma
principal te permite incluir
cualquier tipo de C ++
que desees como un servicio.

Japanese: 
これは内部からバイナリを構築するために
使われています
知っての通りすべてオープンソースです
そしてとても低レベルです
TensorFlow モデルを保存したり
復元したりする方法や
時間が経つにつれ新しいモデルを
ロードする方法などもです
立ち上げてすぐにベストプラクティスを
取り入れるバイナリが含まれてあり
そしてまだ最善なのかどうか
分からない物には
試せるようにフラグで
有効にできるようになっています
他にも Docker コンテナや
チュートリアル
そしてバイナリを Kubernetes で
自動スケールするコードラボなどもあります
最後に Google Cloud ML での
ホストサービスと
その内部化されたバージョンもあります
では次はライブラリの説明です
コアプラットフォームは完全に汎用であり
つまり例えば
今自分にシステムがあるとします
レガシーか自前の ML システムで
提供していて
TensorFlow を取り入れたいとしたら
しばらくその移行期間の間は
自分のレガシーシステムと
混ぜてみたいかもしれません
そしてこのコアプラットフォームでは

Portuguese: 
Elas são o que usamos internamente
para construir nossos binários
e são todas de código aberto.
E são níveis bem baixos.
Elas incluem coisas como salvar
e restaurar um modelo de TensorFlow,
e também como carregar
novas versões de modelo com o tempo.
Temos binários que incluem
todas as melhores práticas
que aprendemos até agora,
fácil de usar,
e para os emergentes que não sabemos bem
se são uma melhor prática,
sinalizam para que possa
habilitá-los e experimentá-los.
Temos também
recipientes Docker e tutoriais
e laboratórios de código
que deixam escalar nossos binários
no Kubernetes e por aí vai.
E, finalmente, temos um serviço
hospedado no Google Cloud ML,
como também uma versão interna dele.
Ok, vamos explorar as nossas bibliotecas.
Nossa plataforma central
é completamente genérica.
E o que isso quer dizer?
Digamos que tenha um sistema atual.
Talvez tenha o servidor em um Legacy
ou em um sistema ML feito em casa
e quer adotar o TensorFlow,
mas no período de transição,
você quer combiná-lo
com o seu sistema Legacy.
A nossa plataforma central
permite-o incluir qualquer classe C++
que você desejar com um servidor...

English: 
These are what we use internally
to build our binaries,
and they're, you
know, all open source.
And they're very low levels.
They include things like how to
save and restore a TensorFlow
model as well as how to load
new model versions over time.
We have binaries
that incorporate
all of the best practices
we've learned thus far
out of the box, and
for the emerging ones
that we're not sure if
it's a best practice yet,
you know, flag so that you
can enable and try them.
We also have Docker
containers, and tutorials,
and code labs that let you
auto scale our binaries
on Kubernetes and so on.
And finally, we have a hosted
service with Google Cloud ML
as well as an internal
version of that.
OK, so diving into
our libraries.
Our core platform is
completely generic,
and what this means is let's
say you have a current system.
Maybe you're serving on a legacy
or in-house built ML system
and you want to
adopt TensorFlow,
but for some transition
period of time
you might want to mix that
in with your legacy system.
So our core platform lets you
include any C++ class you want

Indonesian: 
Ini yang kami gunakan secara internal
untuk membangun biner
dan semuanya adalah sumber terbuka.
Dan bertingkat sangat rendah.
Dan ini termasuk bagaimana menyimpan
dan memulihkan model TensorFlow
dan juga memuat versi
model baru seiring waktu.
Ada biner yang
menggabungkan praktik terbaik
yang kita pelajari sejauh ini
di luar kebiasaan
dan untuk yang baru muncul
yang belum pasti adalah praktik terbaik,
berilah tanda agar Anda
bisa mengaktifkan dan mencobanya.
Juga ada wadah Docker,
tutorial, dan lab kode
yang membuat Anda bisa mengukur
biner kami pada Kubernetes,
dan sebagainya.
Terakhir, kami mengadakan layanan
dengan Google Cloud ML
dan juga versi internalnya.
Masuk ke pustaka kami.
Platform inti kami sangat umum.
Artinya, katakan saja
Anda punya sistem terbaru,
mungkin Anda melayani sistem ML bawaan
atau yang dibangun sendiri
dan Anda ingin mengadopsi TensorFlow,
tapi untuk masa transisi tertentu
Anda mungkin ingin mencampurnya
ke dalam sistem bawaan Anda.
Jadi platform inti kami membuat Anda
bisa memasukkan kelas C++
yang Anda inginkan sebagai layanan--

Korean: 
바이너리를 만들기 위해
내부적으로 사용하는 것이죠
또한 모두 오픈 소스입니다
아주 낮은 수준이죠
이는 어떻게 텐서플로우 모델을 저장하고 복구하는가
어떻게 시간이 지나면서 새 모델 버전을
불러올 수 있나 등을 포함하죠
우리가 지금까지 배운
바로 사용할 수 있는
최고의 실례를 모두
통합하는 바이너리가 있고
아직 최고의 실례인지 확신할 수 없는
최근에 나온 경우는
시도해 볼 수 있도록
플래그를 달 수 있죠
또한 도커 컨테이너, 사용설명서
쿠버네트에서 바이너리를
자동 스케일할 수 있게
해주는 코드 랩 등도 있죠
마지막으로 Google 클라우드
ML을 통한 호스트 서비스와
이것의 내부 버전도 있습니다
그럼 라이브러리로 바로 들어가보죠
저희 코어 플랫폼은 완전히 제네릭합니다
현재 시스템이 있다고 치죠
레거시나 회사 내부에서
만든 ML 시스템에서 서빙하고
텐서플로우를 가져오고 싶은 거죠
하지만 옮기는 기간 동안
여러분의 레거시 시스템으로
섞고 싶은 거죠
따라서 저희 코어 플렛폼은
여러분이 원하는 어떠한 C++ 클래스도

Chinese: 
这样--
资源库中的组件都是分开的
所以每个组件--
如果你去
看一下我们的网页 每个级别中
都有谷歌内部用户的使用历史
每个组件及其结合都有被用到
只有想不到的
这些资源都在被最大化使用
如果我们把最后三个点联系起来
重点就落在
我们所有的应用程序编程接口
总的来说 都能让你添加自己的东西
这样你就能在不同的模型存储中
加入你需要的支持因素
你可能已经是一个
现存的机器学习的用户
也许你已经有成百的数据库模型
如果我们能提供给你一个将模型
取出的方式
你就能轻易将其带入
用来支持改进过的数据库
或者改进过的数据存储系统
好了 接下来要讲的
希望不会太让人头疼
就是我们在TensorFlow服务器中的
高级资源库
现在你们看到的排列
也是我们在二级代码中
已经为你建好的排列方式
绿色的方框基本上是标准的
应用程序编程接口的抽象化数据
黄色的方框

Indonesian: 
Semua komponen dari pustaka
dibangun khusus, jadi setiap komponen--
jika Anda lihat laman, setiap kelas kami
digunakan oleh beberapa klien
di Google secara mandiri
dan berbagai macam kombinasi
yang dapat Anda bayangkan.
Mereka juga digunakan dan diluncurkan
Dan membahas tiga poin terakhir sekaligus,
yang terpenting di sini adalah
semua API kami, tidak terkecuali,
membolehkan Anda memasang
implementasi Anda sendiri.
Jadi Anda bisa menambah dukungan
untuk berbagai penyimpanan model.
Mungkin Anda pengguna ML yang sudah ada,
mungkin Anda punya
ratusan model di basis data.
Jika kami sediakan cara
melepas model dari sistem file
Anda bisa mudah memperluasnya
agar mendukung basis data khusus
atau gudang data khusus.
Jadi, saya akan pandu Anda.
Semoga ini tidak terlalu rumit.
Ini pustaka tingkat tinggi kami
dalam TensorFlow Serving
dan semua ini juga diatur
persis seperti biner kami
yang telah kami bangun untuk Anda.
Kotak hijau adalah abstraksi
standar kami dengan API

English: 
as a servable--
The components of the
libraries are all a la carte,
so every component--
if you go look
at our page, every
single class we
have is used by some customer
inside Google on its own
and in just about
any combination
that you can imagine.
They're also used and deployed.
And taking the last
three bullets together,
the highlight here is
that all of our APIs,
by-and-large, allow you to plug
in your own implementations.
So you can, you
know, add support
for a different model storage.
Maybe you're already
an existing user of ML.
Maybe you have hundreds
of models in a database.
If we provide a way to get
models off a file system,
you can easily extend that
to support a custom database
or a custom data store.
OK, so I'm going to
walk you through.
Hopefully, this is
not too complex.
This is our libraries at a
high level inside TensorFlow
Serving, and they're also
arranged here exactly
as they are inside our binaries
that we pre-build for you.
So the green boxes are
our standard, kind of,
abstractions with APIs,
and the yellow boxes

Korean: 
서빙할 수 있게 포함시켜 줍니다
라이브러리의 컴포넌트는
모두 각각 선택할 수 있고
따라서 저희 페이지를 보시면
저희가 가지고 있는 모든 단일 클래스는
Google 내부의 고객들이 사용하고
여러분이 상상할 수 있는
어떠한 조합으로도 사용되죠
이들은 또한 사용되고 전개됐습니다
이 마지막 세 포인트를 같이 보면
여기서 중점은 API 모두가 대체로
여러분 자체의 실행으로
플러그인할 수 있게 해준다는 점이죠
따라서 다른 모델 저장에 대한
지원도 추가할수 있죠
여러분은 이미 ML을
사용하고 계실지도 모르고
데이터베이스에 수 백개의
모델이 있을 수도 있죠
저희가 파일 시스템에서 모델을
분리할 방법을 제공한다면
이를 커스텀 데이터베이스나
스토어로 지원하도록
쉽게 확장할 수 있습니다
그럼 설명해 드리죠
너무 복잡하지 않길 바랍니다
이것은 텐서플로우 서빙 내부의
고등 라이브러리입니다
이건 저희가 여러분을 위해 미리 만든
바이너리 내부
그대로를 여기에 배열한 것이죠
녹색 상자는 API로
하는 표준 추출이고
노란색 상자는 그러한 추출로

Spanish: 
Los componentes de las bibliotecas
son todos a la carta,
por lo que cada componente…
si miras nuestra página,
cada clase que tenemos
es utilizada por algunos clientes
dentro de Google por su propia cuenta
y en cualquier combinación
que puedas imaginar.
También se utilizan y se despliegan.
Y tomando los tres últimos puntos,
lo más destacado aquí
es que todas nuestras API, en general
le permiten
conectar sus propias implementaciones.
Así que puedes agregar soporte
para un modelo
diferente de almacenamiento.
Quizás ya eres un usuario existente de ML.
Tal vez tienes
cientos de modelos en una base de datos.
Si damos una forma de eliminar
modelos de un sistema de archivos
puedes ampliarlo fácilmente para que
admita una base de datos personalizada
o un almacén de datos personalizado.
Voy a guiarlos. Esperemos
que esto no sea demasiado complejo.
Estas son nuestras bibliotecas
de alto nivel dentro de TensorFlow Serving
y también están arregladas aquí
exactamente como están
dentro de nuestros binarios
que pre-construimos para ti.
Las cajas verdes
son nuestro estándar
como unas abstracciones con APIs

Portuguese: 
Os componentes das bibliotecas
estão todos à la carte,
então, cada componente,
se olhar na nossa página,
cada classe que temos
é usada por algum cliente
dentro do Google, sozinho,
e é quase toda combinação
que você possa imaginar.
Eles também são usados e implantados.
E, juntando os três últimos pontos,
o destaque aqui
é que todas as nossas APIs,
em geral, permitem que se conecte
em suas próprias implementações.
Você pode agregar suporte
para um modelo de armazenamento diferente.
Talvez você já seja um usuário de ML.
Talvez tenha centenas de modelos
em uma base de dados.
Se dermos uma forma de tirar
modelos de um sistema de arquivo,
será fácil ampliar para apoiar
um banco de dados
ou uma loja de dados personalizados.
Ok. Então, vou lhes apresentar.
Espero que não seja muito complexo.
Estas são as nossas bibliotecas, 
de alto nível, no TensorFlow Serving.
E elas estão organizadas aqui,
exatamente como estão
dentro de nossos binários
que pré-fabricamos para você.
Então, as caixas verdes são padrão,
tipo abstrações com APIs

Japanese: 
好きな C++ クラスを
servable として含むことができます
ライブラリのコンポーネントは
全てアラカルトです
我々のページを見てみると
クラスのそれぞれが
Google 内の顧客の誰かに使われていて
そして想像できるどんな組み合わせも
実用されています
そして最後の３つの点を一緒にまとめると
注目すべきものは我々の API は
概ね自分なりの実装を組み込む事ができます
なので 例えば
別のモデルストレージへの
サポートを加える事ができたりします
もしかしたら ML の
既存ユーザーであるかもしれません
データベースに
数百ものモデルがあるのかもしれません
ファイルシステムからモデルを
取り出す手段を提供すれば
それを拡張してカスタムデータベースや
データストアへのサポートを
することができるでしょう
では手順を説明したいと思います
あまり複雑すぎではなければいいのですが
これが TensorFlow Serving 内の
高レベルライブラリであり
バイナリ内で予めビルドされているのと
同じ風にアレンジされています
緑色の箱が API の抽象化という基準で

Portuguese: 
e as caixas amarelas são plug-ins
no interior dessas abstrações.
Então, vamos imaginar
que este é um servidor
e você está recomendando vídeos
e tem a versão um de seu modelo carregada.
E ela se chama My Model.
Então, você tem a fonte
e a fonte é responsável
por identificar novos modelos
que devem ser carregados.
Temos um plugue do sistema
de arquivo na fonte.
Ele faz mesmo o que aparenta.
Monitora o sistema de arquivo,
vê que há uma nova versão e diz:
"Ah, a versão dois chegou!"
E queremos carregar a versão dois
porque ela sobrecarrega
dados mais recentes
e dará melhores recomendações
aos seus usuários.
Então isso criará um carregador
de um TensorFlow SavedModel.
E é importante notar
que o carregador de um SavedModel
sabe como carregar o SavedModel
e sabe como estimar os recursos
tais como RAM ou armazenamento no GPU
que serão usados pelo modelo.
Na verdade, ele não o carrega ainda.
Este é o trabalho do gerente.
Então esse carregador é admitido
ao gerente como uma versão inspirada
e, na verdade, cabe ao gerente
perceber quando ele está pronto,
quando tem programação
de linhas disponível
e quando tem recursos suficientes

Indonesian: 
dan kotak kuning adalah plug-in
untuk abstraksi tersebut.
Bayangkanlah ini adalah server
dan Anda melakukan rekomendasi video
dan versi satu model Anda dimuat.
Namanya adalah My Model.
Sumbernya siap dan ia bertugas untuk
mengenali model baru yang harus dimuat.
Sistem file-nya sudah dimuat
ke dalam sumber
dan bekerja seperti seharusnya.
Ia memonitor sistem file,
melihat apakah ada versi baru
yang berkata, versi dua telah tiba, kan?
Sekarang kita ingin memuat
versi dua, karena--
ia harus dilatih pada data terbaru
dan akan memberikan rekomendasi
yang lebih baik untuk pengguna Anda.
Jadi ia akan membuat muatan
SavedModel dari TensorFlow.
Penting untuk dicatat bahwa
muatan dari SavedModel
tahu bagaimana memuat SavedModel
dan ia tahu cara memperkirakan sumber daya
seperti RAM atau penyimpanan GPU
yang akan dipakai model tersebut.
Ia sebenarnya belum memuatnya.
Itu pekerjaan manajer.
Jadi muatan ini dimasukkan ke manajer
sebagai versi yang mengikuti
dan tergantung pada manajer
untuk tahu kapan ia siap,
kapan thread scheduling tersedia

Chinese: 
是抽象数据中插入的内容
假设这是一个服务器
你想完成视频推荐的功能
并且已经上传了一个模型
叫做我的模型
现在你有了源头数据
和需要用来制作新模型的资源
这个资源需要被上传
我们的文件系统可以植入那个资源中
和名称所反映的一样
这个系统可以监测文件
发现新的版本
新版本就出现了 对吧?
现在我们想要新版本--
因为它是完善过的新数据
会给你的用户推荐更好的产品
所以现在你的系统会制作一个
TensorFlow已村模型的上传器
要明白的是
这个已存模型的上传器
知道怎么上传你的模型
也知道怎么去估计
如在RAM或者GPU存储中
会被此模型用到的资源
它并不会马上就开始上传
什么时候开始会由管理者来决定
上传器由管理者来直接操作
所以是由管理者来决定
什么时候开始上传
什么时候做好准备
和什么时候资源足够充裕

English: 
are plug-ins into
those abstractions.
So let's imagine that
this is a server,
and you're doing
video recommendations,
and you have version one
of your model loaded.
And it's called My Model.
So you have the
source, and the source
is responsible for
identifying new models
and-- that should be loaded.
So we have a file system
plug into the source.
It does exactly
what it sounds like.
It monitors the
file system, sees
that there's a new
version that say,
ah-ha, version two
arrived, right?
And now we want to load version
two because it has-- you know,
was train on fresher
data, and it's
going to provide better
recommendations to your users.
So it's going to create a loader
of a TensorFlow SavedModel.
And it's important to note
that the loader of a SavedModel
knows how to load the
SavedModel and it knows
how to estimate the resources
such as RAM or GPU storage
that will be used by that model.
It doesn't actually load it yet.
That's the job of the manager.
So this loader's admitted to the
manager as an inspired version,
and it's actually
up to the manager
to figure out when it's ready,
when it has threads scheduling
available, and when it
has enough resources

Spanish: 
y los cuadros amarillos
son plug- ins en esas abstracciones.
Imaginemos que este es un servidor
y estás haciendo recomendaciones de video
y tienes la versión uno
de tu modelo cargado.
Y se llama Mi Modelo.
Tienes el código fuente,
y este es responsable
de la identificación de nuevos modelos
y… esto debería cargarse.
Así que tenemos un plug del sistema
de archivos en el código fuente.
Hace exactamente lo que dice su nombre.
Supervisa el sistema de archivos,
ve que hay una nueva versión y dice
ajá, la versión dos llegó ¿cierto?
Y ahora queremos cargar la versión dos
porque tiene…
fue creada con los datos más frescos
y va a proporcionar
mejores recomendaciones a tus usuarios.
Así que va a crear un cargador
de un TensorFlow SavedModel.
Y es importante tener en cuenta
que el cargador de un SavedModel
sabe cómo cargar el SavedModel
y sabe cómo estimar los recursos como
el almacenamiento de memoria RAM o GPU
que serán utilizados por ese modelo.
En realidad, no carga todavía.
Ese es el trabajo del gerente.
Este cargador
es admitido al gerente
como una versión inspirada,
y realmente depende del gerente
averiguar cuándo está listo y cuando tiene
la programación de hilos disponibles,

Japanese: 
黄色い箱が
その抽象化へのプラグインとなっています
ではこれをサーバーだとして
ビデオ推薦をしているとすると
そしてモデルのバージョン１を
ロードしてあるとします
My Model という名前です
ソースがあって そのソースは
ロードされるべき
新しいモデルを判明します
ファイルシステムがソースに
プラグインされます
言葉通りの意味です
ファイルシステムを管理し
新しいバージョンを察知して
例えばバージョン２が来たとします
そこで もっと新しいデータをもとに
訓練されたバージョン２をロードし
ユーザーにもっと良い推薦を提供しようとします
なので TensorFlow SavedModel の
ローダーを作成します
そしてここで知っておくべきことは
SavedModel のローダーは
SavedModel をロードする方法を
知っていて
ついでにそのモデルが使用する RAM や
GPU ストレージなどといったリソースの
推定ができることです
まだロードするわけではありません
それはマネージャーの仕事です
このローダーがマネージャーへ
的確なバージョンとして入れられ
いつ準備が整い
いつスレッドのスケジュールが空いているのか

Korean: 
플러그인하는 겁니다
이것이 서버라고 상상해 보죠
비디오 추천을 하고 있고
여러분의 모델의
첫 번째 버전을 불러 왔죠
이를 마이 모델이라고 부르겠습니다
소스가 있고
그 소스는 새로운 모델을
식별하는 역할을 하죠
이것을 불러 와야겠죠
그럼 소스로 플러그인 된
파일 시스템이 있는 거죠
말 그대로 그렇게 하는 겁니다
파일 시스템을 모니터하고
새로운 버전이 있나 보는 거죠
두번째 버전이 도착했죠
이제 두번째 버전을 불러 와야겠죠
더 새로운 데이터에서
훈련하도록 말입니다
사용자에게 더 나은
추천을 할 테니까 말이죠
텐서플로우 저장모델을
로더를 만들 겁니다
저장모델의 로더는 저장모델을
어떻게 불러오는지 알고
이 모델이 사용할 RAM이나
GPU 저장 같은 리소스를
어떻게 추정할지 알고 있다는 점은
아주 중요합니다
아직 불러오지는 않습니다
이건 매니저가 할 일이죠
이 로더가 매니저에게
괜찮은 버전으로 소개가 되면
이제 매니저에게 달렸죠
언제 준비가 될지 언제 스레드
스케줄링이 이용될 수 있을지
새 버전의 모델을 불러올 만한
리소스가 언제 충분해질지

Spanish: 
y cuando tenga suficientes recursos
para cargar la nueva versión del modelo
lo hará.
Y aquí es donde un complemento clave
entra en juego, en la política de versión.
Y resulta que, en casi todos
los escenarios, si estás sirviendo
algo como
recomendaciones de video a los usuarios,
quieres que el sistema de servicio
siempre esté disponible, ¿cierto?
Nunca querrás tener
un tiempo de inactividad.
Por otro lado, hay casos de uso donde
digamos que tienes un gran lote
de procesos sin conexión que tal vez está
anotando estos videos en lote ¿cierto?
Y no está directamente
dirigido a los usuarios.
Digamos que tu modelo
es muy grande. Es posible que prefieras
tener un poco
de indisponibilidad en ese proceso
y guardar un montón de memoria, ¿cierto?
En lugar de cargar
ambas versiones de ese modelo a la vez
en realidad puedes eliminar el anterior
y luego cargar el nuevo
y sólo tener
un pequeño retraso en tu servidor.
Por lo tanto, las políticas de versiones
le permiten conservar la disponibilidad
o conservar los recursos.
Así que esto es algo bueno.
Vamos a las fortalezas de las bibliotecas.

English: 
to load that new model
version, it'll do so.
And this is where one
really key plug-in
comes into play, which
is the version policy.
And it turns out that in
almost all scenarios, if you're
serving something like video
recommendations to users,
you want that serving system
to always be available, right?
You never want have a downtime.
On the other hand, there
are use cases out there
where let's say you have
an offline, big batch
pipeline that's maybe annotating
these videos in batch, right?
And it's not
directly user facing.
And let's say that
your model is very big.
You might prefer to have a
little bit of unavailability
in that pipeline and save
a bunch of memory, right?
So instead of loading both
versions of that model at once,
you can actually delete the old
one and then load the new one
and just have a little
hiccup in your serving.
So the version policies lets
you preserve availability
or preserve resources.
So it's a nice thing there.
OK, so onto some strengths
of the libraries.
First and foremost
is they're optimized
for very high performance
and robustness.

Korean: 
등등을 알아내는 건 말이죠
바로 이때 주요 플러그인이
중요한 역할을 합니다
바로 버전 정책이죠
거의 모든 시나리오에서 보면
사용자에게 비디오 추천 등을
서빙하고 있다면
서빙 시스템이 항상
이용가능하길 바라겠죠?
다운되는 시간이 있으면 안 되죠
반면에 이러한 사용 경우가 있었죠
예컨대 오프라인의 큰 배치
파이프라인이 있다고 치면
배치에서 이 비디오에 주석을 달겠죠
사용자를 직접 대면하지는 않죠
여러분의 모델이 정말 크다고 가정해 보면
그 파이프라인에서
약간의 비가동성이 있길 바랄 겁니다
메모리 사용을 많이 줄일테니까 말이죠
따라서 이 모델의 두 버전을
동시에 불러오는 대신에
오래된 버전을 지우고
새로운 버전을 불러올 수 있습니다
서빙에서 약간의 문제가
생기긴 하겠지만 말이죠
따라서 버전 정책은
이용가능성과 리소스를
보존하도록 해 줍니다
좋은 점은 이겁니다
라이브러리의 강점에 대해서 알아보죠
먼저 굉장한 고성능과 강인성을
최적화해 줍니다

Portuguese: 
para carregar essa nova versão
de modelo, ele o fará.
E é aqui que entra
um plug-in realmente chave,
que é a política de versão.
E acontece que em quase todos os cenários,
ao servir algo como
recomendações de vídeos aos usuários,
você quer o sistema de serviço
sempre disponível, certo?
Você nunca o quer inativo.
Por outro lado, há casos de uso
em que digamos que você tenha
um encadeamento de grande lote e offline
que talvez esteja anotando
esses vídeos em lote, certo?
E não seja diretamente voltado ao usuário.
E digamos que seu modelo
seja muito grande.
Talvez você prefira ter
um pouco de indisponibilidade
naquele encadeamento e salvar
um monte de memória, certo?
Em vez de carregar as versões
do modelo de uma vez,
você pode deletar a antiga
e aí carregar a nova
e ter só um pequeno atraso no seu serviço.
As políticas de versão lhe permitem
preservar a acessibilidade
ou preservar os recursos.
Então, isso é algo bem legal.
Ok. Passando aos pontos fortes
das bibliotecas.
Antes de tudo, elas são otimizadas
para um desempenho super alto
e robustez.

Japanese: 
そしていつその新しいモデルのバージョンを
ロードできるリソースが揃うのか計算した上で
マネージャーがロードします
そしてここで１つ重要なプラグインの出番で
それがバージョンポリシーです
そしていかなる状況においても
ユーザーにビデオ推薦みたいなものを
提供しているとなると
その Serving システムは
いつでも利用できるべきです
ダウンタイムなどは一切
あってほしくないかといって
オフラインの
大きなバッチパイプラインが
ビデオの注釈をバッチで
行っているというケースもあり得ますね
そしてそれはユーザーに
直接見えているわけではありません
そのモデルが大きいものだとしましょう
そういう場合はメモリを節約するためにも
パイプラインにちょっとだけでも
ダウンタイムがあってもいいかもしれません
なので両方のモデルを
同時にロードするよりも
Serving にちょっとした遅延だけで
古いのを削除して新しいのをロードできます
バージョンポリシーはリソースと
アベイラビリティを保持してくれます
なので結構便利なものです
ではライブラリの長所に話を変えます
１番の点はハイパフォーマンスと
頑健性のために最適化されていることです

Indonesian: 
dan kapan tersedia cukup sumber daya
untuk memuat versi model baru,
ia akan melakukannya.
Di sinilah kunci plug-in berperan
yang merupakan kebijaksanaan versi.
Ternyata hampir di semua skenario,
jika Anda menghidangkan sesuatu
seperti rekomendasi video kepada pengguna
Anda ingin sistem layanannya
selalu tersedia bukan?
Anda tidak ingin ada masa tidak aktif.
Di sisi lain, banyak kasus di luar sana,
di mana contohnya, ada saluran
kelompok besar offline
yang mungkin menganotasi
videonya dalam kelompok
dan tidak langsung berhadapan
dengan pengguna.
Misalnya model Anda sangat besar.
Anda mungkin lebih suka ada sedikit
ketidaksediaan dari saluran tersebut
dan menghemat banyak memori, kan?
Daripada memuat
kedua versi model sekaligus,
Anda bisa menghapus yang lama
dan memuat versi baru
dan kendalanya sedikit saja
dalam layanan Anda.
Kebijaksanaan versi membuat Anda
bisa menghemat ketersediaan
atau menghemat sumber daya.
Jadi ini adalah hal yang bagus.
Mengenai beberapa kelebihan dari pustaka.
Pertama, mereka dioptimalkan untuk
kinerja dan kecanggihan tingkat tinggi.

Chinese: 
可以下载新模型了
这些都具备了它就会开始下载
这时候一个重要因素就会开始出现
就是版本政策
这时候你会发现
基本在所有情形中
如果你在为用户完善
像视频推荐之类的功能
你希望你的系统一直可用 对吧?
不希望系统崩溃
另一方面 有些用户发现
如果你的系统暂不可用
一些服务器
可能会以组别的方式记录下来
不是直接面向用户
假如说你的模型数据特别庞大
你可能希望有些功能被暂停
以此来节省记忆空间 对吧?
比起同时上传模型的两个版本
你其实可以删掉旧的
然后上传新的
只是你系统中的一点小延迟而已
版本政策允许你调节可用性
或者节省资源
是很不错的功能
好了 接下来我们来看资源库的好处
首先 资源库已经被最大化开发
到功能和表现最佳的程度

Indonesian: 
Mereka digunakan di beberapa
sistem layanan terbesar di Google
dalam skala yang cukup besar.
Dan kami melakukan hal-hal seperti
akses ref-count pada model Anda.
Dari tampilan sebelumnya, bayangkan
versi dua dari modelnya dimuat--
dan ini akan lebih banyak detail,
tapi versi dua dimuat.
Anda sebenarnya bisa langsung
mencopot versi satu
karena mungkin masih ada
permintaan yang tertunda.
Kami sebenarnya melacak
melalui ref-counting
permintaan yang muncul
dalam setiap versi model Anda.
Hanya setelah semua permintaan dipenuhi
kita bisa menghapus versi
yang tidak diperlukan lagi.
Terakhir, untuk menekankan,
ada API plug-in yang bagus,
jadi Anda bisa membuat referensi sendiri
untuk mendapat model dari basis data,
lapis RPC, subsistem pub, apa saja.
Oke, pertanyaan terakhir.
Siapa yang telah memakai
pustaka TensorFlow Serving selama ini?
Bagus. Ada beberapa.

Korean: 
따라서 이는 Google의
가장 큰 서빙 시스템의
일부에서 큰 스케일로 사용됩니다
여러분의 모델로 ref-count
접근 같은 것도
하는 거죠
그럼 이전 슬라이드에서
이 두 버전의 모델을
불러온다고 생각해 보죠
세부적으로 들어가기는 하지만
두번째 버전을 불러왔죠
그럼 사실 바로 첫번째 버전을
언로드할 수 있습니다
왜냐하면 요청이 여전히
펜딩상태일 수도 있으니 말이죠
따라서 ref-counting을 통해 모델의
각 버전에 대한 내부 요청을 추적할 수 있죠
모든 요청이 작업거부된 후에만 비로소
더이상 필요하지 않는 버전을
지울 수 있게 되는 거죠
마지막으로 다시 강조하자면
이렇게 좋은 플러그인 API가 있으니
데이터베이스, RPC 레이어
펍 서브시스템 등에서
모델을 만들기 위한
여러분 각자의 소스를
만들 수 있는 거죠
마지막으로 손을 들어 보죠
지금까지 텐서플로우 서빙을 사용하신 분 있나요?
좋습니다
몇 분 계시죠
이를 사용할 생각이 있으신 분이면 누구나

Portuguese: 
Elas são usadas em uns dos maiores
sistemas de serviço no Google,
em uma escala bem ampla.
E fazemos coisas como acessos ref-count
aos seus modelos.
Do slide anterior,
imaginemos que a versão dois
do modelo carrega
e é meio que detalhar,
mas a versão dois está carregada.
Você não pode descarregar
a versão um, imediatamente,
porque pode haver
uma solicitação pendente.
Então, rastreamos
por meio de ref-counting,
as solicitações em voo,
em cada versão de seus modelos,
e só após todos os pedidos
ficarem inativos,
podemos apagar uma versão
que não é mais necessária.
E por último mas muito importante,
só para ressaltar,
temos APIs de plug-in bem legais
para construir suas próprias fontes
para obter modelos de uma base de dados,
uma camada RPC,
um subsistema de publicações,
ou o que você desejar.
Ok. Vamos levantar as mãos.
Quem já usou as bibliotecas
do TensorFlow Serving até agora?
Ótimo. Alguns de vocês.

English: 
So these are used in some
of the largest serving
systems at Google at, you
know, pretty large scale.
And we do things like, you
know, ref-count accesses
to your models.
So from the previous
slide, let's imagine
that version two of the
models load-- and this
is kind of getting
into the details,
but version two is loaded.
You can, actually,
immediately unload version one
because there might still
be a request pending to it.
So we actually keep
track, via ref-counting,
of the requests in-flight on
each version of your models,
and only after all the
requests have quiesced can
we delete a version
that's no longer needed.
And last but not least,
just kind of reemphasizing,
we have these nice
plug-in APIs, so you
can build your own
sources to get models
from a database, an RPC
layer, a pub subsystem, kind
of whatever you like.
OK, so last show of hands.
Who's used TensorFlow
Serving libraries so far?
Great.
A few of you.
So for anyone who's
thinking of using this,

Japanese: 
これらは Google で最も大きい
Serving システムの幾つかに使われており
平たく言えばスケールが大きいです
そしてあなたのモデルへの
参照カウントなどという事をしたりします
では前のスライドで話した
バージョン２のモデルが
ロードされたとしましょう
ちょっと詳しい話ですが
バージョン２がロードされたとします
しかし バージョン１に対する
リクエストが保留中であったりして
直ちにアンロードすることが
できないかもしれません
なので参照カウントを使って
モデルのバージョンそれぞれに対する
リクエストを
保留中でありながらでも管理し
リクエストのすべてが処理済みになってから
必要のないバージョンを
削除するようになっています
そして最後に
こういった API プラグインは
データベースからモデルを作るために
皆さんが自分のソースをビルドしたり
RPC レイヤー
パブサブシステム
とにかく好きなものを
何でもできるように用意しました
では最後の質問です
TensorFlow Serving ライブラリを
使った人はいますか
素晴らしい
数人いますね

Spanish: 
Primero, están optimizadas para obtener
un rendimiento y robustez muy altos.
Éstos se utilizan
en algunos de los servidores
más grandes en Google,
a una escala bastante grande.
Y hacemos cosas como
accesos ref-count a tus modelos.
De la diapositiva anterior
imaginemos que la versión dos
de los modelos de carga--
y estamos entrando en detalle,
pero la versión dos se carga.
De hecho, puedes descargar
la versión 1 inmediatamente porque todavía
podría haber una solicitud pendiente.
Por lo tanto, en realidad mantenemos
un seguimiento, a través de ref-counting
de las solicitudes en vuelo
en cada versión de tus modelos
y sólo después de que
todas las solicitudes se hayan detenido
podemos eliminar
una versión que ya no sea necesaria.
Por último
tenemos estas bonitas APIs de complemento
por lo que puedes crear
tus propios códigos fuente
para obtener modelos
de una base de datos, una capa de RPC,
un subsistema de pub, lo que quieras.
Entonces, una última pregunta.
¿Quién ha utilizado las bibliotecas
de TensorFlow Serving hasta ahora?
Estupendo. Algunos de ustedes.
Así que para cualquiera
que esté pensando en usar esto,

Chinese: 
这些资源被用在一些大型的服务器中
比如谷歌这种大规模的系统
我们会使用这个做一些比如
你的模型ref-count之类的事
回想刚才的幻灯片上
模型的第二的版本上传--
现在就要讲到细节的地方了
但是第二版本已经传好了
你其实可以马上开始删除
第一个版本
因为有可能还有未完成的任务
所以我们通过ref-count来追踪
你每个版本模型的任务
只有在所有任务都完成后
我们才可以删除不需要的版本
最后一点 要再重复一下的是
我们有一些很好的自带的
应用程序编程接口
这样你就可以自己找资源来做模型
资源可以来自数据库 RPC层 下层系统
按你自己的喜好来
好了 再举手回应一个问题
谁用过TensorFlow服务器的资源库?
很好
几个人
如果你想开始使用的话

Japanese: 
これを使おうと思う人には
これがデフォルトとして見えます
これはチュートリアルにもありますが
我々が気がついたことは
現在のライブラリを使用した人たちは
内部的にも外部的にも
それらのライブラリを
ベストプラクティスで組み立てるのに
ちょっとした定型コード
共通コードが必要でした
なので我々は新しい
ServerCore というクラスを作って
これはロードしたいモデルを
宣言することができるようになり
それを ServerCore に通して
これらのモデルのマネージャーを下さいと
詳細にかかわらずに
ベストプラクティスをすぐにくれるという
ように機能します
これで200や300行くらいのコードを
削除することができます
なので試してみてください
コメントや機能リクエストなどを
送ってください
このスライドはわざと短いです
これらのバイナリはとてもシンプルです
TensorFlow Serving のライブラリの
すべてのベストプラクティスを取り組み
それをフラグとともに
GRPC レイヤーで包んで
他に設定や管理などの必要なものも含みます
我々のバイナリは
Google の
高性能ユニバーサルオープンソース RPC
GRPC に基づいていています

Indonesian: 
Bagi yang berpikir untuk memakainya
Anda bisa lihat secara bawaan.
Ini ada dalam tutorial kami.
Tapi bagi yang memakai pustaka yang ada,
yang kami temukan, baik secara
internal maupun eksternal,
adalah ada-- aturan semua pustaka
dengan praktik terbaik
memerlukan banyak teks standar
dan kode umum.
Jadi kami membuat kelas baru bernama
ServerCode dan yang dilakukan adalah
membolehkan Anda memberitahu
serangkaian model yang ingin dimuat,
memberikannya ke ServerCore,
dan berkata, berikan saja
manajer model ini.
Saya tak begitu peduli detailnya,
berikan semua praktik terbaik yang ada.
Jadi, Anda bisa menghapus
sekitar 200 - 300 baris kode.
Silakan dicoba,
kirimkan komentar dan permintaan fitur.
Tampilan ini sangat singkat.
Binernya sangat sederhana,
menggunakan semua praktik terbaik
dari pustaka TensorFlow Serving
dan mengemasnya dengan
lapis GRPC dengan beberapa tanda,
konfigurasi, pemantauan,
dan hal lain yang mungkin diperlukan.
Biner kami berbasis GRPC,
yaitu kerangka RPC universal
kinerja tinggi sumber terbuka dari Google.

Chinese: 
系统里面已经带有这个
这个也会在我们的教学视频里
用过当前资源库的人 我们从内部
和外部系统里发现--
你们在设置资源的时候
用了很多样板文件
还有常见代码什么的
所以我们做了一个
叫做ServerCore的新级别
这样你就可以找到你想上传的模型
发给ServerCore 然后说
请把我列为这些模型的管理者
我一般都不计较细节
把最好的编辑方法都给我
然后 这个系统会允许你删除
大概200到300行代码
值得一试
发送评论 索要功能
这张幻灯片特意做得很简短
其中的二级代码特别特别简单
都是用最好的方式完成
这些是取自TensorFlow服务器的资源库
然后放在GRPC层面中
加入了一些标示和配置等等
都是你需要的
我们的二级代码是以GRPC为基础的
是以谷歌的高级开放资源通用RPC
为模型
你也可以对这个进行延展

Portuguese: 
Para os que pensam em usá-las,
vocês as veriam por padrão.
Estão em nossos tutoriais.
Mas para os que usaram
as bibliotecas atuais,
o que vimos, internamente e externamente,
é que configurar todas aquelas bibliotecas
com as melhores práticas
exigiu muito padrão
e algo como código comum.
Então, fizemos uma nova classe
chamada de ServerCore.
E ela permite que declare
o conjunto de modelos que quer carregar
e passá-los para o ServerCore e dizer:
"Dê-me um gerente desses modelos.
Não me importa os detalhes.
Dê-me as melhores práticas de instalação."
E isso deve deixar você apagar
umas 200 a 300 linhas de código.
Então, faça um teste.
Envie comentários e pedidos de recursos.
Ok, este slide é deliberadamente curto.
Os binários são muito, muito simples.
Eles tiram todas as melhores práticas
das bibliotecas do TensorFlow Serving
e as envolve na camada GRPC
junto com alguns marcadores,
configuração, monitoração
e outras coisas que precise.
Nossos binários são baseados em GRPC,
que é a estrutura RPC universal,
de alto desempenho
e código aberto do Google.

English: 
you would just see
this by default.
This is in our tutorials,
but for those of you who've
used the current
libraries, what we found,
internally and externally,
is that you had this--
setting up all of those
libraries with the best
practices took a bunch of
boilerplate and, kind of,
common code.
So we made a new class called
ServerCore, and what this does
is it lets you declare the
set of models you want loaded
and pass them to
ServerCore and say, just
give me a manager of
these models, please.
I don't really care
about the details.
Give me all the best
practices out of the box.
And so, this should
let you delete
about 200 to 300 lines of code.
So give that a try.
Send comments and
feature requests.
OK, so this slide is
intentionally short.
The binaries are
very, very simple.
They take all of
the best practices
from the libraries
of TensorFlow Serving
and just wrap them GRPC
layer along with some flags,
and configuration, and
monitoring, and other things
you would need.
Our binaries are
based on GRPC, which
is Google's high performance,
open-source universal RPC
framework.
And you can extend this
as well, but this is

Spanish: 
simplemente lo vería por defecto.
Esto está en nuestros tutoriales,
pero para aquellos de ustedes
que han usado las bibliotecas actuales,
lo que encontramos, interna y externamente
es que ustedes tenían--
la configuración de todas esas bibliotecas
con las mejores prácticas tomó un montón
de código repetitivo y de código común.
Así que hicimos una nueva clase llamada
ServerCore, y lo que hace es que te permite
declarar el conjunto de modelos
que deseas cargar y pasar a ServerCore
y decir, sólo denme un administrador
de estos modelos, por favor.
No me importan los detalles.
Dame las mejores
prácticas fuera de lo común.
Y, por lo tanto,
esto debería permitirte eliminar
alrededor de 200 a 300 líneas de código.
Así que dale una oportunidad.
Envía tus comentarios
y solicitudes de funciones.
Entonces, esta diapositiva
es intencionalmente corta.
Los binarios son muy, muy simples.
Toman todas las mejores prácticas
de las bibliotecas de TensorFlow Serving
y simplemente envuelven la capa GRPC
junto con algunos marcadores
y configuración y supervisión
y otras cosas que necesitarías.
Nuestros binarios están basados en GRPC,
que es el marco RPC universal
de alto rendimiento
y de código abierto de Google.

Korean: 
이것을 자동으로 보게 되실 겁니다
저희 사용 설명서이지만
현재 라이브러리를
사용하신 분들의 경우
저희가 외부적 또 내부적으로
발견한 것은 이렇게
이 모든 라이브러리를
최고의 실례로 준비할 때
표준 문안과 일종의 공통 코드를
사용했다는 점이죠
따라서 저희는 서버코어라고 부르는
새로운 클래스를 만들었습니다
이는 여러분이 불러오고 싶은
모델 세트를 알려 주도록 만들고
이를 서버코어로 전해주면서
이 모델의 메니저를
주세요, 라고 하는 거죠
세부 사항은 상관없으니
이미 사용 가능한 최고의
사례를 모두 주세요, 라고 말이죠
이렇게 하시면 200에서 300개의
코드 라인을 지울 수 있을 겁니다
시도해 보십시오
코멘트와 피쳐 요청을 보내 주십시오
이 슬라이드는 일부러 짧게 만들었습니다
바이너리는 아주 간단하죠
텐서플로우의 라이브러리에서
모든 최고 사례를 가지고
플래그 몇 개와 함께
GRPC 레이어로 싸서
여러분이 필요한 컨피겨레이션
모니터링 등을
하는 겁니다
저희 바이너리는 GRPC에 기초합니다
Google의 고성능
오픈 소스 유니버설 RPC
프레임워크이죠
이것 또한 확장 가능 하지만

English: 
what we provide out of the box.
In terms of specific APIs--
currently, open source complete
with the API implementation.
We have a low-level,
Tensor-oriented predict API,
so this should be usable for
any kind of modeling inference
that you would need to do.
Coming soon we have regression
and classification interfaces.
The APIs are already on
GitHub, and the implementation
is out for review.
So it should land very soon.
All right, now I'm to
move on to some challenges
that we've seen along with
the best practices for how
to solve them.
So the first one,
this was a great story
around isolation and latency.
So this is a graph
of latency with--
each of those spikes
is approximately daily,
Mountain View time at noon.
So this is for a
large Google customer
serving several thousand
queries per second.
And right around,
give or take, noon,
there was this latency spike
at the 99.9th percentile.
That put that serving
customer outside of their SLA.
So we looked into
this and it turned out
that there was a
fantastic engineer we'd
been working
closely with, really

Indonesian: 
Ini juga bisa diperluas, tapi
ini kami sediakan secara istimewa.
Dalam hal API tertentu--
saat ini, sumber terbuka lengkap
dengan implementasi API.
Ada API ramalan berorientasi Tensor
tingkat rendah, jadi seharusnya
bisa dipakai untuk model akhir apapun
yang perlu Anda lakukan.
Segera, akan ada antarmuka
regresi dan klasifikasi.
API telah ada dalam GitHub,
dan implementasi sedang diulas.
Jadi akan segera dikeluarkan.
Baik, sekarang kita lanjut ke beberapa
tantangan yang telah kita lihat
bersama dengan praktik terbaik
cara pemecahannya.
Yang pertama, ada cerita bagus
tentang isolasi dan latensi.
Ini grafik latensi dengan--
setiap lonjakan
kira-kira terjadi setiap hari,
waktu Mountain View di tengah hari.
Ini untuk klien besar Google
melayani beberapa ribu
permintaan setiap detik.
Dan sekitar tengah hari, ada
lonjakan latensi di persentil ke-99.9.
Yang menempatkan pelayanan klien
di luar SLA mereka.
Jadi, kami memeriksanya dan
ternyata ada insinyur hebat

Chinese: 
我们可以为你提供更多的服务
要说到特别的应用程序编程接口呢--
当前开放资源有了API的安装才算完成
我们有一个低级的
以Tensor为导向的API
应该是那种模型方式都能用
可以满足你的需要
然后我们来说说回归和分类界面
AIP已经在GitHub上了
你可以安装并发表评论
应该马上开始面向大众
好了 现在我想讲讲我们面临的挑战
目前来讲 我们在尝试以最好的方式
解决问题
第一个 是一个特别棒的故事
和数据孤立性和潜伏性有关
这个图是有关潜伏性的--
每个竖线大概都代表每天
中午时候Mountain View的时间
这是一个很大的谷歌用户服务系统
每秒都有上千的任务
大概在中午的时候呢
潜伏性到达峰值 大概是99.9百分点
正因如此 服务中的用户被放到SLA之外
我们看了一下 发现
有一个一直和我们一起工作的
超赞的工程师

Korean: 
이것이 바로 사용 가능한 버전입니다
자세한 API의 경우
현재 오픈 소스는
API 실행으로 완성됩니다
저수준 텐서-방향 예측 API가 있고
이는 여러분이 필요한
어떠한 모델 인터페이스에서도
사용가능할 겁니다
조만간 회귀와 분류
인터페이스가 나올 겁니다
API는 이미 깃허브에 있고 실행은
검토 중입니다
조만간 사용가능할 겁니다
그러면 이제 저희가 본 문제들과 함께
이를 해결하기 위한 최고의 시례로
넘어가죠
먼저 이것은 아이솔레이션과
지연속도에 대한
좋은 이야기였습니다
이건 지연 속도 그래프입니다
각각의 이 뾰족한 부분은
대략 캘리포니아 시간으로
매일 정오입니다
이는 큰 Google
고객을 위한 것으로
초당 수천개의 질문을 받고 있죠
대략 정오쯤에
99.9프로의 백분위에서
지연속도의 급격한 상승이 있죠
SLA 외부에 서빙 고객을 둔 거죠
저희가 이를 조사해 봤더니
저희와 함께 가깝게 일하던
엔지니어가 있었던 거죠

Portuguese: 
E você pode expandi-la também,
mas é o que oferecemos na instalação.
Em termos de APIs específicas,
atualmente de código aberto,
completa com a implementação da API.
Temos uma API de previsão
voltada ao Tensor e de baixo nível,
então poderia ser usada em qualquer tipo
de inferência de modelagem
que você precise fazer.
Em breve, teremos interfaces
de regressão e classificação.
As APIs já estão no GitHub
e a implementação já está em revisão.
Então deve chegar em breve.
Agora vou passar a alguns desafios
que temos visto,
junto às melhores práticas,
e como resolvê-los.
O primeiro deles...
esta é uma ótima história
sobre isolamento e latência.
Então, este é
um gráfico de latência com...
cada um destes picos é,
em média, a hora diária,
em Mountain View, ao meio-dia.
É para um grande cliente da Google
servindo milhares de buscas por segundo.
E por volta mais ou menos do meio-dia,
havia um pico de latência
no 99.9º percentil.
Isso tirou esse cliente de serviço
de seu SLA.
Então, observamos isso
e acabou que um fantástico engenheiro,
com quem vínhamos trabalhando,

Spanish: 
Y puedes extender esto también, pero
es lo que ofrecemos listo para usarse.
En términos de API específicas…
es actualmente de código abierto completo
con la implementación de la API.
Tenemos un API de predicción
de bajo nivel orientado a Tensor
por lo que esto debería ser utilizable
para cualquier tipo de inferencia
de modelado que necesites hacer.
Pronto tendremos interfaces
de regresión y clasificación.
Las APIs ya están en GitHub
y la implementación está lista
para su revisión.
Así que debería llegar muy pronto.
Ahora voy a pasar a algunos desafíos
que hemos visto junto a las mejores
prácticas para resolverlos.
La primera,
esta fue una gran historia
acerca del aislamiento y la latencia.
Este es
un gráfico de latencia con
cada uno de esos picos
es aproximadamente
hora diaria de Mountain View al mediodía.
Esto es para
un gran cliente de Google que sirve
varias miles de consultas por segundo. 
Y cerca, más o menos, del mediodía
hubo un pico de latencia
en el percentil 99.9
que puso el servidor
de ese cliente fuera de su SLA.
Nos fijamos en esto y resultó
que había un ingeniero fantástico
que había estado trabajando
estrechamente con nosotros,

Japanese: 
そしてこれを拡張することもできますが
これが導入時に提供されるものです
具体的な API というと
現在オープンソースで
API 実装されているものがあります
低レベルの Tensor 用予測 API
これはどのようなモデリング推論にでも
使えるものです
そして近日
回帰と分類インターフェイスも出る予定です
API はすでに GitHub に載っていて
実装版は今レビューされていますので
なので もうすぐ正式に出るでしょう
では次に幾つかの問題と解決するための
ベストプラクティスを見ていこうと思います
１番最初のは分離とレイテンシーに関する
興味深いお話です
これはレイテンシーのグラフで
この急上昇は
毎日午後１２時ごろに起きるものです
これは Google の大規模な顧客が
毎秒数千というクエリを
処理しているものです
そしてちょうど午後１２時あたりに
99.9番目の百分位数にて
レイテンシーにスパイクが生じます
その顧客は彼らの SLA 外に
置かれてしまうわけです
なので我々が調べたところ

Spanish: 
y le gustaba crear
nuevos modelos experimentales
justo antes o después
de irse a almorzar.
Y en realidad,
nos lanzó hacia un bucle porque se movió
hacia delante y hacia atrás
una o dos horas todos los días.
Y así que no encontramos
ningún trabajo automatizado haciendo esto
pero sí encontramos el problema.
Se estaba cargando un nuevo modelo--
podría tener un impacto de latencia
bastante grande en tus modelos
existentes que ejecuten inferencia.
Así que, si nos adentramos
un poco más, resulta que el estándar--
y creo que es un muy buen
estándar para un TensorFlow--
es optimizar el rendimiento.
Eso es lo que la mayoría de nosotros
queremos en la mayoría de las situaciones.
Así que no tienes que colocar
un marcador que diga
¿me dan el rendimiento por favor?
Pero un efecto secundario
de eso es, por defecto,
la optimización de rendimiento para
prácticamente todos los modelos
y todas las sesiones de su tarea
tendrían acceso a todos los hilos.
Por lo tanto, de nuevo, muy buen estándar,
pero para el caso específico
de que tengas muchos modelos
y muchas versiones flotando en el tiempo
lo que realmente quieres hacer
es aislar los hilos de carga
lejos de sus hilos de inferencia.
Así que añadimos…
es una diapositiva bastante elegante,
pero añadimos sólo un marcador.
Puedes establecer el número de subprocesos
de carga, y normalmente lo configuramos
en algún lugar alrededor de uno o dos.

English: 
liked to push new experimental
models right before
or after he went to lunch.
Who knew?
And it-- actually, it
threw us for a loop
because it did move forward
and backward by an hour or two
every day.
And so we didn't find any
automated jobs doing this,
but we did find the problem.
It was loading a new model--
could have a pretty big latency
impact on your existing
models running inference.
So if you dive in a
little bit deeper,
it turns out that
the default-- and I
think it's a very good
default for a TensorFlow-- is
to optimize for throughput.
That's what most of us
want in most situations.
So you don't have to go set a
flag that says, please give me
throughput.
But a side effect of that
is, by default, optimizing
for throughput pretty much
all the models and all
the sessions on your
task will get access
to all of the threads.
So again, very good default,
but for the specific case of you
have many models
and many versions
floating over time, what
you really want to do
is isolate the
loading threads away
from your inference threads.
So we added-- you know,
it's pretty fancy slide,
but we added just one flag.
You can set the number
of loading threads,
and we typically set it to
somewhere around one or two.

Indonesian: 
yang bekerja sama dengan kami,
suka mengeluarkan model eksperimental baru
tepat sebelum atau setelah
ia pergi makan siang.
Siapa yang tahu? Sebenarnya,
ini membingungkan kami
karena ia bergerak maju dan mundur
dalam sejam atau dua jam setiap hari.
Kami tidak menemukan
pekerjaan otomatis untuk ini.
Tapi kami menemukan masalahnya.
Ia memuat model baru--
bisa berdampak latensi besar
pada model yang ada
untuk menjalankan inferensi.
Jika Anda mencari tahu lebih dalam,
ternyata secara bawaan--
dan saya pikir bawaan baik
untuk TensorFlow--
adalah mengoptimalkan throughput.
Itu yang seringnya kita inginkan.
Anda tak harus mengatur tanda
yang berkata, berikan throughput.
Tapi efek sampingnya, secara bawaan
mengoptimalkan throughput,
semua model dan sesi dalam tugas Anda
akan mendapat akses ke semua thread.
Bawaan yang sangat bagus,
tapi untuk kasus tertentu
di mana ada banyak model dan versi
yang menggantung,
Anda harus mengisolasi
thread menggantung ini
dari thread akhir.
Kami menambah--
ini tampilan yang cukup indah,
tapi kami hanya menambah satu tanda.
Anda bisa atur jumlah thread menggantung,
dan kami biasanya mengaturnya
sekitar satu atau dua.

Chinese: 
喜欢在他吃午饭前后
推出新的模型试验
谁能想到呢?
这件事真的把我们搞晕了
因为数据是每天中午前后
发生变化
我们没有找到任何
系统在自动工作的证据
不过最后还是找到原因了
系统在上传新的模型--
产生较大的潜伏性
影响了现有模型的表现
如果你再好好研究一下
发现系统的默认--
我觉得TensorFlow的默认设置很好--
都是为达到最好的表现而制
我们中的大多数应该总希望是这样
所以你其实不用进行特殊标示
来给你完成任务
但是有一个副作用 就是系统默认
几乎所有模型的运作
你的任务中的所有项目
都能联系到各类话题上
这是很好的默认功能
但是对于你的特殊项目来讲
我们有很多种模型
也会在一段时间内
积累很多不同版本
如果你真的想
把一个任务
从其他话题任务中分出来
我们也加入了--这是挺高级的一个功能
我们加入了标签
你可以设置话题的数量
一般设置为一个或者两个

Japanese: 
長い間勤務している優秀なエンジニアが
ランチの前か後に新しい実験モデルを
プッシュする癖があることが分かりました
誰が予想しただろう
そして分かる前までは毎日１時間前後と
時間帯が変わったりしたので
結構困惑しました
こんな感じで自動ジョブは
見つかりませんでしたが
問題は見つかりました
新しいモデルをロードしていたので
推論を実行中の既存モデルに
レイテンシーへの影響を与えていました
そしてもう少し深く見てみると
TensorFlow のデフォルトは
情報量に対して最適化することが
適しているだと思います
それが殆どの状況で求められるものです
わざわざ情報を下さいというフラグを
設定しなくてもいいわけです
しかしその副作用として
情報量に対して最適化するということは
すべてのモデルと
すべてのタスクのセッションが
すべてのスレッドに
アクセスできるようになります
なので いいデフォルト設定ですが
幾つものモデルとバージョンが
長時間存在するといった具体例だと
推論スレッドからローディングスレッドを
分離したいわけです
結構凝ったスライドですが
フラグを１つだけ加えることにより
ローディングスレッドの数を
設定することができ
普段は１つか２つにセットされています

Korean: 
새로운 실험을 점심 먹으러 가기 전후에
넣어두는 걸 좋아했던 겁니다
뜻밖이었죠
사실 이건 저희를 루프로 돌게 했죠
매일 한 두시간 앞뒤로
가도록 만들었으니
말이죠
따라서 이런 일을 자동으로
하는 경우는 찾지 못했지만
문제를 찾긴 했죠
새로운 모델을 불러오고 있었고
현존하는 모델 실행 인터페이스에
꽤 큰 지연속도를 일으킬 수 있었죠
조금 더 자세히 보시면
디포트가 이런 거죠
텐서플로우의 디폴트가
아주 훌륭하다고 생각합니다만
처리율을 위해 최적화된 거죠
대부분의 상황에서 대부분의
사람들이 원하는 것이겠죠
따라서 플래그를 달아서
처리율을 달라고 할 필요가
없는거죠
하지만 이것의 부작용은 자동으로
대부분의 모델의 처리율을
최적화하고 업무의 모든 세션이
모든 스레드에 접근할 수 있도록
한다는 점이죠
다시 한번 훌륭한 디폴트이지만
아주 특별한 경우에
시간이 지나면서 생긴 많은 모델과
버전이 있다면 여러분이 해야 할 일은
인터페이스 스레드에서
불러오는 스레드를
아이솔레이트 시키는 것이죠
멋진 슬라이드이지만
단지 플래그 하나를 추가했을 뿐이죠
불러오는 스레드의 수를 정할 수 있고
보통 하나에서 둘 정도로 정하죠

Portuguese: 
gostava muito de testar
novos modelos de experimentos
antes ou depois de ir almoçar.
Nunca se sabe...
e isso nos surpreendeu porque se moveu
para frente e para trás
por uma hora ou duas, todo dia.
Não achamos nenhum trabalho
automatizado fazendo isso,
mas achamos o problema.
Ele carregava um novo modelo.
Poderia ter grande impacto de latência
em modelos atuais executando inferência.
Se nos aprofundarmos um pouco mais,
ocorre que o padrão,
e acho que é um ótimo padrão
para o TensorFlow,
é otimizar o rendimento.
É o que muitos querem em muitos casos.
Não tem de pôr um marcador que diz:
"Dê-me rendimento."
Mas um efeito colateral disso, por padrão,
ao otimizar para rendimento,
praticamente todos os modelos
e todas as sessões em suas tarefas
terão acesso a todas as linhas.
Então, é um ótimo padrão,
mas no caso de você ter
muitos modelos e muitas versões
flutuando no tempo,
o que quer fazer é isolar
as linhas em carregamento
das linhas de inferência.
Então adicionamos
um slide bem extravagante,
mas só adicionamos um marcador.
Dá para pôr o número de linha em carga,
e, geralmente, definimos
como algo em torno de um ou dois.

Spanish: 
Y te mostraré en la siguiente diapositiva.
Así que puedes ver mucho más detalle,
pero el punto principal de aquí
es que el eje Y cayó por 10x.
Así que los picos de latencia ahora
son aproximadamente cien milisegundos.
Esto está completamente
dentro del SLA del cliente.
El cliente está feliz.
Tenemos una mejor práctica ahora
que todos ustedes pueden usar.
El próximo desafío… y lo insinué antes
es acerca del procesamiento por lotes
el manejo de solicitudes asíncronas
y la obtención de la eficiencia
del procesamiento de lotes
en el momento de servir. Entonces,
si miras al poco tráfico en la derecha
tienes las cajas verdes,
azules, y anaranjadas.
Y éstos representan
las solicitudes de los usuarios
que llegan a diversas horas,
cayendo hacia su servidor.
Y lo que debes hacer, idealmente,
para obtener ese mini-batching
como rendimiento
es esperar durante un período de tiempo.
Tome algunas peticiones, júntelas
y ejecute un cálculo gráfico.
Al mismo tiempo, debes mantener
un límite superior estricto en la latencia
que estás dispuesto a esperar.
Así que hemos hecho
un poco de inversión aquí.

Chinese: 
来看看下一张幻灯片
你可以看到更多细节
但是主要的一点是
可以看到y轴上降了10倍
潜伏性数据现在大概是一百毫秒
绝对处在用户SLA中
用户很开心
现在就有了你们都能采用的最好方案
下一个挑战是--我在之前已经给了提示
就是关于batching和
处理异步任务
确保mini-batching
的服务过程有效率
如果你看一下右边的这个图
有绿色 蓝色和橙色的方块
这些代表你的用户问题
它们出现在不同时间
出现在你的服务器中
这时候你需要做的呢
就是开始类似mini-batching的程序
需要等一段时间
你需要找几个问题
把它们组在一起
然后用一个图表来进行计算
同时你要做的是
确保对你想等待的潜伏性
实行严格的监控
现在来看我们已经花了一定的心思

Korean: 
차후 슬라이드를 보여 드리겠습니다
훨씬 더 상세하게
보실 수 있지만 요점은
Y축이 10배로 줄었다는 점이죠
이제 지연속도 최고점은
대략 100ms이죠
이건 완전히 고객 SLA의 내부입니다
고객이 행복하겠죠
최고의 실례가 있고
모두가 사용할 수 있습니다
다음 문제는 제가 좀전에
이 발표에서 힌트를 드렸는데
배치 문제, 동시다발적이지 않은
요청을 해결하는 법
그리고 서빙할 때 미니 배치의 효율성을
얻는 법이죠
오른쪽에 작은 신호등을 보시면
녹색, 파란색, 주황색의 상자가 있죠
이건 각기 다른 시간에 도착하는
사용자 문의를 나타내고
서버 쪽으로 내려가고 있죠
이상적으로 여러분이 하실 일은
이 미니 배치와 같은 성능을
조금 기다리게 만드는 겁니다
요청 몇 개를 가지고 함께 묶어서
그래프 계산 하나를 운영하는 거죠
동시에 기다릴 수 있는
지연속도의 상한을
정해야겠죠
저희는 여기 투자를 많이 했습니다

Indonesian: 
Saya akan tunjukkan tampilan berikutnya.
Anda bisa melihat lebih detail,
tapi yang utama di sini
adalah sumbu-y turun sampai 10x.
Lonjakan latensi sekarang
sekitar seratus milidetik.
Ini masuk masuk SLA klien.
Klien senang.
Sekarang kami punya praktik terbaik
yang digunakan oleh semua orang.
Tantangan selanjutnya-- saya
memberi petunjuk di awal ceramah--
tentang batching,
menangani permintaan asinkron,
dan mendapat efisiensi dari
mini-batching pada waktu layanan.
Jika Anda lihat lalu lintas
di sebelah kanan
ada kotak hijau, biru, dan jingga.
Ini mewakili permintaan pengguna
yang tiba pada saat yang berbeda,
seperti berjatuhan ke dalam server Anda.
Dan yang ingin Anda lakukan, idealnya
untuk mendapat kinerja
seperti mini-batching
adalah menunggu selama waktu tertentu,
menerima beberapa permintaan,
mengumpulkannya,
dan menjalankan sebuah komputasi grafik.
Pada saat yang sama, Anda ingin menjaga
batas atas yang ketat
pada latensi yang Anda tunggu.
Kami telah melakukan
beberapa investasi di sini.

Japanese: 
設定後のスライドをお見せします
これだともっと詳しいものまで見えますが
注目すべき点は
Y 軸が１０倍ほど縮んだという事です
レイテンシーのスパイクが
今は数百ミリ秒ぐらいになりました
これはすべて顧客の SLA 以内です
顧客も嬉しいでしょう
皆さんにも使える
ベストプラクティスとなるわけです
次の問題は
ちょっと前にも話しましたが
バッチ処理、非同期リクエストの取り扱い
そして Serve 時の
ミニバッチ処理の効率化です
右側の小さい図を見てみると
緑、青、そしてオレンジの箱のがあります
そしてこれらはユーザークエリが
別々の時間に
サーバーへやってくるのを表しています
そして理想的に
ミニバッチ処理的なパフォーマンスを得るには
ちょっとした間待つことです
リクエストを幾つか受け取り まとめて
１つのグラフ計算を実行します
それと同時に待っておけるレイテンシーの
上限を設定しておくべきです
そのためにかなり苦労しました

Portuguese: 
E vou mostrar o slide posterior.
Você pode ver bem mais detalhes,
mas o ponto principal aqui
é que o eixo y caiu em dez vezes.
Os picos de latência, agora,
são mais ou menos cem milissegundos.
Isso está totalmente
dentro do SLA do cliente.
O cliente está feliz.
Temos, agora, uma melhor prática
que todos podem usar.
O próximo desafio,
e insinuei antes na palestra,
é sobre batching e o manuseio
de solicitações assíncronas
e obtendo eficiência de um mini-batching
no tempo de serviço.
Se você olhar o pequeno gráfico à direita,
temos as caixas verdes, azuis e laranjas.
E representam as consultas do usuário
chegando em tempos diferentes,
meio que caindo em direção a seu servidor.
E o que você deseja fazer, de preferência,
para ter aquele desempenho
tipo mini-batching,
é esperar por um certo tempo.
Pegar algumas solicitações, juntá-las
e executar um cálculo gráfico.
Ao mesmo tempo, você deseja muito
manter um limite superior rígido
na latência que você está esperando.
Então fizemos bastante investimento aqui.

English: 
And I'll show you
the after slide.
So you can see much more detail,
but the main point from here
is that the y-axis
dropped by 10x.
So the latency spikes now are
roughly a hundred milliseconds.
This is completely inside
the customer's SLA.
Customer's happy.
We have a best practice now
that all of you can use.
The next challenge-- and
I hinted at this earlier
in the talk-- is about
batching, and handling
asynchronous requests,
and getting the efficiency
of mini-batching at serve time.
So if you look at the
little traffic on the right,
you have the green,
blue, and orange boxes.
And these represent
your user queries
arriving at different
times, kind of falling down
towards your server.
And what you want
to do, ideally,
to get that
mini-batching-like performance
is kind of wait for
some period of time.
Take a few requests,
put them together,
and run one graph computation.
At the same time,
you really want
to keep a strict upper
bound on the latency you're
willing to wait.
So we've done quite a
bit of investment here.

Korean: 
저희의 배치는 라이브러리로써 뿐 아니라
서버를 위한 플래그를
통해서도 이용가능합니다
그리고 재미있는 뉘앙스가 많습니다
저희가 처음 이 일을 시작했을 땐
무슨 의미인지
알지도 못했던 것들이죠
하나의 예로
같은 머신에 모델이
두 개가 있다고 칩시다
실제로 해야 할 일은
이 배치의 스케줄을 교대로 짜는 겁니다
서로 겹치게 해서 스레드를 위해
싸우게 하는 게 아니라 말이죠
따라서 공유된 배치 숄더의
개념이 있는 거죠
각 모델이 각자를 가지고 있고
공유된 숄더를 통해 협력하는 거죠
예고해 드리자면 시퀀스 모델이
이를 재미있게 만들었죠
보통은 댓가성 네트워크가
아니라는 점에서 말이죠
시퀀스의 길이는 다양할 수 있으니
이들을 함께 배치하는 법은 까다롭고
힘들어집니다
유진이 발표 몇 가지를 할 텐데
배치와 시퀀스에 대해 상세하게
설명해 줄 겁니다
새로 나오는 기술 분야이죠
조나단이 저장모델에 대해 언급했죠
이 발표를 하게 되서 너무 기쁘고 모두가 사용해 보시길
권장합니다
저장모델은 텐서플로우 모델을 위해
보편적으로 시리얼화된

Japanese: 
我々のバッチ処理はサーバーのために
ライブラリかフラグとして利用できます
そしてこれをやり始めてから
前までは気づかなかった
色々と興味深いニュアンスがあります
そして１つの例として
同じマシンに２つのモデルがあるとします
実際にはバッチをオーバーラップさせて
スレッドのために競わせるよりも
連続するようにスケジュールさせた方が
いいでしょう
これが共有バッチスケジューラーの概念です
各モデルにそれぞれ固有のものがあり そして
共有スケジューラーを通して協力しあいます
ちょとした予告として
シーケンスモデルは 必ずしも単なる
フィードフォワードネットワークではないので
とても興味深いです
シーケンスは長さが
それぞれ異なる事もあるので
一緒にバッチするというのは
すぐに複雑な事になります
そして幾つかの講演の後に
ユージーンの出番で
彼がバッチ処理やシーケンスについて
もっと詳しく話してくれます
では幾つかの
新規テクノロジーについて
ジョナサンは SavedModel について
話していました
この公開はとても期待されていて
皆にも採用するのをお勧めします
SavedModel は

Spanish: 
Nuestro batching está disponible
como una biblioteca,
así como a través
de un marcador para el servidor.
Y hay un montón
de matices interesantes aquí
que ni siquiera nos dimos cuenta
a lo que estábamos llegando
cuando empezamos a hacer esto.
Y como un ejemplo, imaginemos que
tenías dos modelos en la misma máquina.
Lo que puede que realmente
quieras hacer es programar sus lotes
consecutivamente en lugar de tenerlos
superpuestos y contender por los hilos.
Así que tenemos el concepto
de un planificador de lotes compartidos.
Así que cada modelo tiene el suyo
y cooperan a través
del planificador compartido.
Cómo un adelanto,
los modelos de la secuencia
hacen esto realmente interesante dado que
no son sólo una típica red fee-forward.
Y las secuencias pueden ser
de longitud variable
por lo que se vuelve muy difícil
para juntarlos en un lote.
Y Eugene está en un par de charlas.
Él va a entrar en mucho más detalle
acerca de lotes y secuencias.
En algunas áreas de tecnología emergente.
Jonathan estaba
mencionando un SavedModel.
Estamos muy emocionados de anunciar esto
y animar a todo el mundo a adoptarlo.
Así que SavedModel es el formato
de serialización universal

Portuguese: 
Nosso batching está disponível
como uma biblioteca
como também via um marcador
para o servidor.
E há muitas nuances interessantes aqui
que nem percebemos onde íamos chegar,
quando começamos com isso.
E, apenas como um exemplo,
imaginemos que você tem dois modelos
na mesma máquina.
O que você quer fazer
é programar seus lotes
em direções opostas,
em vez de tê-los sobrepostos
e competindo pelas linhas.
Temos o conceito de um
"agendador de lote compartilhado".
Cada módulo tem o seu e se ajudam
via um agendador compartilhado.
Como um teaser para mais tarde,
os modelos de sequência tornam isso
bem interessante,
dado que eles não são, geralmente,
uma rede do tipo feed-forward.
E as sequências podem ter
extensão variada,
fica bem difícil e desafiante
saber como juntá-las em lote.
E Eugene vai dar algumas palestras.
Ele dará mais detalhes
sobre batching e sequências.
Algumas áreas de tecnologia emergente.
Jonathan estava mencionando o SavedModel.
Estamos bem felizes em divulgá-lo
e aconselhar a todos que o adotem.
O SavedModel é
o formato universal de serialização

English: 
Our batching is
available as a library
as well as via flag
for the server.
And there are a lot
of interesting nuances
here that we didn't even realize
what we're getting to when
we first started doing this.
And as just one
example, let's imagine
that you had two models
on the same machine.
What you might
want to actually do
is schedule their
batches back to back
instead of having them overlap
and contend for threads.
So we have the concept of
a shared-batch scheduler.
So each model has
its own, and they
cooperate via shared scheduler.
As a teaser for
later, sequence models
make this really interesting
given that they're typically
not just a fee-forward network.
And the sequences can
be of varying length,
so it gets very tricky
and challenging for how
to batch these together.
And Eugene is up in
a couple of talks.
He's going to go into much
more detail about batching
and sequences.
A few areas of emerging tech.
So Jonathan was
mentioning a SavedModel.
We're quite excited to announce
this and encourage everybody
to adopt it.
So SavedModel is the
universal serialization format

Indonesian: 
Batching kami tersedia sebagai pustaka
juga melalui tanda untuk server.
Dan banyak nuansa menarik di sini
yang kami tak sadari akan mendapatnya
saat pertama membuatnya.
Satu contoh, bayangkan ada dua model
di mesin yang sama.
Yang harus dilakukan adalah
menjadwalkan batch mereka bolak-balik
alih-alih bertumpang tindih
dan bersaing untuk thread.
Jadi, ada konsep penjadwal shared-batch.
Masing-masing model memilikinya dan mereka
bekerja sama melalui penjadwal bersama.
Mengintip sedikit topik selanjutnya,
Sequence Model membuat ini menarik
karena biasanya mereka bukan
hanya jaringan fee-forward.
Panjang urutannya bisa sangat berbeda,
jadi sangat rumit dan menantang
untuk mem-batch semua sekaligus.
Eugene akan memberi ceramah.
Ia akan membahas lebih detail
tentang batching dan urutan.
Beberapa area teknologi yang bermunculan.
Jonathan menyebut SavedModel.
Kami sangat senang mengumumkannya dan
mendorong semua orang untuk memakainya.

Chinese: 
我们的batching已经是可用的资源
也能从服务器中添加标签
这里包括很多有趣的细节
我们在开始研究这个项目的时候
完全没有意识到
举个例子来说 假设
你在同一个机器上有两个模型
你需要做的是
在计划batch的时候让时间连接上
而不是有重叠并且激发话题讨论
我们现在有了分享batch的时间安排
每个模型都有自己的时间表
通过计划工具来进行合作
这也可以引出我们的下一步
序列模型特别有趣 因为它们通常
不只是一个缴费的网络系统
序列可以是不同长度的
所以想要讲数据batch在一起
就变得很棘手
Eugene之后会来做几个演讲
他会更细致地讲解batching
和序列问题
还有几个正在合并的技术
Jonathan之前提到了SavedModel
说到这个我们都很激动 并且希望
每个人都能开始使用它
SavedModel是一个大众的序列模式

Chinese: 
为TensorFlow的模型服务
它具有--包括在flow 1.0版本
和当前的TensorFlow服务器中
我们在回顾视频中有提到的
SavedModel中有两个marquee特征
第一个是它具支持多个MetaGraphs
对于一直在做完善的用户来说
这个特征--你可能不知道为什么需要
但是一旦你明白了更多细节 就能看到
服务时间对不同MetaGraphs来说
真的很重要
举个例子
假如你现在要完善一个模型
想在服务器中保存这个任务
通常来说你想要删除一些东西
比如输入队列之类的
然后减少分层
这些你要尽量不留在你的制作模型中
有几个人已经试过了
不那样的话你就会有坏结果
甚至没有结果
因为你把它们留在模型中了
还有一些你可能要注意
比如需要对你的服务图表进行转换
确保你的图表有数据显示
为GPU或者TPU服务
多个MetaGraph的支持功能
让你操控随意数量的MetaGraphs
你可以通过建立简单的标签
来对它们进行存储和使用
你可以用Serve标签 Train标签

Spanish: 
para los modelos TensorFlow.
Se ha incluido en términos de flujo 1.0
y también en TensorFlow Serving
en este mismo momento, en vivo en el repo.
Hay dos características
de carcasa de SavedModel.
La primera es
el apoyo a múltiples MetaGraphs.
Y para la gente que ha estado,
haciendo entrenamiento mayormente
esto-- quizás no sepas
porqué desearías esto,
pero una vez que oigas los detalles,
verás que al momento del servicio
es realmente importante
tener diversos MetaGraphs.
Y el caso de uso aquí es
digamos que estabas entrenando un modelo
y lo guardaste para servir.
Por lo general, deseas eliminar las cosas
que son específicas de entrenamiento como
colas de entrada. Y eliminar las capas.
Realmente no los quieres
en tus modelos de producción.
Algunas personas lo han intentado.
Obtendrás resultados realmente malos.
o ningún resultado en absoluto
si sólo dependen de una señal.
Otras cosas que quizás quieras hacer
es transformar
tus gráficos de servicio.
Es posible que desees tener
un gráfico cuantificado
para servir en un GPU o un TPU.
Y lo que hace
el soporte múltiple de MetaGraph
es que te permite tener
cuantos MetaGraphs desees
y puedes almacenarlos
y acceder a ellos con etiquetas simples.
Así que puedes marcar uno con Servidor,
uno con Entrenamiento

Indonesian: 
SavedModel adalah format serialisasi
universal untuk model TensorFlow.
Tersedia dalam versi flow 1.0,
juga pada TensorFlow Serving
seperti langsung
di penyimpanan pada saat ini.
Ada dua fitur terdepan dari SavedModel.
Yang pertama adalah dukungan
untuk berbagai MetaGraph.
Bagi yang banyak melakukan pelatihan,
Anda mungkin tak tahu ini untuk apa,
tapi jika Anda tahu lebih detail
yang dilihat pada saat layanan,
sangat penting untuk punya
berbagai MetaGraph.
Pada kasus ini misalnya,
Anda sedang melatih sebuah model
dan Anda menyimpannya untuk layanan.
Biasanya Anda ingin menghapus 
pelatihan tertentu
seperti antrian input
dan lapisan drop out.
Anda tidak menginginkannya
dalam model layanan produksi.
Ada yang sudah coba,
Anda akan dapat hasil yang buruk
atau tak ada hasil sama sekali
jika hanya bergantung pada tanda.
Hal lain yang mungkin ingin dilakukan
adalah mengubah grafik layanan.
Anda mungkin ingin grafik terkuantisasi
untuk layanan dalam GPU atau TPU.
Yang dilakukan layanan MetaGraph adalah
memberi sebanyak mungkin MetaGraph
dan Anda bisa menyimpan
dan mengaksesnya dengan tag sederhana.
Anda bisa memberi tag
dengan Serve, dengan Train,

Portuguese: 
para os Modelos TensorFlow.
Ele está incluso em termos do flow 1.0
e também no TensorFlowServing,
a partir de hoje,
disponível no repositório.
Há dois recursos de letreiro
do SavedModel.
O primeiro é o apoio
para múltiplos MetaGraphs.
E sobretudo para aqueles
que vêm fazendo treinamento,
talvez não saibam por que desejariam isso,
mas com mais detalhes,
verá que no tempo de serviço
é muito importante ter
MetaGraphs diferentes.
E o caso de uso aqui é, 
digamos que estivesse treinando um modelo
e fosse salvá-lo para serviço.
Então vai remover as coisas
específicas de treinamento,
tais como filas de entrada
e abandonar camadas.
Você não quer tê-los
em seus modelos de produção de serviço.
Alguns tentaram.
Você tem resultados muito ruins.
Ou nenhum resultado,
se só esperarem um sinal.
Outra coisa que talvez queiram fazer
é transformar seus gráficos de serviço.
Talvez queiram um gráfico quantificado
para servir em uma GPU ou TPU.
E o que o suporte múltiplo
do MetaGraph faz
é deixar que você tenha
quantos MetaGraphs desejar
e pode armazená-los ou acessá-los
por simples marcadores.
Então, pode marcar um com Servir,
um com Treinar,

Japanese: 
TensorFlow モデルの
ユニバーサルシリアル化形式です
TensorFlow 1.0 に含まれていて
TensorFlow Serving にも
現在ライブで含まれています
SavedModel には
２つの特徴があります
１つは複数の MetaGraph への
サポートです
トレーニングを主にしてきた人たちには
なぜこんなのが必要なのか
分からないかもしれませんが
もっと詳しいことを聞いて頂ければ
Serve 時に違う MetaGraph があることが
とても重要なことだと分かるでしょう
例えば ここでの利用例として
モデルをトレーニングしているとして
Serving のために
保存しようとするとします
入力クエリや
ドロップアウトレイヤーなどという
トレーニング用の物は
取り除いておきたいでしょう
そういったのは本番用の
Serving モデルには欲しくないでしょう
試した人達は
キューにひっかかってしまうか
或いは すごく悪い結果を得たか
結果が得られなかったかです
他にやっておきたいことは
Serving グラフを
トランスフォームしていかもしれません
GPU や TPU に Serving するために
数値化されたグラフがほしいかもしれません
なので複数 MetaGraph のサポートは
いくらでも必要なだけ MetaGraph を使え
単純なタグで保存やアクセスができます

Korean: 
형태입니다
플로우 1.0 버전에 포함되고
현재 라이브로 텐서플로우 서빙에서도
포함됩니다
저장모델에는 두 가지
중요 피쳐가 있습니다
첫번째는 다양한
메타그래프에 대한 지원입니다
훈련을 위주로 해 온 분들이라면
이것이 왜 필요한지 모를 수도 있지만
일단 상세히 들어보시면 서브 시간에서
다른 메타그래프를 가지는 것이
중요한 이유를 아실 겁니다
여기에서는 예컨대
모델을 훈련시킨다고 칩시다
서빙을 위해 저장하려는 거죠
보통 인풋 큐와 같은 훈련만을 위한 것은
삭제하고 싶으시겠죠
드랍아웃 레이어도 그렇죠
실행 서빙 모델에서는
이러한 것들이 필요없죠
몇몇 분들이 시도해 봤죠
큐에만 있다면
정말 안 좋은 결과를 보거나
결과가 아예 안 나오겠죠
또 다른 점은
서빙 그래프를 변환시키고 싶으시겠죠
따라서 GPU나 TPU에서 서빙되는
양자화 그래프를 만들어야겠죠
다양한 메타그래프 지원이 하는 일은
원하는 메타그래프는
모두 가지게 해 주고
간단한 태그로 저장하고
접근할 수 있게 해줍니다
따라서 하나는 서브
다른 하나는 훈련이라는 태그를 달고

English: 
for TensorFlow Models.
It has-- it's included
in terms of flow 1.0
and also in TensorFlow
Serving as of right
now, live on the repo.
There are two marquee
features of SavedModel.
So the first one is support
for multiple MetaGraphs.
And for folks who have been,
you know, mostly doing training,
this-- you might not
know why you'd want this,
but once you hear more details
you'll see at serve time
it's really important to
have different MetaGraphs.
And the use case here is let's
say you were training a model,
and you went to
save it for serving.
So you typically want to
remove things that are training
specific like input queues.
And drop out layers.
You really don't want those in
your production serving models.
A few people have tried.
You get really bad
results or no results
at all if they
just hang on a cue.
Other things you
might want to do
is you might want to
transform your serving graphs.
So you might want to
have a quantized graph
for serving on a GPU or a TPU.
And what the multiple
MetaGraph support does
is it lets you have as
MetaGraphs as you want,
and you can store and
access them by simple tags.
So you can tag one with
Serve, one with Train,

Indonesian: 
dengan Serve dan GPU atau TPU,
dan seterusnya.
Konsep berikutnya adalah SignatureDefs.
SignatureDef menjelaskan
tanda khusus dari komputasi
yang didukung oleh grafik TensorFlow.
Ini sangat penting.
Jika Anda melihat tampilan ini,
banyak orang mungkin langsung--
terutama manusia, kita hebat dalam ini.
Anda bisa baca kelas input dan skor
dan mungkin langsung tahu
grafik ini tentang apa.
Tapi jika Anda tampilkan grafik ini
tanpa label ke sistem layanan,
ia takkan tahu yang harus dilakukan, kan?
Dengan grafik ini, Anda bisa
mengumpan atau menjemput
dari titik manapun pada kebanyakan grafik.
Bagaimana Anda mengenali
ke mana input dan output,
itulah yang dilakukan SignatureDef.
Pada kasus ini, mereka menetapkan
bahwa titik tengah di kiri
adalah tempat mengumpan contoh TensorFlow
dan titik kanan atas
adalah Classes .
dan kanan bawah adalah
bilangan Scores poin mengambang
untuk, misalnya sebuah klasifikasi.
Dalam SignatureDef, kami menambah
dukungan untuk Multi-headed Inference.
Jadi ini salah satu permintaan fitur
terbanyak yang diterima dari masyarakat.

Portuguese: 
um com Servir e GPU ou TPU,
e por aí vai.
O próximo conceito é SignatureDefs.
SignatureDefs define
a assinatura de um cálculo
suportada por um gráfico TensorFlow.
E isso é muito importante.
Se você olhar o slide,
muitos podem, de imediato,
sobretudo os humanos, somos bons nisso,
ler as classes de input e os resultados
e imaginar o que está ocorrendo
com este gráfico.
Mas se entregasse este gráfico
sem as etiquetas
a um sistema de serviço,
talvez ele não soubesse o que fazer.
Com estes gráficos, você pode
alimentar ou buscar
de qualquer nó na maioria dos gráficos.
Como identificar para onde vai
sua entrada e sua saída?
É isso o que SignatureDefs faz.
Neste caso, especificam
que o nó central, à esquerda,
é onde quer alimentar
seu exemplo de TensorFlow,
o nó na parte superior direita
são suas classes de linhas.
E a parte inferior direita
são suas pontuações
para, digamos, uma classificação.
Ao construir em SignatureDefs,
agregamos suporte
para a Multi-headed Inference.
Essa é uma das principais solicitações
que recebemos da comunidade.

English: 
one with Serve and
GPU or TPU, and so on.
The next concept
is SignatureDefs.
So a SignatureDef
defines the signature
of a computation supported
by a TensorFlow graph.
And this is really important.
So if you look at the
slide, most people
probably can right away--
especially for humans.
We're good at this.
You can read input
classes and scores
and probably figure out what's
going on with this graph.
But if you handed this
graph without those labels
to a serving system,
it would probably
have no idea what to
do with it, right?
With these graphs, you can
feed or fetch from just
about any node in most graphs.
So how would you identify
where your input goes
and where your output goes, and
that's what SignatureDefs do.
So in this case, they specify
that that middle node,
on the left, is where you want
to feed in your TensorFlow
example, and the top right
node is your string Classes,
and the bottom right is
your floating point Scores
for, say, a classification.
Building onto
SignatureDefs, we're
adding support for
Multi-headed Inference.
So this is one of the
top feature requests
we've had from the community.

Spanish: 
uno con Servir y GPU o TPU
y así sucesivamente.
El siguiente concepto es SignatureDefs.
Un SignatureDef define la firma
de un cálculo soportado
por un gráfico TensorFlow.
Y esto es realmente importante.
Si miras la diapositiva,
probablemente la mayoría de la gente
puede hacerlo de inmediato, especialmente
los humanos. Somos buenos en esto.
Puedes leer las clases de entrada
y las puntuaciones y, probablemente
averiguar qué está pasando
con este gráfico.
Pero si entregaste
este gráfico sin esas etiquetas
a un sistema de servidor,
probablemente no tendría idea
de qué hacer con él, ¿cierto?
Con estos gráficos, puede alimentar
o buscar desde casi cualquier nodo
en la mayoría de los gráficos.
¿Cómo identificar a dónde va
la entrada y a dónde va la salida?
Eso es lo que hace SignatureDefs.
En este caso, especifican
que ese nodo central, a la izquierda
es donde deseas alimentar
tu ejemplo de TensorFlow
y el nodo superior derecho
es la cadena de Classes
y la parte inferior derecha
es tu punto flotante Scores
para, digamos, una clasificación.
Basándonos en SignatureDefs,
estamos añadiendo soporte
para el Multi-headed Inference.
Esta es una
de las solicitudes más importantes
que hemos recibido de la comunidad.

Korean: 
하나는 서브, GPU, TPU
이런 식으로 태그를 다는 거죠
다음 개념은 시크너쳐데프입니다
시그너쳐데프는 텐서플로우
그래프에 의해
지원되는 시그너쳐 계산을 정의 내립니다
정말 중요하죠
슬라이드를 보시면 대부분의 사람들이
특히 인간은 이런 걸 잘 하니까
말이죠
인풋 클래스와 점수를 읽을 수 있고
이 그래프에서 일어나는 일을
아마 알아낼 수 있을 겁니다
하지만 라벨 없이 이 그래프를
서빙 시스템에 넘기면 아마
뭘 해야 할지 모를 겁니다
이 그래프를 통해 대부분의
그래프의 어떠한 노드에서도
피드하거나 패치할 수 있습니다
그럼 여러분의 인풋과
아웃풋이 어디로 가는지
어떻게 식별할 수 있을까요
그것이 바로 시그너쳐데프가 하는 일이죠
이 경우 중간 노드, 좌측 노드
그리고 우측 상단의 노드는
스트링 클래스이고
우측 하단은 예컨대 지나가는
분류를 위한 포인트 스코어라고
상세화한 거죠
시그너쳐데프로 만들면서 멀티헤디드
인터페이스로의 지원을 더한 겁니다
이것이 저희가 커뮤니티로부터 요청받은
탑 피쳐 중 하나입니다

Chinese: 
另一个用Serve和GPU或者TPU 等等
下一个要说到的是SignatureDefs
SignatureDef定义了
TensorFlow图表计算公式的签名样式
这个特别重要
请看一下幻灯片
大多数人可能马上就--
尤其是人类
我们很擅长这个
你可以阅读输入等级和分数
也许可以得知这些图标代表什么
但是如果你在没有标签的时候
就保存了图表
你的服务器系统
可能就不知道要怎么操控了 对吧?
你可以填充或者使用图表
对任何图表都能这样
那你要怎么知道在哪里输入了内容
在哪里有输出
怎么知道SignatureDefs是怎么回事呢
通常这个时候
中间的节点会被具体化
在左边是填充TensorFlow例子的地方
右上方的节点是你的阶层
右下方是你的分数点
分级的分数点
在SignatureDefs的基础上
我们增加了多点推理的支持方式
这是很多人提到的一个要求
我们在社区评论中常见到

Japanese: 
例えば１つは Serve のタグをつけ
もう１つは Train
そして Serve と
GPU か TPU がついているの等々
次の概念は SignatureDefs です
SignatureDef は
TensorFlow グラフのサポートがある計算の
シグネチャを定義します
そしてとても重要なことです
スライドを見てみると
多分多くの方にはすぐ分かると思います
人には直感でわかります
入力クラスやスコアなどを読んで
このグラフで
何が起きているのか分かるでしょう
ですがこのグラフをラベルなしで
Serving システムに手渡せば
恐らく何をすればいいのか
分からないでしょう
こういうグラフではどのノードからも
フィードやフェッチなどができるでしょう
なのでどこに入力が行って
どこに出力が行くのかというのを
SignatureDefs がやってくれます
このケースだと 左側の真ん中のノードが
TensorFlow の例をフィードしたい所で
１番上の右側のノードが
String クラスで
右下のは分類用の
浮動小数点 Scores であるとします
SignatureDefs を元に
マルチヘッド推論へのサポートを
導入しています
コミュニティからのリクエストの中で
１番多くあったのがこの機能です
マルチヘッド推論をご存知の方はいますか

Indonesian: 
Ada yang tahu Multi-headed Inference?
Oke, sangat sedikit.
Ini akan menjadi terkenal dan lebih umum
karena orang memroduksi dan meluncurkan
pembelajaran mesin dalam produk mereka.
Jadi, sangat umum sehingga
Anda bisa mulai dengan satu model
mungkin model click-through,
untuk melakukan prediksi
pada rekomendasi video.
Tapi seiring waktu Anda mungkin
juga ingin melatih model untuk konversi
atau mungkin orang yang
menonton keseluruhan video.
Dan seringkali orang melakukannya
dengan melatih model kedua,
tapi untuk permulaan
Anda melatih pada data yang sama.
Semua data Anda, pre-processing,
semua lapisan tersembunyi seringnya sama,
dan pada saat layanan, Anda banyak
melakukan komputasi yang berulang.
Jadi Anda parse input, pre-process,
melakukan komputasi
lapisan tersembunyi yang sama,
tapi hanya lapisan output yang berubah.
Jadi Multi-headed Inference kami
mendukung pembuatan tanda khusus,
mengizinkan Anda menetapkan
berbagai tanda khusus bersamaan,
dan menjalankannya sekaligus
dalam satu permintaan,
itulah yang dilakukannya.
Menjalankan Multi-headed Inference
akan menghemat

Japanese: 
オーケー
とても少ないですね
これは機械学習を実際に稼働し始めれば
もっと人気があって普遍的になると思います
ビデオ推薦の推測のためとかに１つのモデルや
クリックスルーモデルを使うのは
とてもよくあることです
ですが時間が経つにつれ
いつかはコンバージョンや
ビデオ全体を見る人のためのモデルを
訓練したいという事をになるかもしれません
そしてこれを実際にするために人はよく
２つ目のモデルを訓練したりするわけですが
結局のところ
殆ど同じデータを訓練しているわけですね
あなたのデータすべてプリプロセッシング
非表示レイヤー これらは殆ど同じです
つまり Serve 実行時に重複した計算を
しているわけです
入力を構文解析
プリプロセッシングして
同じ非表示レイヤー計算をしながら
出力のレイヤーだけが
変わるだけです
なので我々のマルチヘッド推論は
シグネチャのビルドをサポートし
複数のシグネチャを
一緒に指定できるようになっています
そして例えば １つのリクエストで
すべて一緒に実行したいのならそうします
マルチヘッド推論を行えば
作動オーバーヘッドと
マルチモデルの展開の複雑さの手間を

Portuguese: 
Alguém está familiarizado
com a Multi-headed Inference?
Ok. Muito poucos.
Isso vai ser muito popular e mais comum
conforme as pessoas produzam e implantem
o aprendizado automático em seus produtos.
Então, é muito comum
que inicie com um modelo,
talvez com um modelo de clickthrough,
para fazer previsões sobre
suas recomendações de vídeo.
Mas, com o tempo, talvez decida,
"Também gostaríamos de treinar
um modelo para conversões
ou talvez para pessoas 
que assistem ao vídeo inteiro."
E, muitas vezes, as pessoas treinariam
um segundo modelo.
Mas os iniciantes treinam
em quase todos os mesmos dados.
Todo o seu pré-processamento de dados,
todas as suas camadas ocultas,
muitas vezes, são os mesmos
e, no tempo de serviço, você está fazendo
muita computação redundante.
Está analisando sua entrada,
pré-processando-a,
fazendo a mesma, sabe, computação oculta,
e só as camadas de saída mudam.
O nosso suporte de Multi-headed Inference
se baseia em assinaturas
e o deixa especificar
várias assinaturas em conjunto
e dizer: "Execute isso em conjunto
em uma solicitação"
e ela o fará.
Executar a Multi-headed Inference
poupará sobrecarga operacional

Chinese: 
有人对多点推理比较熟悉吗?
好
很少几个人
这个将会变得特别受欢迎
因为人们制作和使用机器学习
并将其用于自己的产品上
真的很常见
你可能开始只有一个模型
可能是一个点式模型
用来做视频推荐的预测
过一段时间 你可能决定
也想改善一个模型 用于对话中
或者支持人们观看整个视频
很常见的情况是 人们到处讲
讨论完善另一个模型
但是刚开始 你完善的
几乎是同样的数据
你的所有的数据 处理工作
所有的隐藏层面
通常都是一样的
在服务器中
你其实做了
很多不必要的计算
这么说来其实你在反复输入
重复操作
因为这里有隐藏的计算
改变了的之有外部层面
我们的多点推论支持签名功能
让你对不同任务进行标注
如果这些都在同一个任务中
它就会有这个功能
运用多点推论这个功能
会节省你很多实际时间 减少复杂

English: 
Is anyone familiar with
Multi-headed inference?
OK.
Very few.
This is going to be
really popular and more
common as people productionize
and deploy machine learning
in their products.
So it's really,
really common that you
might start with one model,
maybe a click-through model,
to do predictions on, say,
your video recommendations.
But over time, you
might decide, you know,
we'd also like to train a model
for conversions or maybe people
who watch the whole video.
And quite often people
would go about this
by actually training
a second model,
but for starters,
you're training on
almost all the same data.
All of your data,
pre-processing,
all of your hidden layers,
quite often, are the same,
and then at serve
time you're doing
a lot of redundant computation.
So you're parsing your
input, preprocessing it,
doing the same, you know, hidden
layer computation, and really
only the output layers change.
So our Multi-headed Inference
support builds on signatures,
and lets you specify
multiple signatures together.
And say, run these
together in one request,
and it will do that.
Performing
Multi-headed Inference
will save you operational
overhead and complexity

Spanish: 
¿Alguien está familiarizado
con el Multi-headed Inference?
Muy pocos.
Esto va a ser muy popular y más común
a medida que la gente produzca
y despliegue el aprendizaje automático
en sus productos.
Por lo tanto, es muy común
que comiences con un modelo,
tal vez un modelo de clic, para
hacer predicciones sobre, por ejemplo,
tus recomendaciones de videos.
Pero con el tiempo, podrías decidir,
ya sabes, también nos gustaría entrenar
un modelo para conversiones o tal vez
para gente que vea todo el video.
Muy a menudo la gente comenzaría
por el entrenamiento de un segundo modelo
pero principiantes, estás entrenando
en casi todos los mismos datos.
Todos tus datos, pre-procesamiento,
todas tus capas ocultas,
a menudo, son lo mismo
y luego en el tiempo de servicio
estás haciendo una gran cantidad
de computación redundante.
Así que estás analizando
tu entrada, preprocesándola,
haciendo lo mismo cálculo de capa oculta
y realmente
solo cambian las capas de salida.
Por lo tanto, nuestro soporte
Multi-Headed Inference se basa en firmas
y te permite especificar
varias firmas juntas.
Y decir,
ejecuta estos juntos en una solicitud
y lo hará.
La realización del Multi-headed Inference
te ahorrará gastos generales operativos

Korean: 
멀티헤디드 인터페이스는 다들 아시나요?
네
거의 모르시죠
이건 제품에 머신러닝을 상품화하고
전개함에 따라 더욱 인기가 있고
흔해질 겁니다
하나의 클릭 스루 모델로
시작하는 것은 아주 흔합니다
예컨대 비디오 추천에 대한
예측을 하기 위해서 말이죠
하지만 시간이 지나면서
컨버전이나 비디오 전체를
보는 사람들을 위한
모델도 훈련시키고 싶겠죠
많은 경우 실제로 두 번째 모델을
훈련시키면서 시작하지만
초보자의 경우 거의 모든 똑같은
데이터를 훈련시기는 거죠
모든 데이터, 미리 하는 처리
모든 숨겨진 레이어는
많은 경우 똑같습니다
서빙 시간에 불필요한 같은 계산을
많이 하는 거죠
인풋을 분석해서 미리 처리하고
같은 숨겨진 레이어 계산을 하고
아웃풋 레이어만 바꾸는 거죠
저희 멀티헤디드 인터페이스 지원은
시그너쳐에서 만들고
여러 개의 특정 시그너쳐를 함께
구체화할 있게 해줍니다
한번의 요청으로 이를 다함께 실행하면
그렇게 하는 거죠
멀티헤디드 인터페이스를 실행하면
운영적 간접비용과
여러 모델을 전개하는 데에 드는

Japanese: 
省くことができます
帯域幅と CPU 待機時間を
減らすことができます
あと１、２週間ほどで公開されるので
楽しみです
ではまとめておきます
もう一度ですが
ユージーンがシーケンスモデルについて
後で詳しくお話します
ただシーケンスモデルには
色々な形があるというのを
お見せしておきたいです
普段は Serve するために
待機時間と計算コストが高いものですが、
皆さんが Serve するために
効率よくするための手段を
具体的にはバッチ処理、パディングなどを
我々が調査しています
では興味のある方からのコラボレーションや
プルリクエスト、機能リクエスト、
バグ報告など歓迎します
毎週 GitHub へ我々のコードを
同期しています
プルリクエストや質問に答えたり
コメントやアイデアなどを促進するために
常にデベロッパーが待機中です
連絡は
discuss@tensorflow.org へ

English: 
of deploying multiple models.
It'll save you bandwidth
CPU latency, and so on.
So we're really excited, and
that should land sometime
in the next week or two.
All right, so wrapping up.
And again, Eugene is going
to go into much more depth
on sequence models.
I just wanted to
highlight that there
are many flavors
of sequence models.
They are generally
very expensive to serve
both in compute
cost and latency,
and we're investigating,
specifically,
batching, padding, and
unrolling strategies
to make them more efficient
and effective for all of you
to serve.
All right, so for
anybody who's interested,
we really warmly welcome
collaboration, pull requests,
feature requests,
bugs, and so on.
We sync all of our
code to Github weekly.
We have a developer
on call, and it
includes facilitating your pull
requests, answering questions,
comments, and ideas, and so on.
To get in touch, you can reach
us at discuss@tensorflow.org.

Indonesian: 
biaya operasional serta
kompleksitas penyebaran berbagai model.
Juga akan menghemat latensi
CPU bandwidth, dan sebagainya.
Jadi, kami sangat senang dan itu
harusnya keluar sekitar minggu depan.
Baiklah, untuk merangkum,
Eugene akan membahas lebih dalam
tentang model berurutan.
Saya hanya ingin tekankan
ada banyak jenis model berurutan.
Umumnya sangat mahal untuk melayani
biaya komputasi dan latensi sekaligus,
dan kami sedang menyelidiki, khususnya
batching, padding, dan strategi unrolling
untuk membuatnya lebih
efisien dan efektif bagi pelayanan Anda.
Baiklah, bagi Anda yang tertarik,
kami menyambut hangat kolaborasi,
permintaan pull, permintaan fitur,
bug, dan sebagainya.
Kami mensinkronisasi semua kode kami
ke GitHub setiap minggu.
Ada pengembang panggilan,
yang juga memfasilitasi permintaan pull,
menjawab pertanyaan, komentar,
ide, dan sebagainya.
Untuk menghubungi kami,
silakan melalui discuss@tensorflow.org.

Portuguese: 
e a complexidade de usar vários modelos.
Ela poupará a largura de banda,
a latência da CPU e muito mais.
Então, estamos muito felizes
e deve chegar em breve,
em uma ou duas semanas.
Então, resumindo.
Eugene abordará mais
sobre os modelos de sequência.
Só queria ressaltar que há
modelos de sequência para muitos gostos.
No geral, são muito caros para servir
tanto em custo computacional
como em latência,
e estamos investigando, especificamente,
as estratégias de batching,
preenchimento e desenrolamento
para torná-las mais eficientes
e eficazes para todos.
Então, para quem tiver interesse,
nós recebemos colaboração, pull requests,
solicitações de recursos,
erros e tudo mais.
Sincronizamos todo nosso código
para o Github toda semana.
Temos um desenvolvedor em plantão
e isso inclui facilitar
seus pull requests, responder perguntas,
comentários, ideias e tudo mais.
Para entrar em contato,
escreva para discuss@tensorflow.org.

Korean: 
복잡성을 줄여줄 겁니다
밴드위스 CPU 지연속도 등을
줄이는 거죠
정말 신나고 다음 주나 2주 후에
완성될 겁니다
마무리하겠습니다
다시 한번, 유진이
시퀀스 모델에 대해 훨씬 더 자세히
발표할 겁니다
시퀀스 모델에 다양한 측면을
강조하고 싶었습니다
계산 비용과 지연속도에 있어서
보통은 비용이 많이 들죠
특히 저희가 조사한 것은
배치, 패딩, 언롤링 전력 등인데
여러분 모두가 좀더 효율적이고
효과적으로 서빙할 수 있도록
만들기 위함이었습니다
관심 있으신 분들은
언제든 협력하는 것을 환영하고 풀 요청이나
피쳐 요청, 버그 등을 보내 주십시오
저희의 모든 코드는
깃허브에 매주 싱크됩니다
항상 개발자가 대기하고 있고
풀 요청이나 질의 응답, 코멘트, 생각 등을
가능하도록 말이죠
연락을 원하시면
discuss@tensorflow.org를 방문해 주십시오

Spanish: 
y la complejidad
de la implementación de varios modelos.
Te ahorrará tiempo de latencia
de ancho de banda.
Así que estamos muy emocionados
y esto debería salir
en algún punto entre una semana o dos.
De acuerdo, resumiendo.
Eugene va a entrar
en mucho más profundidad
en los modelos de secuencia.
Sólo quería resaltar que hay muchos
sabores de los modelos de secuencia.
Por lo general, son muy caros para servir
tanto en costo computacional
como en latencia y estamos investigando, específicamente
el procesamiento por lotes, el relleno
y las estrategias de desenrollado
para que sean más eficientes
y eficaces para todos ustedes.
Para cualquiera que esté interesado,
realmente acogemos
con entusiasmo la colaboración
las solicitudes de tracción,
las solicitudes de características,
los errores, etc.
Sincronizamos todo nuestro código
a Github semanalmente.
Tenemos un desarrollador al teléfono,
e incluye facilitar tus solicitudes
responder preguntas,
comentarios e ideas, y demás.
Para ponerse en contacto,
puedes contactarnos
en la siguiente dirección:
discuss@tensorflow.org

Chinese: 
简化使用多个模型的过程
会给你省很多CPU潜伏带宽
我们真的很兴奋
希望在今后一两周
将这个功能推广出去
好了 总结一下
Eugene将会更深入地
给大家解释序列模型
我想强调的是
序列模型有很多种类
通常用起来挺贵的
计算经费多 潜伏性大
我们花了很多功夫在上面
进行batching, padding
试用多种手段
旨在让它们更有效 更好用
让用户满意
好了 如果有哪位感兴趣
我们欢迎你参与合作 提出问题
探讨系统不足等等
每周我们都会在Guthub上传代码
我们有工作人员随时在线
帮助解决用户疑难 回答各类问题
讨论反馈 了解新想法 等等
如果你想联系我们
请发邮件到discuss@tensorflow.org

Japanese: 
どうやって始めるられるかの
リンクなどがここにあります
オフラインで読んで頂いて
質問や意見があったら是非とも
我々に連絡をください
聴講していたきありがとうございます
次はアシッシュさんです

Spanish: 
Aquí hay un montón de enlaces
para saber cómo puedes empezar.
Te dejaré leer esto sin conexión,
y por favor ponte en contacto
con tus preguntas y comentarios.
De acuerdo, así que muchas gracias
y luego de esto viene Ashish.

Indonesian: 
Berikut ini sejumlah tautan
mengenai cara memulai.
Ini boleh dibaca offline
dan silakan menghubungi kami
dengan pertanyaan dan masukan Anda.
Baiklah, terima kasih banyak
dan berikutnya adalah Ashish.

English: 
So here are a bunch of links
for how you can get started.
I'll let you read these
offline, and please
do get in touch with your
questions and feedback.
All right, so thanks very
much and up next is Ashish.
[APPLAUSE]
[MUSIC PLAYING]

Portuguese: 
Aqui está um monte de links
sobre como podem começar.
Vou deixar que os leiam offline
e, por favor, enviem
suas perguntas e feedback.
Muito obrigado e a seguir teremos Ashish.

Korean: 
여기 여러 링크로 시작하시면 됩니다
오프라인으로도 볼 수 있도록 하겠습니다
여러분의 질문과 피드백을
보기 위해서 말이죠
정말 감사드리고
다음은 아쉬스의 발표가 있겠습니다
[박수]
[음악재생]

Chinese: 
这还有一些链接 可以帮你起步
我会在之后给你们链接
有问题或者反馈
请随时联系我们
好了 谢谢大家
下面的主讲人是Ashish
[掌声]
[音乐]
