
English: 
[MUSIC PLAYING]
DANDELION MANE: I always wind
up doing these live demos,
so I never get the privilege
of just jumping straight
into slides, and so there's some
amount of computer wrangling.
But [INAUDIBLE]?
All right, so my
name is Dandelion.
I'm the only person I know
who has an emoji signature.
It's the dandelion emoji
and then the lion emoji,
although I didn't actually
put this on the slide.
And I'm here to talk
about TensorBoard.
So TensorBoard is a
really exciting tool.
It's been built by a number
of engineers at Google.
And the basic idea
behind TensorBoard
is everyone knows that
neural networks can sometimes
be a bit of a black box.
And so we want to
TensorBoard to be something
of a flashlight,
something that will
let you take the confusing
world of TensorFlow
and start to dive into it.
Now it's a pretty
complicated tool.
It's got a lot of
bits and pieces.
So the way that I'm going
to explain it to you
is by going through an example.
So we're going to take
a simple MNIST model.

Korean: 
항상 제가 이 라이브 데모를
마무리합니다
그래서 슬라이드로
바로 넘어갈 수가 없는데요
컴퓨터를 좀 붙잡고 있어야해요
하지만 됐죠?
좋아요, 제 이름은 댄들라이언이고
저만 유일하게 이모티콘 사인을
갖고 있어요
댄들라이언 이모티콘이랑
라이언 이모티콘이죠
슬라이드에 넣진 않았지만요
TensorBoard에 대해
이야기하겠습니다
TensorBoard는
흥미로운 도구예요
구글의 수많은 엔지니어들이 개발했어요
TensorBoard의
기본 개념은 이래요
모두가 알다시피 신경 회로는 가끔
블랙 박스처럼 기능하는 거죠
저흰 TensorBoard를
플래시등처럼 작동시켜
여러분이 복잡한 TensorFlow를
시작하는 데 도움을 드리고 싶어요
이건 꽤 복잡한 도구인데요
세세한 부분이 많아요
그래서 저는 예제를 통해서 설명할게요
간단한 MNIST 모델을 보도록 하죠

Indonesian: 
Saya selalu melakukan demo langsung
jadi saya tak pernah sempat
menjelaskan langsung dari slide
saya banyak berkutat dengan komputer.
Tapi [tidak terdengar]?
Baik, nama saya Dandelion.
Setahu saya, cuma saya
yang bertanda tangan emoji
yaitu Emoji dandelion dan emoji singa.
Tetapi saya tak memasukkanya ke slide.
Saya di sini untuk membahas
tentang TensorBoard.
TensorBoard adalah alat
yang sangat menarik.
Ia dibuat oleh sejumlah teknisi di Google.
Ide dasar di balik TensorBoard,
agar semua orang tahu
bahwa jaringan neural terkadang bisa
menjadi seperti kotak hitam.
Kami mau jadikan TensorBoard
menjadi seperi lampu senter
yang membawa Anda ke dunia
TensorFlow yang membingungkan
dan mulai menyelaminya.
Ia adalah alat yang cukup rumit.
Banyak detailnya.
Jadi cara saya menjelaskannya
adalah dengan memberi contoh.
Kita ambil model MNIST yang sederhana.

Japanese: 
ライブデモをするのは
いつも四苦八苦します
スライドに直接 入れたことなんてないです
コンピューターが対抗するんです
でも...[ 聞き取れず ]
では 私の名前はダンデライオンです
私は絵文字サインを持っている
唯一の人間です
タンポポとライオンの絵文字です
スライドの中にはありませんけどね
ここでは TensorBoard の
お話をします
TensorBoard は
とてもすごいツールです
大勢の Google エンジニアがビルドしました
TensorBoard を作った基本的考えは
ニューラルネットワークが
ブラックボックスっぽいと
みんなが思っていることです
TensorBoard がそれを
少しわかりやすくし
皆さんが TensorFlow の世界に
取り組めるように欲しかったです
これは非常に複雑なツールです
多くの小さなパーツの寄せ集めです
ですので 
例を使って説明していきます
まずは 単純な
MINIST モデルからいきます

Spanish: 
Siempre me pasa esto
en las demostraciones en vivo
casi nunca tengo la suerte
de ir directamente a las diapositivas
generalmente pasa
algo con la computadora.
Pero…
Muy bien, me llamo Dandelion.
Soy la única persona que conozco
que tiene una firma con emojis.
Es el emoji de diente de león y de león,
aunque no los puse en la diapositiva.
Les voy a hablar de TensorBoard.
TensorBoard es
una herramienta muy emocionante.
Lo construyeron ingenieros de Google.
Y la idea básica detrás
de TensorBoard es que todos saben
que las redes neuronales
a veces son como una caja negra.
Entonces queremos que
TensorBoard sea como una linterna
algo que permita tomar
el mundo confuso de TensorFlow
y empezar a sumergirse en él.
Es una herramienta bastante complicada,
tiene muchas partes y piezas.
Así que la forma en que voy
a explicarles será con un ejemplo.
Vamos a tomar un modelo MNIST simple.

Chinese: 
[音乐]
单迪伦·马内：总是轮到我做这样的实时展示
所以总是不能直接开始讲幻灯片
电脑需要调试
但是 --
好了，我是单迪伦
我是我知道的唯一一个
用表情做签名的人
是一个蒲公英的表情
加一个狮子的表情
不过我没有把它们放入幻灯片
我来讲讲TensorBoard
TensorBoard是一个令人兴奋的工具
由Google的很多工程师创建
TensorBoard的基本理念就是
大家知道神经网络有时
会很难以理解
所以我们希望TensorBoard能指明道路
帮助你理解TensorFlow的种种功能
开始直接工作
这个工具十分复杂
有很多十分琐碎的部分
所以我向你展示的方式
是通过一个具体的例子
我们用混合美国国家标准技术研究所
（MNIST）模型举例

Portuguese: 
Eu sempre acabo
fazendo essas demostrações ao vivo,
então nunca tenho o privilégio 
de ir direto a slides,
por isso há um pouco 
de disputa de computador.
Mas...
Está tudo certo?
Tudo bem, meu nome é Dandelion.
Sou a única pessoa que eu conheço
que tem uma assinatura em emoji.
É o emoji do dente-de-leão com o do leão,
só que eu não coloquei isso no slide.
Estou aqui para falar sobre TensorBoard.
TensorBoard é uma ferramenta 
muito empolgante,
foi construída por engenheiros no Google.
E a ideia básica por trás de TensorBoard
é que sabemos que redes neurais
podem ser meio como uma caixa-preta.
Queremos que TensorBoard 
seja como uma lanterna,
que vai permitir a você mergulhar
no mundo de TensorFlow.
Mas é uma ferramenta muito complicada.
Tem um monte de pedaços.
Então vou explicar a vocês 
através de um exemplo.
Vamos pegar um modelo MNIST simples.

Korean: 
여기엔 최상단에
나선형의 풀링 레이어가 있습니다
완전히 연결된 레이어가
두 개 있을 거예요
우리 예상대로 나타날 겁니다
이 모델을 함께 만들어봅시다
잘못된 점을 찾아보고
TensorBoard를 이용해서
이해하는 법을 알아봅시다
코드 세트를 보여드릴게요
조금 빨리 보도록 할게요
지금 당장 코드를 습득할 필요는 없어요
제 GitHub에 등록되어 있거든요
그리고 마지막에 링크를 보여드릴 거예요
시작할 때
TensorFlow에 레이어를 넣습니다
나선형 레이어도 추가하고 싶어요
변수를 두 개 만들거예요
이들은 가중치와 바이어스를 가집니다
그리고 나선형 적용을 하고
나선에 reLU를 적용하고
바이어스를 더한 후 출력합니다
그리고 완전히 연결된 레이어를
만들어봅시다
이건 더 쉬워요
다시, 가중치와 바이어스가 있고
행렬 곱과 덧셈 reLU를 적용합니다
출력합니다
이제 레이어가 생겼으니

Chinese: 
在顶部会有一些卷积层和池化层
接着是两个完全联通的层
然后它会给出我们的预测
让我们共同建立这个模型
看看那些地方会出问题
以及TensorBoard如何帮助我们
更好地理解这一模型
接下来我会展示一些代码
我会一带而过
你不需要记下所有代码
我会把他们以概要的方式
全部发布在GitHub上
最后我们还会发布推特链接
首先，让我们在TensorFlow里建一些层
我们想要一个卷积层
建立两个变量
它们会有权重和偏差
然后我们加入卷积运算
再在卷积上加入一个reLU
以及偏差，然后返回
然后我们做一个完全联通的层
这更容易
这回我们还是有权重和偏差
我们做矩阵乘法和加法的reLU
然后返回
有了这几个层

Portuguese: 
Terá algumas camadas 
de conjugação no topo
e duas camadas inteiramente conectadas.
E então vai cuspir nossa previsão.
Vamos construir este modelo juntos, 
explorar o que pode dar errado
e como podemos usar TensorBoard 
para entender melhor.
Vou mostrar um monte de código.
Vou seguir meio rapidamente.
Vocês não precisam se preocupar em pegar
tudo sobre o código agora,
pois o resumo está no meu GitHub 
e vamos também tuitar o link no fim.
Para começar, vamos juntar 
algumas camadas no TensorFlow.
Queremos uma camada convolucional.
Vamos fazer duas variáveis.
Terão os pesos e as tendências.
Então vamos aplicar a op convolucional
e um retificador à convolução
mais as propensões e então retornar isso.
Então vamos fazer uma camada 
inteiramente conectada.
Isto é mais fácil ainda.
Mais uma vez, temos pesos e tendências.
Vamos fazer a retificação da multiplicação
e da adição da matriz, e retornar isso.

Japanese: 
一番上部には 畳み込みとプーリングの
２つの層を作ります
そして それに結合する
２つの層を付けます
それから 予測を出します
このモデルを皆さんと一緒に
ビルドして 不具合を探し
TensorBoard をより理解するための
使い方を探っていきます
では その一連のコードをお見せします
ざっと通しますが
GitHub に GIst として
投稿してありますので
今はコードをすべて把握できるかと
心配する必要はありません
そのリンク先は最後にお伝えします
では TensorFlow 内の
層をまとめることから始めましょう
まず 畳み込み層を入れたいので
ウェイトとバイアスの
２つの変数を作ります
そして 畳み込みオペレーションを
適用させます
ランプ関数 / ReLUを畳み込み + バイアスに
適用して返します
それから全結合層を作ります
これもシンプルです
もう一度 ウェイトとバイアスを入れます
行列の乗法と加法の
ランプ関数を実行して返します
複数の層ができたので

Spanish: 
Va a tener un par
de capas de circunvolución
y de pooling en la parte superior.
Va a tener dos capas
totalmente conectadas.
Y luego nos dará la predicción.
Vamos a construir este modelo
y explorar qué puede salir mal
y cómo podemos utilizar TensorBoard
para comprenderlo mejor.
Estoy a punto de mostrar mucho código.
Voy a pasar por él rápidamente.
No tienen que preocuparse
por ver todo el código ahora
porque el código estará
publicado en mi GitHub
y también vamos
a tuitear el enlace al final.
Para empezar, vamos a tomar
algunas capas de TensorFlow.
Voy a tener 
una capa de circunvolución.
Voy a hacer dos variables,
con los pesos y los sesgos.
A continuación voy a
aplicar el op circunvolucional
aplicamos una reLU a la circonvolución
además de los sesgos y luego regreso eso.
Después vamos a hacer
una capa totalmente conectada.
Esto es más simple.
Una vez más, tenemos pesos y sesgos.
Vamos a hacer el reLU de la multiplicación
y suma de matrices y lo regresamos.
Ya que tenemos algunas capas

Indonesian: 
Ada lapisan konvolusional
dan pooling di atasnya.
Ada dua lapisan yang
tersambung sepenuhnya.
Lalu ia akan membuat prediksi.
Kita akan membangun model ini
bersama-sama dan mengenal kesalahan
dan cara pakai TensorBoard
untuk lebih memahaminya.
Saya akan tunjukkan kumpulan kode.
Saya akan membahasnya dengan cepat.
Kini tak perlu khawatir
mengingat semua kode
karena akan diposting
di GitHub saya sebagai sebuah gist
juga kami akan tweet tautannya
di akhir nanti.
Pertama, mari gabungkan beberapa
lapisan di TensorFlow.
Ingin ada lapisan konvolusional.
Kita akan buat dua variabel.
Variabel ini akan punya weight dan bias.
Kita akan terapkan operasi konvolusional
kita akan terapkan reLU
ke convolution dan bias
lalu mengembalikannya.
Kita akan buat lapisan yang
terhubung sepenuhnya.
Ini sangat sederhana.
Sekali lagi, kita punya weight dan bias.
Kita akan lakukan perkalian
dan pertambahan matriks reLu
dan mengembalikannya.

English: 
It's going to have a
couple convolutional
and pooling layers at the top.
And then it's going to have
two fully connected layers.
And then it's going to
spit out our prediction.
And we're going to just build
this model together and explore
what can go wrong and how
we can use TensorBoard
to better understand it.
So I'm about to show
a bunch of code.
I'm going to go through
it kind of quickly.
You don't need to worry
about getting all the code
right now because it's posted
on my GitHub as a gist,
and we'll also tweet
out the link at the end.
So to start, let's put together
some layers in TensorFlow.
So we wanted to have
a convolutional layer.
So we're going to
make two variables.
These will have the
weights and the biases.
We're going to then apply
the convolutional op,
we're going to apply a
reLU to the convolution
plus the biases, and
then we return that.
Then we're going to make
a fully connected layer.
This is even simpler.
Once again, we have
weights and biases.
We're going to do the reLU
of the matrix multiplication
and addition, and
we return that.
Now that we have some
layers, we can set up

English: 
the feed-forward
part of our network.
We have some input placeholders
which we'll just take
in our images and our labels.
We'll reshape the image so that
it actually looks like a 28
by 28 pixels so we
can convolve on it.
Then we'll start putting
together our layers.
We've got the two
convolutional layers.
We flatten it, we get the
two fully connected layers.
And that's basically
our whole network.
And finally, we need
to compute the loss
and start to actually
train things.
So we're going to use cross
entropy for our loss function.
We're going to use an Adam
optimizer to do the training
step.
And just for convenience,
we'll record the accuracy
so that we can print
that out to the console.
So finally, we just need
to do a little bit of work
to turn this model on.
We're going to iterate--
we're going to initialize
all of the variables.
Then we're going to do
2,000 steps of training.
For each step, we're going
to take an [INAUDIBLE]
of the MNIST training data.
Occasionally, we're going
to report the accuracy
so we can see if it's working.
And then finally, we'll
run the training step.
So we have our model.

Spanish: 
podemos establecer
la retroalimentación de la red.
Tenemos algunos placeholders
de entrada que solo tomaremos
en nuestras imágenes y etiquetas.
Vamos a redimensionar la imagen
para que tenga 28 por 28 pixeles
y podamos aplicar la circunvolución.
Después vamos a empezar
a armar nuestras capas.
Tenemos las
dos capas de circunvolución.
Las aplanamos y tenemos
las dos capas totalmente conectadas.
Y esa es básicamente toda nuestra red.
Por último, tenemos que calcular
la pérdida y empezar a entrenar todo.
Utilizaremos la entropía cruzada
para nuestra función de pérdida.
Vamos a utilizar un AdamOptimizer
para hacer el entrenamiento.
Y solo por conveniencia
registraremos la exactitud
para poder imprimirla en consola.
Ya solo hay que hacer un poco de
trabajo para echar a andar el modelo.
Vamos a iterar, 
a inicializar todas las variables.
Después vamos a hacer
2,000 pasos de entrenamiento.
Para cada paso, vamos a tomar un conjunto
de datos de entrenamiento de MNIST.
De vez en cuando,
informamos la precisión
para que veamos si está funcionando.
Y, por último, vamos a ejecutar
la etapa de entrenamiento.
Ya tenemos nuestro modelo.

Chinese: 
我们便可以建立网络的前馈部分
我们有一些输入占位符
用它可以添加图片和标记
我们重新界定图片尺寸为28x28像素
这样便可以在上面进行卷积
然后我们将层建在一起
我们有了两个卷积层
使它扁平化，获得两个完全联通的层
这就是整个网络
然后我们需要计算损失
并开始训练
我们对损失函数使用交叉熵
我们使用亚当优化器（AdamOptimizer）进行训练
出于方便，我们会记录准确度
以在控制器上输出
最后，我们还差最后一步
便可以启动这个模型
我们将初始化所有变量
然后进行2000步训练
每一步我们都会记录
MNIST训练数据
有时，我们会报告准确度
看看是否正常运转
最后，我们会运行训练步骤
让我们启动这一程序

Korean: 
우리 네트워크 피드포워드
부분을 만듭니다
입력 플레이스홀더가 있고
거기에 이미지와 라벨을 넣습니다
이미지를 28 x 28 픽셀로
보이도록 수정해
둘러쌀 수 있도록 만듭시다
그리고 레이어를 함께 넣고
두 나선형 레이어가 있습니다
이걸 평면화하면
완전히 연결된 레이어가 두 개 생겨요
이게 기본적인 우리 네트워크입니다
그리고 손실을 계산해야 하고
실제로 훈련해야 해요
그래서 손실 함수를 위해
크로스 엔트로피를 사용할 거예요
AdamOptimizer를 사용해
훈련합니다
그리고 편리성을 위해 정확도를 측정하여
그걸 콘솔에 출력하도록 합니다
마지막으로, 이 모델을 활성화하려면
약간의 작업이 필요해요
반복할 거예요
모든 변수를 개시할 거예요
그리고 훈련 2,000단계를 거치고요
각 단계 마다 MNIST 훈련 데이터를
[청취불가]할 거예요
때때로 정확도를 보고해서
작동하는지 확인 할 수 있어요
마지막으로 훈련 과정을 실시합니다
우리 모델이 있죠

Portuguese: 
Agora que temos algumas camadas, podemos
configurar a parte pré-alimentada da rede.
Temos alguns marcadores de input que vamos
levar às nossas imagens e etiquetas.
Vamos redimensionar a imagem 
para que se pareça com 28 por 28 pixels
para que possamos convolucionar nela.
Então vamos começar juntando as camadas.
Temos duas camadas convolucionais.
Nivelamos para obter duas camadas
inteiramente conectadas.
Isso basicamente é nossa rede toda.
Finalmente precisamos computar a perda
e começar a realmente treinar as coisas.
Então vamos usar entropia cruzada
para nossa função de perda.
Vamos usar um otimizador Adam
para fazer o passo de treinamento.
E só por conveniência, vamos gravar 
a exatidão, para imprimir ao console.
Então precisamos trabalhar um pouco
para ligar esse módulo.
Vamos iterar;
inicializar todas as variáveis.
Então vamos fazer 
2.000 passos de treinamento.
Para cada passo vamos pegar um lote
de dados de treinamento MNIST.
Depois vamos reportar a exatidão
para vermos se funciona.
E finalmente vamos rodar
o passo de treinamento.
Então temos nosso modelo.

Japanese: 
ネットワークの先行予測を
セットアップできます
画像とラベルを入れるための
プレースホルダーがあります
その画像を作り直します
実際 28 ×28 ピクセルに見えれば
そこに畳み込むことができます
それから層をまとめ始めましょう
２つの畳み込み層がありますので
それを平らにすると
２つの完全結合層が得られます
これが基本的なネットワークの全容です
最終的に その損失を計算して
実際にトレーニングを始める必要があります
なので 損失関数のためには
交差エントロピーを使います
トレーニングのステップを踏むためには
Adam オプティマイザを使います
コンソールに表示できるように
正確度を記録して行きましょう
最後は このモデルを返すための
作業を少し行います
すべての変数を初期化します
それから 2000 の
トレーニング段階を踏みます
それぞれの段階に山ほどの
MNIST トレーニングデータを使います
時には正確度を報告して
動作を確認します
それから やっと
トレーニングの実行です
モデルはできたので
次にいきましょう

Indonesian: 
Setelah ada beberapa lapisan,
kita atur feed-forward dari jaringan kita.
Kita punya penampung input
yang kita ambil pada gambar dan label.
Kita bentuk ulang gambarnya
agar terlihat seperti 28/28 pixel
agar kita bisa menggabungnya.
Mari mulai gabungkan lapisan kita.
Kita punya dua lapisan konvolusional.
Kita ratakan, ada dua lapisan
yang terhubung sepenuhnya.
Itu adalah keseluruhan jaringan kita.
Akhirnya, kita harus menghitung loss
dan mulai melatih.
Kita akan gunakan entropi silang
untuk fungsi loss.
Kita akan gunakan pengoptimal Adam
untuk melakukan langkah pelatihan.
Agar praktis, kita akan rekam akurasi
sehingga kita bisa mencetaknya ke konsol.
Akhirnya, perlu sedikit sentuhan
untuk menghidupkan model ini.
Kita akan memulai seluruh variabelnya.
Lalu, kita akan melakukan
2.000 langkah latihan.
Tiap langkah, kita akan ambil
[tidak terdengar] dari data latihan MNIST.
Terkadang, kita akan melaporkan akurasi
agar kita tahu itu berfungsi.
Akhirnya, kita akan melakukan
langkah latihan.
Kita sudah punya model.

English: 
Let's turn it on.
At zero step, it
has 10% accuracy.
That seems about right.
At step 500, it
has 12% accuracy.
Not exactly what
we were hoping for.
And then it even goes down.
And we can see really, this
model didn't learn anything.
It's just getting baseline
10% by random guessing.
So what are we going to do
about this broken model?
Well, I just said we
have a flashlight,
so let's turn it on.
And the first thing
we might want to do
is visualize the computational
structure of our TensorFlow
graph.
Because we spent all
this code setting it up,
but what if it's miswired?
What if somehow we just
didn't make the connections
or the computation we expected?
So we're going to need
something called--
we're going to need a class
that lets us write data
from TensorFlow to disk so that
we can read it TensorBoard.
And that class is
called the FileWriter.
It basically just
writes any information
you're going to
visualize in TensorBoard.
And to visualize the
graph, it's very simple.
We set up the FileWriter.
We give it a directory.
And then we add to our
sessions graph to that writer.

Korean: 
실행해봅시다
0단계에서, 정확도는 10%입니다
그렇게 보이네요
500단계에서 정확도는 12%입니다
우리가 원하는 수준은 아니죠
더 해봅시다
보면, 이 모델은 아무것도
습득을 못했네요
무작위 추측으로 10%정도만 나타내죠
이 망한 모델을 어떻게 할까요?
제가 플래시등이 있다고 했죠
그걸 켜볼까요
제일 처음 해야할 것은
TensorFlow 그래프의
컴퓨터 구조를 시각화하는 것입니다
이 모든 코드를 설치했지만
이게 잘못 연결되었을 수 있으니까요
혹은 연결을 짓지 않았거나
우리가 예상했던 계산을
넣지 않았을 수도 있죠
그래서 뭔가가 필요한데요
우린 TensorFlow에서 디스크로
데이터를 쓰게 해줄 클래스가 필요해요
그럼 TensorBoard로
읽을 수 있거든요
이 클래스는 FileWriter입니다
기본적으로 정보를 쓰는 겁니다
TensorBoard에 시각화할게요
그래프 그리는 것은 매우 간단해요
FileWriter를 넣고
디렉토리를 만듭니다
그리고 그 Writer에
우리 세션 그래프를 줍니다

Japanese: 
[ モデルを実行して...]
０の段階では
正確度は 10 % です
正しい気がしますね
500 段階で
正確度は 12 % です
これは希望どおりではありません
正確度が低いままなら
このモデルは
なにも学習していないようです
当てずっぽうに予想した
10 % の基線が結果として出たのです
では この破たんしたモデルを
どうすればいいでしょう？
照らす光がありましたよね
点けてみましょう
まず最初に
TensorFlow グラフの計算構造を
視覚化したいですよね
全コードを使ってセットアップしたのに
接続ミスだったら？
結合や期待された計算が
作成されてなかったら？
なので 必要なのは
この様な
TensorFlow からのデータを
ディスクに書き込むクラスです
そうすれば
それを TensorBoard で読めます
そのクラスこそ FileWriter です
TensorBoard に視覚化する情報なら
基本的にすべて書きます
グラフの視覚化は非常に簡単です
FileWriter をセットアップして
ディレクトリを入れ
ライターにグラフのセッションを
加えるだけです

Indonesian: 
Mari hidupkan.
Pada langkah nol, ia punya 100% akurasi.
Sepertinya, itu benar.
Pada langkah 500, ia punya 12% akurasi.
Itu bukan yang kita harapkan.
Bahkan terus menurun.
Bisa dilihat, model ini tak
mempelajari apapun.
Ia hanya memperoleh baseline
10% dengan tebakan acak.
Apa yang akan kita lakukan dengan
model rusak ini?
Saya katakan bahwa kita punya senter,
ayo nyalakan.
Yang pertama kita lakukan adalah
menggambar struktur komputasi
dari grafik TensorFlow.
Kita menulis semua kode
untuk menyetelnya
bagaimana jika keliru?
Bagaimana jika kita tak menghubungkannya
atau menghitungnya sesuai harapan?
Kita butuh kelas agar kita bisa
menulis data dari TensorFlow ke disk
sehingga kita bisa membacanya
di TensorBoard.
Kelas itu disebut FileWriter.
Utamanya, ia hanya menulis informasi
yang akan digambarkan di TensorBoard.
Buat grafik visualisasi
sangat sederhana.
Kita atur FileWriter.
Kita berikan direktori.
Lalu kita tambahkan grafik
sesi ke writer itu.

Portuguese: 
Vamos ligar.
No passo zero tem 10% de exatidão.
Parece certo.
No passo 500 tem 12% de exatidão.
Não é exatamente o que esperamos.
E então chega até a cair.
Podemos ver que este modelo 
realmente não aprendeu coisa alguma.
Está apenas obtendo 10% de parâmetro
através de palpites aleatórios.
O que vamos fazer 
com este modelo quebrado?
Bem, acabei de dizer 
que temos uma lanterna,
então vamos ligar e começar 
visualizando a estrutura computacional
do nosso gráfico TensorFlow.
Porque gastamos todo esse código,
mas e se algo está fora do lugar?
E se não fizemos as conexões
ou a computação que esperávamos?
Vamos precisar de algo chamado...
Uma classe que nos deixa
gravar dados do TensorFlow no disco
para lermos no TensorBoard.
E essa classe se chama FileWriter.
Basicamente escreve qualquer informação
que você vai visualizar no TensorBoard.
E para visualizar o gráfico 
é muito simples.
Configuramos o FileWriter.
Damos a ele um diretório.
E adicionamos 
o gráfico da sessão ao gravador.

Spanish: 
Vamos a ejecutarlo.
En el paso cero, tiene 10% de precisión.
Eso parece bastante bien.
En el paso 500, hay un 12% de precisión.
No es exactamente lo que esperábamos.
Y entonces, incluso se pone peor.
Y podemos ver que
este modelo no aprendió nada.
Está alrededor
del 10% por adivinar al azar.
Entonces, ¿qué vamos a hacer
con este modelo fallido?
Acabo de decir que tenemos
una linterna, vamos a encenderla.
Y lo primero que podría querer hacer
es visualizar la estructura computacional
de nuestra gráfica de TensorFlow.
Pasamos todo ese tiempo
creando el código pero
¿y si está conectado incorrectamente?
¿Qué tal si algo que hicimos está mal
y no hace las conexiones y los cálculos?
Vamos a necesitar algo llamado:
clase que nos permita escribir datos
de TensorFlow al disco
para que podamos leerlos en TensorBoard.
Esa clase se llama FileWriter.
Básicamente guarda cualquier información
que se visualice en TensorBoard.
Y visualizar el gráfico, es muy simple.
Tenemos el FileWriter.
Le damos un directorio.
Entonces lo añadimos
a nuestro gráfico de sesiones.

Chinese: 
第0步时它有10%的准确度
这是正常情况
第500步时，12%的准确度
这不完全是我们想要的
甚至还会下降
可以看到这一模型什么都没学到
只是通过随机猜测得到10%的最低准确度
如何修复这种有问题的模型？
刚刚讲过我们有可以利用的
帮助办法
要做的第一件事，可能就是
显现TensorFlow图表的
计算结构
我们写了这么多代码
万一有地方出错了呢？
万一我们没有做好想要的
连接或是运算？
所以我们需要一个类
让我们可以从TensorFlow写数据到硬盘
以方便在TensorBoard读取
这个类叫做FileWriter
它会写入任何
你将在TensorBoard显现的信息
显现图表是很容易的
我们建立FileWriter
给它添加目录
然后给这个写手添加会话图

Portuguese: 
Agora ligamos o TensorBoard.
Ele vem pré-instalado no pacote PIP.
Você pode escrever TensorBoard
na linha de comando e passar um logdir.
E isso nos leva à nossa
primeira demonstração.
Que está...
Aqui.
Não tem escala, 
nem informação, nem imagens.
A única coisa que temos é um gráfico.
Então podemos ir à aba do gráfico.
E vemos algo realmente confuso.
Posso meio que ver como
corresponde ao gráfico que fizemos.
Na esquerda temos uma convolução, um pouco
de adição, uma retificação, conjugação.
Mas também tem essas partes
que eu não sei de onde vieram,
mesmo que eu tenha criado o gráfico.
O que vemos aqui é que os gráficos
do TensorFlow são muito complicados.
E para fazermos essa ferramenta
nos dar uma visão útil,
precisamos trabalhar um pouco 
para estruturar o gráfico.
Basicamente precisamos limpar o gráfico.
Talvez você saiba,
todo gráfico TensorFlow

English: 
And now finally, we just
turn on TensorBoard.
It comes pre-installed
in the PIP package,
so you can just, at
the command line,
write TensorBoard
and pass it a logdir.
And that brings us to our
first demo, which is here.
So it has no scale or
information, has no images.
The only thing we
gave it is a graph.
So we can go to the graph tab.
And we get something that's
really quite confusing.
So I can kind of see
how this corresponds
to the graph we made.
Because maybe we see on the
left we've got a convolution,
we've got some addition, we've
got a reLU, we've got pooling.
But it also has all of
these parts that I really
don't have any idea where they
came from even though I just
made the graph myself.
So what we're seeing here
is that TensorFlow graphs
are really complicated.
And the way that we can get
this tool to actually give us
useful insight, we need
to do a little bit of work
to structure the graph.
So essentially, we need
to clean the graph.
Now you may know that every
TensorFlow graph is based

Spanish: 
Y ejecutamos TensorBoard.
Viene preinstalado en el paquete PIP.
Puedes escribir en la línea de comandos
"tensorboard" y pasarle el directorio log.
Y eso nos lleva a nuestro primer demo
que está aquí.
No tiene escalas ni información,
no tiene imágenes.
Lo único que sale es una gráfica.
Vamos a la pestaña de gráficos.
Y obtenemos algo que
es realmente muy confuso.
Puedo ver cómo se corresponde
al gráfico que hicimos
porque a la izquierda
tenemos una circunvolución
tenemos algunas sumas
un RELU, el pooling.
Pero también tiene todas estas partes
que no tengo idea de dónde vengan
a pesar de que yo mismo la hice.
Lo que vemos aquí es
que los gráficos de TensorFlow
son realmente complicados.
Y para poder usar esta
herramienta para tener información útil
hay que hacer un poco de trabajo
para estructurar el gráfico.
En sí, tenemos que limpiar el gráfico.
Tal vez sepan que
cada gráfico de TensorFlow

Japanese: 
すると TensorBoard を
オンにするだけで
それが PIP パッケージに
プレインストールされますので
コマンドラインに
TensorBoard を書くだけで
LogDir に渡されます
ということで最初のデモです
それは... こちらです
ここにはスケールも画像もなく
グラフの情報だけがあります
なので GRAPH タブにいきます
そして 出てきたのは
とてもゴチャゴチャしていますね
作成したグラフに対応するものは
一応 見てとれます
左側を見ると
畳み込みがあって 追加事項があって
ランプ関数に プーリングもあります
自分でグラフを作ったのに
どこから 持って来たのか
全く心当たりのない部分もあります
TensorFlow グラフが
実に複雑なのがわかりますね
このツールを使うことで
実に便利な洞察力が持てます
グラフを構成するには
少し作業が必要ですね
まず このグラフを
わかりやすくする必要があります
ご存知だと思いますが
全ての TensorFlow グラフは
このネーミングシステムに基づいています

Indonesian: 
Akhirnya, kita hidupkan TensorBoard.
Ia sudah terpasang di paket PIP
bisa ditambahkan di command line
tulis TensorBoard dan beri logdir.
Itu menghantarkan kita ke
demo pertama yang berada--
di sini.
Tak punya skala atau informasi,
tak punya gambar.
Kita hanya perlu memberi grafik.
Kita bisa menuju ke tab grafik.
Kita menemukan sesuatu yang
lumayan membingungkan.
Saya tahu hubungannya
dengan grafik yang kita buat.
Mungkin karena di sisi kiri
ada convolution,
beberapa tambahan, reLU, pooling.
Tapi ia memiliki seluruh bagian ini
yang saya tak tahu sumbernya
walau saya sendiri yang membuat grafiknya.
Terlihat di sini bahwa grafik
TensorFlow sangat rumit.
Untuk membuat alat ini
memberikan kita wawasan bermanfaat
kita harus beri sedikit sentuhan
pada struktur grafiknya.
Terutama, kita harus bersihkan grafiknya.
Anda mungkin tahu bahwa
semua grafik TensorFlow
berdasarkan sistem penamaan ini

Chinese: 
现在，只需启动TensorBoard
它已在PIP包裹中预安装
在命令行里
你可以直接写TensorBoard，给它一个logdir
接下来就是我们的第一个展示
就在这
它没有等级，也没有信息或图片
我们只给了它一个图表
我们进入图表栏
看到一个非常难懂的图表
我大概能看懂这和
我们做的图表有什么联系
在左边，我们有卷积
有加法，reLU，还有池化
但它也有这些我不知道
从哪里来的部分
尽管这是我制作的图表
我们可以看到
TensorFlow非常复杂
如何能让这个工具给我们有用的内容？
我们需要想办法
给表格赋予结构
也就是说，我们需要清理图表
你可能知道，每个TensorFlow图表

Korean: 
마지막으로 TensorBoard를
실행하죠
이건 PIP 패키지에
사전 설치되어 있어요
그래서 명령 줄에
TensorBoard를 쓰고
logdir로 넘깁니다
그럼 첫 데모가 이렇게 나타납니다
스케일, 정보, 이미지가 없어요
그저 그래프만 넣었어요
그래프 탭으로 갈 수 있어요
꽤 혼란스러운 게 있는데요
우리가 만든 그래프가
어떻게 대응되는지 볼 수 있어요
왼쪽에서 볼 수 있듯이 나선을 가져요
추가가 있고 reLU와 풀링이 있죠
사실 제가 그래프를 만들었는데도
어디서 왔는지 모를 부분들도 있네요
여기서 볼 수 있는 것은
TensorFlow 그래프가
매우 복잡하단 것입니다
이 도구를 활용해 유용한
인식을 얻어내려면
그래프를 구조화하는 작업을 거쳐야합니다
기본적으로, 그래프를 깔끔하게 해야해요
모든 TensorFlow그래프가

Indonesian: 
di mana terdapat operasi dan punya nama.
Bisa dikendalikan dengan
memberi nodus tersendiri
nama spesifik dan dengan mengatur
cakupan nama
yang menyebabkan semua grup operasi
terhubung memiliki
struktur penamaan yang sama.
Mari aplikasikan ke model
yang baru saja kita buat.
Pertama, di definisi lapisan, kita
akan mengambil beberapa operasi penting,
seperti variabel, dan beri
nama yang jelas,
seperti W untuk Weight dan B untuk Bias.
Kita akan aplikasikan cakupan nama
ke semua lapisan jadi semua
operasi konvolusional
tetap mengelompok dan juga
di lapisan yang terhubung sepenuhnya.
Lalu, saat kita mengatur grafik
kita beri nama pada stakeholder.
Kita gunakan fungsi ini untuk memberi
cakupan nama ke lapisan kita.
Terakhir, tambahkan cakupan nama
ke pelatihan dan komputasi loss
dan seterusnya.
Setelah kita melakukannya,
kita bisa membuat ringkasan lain
di mana FireWriter menunjuk
ke direktori lain.
Pakailah direktori berbeda dengan
TensorBoard agar data tetap terpisah.
Kita hidupkan TensorBoard yang
menunjuk ke direktori itu.

English: 
on this naming system
where it has these ops
and the ops have names.
We can control the names
by giving individual nodes
specific names and by setting
up names scopes, which
cause all groups of related
ops to have the same naming
structure.
So let's go and apply that
to the model we just built.
First, in our layer
definition, we're
going to take a couple
ops that are important,
like the variables, and
give them explicit names,
like W for Weights
and B for Biases.
And then we're going
to apply name scopes
to the entire layers so that
all of our convolutional ops
will stay grouped and likewise
in the fully connected layer.
Then, when we actually
set up our graph,
we pass a couple of more names,
like giving the placeholders
names.
And we use this function to
give name scopes to our layers.
And finally, we add a
couple of names scopes
to the training and the loss
computation and so forth.
So now that we've
done that, we can
construct another summary
FileWriter pointing
at a different directory.
You always want to use
a different directory
with TensorBoard to
keep data separated.

Japanese: 
オペレーションが存在し
オペレーションには名前付いています
これはオペレーションに関する全グループに
同じ名前を与えるためのもので
個別にノードや特定の名前を入れ
名前空間をセットアップすることで
名前をコントロールできます
では ビルドしたモデルを
これに適用しましょう
まず 層の定義に この変数のように
２つの重要なオペレーションを採用します
「ウェイトは w」「バイアスは b」のように
わかりやすい名前を付けます
それから 名前空間を層全体に適用すると
すべての畳み込みオペレーションが
グループ化したままになります
これは全結合層も同じです
そして グラフを実際に
セットアップする際は
プレースホルダ名を付けるように
名前を２つ渡します
この関数を使って名前空間を
層に付けます
そして最終的には
名前空間を２つ追加して
トレーニングや損失計算などに使います
では それが済んだので
他のディレクトリでも
FileWriter を指定するサマリーを
組み立てることができます
データを分散して保持するために
違うディレクトリも
TensorBoard に使いたいですよね
ですので ディレクトリを指定する
TensorBoard をオンできます

Korean: 
ops가 있고 이름을 가지는 시스템에
기반해있단 게 보이시죠
이름을 관리하기 위해서
개별적 노드에 특정 이름을 부여하고
관련된 ops 묶음이
같은 이름 구조를 가질 수 있게 합니다
가서 우리가 방금 만든
모델에 적용합시다
먼저, 레이어 정의에서
변수처럼 중요한 ops를 선택하여
Weights의 W, Biases의 B처럼
분명한 이름을 부여합니다
그리고 전체 레이어에 이름 범위를 주고
우리 모든 나선형 ops가 그룹으로
완전히 연결된 레이어에 있도록 합니다
그럼 그래프를 설정할 때
플레이스홀더의 이름을 부여하듯
더 많은 이름을 넘겨줍니다
이 기능을 사용해 우리 레이어에
이름 범위를 줍니다
마지막으로, 훈련과 손실 계산 등에
이름 범위를 추가합니다
이제 그걸 끝냈으면
FileWriter가
다른 디렉토리를 가리키는
다른 개요를 만들 수 있어요
TensorBoard에서
데이터를 분리해 유지하려면
항상 다른 개요를 사용할 것입니다
그 디렉토리를 가리키는
TensorBoard를 켭니다

Portuguese: 
é baseado nesse sistema
onde as ops têm nomes.
Podemos controlar dando
nomes específicos a nós individuais
e configurando atribuições de nomes
para que todos os grupos de ops
relacionadas tenham a mesma
estrutura de nome.
Vamos aplicar isso
ao modelo que construímos.
Primeiro, na definição de camada,
vamos levar algumas ops importantes,
como as variáveis, 
e dar-lhes nomes específicos,
como W para pesos e B para tendências.
Então vamos aplicar 
atribuições de nome às camadas
para que todas as nossas ops
convolucionais estejam agrupadas
e do mesmo todo por toda a camada.
Então, quando configuramos nosso gráfico,
passamos mais alguns nomes,
por exemplo dando nomes aos marcadores.
E usamos essa função para dar 
atribuições de nome às nossas camadas.
E adicionamos algumas atribuições de nomes
à computação de treinamento e de perda.
Agora que fizemos isso, vamos construir
outro sumário de FileWriter
apontando para um diretório diferente.
Sempre usamos diretórios diferentes
para manter os dados separados
no TensorBoard.

Chinese: 
都是基于这个命名系统
这些运算都有命名
我们控制命名的方式是
为每个节点命名
并建立名称范围
这会让所有相关的运算组
拥有同样的命名结构
让我们将这应用在刚刚建好的模型上
首先，在层定义里
我们会给一些重要的运算
例如变量，给他们明确的命名
比如，W就是权重
B是偏差
然后应用名称范围到整个层
由此所有的卷积运算会分好组
在完全联通的层里也会分好组
然后，在建立图表时
我们加入更多的名称
例如为占位符命名
我们用这个函数为层添加名称范围
最后，我们添加一些名称范围
到训练和损失运算中去
现在我们可以让另一个概要FileWriter
指向一个不同的目录
我们应当在TensorBoard利用不同的目录
使数据保持分离

Spanish: 
se basa en este sistema de nomenclatura
donde están estas operaciones
y las operaciones tienen nombres.
Podemos controlar los nombres
con nodos individuales
nombres específicos y
con nombres para los alcances
lo que hace que todos los grupos
de operaciones relacionados
tengan el mismo nombre
en la estructura.
Apliquemos esto al modelo
que acabamos de construir.
En primer lugar, en la definición de capas
tomamos un par de operaciones
que son importantes
como las variables y les
damos nombres explícitos
como "W" para pesos y "B"para sesgos.
Y luego aplicamos nombres
de alcance a todas las capas
y así nuestras operaciones
circonvolucionales estarán agrupadas
y lo mismo para la capa
totalmente conectada.
Entonces, ya tenemos nuestra gráfica
agregamos un par de nombres más,
a los placeholders.
Y utilizamos esta función para
dar nombres de alcance a nuestras capas.
Y, por último, añadimos
un par de nombres de alcances
al entrenamiento y al cálculo
de la pérdida.
Ya que tenemos esto,
podemos crear otro FileWriter
apuntando a un directorio diferente.
Siempre usen un directorio
diferente con TensorBoard
para mantener los datos separados.

Indonesian: 
Kini kita punya grafik yang jauh
lebih baik.
Lihat di sini, ini
mulai berhubungan secara bermakna
dengan grafik yang kita pikirkan.
Ada blok pelatihan ini, yang
terhubung dengan semuanya.
Itu karena ketika Anda menghitung gradien,
Anda harus berhubungan dengan
tiap variabel di grafik.
Untuk sekarang kita pindahkan ke sisi
karena itu tidak menarik bagi kita.
Kita bisa jelajah dan katakan, kita
punya placeholder x kita.
Bentuk ulang datanya.
Lalu telusuri tiap lapisan
konvolusional ini
di mana ada beberapa variabel.
Kita punya convolution dan penambahan.
Kita bisa pindai grafik
dan perhatikan semua yang dihubungkan
sesuai harapan kita.
Saya akan sebutkan fitur
dari penggambaran grafik.
Masalahnya, jelas, Anda
bisa jelajahi lapisan berbeda dari
tingkat abstraksi
dengan menyelam ke
bagian-bagian tersendiri.
Kita bisa menyelam lebih dalam.
Di sini, kita peroleh mekanik
dari komputasi entropi silang.
Rupanya semua yang terpotong ini
adalah untuk komputasi entropi silang.
Anda akan lihat kotak yang berbeda
memiliki warna yang berbeda.

English: 
And we can turn on TensorBoard
pointing in that directory.
And now we get a
much nicer graph.
So you can see here
that this actually
starts to correspond pretty
meaningfully to the graph
that we had in mind.
We have this
training block, which
is connected to everything.
That's because when you are
computing the gradients,
you need to connect to
every variable in the graph.
But maybe for now we'll
move it to the side
because it's not as
interesting to us.
And now we can kind of
explore and say, OK, we
have our x placeholder.
We reshaped the data.
Then we go through each of
these convolutional layers
where we have some variables.
We have the convolution
and the addition.
And we can kind of
scan through a graph
and see that everything is wired
up the way that we expected.
Now, I'll point
out a few features
of the graph visualizer.
One thing is, as
you've noticed, you
can explore different layers
of levels of abstraction
by diving into
individual pieces.
And we can dive in further.
And here, we're
getting the mechanics
of computing cross entropy.
It turns out all of
this sliced stuff
was for computing cross entropy.
Also, you'll notice
that different boxes
have different colors.

Spanish: 
Ejecutamos TensorBoard
apuntando a ese directorio.
Ahora tenemos un gráfico
mucho más agradable.
Se puede ver que de hecho
empieza a corresponder bastante
a la gráfica que teníamos en mente.
Tenemos este bloque de entrenamiento
que está conectado a todo.
Eso es porque al calcular los gradientes
necesita conectarse
a todas las variables de la red.
Pero por ahora vamos a dejarlo
de lado porque no nos interesa ahora.
Ahora podemos analizar y ver
que tenemos nuestro placeholder x.
Hemos reconfigurado los datos.
Luego pasamos por
estas capas circonvolucionales
donde tenemos algunas variables.
Tenemos la circonvolución y la suma.
Y podemos navegar por el gráfico
y ver que todo
esté conectado como queremos.
Voy a señalar algunas características
del visualizador gráfico.
Como ven, pueden explorar
diferentes capas de niveles de abstracción
al entrar en piezas individuales.
Podemos entrar más.
Y aquí llegamos al cálculo
de la entropía cruzada.
Resulta que todo esto es para
el cálculo de la entropía cruzada.
Además, verán que diferentes
cajas tienen diferentes colores.

Japanese: 
グラフがとても良くなりました
このグラフが実際に
期待どおりになってきていますね
トレーニングのブロックが
全てにつながっています
これは素材を計算する際に
グラフ内のすべての変数が必要だからです
これは面白味がないので
ここでは端に移動させます
例えば この様に見ていくこともできます
X のプレースホルダがあるし
データも再編集した
変数の入った畳み込み層も
それぞれ ひととおり網羅した
畳み込みと追加もあり
グラフをひととおり確認できて
すべてが期待どおりに
つながっているのを確認できます
では グラフビジュアライザーの
機能に注目します
お気づきのように
それぞれの部分に潜入すると
概要のレベルで
その層をいろいろと探ることができます
もっと深くも潜入できます
ここは交差エントロピーの
計算機能ですね
この出てきたものは
すべて交差エントロピーの計算用です
また ボックスごとに色が違っていますが

Portuguese: 
E ligamos o TensorBoard, 
apontando para aquele diretório.
E agora temos um gráfico muito mais legal,
que começa a corresponder 
bastante ao gráfico que temos em mente.
Temos esse bloco de treinamento,
que está conectado a tudo.
Porque quando você está 
computando os gradientes,
precisa conectar 
a todas as variáveis no gráfico.
Mas por enquanto vamos mover isso de lado
porque não interessa para nós.
E agora podemos explorar e dizer
"ok, temos nosso espaço reservado X".
Reformulamos os dados e vamos 
a cada uma dessas camadas convolucionais
onde temos algumas variáveis.
Temos a convolução e a adição.
Podemos passar os olhos pelo gráfico
e ver que tudo é conectado
do jeito que esperamos.
Agora mostrarei algumas características
do visualizador de gráfico.
Como podem notar, é possível explorar
camadas diferentes de níveis de abstração
mergulhando em pedaços individuais.
E podemos mergulhar mais ainda.
Aqui estamos pegando a mecânica 
de computar entropia cruzada.
No fim, todas essas coisas divididas
eram para computar entropia cruzada.
Você também vai notar
que as caixas têm cores diferentes.

Korean: 
이제 더 좋은 그래프가 나왔죠
이로써 우리가 생각한 그래프와
꽤 밀접하게 대응하기 시작하는 게
보이실 겁니다
이 훈련 블록이 있는데요
이것은 모든 것과 연결되어 있습니다
그래서 그레디언트를 구현할 때
그래프 안의 모든 변수를
연결해야 합니다
하지만 지금은 이건 내버려둡니다
이게 그렇게 흥미롭지 않으니까요
이제 조금 탐색해보고
우리 x 플레이스홀더를 추가합시다
데이터를 재형상화합니다
이 나선형 레이어들을 따라갑니다
여기 변수가 좀 있네요
여기 나선과 첨가된 게 있습니다
그럼 그래프를 둘러볼 수 있고
우리가 바라던 대로
모든 게 연결되어 있죠
그래프 비주얼라이저의
몇 가지 기능을 짚어보겠습니다
눈치채셨겠지만 각 단위로 들어가서
다른 추출 수준의 레이어를
탐색할 수 있습니다
더 깊이 들어갈 수 있죠
컴퓨팅 크로스 엔트로피 개념이 사용되죠
이 조각난 부분들이 모두
컴퓨팅 크로스 엔트로피를 위한 거죠
또한, 다른 박스는
다른 색을 띄는 게 보이시죠

Chinese: 
我们可以启动TensorBoard
让它指向那个目录
现在这个图表更易懂
这里你可以看到
它和我们想要的图表
非常有意义地相连
这个训练块
和一切相连
这是因为当你在计算变化率时
你需要和图表里的每个变量联通
但现在我们会把它放在一边
因为这不是很有用
现在我们可以自由探索
有了x占位符
对数据进行重组
然后我们重新检查每一个卷积层
每个层里都有变量
我们有卷积和加法
可以在图表中检查一遍
看看是不是所有地方都对
现在，我来展示图表显示器的
几种功能
其中一个就是你可以进入每一块
探索不同层次的抽象度
我们还可以探索得更深
这里，我们看到计算交叉熵的
运算方式
这些一片片的部分
是为了计算交叉熵
你还会发现
不同的框有不同颜色

Spanish: 
El visualizador gráfico identifica
subestructuras similares repetidas
de la gráfica y les da el mismo color.
Podemos estar seguros
de que estas dos capas
tienen la misma estructura
porque ambas son verdes.
Tal vez parezca que no es tan importante
pero cuando estábamos migrando
la creación de gráficos en TensorFlow
hace como un año y medio
y este es un gráfico muy complicado
con decenas de miles de nodos
estuvimos atorados durante semanas.
Teníamos resultados erróneos.
Y pensamos que tal vez
TensorFlow simplemente estaba mal.
Tal vez habíamos pasado
un año desarrollando este nuevo software
y no iba a funcionar.
Y resultó que el problema
era que uno de los submódulos iniciales
tenía un ligero error.
Estaba conectado un poco diferente
y eso arruinaba el entrenamiento.
Hay un par de configuraciones
más que se pueden usar.
Por ejemplo, podemos ver
por colores según el dispositivo.
En este caso, todo se puso en el
mismo dispositivo así que está todo gris.
Pero si tuviera una
combinación de CPU y la GPU
se puede tener una idea
de dónde se colocaron las cosas.

English: 
The way that the graph
visualizer works is it
identifies repeated, similar
substructures of the graph
and gives them the same color.
So we can be sure that these
two fully connected layers have
the exact same
structure as each other
because they are
both colored green.
Now this sounds
like it might not
be such an important feature.
But actually, when
we were porting
the inception graph
over to TensorFlow
back a year and a half ago--
and this is a very complicated
graph with tens of thousands
of nodes, we were
stuck for weeks.
And we were getting
the wrong results.
And we actually thought maybe
TensorFlow was just broken.
Maybe we had spent like a year
developing this new software
and it just wasn't
going to train.
And it turned out the real issue
is that one of the inception
submodules had a slight bug.
So it was wired
slightly differently,
and that was breaking
the training.
There are a couple of other
settings you can use here.
So, for example, we can
look at coloring by device.
In this case, everything
was put on the same device
so it's all gray.
But if you were using
a mix of CPU and GPU,
you can use that to get an idea
of where things were placed.

Korean: 
그래프 비주얼라이저는
반복된 것, 그래프의
하위 구조를 인식하고
같은 색을 부여합니다
그래서 두 개의 연결된 레이어가
모두 녹색으로 채워져있어서
완전히 같은 구조인 걸 알 수 있죠
이게 그렇게 중요한 기능이
아닌 것처럼 느껴질 수도 있어요
하지만 사실 개시 그래프를
TensorFlow로 보내면
일 년 반전에는
수천 개의 노드가 있는
매우 복잡한 그래프가 되어서
몇 주 동안 붙잡고 있었어요
그리고 잘못된 결과를 얻었죠
사실 TensorFlow가
결함이 있다고 생각했어요
이 새로운 소프트웨어를 만들었는데
훈련이 불가하다고 생각했죠
하지만 진짜 문제로 개시 서브모듈에
버그가 약간 있단 걸 알게되었죠
그래서 약간 다르게 연결되었었죠
그래서 훈련 과정을 망쳤어요
여기 다른 설정도 이용할 수 있습니다
예를 들어, 기기마다의 색을
볼 수 있어요
이 경우에, 모두 같은 기기에
있기 때문에 모두 회색입니다
하지만 CPU나 GPU를
여러 개 사용할 때
배치가 어떻게 되었는지
확인할 수 있습니다

Portuguese: 
O visualizador de gráfico identifica
subestruturas similares e repetidas
e confere a elas a mesma cor.
Então podemos ter certeza de que 
essas duas camadas têm a mesma estrutura
porque são ambas verdes.
Pode não parecer um recurso importante, 
mas quando estávamos trazendo
o gráfico de lançamento para 
o TensorFlow um ano e meio atrás,
e era um gráfico muito complicado,
com dezenas de milhares de nós,
ficamos empacados por semanas.
Recebíamos resultados errados.
E chegamos a pensar que talvez
o TensorFlow estivesse quebrado.
Levamos cerca de um ano 
desenvolvendo esse novo programa
e ele não estava treinando.
No fim a questão era que um 
dos submódulos de lançamento
tinha um pequeno erro.
Estava conectado de modo ligeiramente
diferente, quebrando o treinamento.
Há algumas configurações 
que você pode usar aqui.
Então, por exemplo, podemos ver 
a coloração por dispositivo.
Nesse caso tudo estava no mesmo
dispositivo, então era tudo cinza.
Mas se estivesse usando uma combinação
de CPU e GPU, poderia usar isso
pra ter uma ideia de onde as coisas estão.
Também podemos ligar

Indonesian: 
Cara penggambar grafik bekerja adalah ia
mengidentifikasi substruktur terulang
dan serupa dari grafiknya
dan memberinya warna yang sama.
Bisa pastikan dua lapisan terhubung
sepenuhnya ini punya
struktur yang sama satu sama lain
karena mereka berdua berwarna hijau.
Terdengar seperti itu bukan
fitur yang begitu penting.
Nyatanya, saat kita hubungkan
grafik insepsi ke TensorFlow
satu setengah tahun lalu--
dan ini grafik yang amat rumit
dengan puluhan ribu nodus
terhenti berminggu-minggu.
Dan hasilnya salah.
Kita bahkan berpikir mungkin
TensorFlow rusak.
Mungkin setahun untuk
mengembangkan software baru ini
dan itu takkan berhasil.
Rupanya masalah sebenarnya ialah
salah satu submodul
insepsi memiliki sedikit bug.
Itu terhubung sedikit berbeda
dan itu merusak pelatihannya.
Ada pengaturan lain yang
bisa gunakan di sini.
Contohnya, kita bisa perhatikan
pewarnaan berdasarkan perangkat.
Semua diletakkan di perangkat yang sama
jadi semua abu-abu.
Tapi jika pakai campuran CPU dan GPU,
Anda bisa memakainya untuk tahu
di mana meletakkannya.

Chinese: 
图表显示器工作的方式
是辨别图标里重复、相似的亚结构
并给它们相同的颜色
这样我们可以确保这两个完全联通的层
拥有完全相同的结构
因为它们都是绿色的
这听起来不像是
什么特别重要的功能
但实际上，一年半以前
当我们把起始图
接入TensorFlow端口时 --
而且这是一个十分复杂的图表
有着上万个节点，我们当时花了几周的时间
而且我们的结果也不正确
我们以为TensorFlow出了故障
也许我们花了一年的时间
开发这个新软件
但就是没法训练它
后来发现真正的问题是
其中一个起始亚模组有小的故障
也就是说它接入时的方法不同
造成训练时出现问题
你还可以使用其他的几个设置
比如，通过设备添加颜色
在此图中，一切都出现在同一个设备上
所以颜色全是灰色
但如果共同使用CPU和GPU
你可以借此了解所有内容在哪里出现

Japanese: 
グラフビジュアライザーは
何度も似ているグラフの土台を特定し
同じ色を配色します
この２つの完全結合層は同じ緑色なので
完く同じ構造だと確信できます
これは それほど重要な機能に
聞こえないかもしれませんが
実は１年６カ月前の
TensorFlow につなげる
Inception グラフを提供していた時は
ノードが山ほどある
非常に複雑なグラフだったんです
そこで数週間 粘りましたが
間違った結果が出てしまうのです
TensorFlow が壊れてると
実は思っていました
この新ソフトウェアの開発に
１年間かけたとしても
トレーニングまでは
無理だと思ってました
そして 本当の問題は
Inception サブモジュールにある
小さなバグだったと判明したのです
だから つながりが少しズレて
トレーニングが破たんしたのです
こちらには使用できる
２つの他のセッティングがあります
例えば デバイスによる色つけです
同じデバイス上にあるものは
すべてグレーです
しかし CPU と GPU が
混ざったものを使っていたら
これを ものの場所を見つけるのに
使うことができます

Chinese: 
还可以打开输入跟踪
可以选择任意部分
可以看到所有的依赖在图标上的位置
其他所有都会变灰
是的
这样看，我们的确得到了
我们大致想要的图表
但这并不是训练
应该获得更多信息
也是时候开始使用其他栏
我们需要从TensorFlow
向硬盘写入运行时间的数据
这么做的办法，就是通过
一个叫概要的系统
概要是一种特殊类型的TensorFlow运算
它会从图表中代入一个常规张量
然后输出协议缓冲区
我们可以写入硬盘
有几种不同类型的概要
最简单的是标量概要
它会写下单一数值
你通过它来创造线表格
另一种是图像概要
可以写出一个图像，用它来形象化
比如，你有
一个生成性图像模型
或者你只想
检查你的输入数据
格式是否正确

English: 
We can also turn
on trace inputs,
and then you can choose
any individual piece
and kind of see what all of its
dependencies are in the graph.
Everything else gets grayed out.
So yeah.
But from looking
at this, it does
look like we have, more or
less, the graph we expected.
But as we saw, it's
not training at all.
So it's time to get a little
bit more information and time
to start using these other tabs.
Now to do that, we
need to actually write
data, runtime data,
from TensorFlow to disk.
And the way we do that
is through a system
called summaries.
A summary is basically a
special kind of TensorFlow op.
It will take in a regular
tensor from your graph,
and then it will
output protocol buffers
that we can write to disk.
Now, there are a couple of
different kinds of summaries.
The simplest is the scalar
summary which will just
write down a single
value, and you
use it to create these
nice line charts.
Then there are image summaries,
which we'll write out an image.
And you can use it to
visualize, for example,
if you have a generative
model of images,
or if you just want to
check that your input
data is formatted correctly.

Indonesian: 
Kita juga bisa hidupkan input jejak,
lalu bisa pilih potongan apa saja
dan lihat dependency-nya di dalam grafik.
Semua dipudarkan.
Melihat ini, setidaknya kita
punya grafik yang kita harapkan.
Tapi sebenarnya, itu bukanlah pelatihan.
Waktunya mendapatkan
lebih banyak informasi
dan waktu untuk menggunakan
tab lainnya.
Untuk melakukannya, kita harus menulis
data, data runtime, dari
TensorFlow ke disk.
Caranya adalah melalui sistem
yang disebut summary.
Summary adalah jenis khusus
dari operasi TensorFlow.
Ia mengambil tensor reguler
dari grafik Anda
lalu itu akan output penyangga protokol
yang bisa kita tulis ke disk.
Ada beberapa jenis perbedaan dari summary.
Paling mudah ialah summary
skalar yang akan
menuliskan satu nilai, dan Anda
gunakan itu untuk membuat
grafik garis bagus ini.
Lalu ada image summary, yang akan
kita buatkan gambar.
Itu untuk menggambarkan, misalnya,
jika Anda punya model generatif gambar,
atau ingin periksa input data
apakah sudah diformat dengan benar.

Korean: 
추적 입력을 켤 수도 있어요
개별 부분을 선택하여
그래프에서 어떤 부분이
연결되어 있는지 확인할 수 있어요
그 외의 것은 회색이 되어버리죠
네
이걸 보니
우리가 예상하던 그래프와 비슷하네요
하지만 이건 훈련이 되어있지 않아요
이 다른 탭을 사용하기 위해서
시간을 들여 더 알아봅시다
그러기 위해서
TensorFlow에서 디스크로
데이터를 쓰고, 실행해야 합니다
이때 summaries라는
시스템을 활용합니다
Summary는 기본적으로
TensorFlow op의 특별한 종류예요
그래프에서 보통 tensor를 가져와
우리가 디스크에 쓸 수 있는
protocol buffer를 출력합니다
이제, 다른 summaries들이
있네요
가장 간단한 것은
스칼라 summary고
하나의 변수만 적으면 돼요
이걸 이용해 선도표를 만들 수 있죠
이미지 summary는
이미지를 쓸 수 있습니다
예를 들어 생성 이미지 모델이 있거나
입력한 데이터가 제대로 나왔는지
확인할 때, 가시화할 수 있죠

Spanish: 
También podemos activar
el rastreo de entradas
y entonces se puede elegir
cualquier pieza individual
y ver cuáles son todas
sus dependencias en el gráfico.
Todo lo demás queda atenuado.
Al observar esto,
se parece más a menos
al gráfico que esperábamos.
Pero como vimos, no está aprendiendo.
Es momento de obtener
un poco más de información
y de empezar
a utilizar estas otras pestañas.
Para eso, tenemos que
escribir en disco
los datos de tiempo
de ejecución TensorFlow al disco.
Para eso usamos
un sistema llamados resúmenes.
Un resumen es básicamente un tipo
especial de operación de TensorFlow.
Toma un tensor regular de la gráfica
y produce buffers de protocolos de salida
que podemos escribir en el disco.
Hay un par de resúmenes diferentes.
El más simple es el resumen escalar
que solo escribe un valor único
y se usa para crear estos
bonitos gráficos de líneas.
Después están los resúmenes
de imagen que producen una imagen.
Se puede visualizar, por ejemplo:
un modelo generador de imágenes
o para ver que los datos de entrada
tengan el formato correcto.

Portuguese: 
a detecção de inputs
e escolher qualquer pedaço individual
e ver no gráfico 
todas as suas repartições.
Todo o resto fica cinza.
Então, sim.
Ao ver isto, parece que temos
mais ou menos o gráfico esperado.
Mas como vimos, não está treinando.
Então está na hora de aprendermos
a usar essas outras abas.
Para fazer isso precisamos escrever dados
de execução do TensorFlow para o disco.
Através de um sistema chamado Sumários.
Um sumário é basicamente 
um tipo especial de op do TensorFlow.
Vai assimilar um tensor regular 
do seu gráfico e então emitir buffers
que podemos escrever no disco.
Existem alguns tipos 
diferentes de sumários.
O mais simples é o sumário escalar,
que vai escrever um valor único,
usado para criar 
esses gráficos de linhas.
Há também os sumários de imagem,
que escrevem uma imagem.
E pode usar para visualizar, por exemplo, 
um modelo generativo de imagens,
ou se quiser checar se os seus
dados de input estão bem formatados.

Japanese: 
また Trace Input をオンにすると
個々で選択することが可能になり
グラフ内の依存性を全て確認できます
その他は すべてグレーになります
こうして見ると
より期待に沿ったグラフになっています
でも 見てのとおり
全くトレーニングをしていません
ですので もう少し情報を取り入れて
他のタブも使っていきましょう
そのためには
TensorFlow からディスクに
ランタイムデータを書く必要があります
それをするには
サマリーというシステムを利用します
サマリーは基本的に特別な
TensorFlow オペレーションで
グラフから一般的なテンソルを取り込み
ディスクに書ける
プロトコルバッファを出します
異なった種類のサマリーがあります
最もシンプルなのはスカラーサマリーで
単独の値を書き出します
これを使えば
ステキな線グラフが描けます
それから こちらの画像サマリーは
画像を書き出します
画像作成モデルがあるときや
入力したデータが正しく
形作られているかを確認したいときに
これを使って可視化できます

Indonesian: 
Kita punya summary audio.
Misalnya, tim magenta
akan dibahas nanti,
sedang mengerjakan
generasi musik banyak yang betul-betul
ditambahkan summary audio ke TensorBoard.
Ada summary histogram, dan ini
membiarkan Anda perhatikan
distribusi bentuk dari nilai berbeda.
Sangat bagus mengedepankan variabel Anda,
seperti weight
Akhirnya, kita punya TensorSummary.
TensorSummary itu summary terbaru.
Idenya ialah ia bisa membuat
jenis nilai apapun
karena semua di TensorFlow adalah
sebuah Tensor.
Kita belum tambahkan dukungan
sepenuhnya untuk itu.
Saya akan sedikit bahas saat kita
bicarakan rencana TensorBoard mendatang.
Kita akan tambahkan summary.
Ada dua summary skalar ini,
karena lihat bagaimana
entropi silang dan akurasi
berubah sepanjang waktu.
Baik juga untuk lihat gambar input kita,
pastikan itu digit MNIST, seperti
yang diharapkan.
Akhirnya, di tiap lapisan
akan kita tambahkan histogram
yang akan menunjukkan weight, bias,
dan aktivasi.
Setelah itu, kita harus pikirkan,
bagaimana cara menjalankan summary ini?

Korean: 
오디오 summary도 있어요
예를 들어, 나중에 얘기해드릴 건데
음악 생성 쪽 일을 하고 있는
마젠타 팀이
실제로 TensorBoard에
오디오 summary를 추가했어요
히스토그램 summary도 있어요
여기서 다른 변수들이
분포되어 있는 걸 볼 수 있어요
여러분 무게 같은 변수에
붙어 있는 게 좋겠죠
마지막으로
TensorSummary가 있어요
TensorSummary는 최신이에요
TensorFlow에 있는 건
모두 Tensor이므로
어떤 값이든 쓸 수 있어요
하지만 이에 관한 지원은
다 준비를 못했어요
TensorBoard의 계획이 나오면
그때 더 다루겠습니다
summary를 추가해볼게요
두개의 scalar summary가 있어요
시간이 지나면서
크로스 엔트로피랑 정확도가
변하는 걸 보는 게 좋죠
입력된 이미지를 보는 것도 좋고
우리가 원하는 MNIST 자리인지
알아봅니다
마지막으로 각각의 레이어에
히스토그램을 추가하여
무게와 바이어스, 활성을 보여주게 해요
앞서 말한 것을 바탕으로
어떻게 이 summary들을
실행할까요?

Japanese: 
オーディオサマリーもあります
このあと登場しますが
多くの音楽生成を手掛けている
Magenta チームは
このオーディオサマリーを
TensorBoard に追加しました
ヒストグラムサマリーもあり
いろいろな値の分布を形にしてくれます
これは ウェイトの様に
非常にわかりやすく変数に親和します
最後は テンソルサマリーです
これは最新のサマリーで
どんな値でも書き出すことができます
TensorFlow 内のものは
全てテンソルだからです
でも まだ完全に
サポートされていません
このことは TensorBoard の
将来的プランのところで少し議論します
では サマリーを追加します
交差エントロピーと正確性で
変化する様子が常時 見て取れるので
２つのスカラーサマリーを入れます
挿入画像も見栄えが良いですね
期待通りに MINIST の
数字のみを確認します
そして最後に それぞれの層の中に
ヒストグラムを２つ追加しましょう
ウェイトとバイアスと
活性化が表示されます
以上です
では実際に どうやって
このサマリーを実行するのでしょう？

Spanish: 
Tenemos un resumen de audio.
Por ejemplo, el equipo de Magenta
que se presentará más tarde
y que está trabajando
en la generación de música
usa el resumen de audio para TensorBoard.
Hay resúmenes de histograma
con ellos podemos ver la forma de
las distribuciones de diferentes valores.
Puede ser muy agradable adjuntarlas
a las variables, como a los pesos.
Y, por último, tenemos TensorSummary.
TensorSummary es el resumen más reciente.
La idea es que se puede
escribir cualquier tipo de valor
porque todo en TensorFlow es un tensor.
Pero todavía no hemos añadido
soporte completo todavía.
Voy a hablar un poco
más de él cuando lleguemos
a los planes para
el futuro con TensorBoard.
Agregemos un par de resúmenes.
Tenemos dos resúmenes escalares
para ver cómo la entropía cruzada y
la precisión están cambiando en el tiempo.
También queremos ver
las imágenes de entrada
solo para asegurarnos
de que son cifras MNIST.
Y también en cada una de
nuestras capas añadiremos histogramas
que nos mostrarán los pesos,
los sesgos y las activaciones.
Con todo esto tenemos que pensar
¿cómo vamos a ejecutar estos resúmenes?

Portuguese: 
Temos um sumário de áudio.
Por exemplo, o time vermelho, que está 
trabalhando muito com geração de música,
adicionou o sumário de áudio 
ao TensorBoard.
Há sumários de histograma,
que permitem ver a forma de distribuição
de valores diferentes.
Pode ser muito legal anexar 
às suas variáveis, por exemplo pesos.
E finalmente, temos o TensorSummary.
O TensorSummary é o mais novo sumário.
A ideia é que ele pode
escrever qualquer tipo de valor
pois tudo no TensorFlow é um tensor.
Mas ainda não há suporte completo.
E vou discutir um pouco mais quando
falarmos do planos futuros do TensorBoard.
Agora vamos adicionar alguns sumários.
Tínhamos estes dois sumários escalares,
seria bom ver como a entropia cruzada
e a consistência mudam com o tempo.
Seria legal também ver nossas imagens
de input para ter certeza de que são
dígitos MNIST, como esperado.
E então, finalmente, vamos adicionar 
em cada uma das nossas camadas
alguns histogramas que vão mostrar
os pesos, as tendências e as ativações.
Considerando tudo, como vamos 
rodar todos esses sumários?

Chinese: 
我们还有音频概要
例如，Magenta团队
他们一会会来展示
他们在研究如何生成音乐
他们将音频概要加入了TensorBoard
还有柱状图概要
帮你了解
不同数值分布的形状
它可以很好地附加在变量上
例如权重
最后，还有张量概要
张量概要是最新的一种概要
它可以写出任何一种数值
因为TensorFlow中的一切都是张量
但我们还没有完全加好支持它的内容
当我们讲到TensorBoard未来计划时
我会再讲一讲这方面内容
现在，我们继续加入别的概要
我们有这两种标量概要
因为这样就可以看出
交叉熵和准确度
随时间的变化
也可以看到我们的输入图像
但要确保他们是
我们想要的MNIST数位
最后，在每一个层里
我们添加一些柱状图
它会告诉我们权重、偏差和启动
说了这么多
我们需要知道如何运行这些概要

English: 
We have an audio summary.
So, for example,
the magenta team,
which we'll hear from
later and is working
on a lot of music
generation actually
added the audio
summary to TensorBoard.
There are histogram
summaries, and these
let you look at the
shape of distributions
of different values.
So it can be very nice to
be attach to your variables,
like your weights.
And finally, we have
the TensorSummary.
The TensorSummary is
the newest summary.
The idea is that it can
write out any kind of value
because everything in
TensorFlow a Tensor.
But we haven't quite added
support for it fully yet.
And I'll discuss it a
little bit when we get
to TensorBoard's future plans.
So now we'll add a
couple of summaries.
We had these two
scaler summaries,
because it would be
nice to look at how
the cross entropy
and the accuracy
are changing over time.
It would also be nice to
look at our input images,
just make sure that they're
MNIST digits, like we expect.
And then, finally,
in each of our layers
we'll add a couple
histograms that
will show us the weights, the
biases, and the activations.
So with that all said,
we need to think, OK,
how are we actually going
to run these summaries?

Japanese: 
サマリーオペレーションを
個々に実行すればよいのです
するとプロトコルバッファが
与えられます
ディスクに入れるためには
それを FileWriter に渡せばよいです
６、７個のサマリーオペレーションを入れ
全部を個々に実行するのは
手間がかかりますね
何百 何千というサマリーがある
Inception などのグラフは特にそうです
なので その代わりに
単独のターゲットを作りだす
Marge All サマリーがあります
それを実行すると
グラフ全体の全サマリーが手に入ります
つまり FileWriter をもう１つ作り
トレーニングのコードを編集すれば
サマリーをマージして
ディスクに書くことができます
最後は新ディレクトリを指定する
TensorBoard をオンにするだけです
では 実際にモデル内で起こることを
探していきましょう
ご覧のとおり
正確性は10% 前後です
その背景の基データは
非常にゴチャゴチャしています
これは バラバラな標本が
あちこちにあるからです
近似曲線をより明らかにするため
これを滑らかにできます
交差エントロピーもあります

Spanish: 
Y la respuesta es que
ejecutamos cada resumen.
Nos darán los búferes de protocolo
y entonces podemos pasarlos al FileWriter
para escribirlo en el disco.
Sería muy tedioso si tuviéramos
que dar seguimiento
a estas seis o siete
operaciones de resumen
y ejecutarlas individualmente,
sobre todo si tuviéramos
un gráfico inicial con cientos
o miles de resúmenes.
En vez de eso, podemos combinar
los resúmenes y crear un solo objetivo
se ejecuta, y genera todos
los resumen en el gráfico entero.
Podemos crear otro FileWriter.
Modificar nuestro código de entrenamiento
para que ejecute el resumen
combinado y lo escriba en el disco.
Entonces solo tenemos que ejecutar
TensorBoard apuntando al nuevo directorio.
Ya podemos empezar a explorar qué
está sucediendo realmente en este modelo.
Como vimos, la exactitud
oscila alrededor del 10%.
Al fondo, se pueden ver que
los datos originales son muy ruidosos
porque se trata de un muestreo aleatorio.
Podemos suavizarlo para
ver la tendencia con mayor claridad.
También tenemos la entropía cruzada

Indonesian: 
Jawabannya ialah menjalankan
tiap summary op.
Memberi kita buffer protokol,
lalu kita bisa oper ke FileWriter untuk
menempatkannya di disk.
Akan lama jika kita harus
perhatikan 6 atau 7 summary op ini
dan jalankan sendiri-sendiri
terutama jika kita ke grafik
seperti insepsi yang punya ratusan
atau ribuan summary.
Alih-alih, kita punya
Merge All summary ini
yang membuat target tunggal.
Kita jalankan, dan dapatkan tiap
summary di grafik.
Kita bisa membuat FileWriter lainnya.
Kita bisa ubah kode pelatihan
untuk jalankan summary
yang tergabung dan menulisnya ke disk.
Akhirnya, hidupkan saja TensorBoard
yang menunjukkan direktori baru kita.
Kini, kita bisa mulai jelajahi
yang sebenarnya terjadi di model ini.
Seperti yang terlihat,
akurasi di angka 10%.
Di backdrop, Anda bisa lihat
data asli sangatlah berantakan
karena adanya sampel acak
yang berpindah-pindah.
Bisa kita perhalus untuk melihat
baris tren lebih jelas.
Kita juga punya entropi silang.

Chinese: 
答案就是我们运行每个概要运算
它会给我们协议缓冲区
然后把缓冲区递给FileWriter，
将它们写入硬盘
记录那六七个概要运算
并一个一个地运行
会是十分枯燥的
特别是当我们有一个起始图表
它可能会有成百上千个概要
然而，我们有这个叫“合并全部”的概要
它创建单一的目标
运行后，我们将在图表里获得每一个概要
我们创建另一个FileWriter
修改训练代码
这样就可以运行合并概要，写入硬盘
最后，只需要启动TensorBoard
指向新的目录
现在可以开始探索这个模型
真正有用的地方
像我们看到的，
准确度徘徊在10%左右
在背景里，可以看到原始数据十分嘈杂
因为随机取样不断变化
让我们将它变得柔和
就能更清楚地看到趋势线
同时还有交叉熵

English: 
And the answer is that
we run each summary op.
It gives us the
protocol buffers,
and then we can pass them to our
FileWriter to get them to disk.
It would be really
tedious if we needed
to keep track of those
six or seven summary ops
and run them all individually,
especially if we'd
go to a graph like Inception
that might have hundreds
or thousands of summaries.
So instead, we have
this Merge All summary
that creates a single target.
We run it, and we get every
summary in the whole graph.
So we can go and create
another FileWriter.
We can go and modify
our training code
so that it will run the merged
summary and write it to disk.
And then, finally, we just
need to turn on TensorBoard
pointing out our new directory.
So now we can start
to explore what's
really happening in this model.
So as we saw, the accuracy
bounces around 10%.
In the backdrop, you can see
the original data is very noisy
because it's just got random
sampling moving around.
So we can smooth it to see
the trend line more clearly.
And then we also have
the cross entropy.

Portuguese: 
Bem, rodamos cada op de sumário.
Isso nos fornece buffers de protocolo
e podemos passá-los ao nosso FileWriter
para levá-los ao disco.
Seria realmente chato rastrear todas
as seis ou sete ops de sumário
e rodá-las individualmente, especialmente
se fossemos a um gráfico como Inception
que pode ter centenas de milhares
de sumários.
Então temos esse sumário Agrupar Tudo, 
que cria uma única meta.
Ao rodar temos 
todos os sumários do gráfico.
Assim podemos criar um outro FileWriter.
Podemos modificar nosso código
de treinamento para que rode
o sumário agrupado e escreva no disco.
E então, finalmente, só precisamos
ligar o TensorBoard apontando
para o nosso novo diretório.
Agora podemos começar a explorar
o que realmente acontece nesse modelo.
Como vimos, 
a exatidão está em cerca de 10%.
No fundo podemos ver 
que os dados originais são muito ruidosos
porque só considera 
a amostragem aleatória circulando.
Então podemos suavizar para ver
a curva de tendência mais claramente.
Também temos a entropia cruzada.

Korean: 
정답은 op을 하나씩 실행하는 겁니다
이것은 protocol buffer를 제공하고
그걸 디스크에 넣기 위해
FileWriter로 넘겨줍니다
여섯 개 혹은 일곱 개의
summary op을 추적해야 하고
그걸 따로 실행시키는 건
지루한 일입니다
특히 수백 수천 개의
summary가 있는
개시 같은 그래프를 볼 때요
대신, Merge All Summary를 이용해
단일한 개체를 만듭니다
이걸 실행하면 모든 summary가
한 그래프에 담겨요
FileWriter를 하나 더 만듭니다
우리 훈련 코드를 수정하여
병합된 summary를 실행하고
디스크에 써봅시다
그리고 새로운 디렉토리를 가리키는
TensorBoard를 켜면 됩니다
이제 이 모델이 어떻게 되는지 봅시다
보시다시피 정확도는 10%정도죠
뒤로 돌리면, 원래 데이터에
노이즈가 많은 게 보이시죠
이건 랜덤 샘플링이었거든요
경향이 어떻게 되는지 보려면
부드럽게 만듭니다
그리고 크로스 엔트로피가 있어요

Portuguese: 
E é bem interessante 
que a entropia cruzada se mantenha
exatamente constante
por toda a série de treinamento,
o que significa que algo 
está muito errado com o modelo.
Podemos também ver a aba das imagens.
E aqui, ok, nossas imagens realmente 
parecem boas imagens MNIST.
Podemos ver numa dimensão 
de pixel verdadeira
e então perceber 
que algo deu errado.
Mas também podemos expandir.
Temos algumas opções diferentes aqui.
É muito interessante ver 
as distribuições e histogramas.
Há dois jeitos diferentes de visualizar
a mesma informação de histograma.
O diagrama de distribuição nos diz
que todos os valores empacaram no zero.
E o diagrama de histograma vai nos dizer
exatamente a mesma coisa.
Todas as nossas ativações foram
um pico gigante no zero.
Todas as nossas tendências e todos os
nossos pesos também empacaram no zero.
Isso nos mostra que algo está errado
na configuração das camadas.
Porque quando as tendências e os pesos
estão no zero, teremos zero gradientes
passando pelo gráfico e nada vai treinar.

Spanish: 
y es bastante interesante,
porque se mantiene
exactamente constante
durante todo el entrenamiento
lo que sugiere que hay algo
que está muy mal con el modelo.
También podemos revisar
la pestaña de "Imágenes".
Aquí tenemos que nuestras
imágenes MNIST son correctas.
Y podemos verlas en
tamaño real y recuerden que…
algo salió mal ahí.
Podemos expandirla.
Tenemos diferentes opciones.
Y lo que es realmente interesante
son las distribuciones e histogramas.
Hay dos formas diferentes de visualizar
la misma información del histograma.
La tabla de distribución nos dice que
todos los valores se quedaron en cero.
Y el gráfico de histograma
nos dice exactamente lo mismo.
Todas nuestras activaciones
son un pico gigante en cero.
Y además, todos nuestros
sesgos y pesos están en cero.
Esto nos da una idea de que
probablemente hicimos algo mal
cuando establecimos nuestras capas
porque cuando los sesgos
y los pesos son todos cero
no tenemos ningún gradiente a través
de la gráfica y no va a aprender nada.

Korean: 
이건 꽤 흥미로운데 크로스 엔트로피가
모든 훈련 내내 일정하게 유지되고
이 모델에선 정말
잘못된 것이기 때문이죠
Images 탭도 볼 수 있습니다
여기 보면 우리 이미지가
정교한 MNIST 이미지처럼 보이네요
실제 픽셀 사이즈를 볼 수 있고
그리고
뭔가 잘못되었군요
하지만 늘릴 수도 있습니다
여기 다른 것도 가능합니다
그리고 흥미로운 것은
distributions과
histograms를 볼 때예요
이 둘은 같은 히스토그램을
가시화하는 다른 방법입니다
분포도는 모든 값이
0에 달려있다고 알려주네요
히스토그램 차트도 같은 것을 보여주고요
우리 activations은 모두 0이었네요
또한, 모든 바이어스와 무게도 0이고요
이로써 레이어를 만드는 데
뭔가 잘못된 걸 알 수 있죠
바이어스와 무게가 모두 0일 때
그레디언트가 그래프를 거치지 않고
아무 훈련도 이루어지지 않아요

Chinese: 
这很有趣，因为交叉熵
在训练过程中保持不变
这就证明模型有很严重的问题
我们还可以观察图像栏
这里我们看到，我们的图像
看起来就是MNIST图像
我们可以看一个真实的像素大小
并记住
这地方有问题
还可以扩展
这里有几种不同的能力
当观察分布和柱状图时
我们发现它非常有趣
这是有关显现同样柱状图
信息的两种不同方式
分布图显示
所有的数值都是零
柱状图会显示
完全相同的结果
所有的启动在零时
都像一个巨大的尖刺
而且，所有的偏差和权重也都是零
这告诉我们，在设置层时
可能出了问题
因为当偏差和权重都是零时
会有零个变化率通过图表
什么都得不到训练

Japanese: 
非常に興味深いことに
この交差エントロピーは
トレーニングをしている間
ずっと安定していることです
つまり モデルに深刻な不具合があることを
示唆しています
IMAGES タブも確認できます
こちらで確認すると
画像が実際に
MINIST を実行しているようです
実際のピクセルサイズを確認できるし
間違った部分も確認できます
２つの異なった種類の機能を利用し
拡大もできます
分布とヒストグラムを見ると
実に興味深いことがわかります
これは実際に同じヒストグラムの情報を
違う２つの方法で可視化したものです
分布図は すべての値が
0 にあることを示しています
ヒストグラムの表も
全く同じことを示しています
全てのアクティベーションが
0 に集中しています
また バイアスとウェイトも
0 のままです
これで層のセットアップが間違ったと
直観的にわかります
なぜなら バイアスもウェイトも
0 だからです
勾配が 0 のグラフは
トレーニングが全くされないということです

Indonesian: 
Ini lumayan menarik karena entropi silang
tetap konstan sepanjang proses pelatihan,
yang menunjukkan ada yang salah
dengan modelnya.
Kita juga bisa lihat tab Images.
Di sini kita temukan,
gambar kita sebetulnya
terlihat seperti gambar MNIST yang indah.
Kita bisa lihat ukuran pixel sesungguhnya
lalu diingatkan bahwa--
ada yang salah.
Tapi Anda juga memperluasnya.
Kita punya beberapa kapabilitas di sini.
Hal yang kita anggap amat menarik
ialah saat kita lihat
distribusi dan histogram.
Sebenarnya ini 2 cara berbeda
untuk menggambarkan 
informasi histogram yang sama.
Distribusi grafik memberitahukan
bahwa semua nilai terhenti di nol.
Grafik histogram akan memberitahukan
hal yang persis sama.
Semua aktivasi ada di angka nol.
Semua bias dan weight
tertahan di angka nol.
Ini memberi tahu bahwa mungkin ada
yang salah saat kita mengatur lapisan.
Karena saat bias dan weight semuanya nol,
kita akan punya gradien nol melewati
grafik dan tidak ada latihan sama sekali.

English: 
And this is pretty interesting
in that the cross entropy is
staying exactly constant
throughout the entire training
run, which is just something is
seriously wrong with the model.
We can also take a
look at the Images tab.
And here we find OK,
our images actually
do look like fine MNIST images.
And we can look at
a true pixel size
and then be reminded that--
something went wrong with that.
But you also expand it.
So we have a couple of
different capabilities here.
And what we'll see
really interesting
is when we look at the
distributions and histograms.
So this is actually
two different ways
of visualizing the same
histogram information.
The distribution
chart is telling us
that all of the values
were stuck at zero.
And the histogram chart
is going to tell us
the exact same thing.
All of our activations were
one giant spike at zero.
And also, all of our biases
and weights were stuck at zero.
So this gives us an intuition
that something was probably
wrong when we set up our layers.
Because when the biases
and weights are all zero,
we're going to have
zero gradients passing
through the graph and
nothing will train at all.

Portuguese: 
Vejamos nosso código, 
onde configuramos as camadas.
Vou ver a camada convolucional, 
por exemplo.
E realmente configuramos as tendências
e os pesos para inicializar em zero,
o que foi um erro.
Então podemos alterar isso 
para uma inicialização mais sensível,
como uma normal truncada para os pesos
e um valor constante para as tendências.
Agora podemos rodar nosso modelo
com as alterações nas configurações.
E começamos a ver resultados bem melhores.
Vemos aqui que nossa entropia cruzada
rapidamente cai para zero.
E nossa exatidão rapidamente sobe para um
ou para exatidão perfeita.
Ao ver os dois diagramas ao mesmo tempo,
podemos criar grupos de diagramas
usando expressões regulares.
Assim podemos colocar tudo 
em um diagrama, em um grupo.
Também podemos ver nos histogramas
que temos melhores distribuições.
A barra lateral sobre essas 
visualizações de histograma

Korean: 
이 레이어를 설정했던 코드를 봅시다
예를 들어 나선형 레이어를 봅시다
우리는 실제로 바이어스와 무게를
0이 되게 설정했는데 이게 실수였죠
더 적절한 시작값으로 바꾸어서
줄여진 보통값을 무게에,
일정한 값을 바이어스에 넣습니다
이제 바뀐 설정으로
다시 모델을 실행할게요
결과가 나아지기 시작했네요
크로스 엔트로피가 0에 가깝게
빠르게 떨어지는 게 보이죠
정확도는 1 또는 완벽에 가깝게
빠르게 상승하고 있고요
이 두 차트를 동시에 본다면
보통 표현을 사용해
차트 그룹을 만들 수 있어요
모든 걸 한 차트
그룹에 넣을 수 있죠
비슷하게, 히스토그램을 볼 때
시간이 갈수록 나은 분포도를
볼 수 있어요
히스토그램 가시화에 관한 사이드바예요
뉴욕 타임즈에서 일한 적 있는

Japanese: 
では この層をセットアップした
コードを確認しましょう
例として畳み込み層を確認します
すると バイアスとウェイトが
0 に初期設定されています
これが間違いです
もっと注意深く初期化しましょう
例えば ウェイトには切断正規
バイアスには定値
[ デモ ]
では これから 修正した設定で
モデルを再び実行します
ずっとマシな結果が出ました
こちらの交差エントロピーは
すぐに 0 以下になりました
正確性は素早く上昇して
完全な1 に近くなりました
この２つの表を同時に比べたい場合は
通常の表記法で
グラフのグループを作ることができます
すべてを１つの表に
まとめて入れることができます
同様に 例えば
ヒストグラムを確認すると
時系列の良好な分布が出ます
こちらのヒストグラム可視化の
サイドバーは
とても賢いシャウン・カーターが作りました

English: 
So let's take a look
at our code for where
we set up these layers.
I'm going to look at
the convolutional layer,
for example.
And you can see that we actually
set the biases and weights
to initialize at zeros,
which was a mistake.
So we can change that to have
a more sensible initialization,
like a truncated
normal for the weights
and a constant value
for the biases.
And now we can just
rerun our model
with the changed settings.
And we start to get
much better results.
We can see here that our
cross entropy rapidly
decreases towards zero.
And our accuracy rapidly
increases towards one,
or perfect accuracy.
If we want to see these two
charts at the same time,
we have the ability to
create groups of charts
using regular expressions.
So we could put everything
in one chart, in one group.
Similarly, we can now see that
if we look at the histograms,
for example, we actually have
nice distributions over time.
Sidebar about these
histogram visualizations.
They were made by the
really talented Shawn

Indonesian: 
Mari lihat kode kita dimana
kita atur lapisan ini.
Saya akan lihat lapisan,
misalnya konvolusional.
Bisa dilihat, sebenarnya kita
mengatur bias dan weight
untuk memulai dari nol,
sebenarnya itu salah.
Kita ubah agar punya inisialisasi
yang lebih baik,
seperti normal terpotong untuk weight
dan nilai konstan untuk bias.
Kita bisa jalankan ulang model kita
dengan pengaturan yang sudah berubah.
Mulai dapat hasil lebih baik.
Kita lihat di sini bahwa
entropi silang secara cepat
berkurang ke nol.
Akurasi kita secara cepat
bertambah ke satu,
atau akurasi yang sempurna.
Jika ingin lihat dua grafik bersamaan,
kita punya kemampuan untuk
menciptakan kelompok grafik
menggunakan ekspresi reguler.
Kita bisa menaruh semua di satu
grafik, di satu grup.
Kita bisa lihat bahwa jika
kita cek ke histogram,
misalnya, kita sebenarnya punya
distribusi yang baik sepanjang waktu.
Sidebar tentang penggambaran
histogram ini.
Mereka dibuat oleh Shawn Carter yang

Chinese: 
让我们看看建立这些层时
用到的代码
先拿卷基层举例
可以看到我们让偏差和权重从零初始化
这是个错误
修改这地方，获得更合理的初始化
例如权重的截断正常值
和偏差的常量
在更改设置后
我们可以重新运行模型
这样就开始获得更好的结果
我们可以看到
交叉熵迅速地降至零
准确度迅速地趋向一
一代表完美准确度
如果想要同时看到这两张图
我们可以用正则表达式
创建图组
我们既可以把一切都归在一张图、一个组里
或者，如果现在观察柱状图
随时间变化的分布看起来很好
还有关于柱状图显示的工具栏
它是由杰出的肖恩·卡特制作

Spanish: 
Vamos a echar un vistazo a nuestro
código donde se crean estas capas.
Veamos la capa de
circonvolución, por ejemplo.
Aquí podemos ver que los sesgos y pesos
se inician en cero, lo que es un error.
Podemos cambiar eso para tener
una inicialización más sensata
como una normal truncada para los pesos
y un valor constante para los sesgos.
Y ahora volvemos a ejecutar
nuestro modelo con esos ajustes.
Y empezamos a obtener
resultados mucho mejores.
Podemos ver aquí que la entropía
cruzada disminuye hacia cero con rapidez
y la precisión aumenta rápidamente
hacia uno o la precisión perfecta.
Si queremos ver estos
dos gráficos al mismo tiempo
podemos crear grupos de gráficos
usando expresiones regulares.
Podríamos poner todo
en un gráfico, en un grupo.
Del mismo modo, ahora
podemos ver en los histogramas
que tenemos buenas
distribuciones en el tiempo.
Un comentario al margen sobre
las visualizaciones de histograma:

Indonesian: 
amat bertalenta, dulu bekerja di
"New York Times."
ia terinspirasi jika pernah
lihat cover album Joywave, dimana itu
seperti bentuk gelombang bunyi
meluas sepanjang waktu,
ia tipe pria yang lihat
cover album dan berpikir,
itu akan membuat visualisasi yang bagus.
Kita bisa lakukan hal-hal keren
di sini, seperti kita bisa mengubahnya
dari offset ke overlay.
Jika Anda ingin lihat bagaimana
berubah sepanjang
waktu offset-nya itu berguna.
Jika ingin lihat bentuk dalam
absolut dan relatif,
overlay cukup berguna.
Ada informasi yang persis sama
di grafik distribusi, dimana sekarang itu
menunjukkan tampilan berbeda,
kita bisa lihat,
misalnya, untuk baris sangat samar ini
ialah nilai maksimumnya.
Ada nilai maksimum sangat tinggi
untuk aktivasi.
Tapi disini, kita lihat perseratus ke-90
dan perseratus ke-60.
Itu sebenarnya lumayan ramai.
Yang penting ialah model kita
akhirnya berfungsi
Kita bisa lihat itu berlatih
dengan lebih baik.
Ada model yang baik, kita mungkin bilang,
oke, kita memilih tingkat
pembelajaran secara arbitrer,

Portuguese: 
foram feitas pelo talentoso Shawn Carter,
que trabalhava no New York Times.
Ele se inspirou na capa desse álbum
chamado Joywave, onde há formas tipo
onda sonora espalhada com o tempo,
é o tipo de cara que vê uma capa e pensa
"ah, isso seria uma visualização e tanto".
Podemos fazer algumas coisas bacanas aqui,
tipo trocar de desvio a sobreposição.
Para ver como evoluiu com o tempo
o desvio é útil.
Para ver como ficou em termos absolutos
e relativos, a sobreposição é bem útil.
Temos essa mesma informação
nos diagramas de distribuição,
que nos mostram uma visão diferente
onde essa linha bem clara 
é o valor máximo, por exemplo.
Podemos ver que havia um valor máximo
muito alto para as ativações.
Mas aqui vemos o 90° e o 60° percentis.
Estavam razoavelmente bem agrupados.
Mas o importante aqui 
é que nosso modelo está funcionando.
E vemos que está treinando muito melhor.
Agora que temos um bom modelo,
como havíamos escolhido 
a nossa taxa de forma harbitrária

Japanese: 
彼はニューヨークタイムズ紙で
働いていて ひらめきました
Joywave というアルバムの
カバーを見たことがあるでしょうか
そこには提示的に広がる
音声波形の様なものでした
彼はアルバムのカバーを見て
こう考えました
「ああ これは良い可視化だね」
この表記では 素晴らしいことに
オフセットからオーバーレイに
切り替えるなどができます
時系列に取り込み方を見たいとき
オフセットは便利です
絶対的と相対的な見た目を
確認したいときは
オーバーレイが非常に便利です
分布図には全く同じ情報があるのに
見た目が違います
例えば この薄い棒は最大値です
アクティベーションの最大値が
とても高いことが見て取れますね
しかし こちらの90 パーセンタイル値や
60 パーセンタイル値を見ると
集まり方が とても似ています
ここで重要なのは
最終的にモデルが動くことです
トレーニングはうまく
行われているということです
では 良いモデルになりました

English: 
Carter, who used to work
at the "New York Times."
and he was inspired
if you've ever
seen this album cover
called Joywave, where it's
like an audio wave forms
spread out over time,
he's the kind of guy who sees
an album cover and thinks,
ah, that would make a
great visualization.
So we can do a
couple of cool things
here, like we can switch them
from the offset to overlay.
So sort of if you want to
see how it evolved over time,
the offset is useful.
If you want to see how it looked
in absolute and relative terms,
the overlay is quite useful.
We have the exact
same information
in the distribution
charts, where now it's
showing us a different
view, where we can see,
for example, this very pale
line is the maximum value.
So we can see that there
was a very high maximum
value for the activations.
But here, we're looking at
like the 90th percentile
and the 60th percentile.
It was actually fairly
closely clustered.
But the important thing here
is that our model is finally
working.
And we can see that it's
training a lot better.
So now that we have a
good model, we might say,
OK, well, we chose a learning
rate kind of arbitrarily,

Korean: 
매우 재능있는 숀 카터가 이걸 만들었고
그는 오디오 웨이브 형태가
시간이 갈 때 바뀌는
Joywave라는 앨범 커버를 보고
영감을 받아서 이걸 만들었어요
그는 앨범 커버를 보고 생각했죠
이렇게 보여지면 좋을 것 같다고요
여기서 멋진 걸 할 수 있는데요
오프셋에서 오버레이로 바꿀 수 있어요
시간이 가면서 어떻게 변했는지 보려면
오프셋이 유용합니다
절대적이고 관련도 있게 보고 싶다면
오버레이가 꽤 유용하죠
분포도에서 완전히 같은 정보가 있고
여기서 지금은 다른 모습이 보이는데요
예를들어, 이 연한 선은 최대 값입니다
활성 값으로 매우 높은 최대값이
있었던 걸 알 수 있어요
하지만 지금은 90에서 60정도인 것을
볼 수 있어요
매우 가깝게 군집되었죠
하지만 여기서 중요한 것은
우리 모델이 드디어 작동한다는 거예요
훈련도 더 잘 되는 게 보이시죠
이제 좋은 모델이라고 말할 수 있겠네요
우리는 습득율을 꽤 추상적으로 잡았고

Spanish: 
Las hizo el talentoso Shawn Carter
quien trabajaba en el "New York Times"
y se inspiró en una portada
de un disco de "Joywave"
que son como unas ondas
de audio a través del tiempo
es el tipo de persona que ve
una portada de un disco y piensa
"sería una buena visualización".
Podemos hacer un par
de cosas interesantes
como cambiar el desplazamiento
hasta la superposición.
Si quieren ver cómo ha evolucionado
con el tiempo el desplazamiento es útil.
Si quieren ver cómo se ve
en términos absolutos y relativos
la superposición es bastante útil.
Tenemos la misma información
en las gráficas de distribución
pero nos da una visión diferente,
en la que podemos ver, por ejemplo
que esta línea muy pálida
es el valor máximo.
Podemos ver que hay
un valor máximo muy alto
para las activaciones.
Pero aquí vemos el 90º y el 60º percentil
y están estrechamente agrupados.
Pero lo importante es que nuestro
modelo finalmente funciona.
Y podemos ver que está
entrenando mucho mejor.
Ya que tenemos un buen
modelo, podríamos decir
bien, elegimos una tasa de
aprendizaje arbitrariamente

Chinese: 
他曾在纽约时报任职
你可能见过这个名叫《快乐波浪》的专辑封面
看起来像是声波随着时间而扩散
肖恩就是这种看到了专辑封面
会立刻受到启发
认为这是一个很好的形象化范例
我们可以做几种不同的事，都很有趣
比如，可以在抵消和覆盖间切换
如果你想知道随时间有着怎样的变化
抵消功能就很有用
如果想知道以绝对值和相对值表达的样子
覆盖功能就很有用
在分布图里有完全相同的信息
这里有着不同的显示
比如，这道浅色的线代表最大值
可以看到，对于启动来说
有一个非常高的最大值
但在这里，我们看的是第90和
第60百分位数
它们很近距离地聚在一起
但重要的是
我们的模型终于正常工作了
可以看到，现在训练的结果好了很多
有了好的模型
我们会发现

Indonesian: 
kita pilih model arsitektur kita
secara arbitrer.
Bagaimana jika dilakukan
secara berbeda?
Jika coba tingkat
pembelajaran berbeda
dan bagaimana jika kita coba
model arsitektur berbeda?
TensorBoard bisa sangat berguna
untuk ini juga
karena memberi Anda cara bagus
untuk bandingkan
versi model kita yang berbeda
menumpuk pada semua variabel
yang berbeda ini.
Kita bisa buat perubahan ke kode kita.
Kita ulang tiga tingkat
pembelajaran berbeda.
Lalu kita akan ulang menggunakan
satu atau dua lapisan terhubung
dan satu atau dua lapisan konvolusional.
Kita akan buat rangkaian unik untuk
tiap pengaturan hyperparameter
yang menjelaskannya.
Misalnya, tingkat pembelajaran,
garis bawah, 1e negatif 3,
terhubung sepenuhnya = 2,
lalu konvolusional = 2.
Kita akan buat penulis summary baru
yang menunjuk ke direktori yang
punya rangkaian itu di namanya.
Sekarang kita bisa menjalankan modelnya
Kita akan menunjuk TensorBoard
di direktori tingkat awal.
Tadi, kita menunjuk
TensorBoard di direktori untuk
run spesifik.
Sekarang kita ingin lihat awal run
sehingga bisa temukan semua data
dan membandingkannya.

Korean: 
모델 구조도 추상적으로 잡았어요
다르게 했다면 어떻게 됐을까요?
다른 습득율을 지정했다면 어떨까요?
다른 모델 구조를 사용했다면
어땠을까요?
TensorBoard는 여기서도
유용합니다
여러분 모델의 다른 버전을
비교할 수 있게 해주거든요
다른 모든 변수들에 관해서요
그래서 코드에 변화를 줘봅시다
습득율을 세 값으로 수정합시다
그리고 한두 개의
완전히 연결된 레이어와
한두 개 연결된 나선형 레이어를
수정해봅시다
이 hyperparmeter 설정을 위해
특별한 명령구를 사용할 거예요
예를 들어, 습득율은 _1E-3
fc=2, conv=2 입니다
새로운 summary writer를 만듭니다
이것은 이름에 그 명령구가 있는
디렉토리를 가리킵니다
이제 실제로 모델을 실행해봅시다
TensorBoard를
부모 레벨 디렉토리에서 지정합니다
과거에, TensorBoard를
특정 실행에 있어서만
디렉토리에서 지정했었습니다
이제 실행들의 부모 단계를 보고
이 모든 데이터를 찾아
비교할 수 있어요

Japanese: 
ここでは 学習レートやモデル構造を
任意に選びましたが
でも 異なった方法で行うと
どうなるでしょう
２つの異なった学習レートや
モデル構築を試すなら？
こういうことにも
TensorBoard は本当に便利です
いろんな変数で蓄積した
いろんなバージョンのモデルを比較するのに
良い方法を与えてくれます
コードを少し 変更しましょう
３つの違う学習レートで反復しましょう
それから 完全結合層と畳み込み層を
１つか２つ反復します
そして 個々のハイパーパラメーター設定を
説明する独自の文字列を作ります
例えば lr_1e-3 として
fc=2 と conv=2 とします
そして 新サマリーライターを作ります
これは 名前の中から
その文字列のディレクトリを指定します
すると モデルが実行されます
そして 親レベルのディレクトリの
TensorBoard を指定します
以前は実行用ディレクトリの
TensorBoard を指定していましたが
今は実行の親の方を確認します
すると データが全部見つかって
比較できます

English: 
and we chose our model
architecture kind
of arbitrarily.
But what if we had done
things differently?
What if we tried a couple
of different learning rates
and what if we had tried a
couple of different model
architectures?
TensorBoard can be really
useful for this as well
because it gives you
a good way to compare
how different versions
of your models
stack up on all of these
different variables.
So we can make a couple
of changes to our code.
We're going to iterate over
three different learning rates.
And then we'll
iterate over using
one or two fully
connected layers
and one or two
convolutional layers.
And we're going to
make a unique string
for each of these hyperparameter
settings describing it.
For example, learning rate,
underscore, 1e negative 3,
then fully connected equals
2, and then convolutional
equals 2.
And we'll create a
new summary writer
that's pointing to
a directory that
has that string in the name.
And now we can
actually run the model.
And we're going to point
TensorBoard at the parent level
directory.
So in the past,
we've been pointing
TensorBoard at the
directories for specific runs.
And now we want to look
at the parent of runs

Spanish: 
y elegimos nuestro modelo de
arquitectura de forma arbitraria.
Pero ¿y si lo hubiéramos
hecho de otra diferente?
¿Y si probamos diferentes
ritmos de aprendizaje
y diferentes modelos de arquitecturas?
TensorBoard puede
ser realmente útil para esto
porque les da una buena manera de comparar
cómo las diferentes
versiones de sus modelos
se comportan con
estas diferentes variables.
Podemos hacer unos cambios en el código.
Vamos a iterar con tres
diferentes ritmos de aprendizaje.
Y luego vamos a iterar usando una
o dos capas totalmente conectadas
y una o dos capas circonvolucionales.
Y vamos a hacer una cadena única
para cada configuración
de estos hiperparámetros.
Por ejemplo, "lr_1E-3",
totalmente conectadas es igual a dos
y luego la circonvolucional es igual a 2.
Y vamos a crear un nuevo
resumen apuntando a un directorio
que tiene esa cadena en el nombre.
Y ahora podemos correr el modelo.
Y vamos a apuntar TensorBoard
al nivel primario del directorio.
Antes apuntábamos TensorBoard al
directorio para ejecuciones específicas.
Y ahora queremos apuntar
al directorio padre
de modo que pueda encontrar
todos estos datos y compararlos.

Portuguese: 
e também a nossa arquitetura
de modelo desta forma,
mas e se fizéssemos as coisas
de modo diferente?
E se tentássemos taxas
de aprendizado diferentes,
arquiteturas de modelo diferentes?
TensorBoard pode ser muito útil
por isso também, porque compara bem
como versões diferentes dos seus modelos
se acumulam em todas essas variáveis.
Então fazemos algumas 
alterações no nosso código.
Vamos iterar em três taxas
diferentes de aprendizado.
E então iterar usando uma ou duas
camadas inteiramente conectadas
e uma ou duas camadas convolucionais.
Vamos fazer uma série única
para cada uma dessas configurações
de hiperparâmetro.
Por exemplo, "lr_1-3, fc=2, conv=2"
E vamos criar 
um gravador de sumário
apontando ao diretório 
com aquela série no nome.
Agora podemos realmente rodar o modelo.
E vamos apontar o TensorBoard 
ao diretório de nível principal.
Antes estávamos apontando o TensorBoard
a diretórios com execuções específicas.
E agora vamos apontar
para a execução principal
para encontrar 
todos esses dados e comparar.

Chinese: 
我们任意选择了学习率
模型建构也是随意选择的
但换一种做法会怎样呢？
如果尝试几种不同的学习率会怎样？
或者尝试几种不同的模型建构？
TensorBoard在这方面很好用
因为它能让你比较
不同版本的模型与这么多不同的变量
怎样搭配会更好
这样便可以对我们的代码进行修改
我们会在三种不同的学习率间进行重复
然后我们会利用
一到两个完全联通的层
以及一两个卷积层来重复
然后我们为每一个超参数设置
创造一个独特的字符串
这些设置描述了字符串
比如，“lr_1E-3”
然后是“fc=2”
“conv=2”
然后创造一个新的概要写手
指向有那个名字的字符串
所在的目录
现在可以运行模型了
让TensorBoard指向上一级目录
以前，我们一直让TensorBoard指向
具体测试的目录
现在我们想观察测试的上一级

Korean: 
이제 다음 데모로 넘어가봅시다
여기 왼쪽의 실행 장소에
우리가 시험해볼 모든 다른
hyperparameter 세팅이 있는 게 보이시죠
그리고 우리 크로스 엔트로피를 보면
다른 실행에서 어떻게 되는지
비교할 수 있습니다
이처럼 정확도도 있고요
실제로 변수들이 많죠
어떤 모델은 거의 학습을 못하고요
어떤 모델은 정말 완벽하네요
크로스 엔트로피를 보면
더 명확한 것을 원하실 건데요
모든 게 높은 값에서 시작하는 것처럼
보여지는 걸 재조정합니다
줌인하면 더 명확한 걸 얻을 수 있어요
대수적 스케일로 전환할 수도 있는데
그러면 차이가 더 잘 드러나서
가끔 매우 유용합니다
그리고 우리 도구 팁을 살펴봅시다
여길 보면 가장 안 좋은 부분은
습득율 -3이고
나선형과 모두 연결된 것이 보입니다
가장 좋은 부분은 여기인데 같지만

Portuguese: 
Vamos à nossa próxima demonstração.
E aqui temos um site de execução 
à esquerda, com todas essas configurações
de hiperparâmetros diferentes,
que nós experimentamos.
Podemos ver, por exemplo, 
nossa entropia cruzada
e como se comparam
em diferentes execuções.
Temos também a exatidão aqui em cima.
Podemos ver que houve muita variação.
Alguns dos modelos quase não aprenderam
coisa alguma e alguns foram muito bem.
Se olharmos a entropia cruzada, 
talvez tenhamos mais clareza.
Inicialmente tudo começa alto
e então redimensiona o mostrador.
Podemos aumentar o zoom
e ver as coisas mais claramente.
Podemos também alternar 
a escala de algoritmo
o que torna as diferenças 
um pouco mais acentuadas
e pode ser muito útil.
Então podemos começar 
a explorar as dicas de ferramentas
e ver, que esta execução, que foi a pior,
foi a taxa de aprendizado 3 negativo
foi também convolucional 
e inteiramente conectada.
E essa, que foi uma das melhores, 
foi a mesma coisa,

English: 
so that it can find all of this
data and compare it for us.
So now we can go
to our next demo.
And here, we have this
run site on the left
has got all of these different
hyperparameter settings
that we experimented with.
And now we can look at, for
example, our cross entropy
and start to see
how they compare it
across the different runs.
Similarly, we have
accuracy up here.
So we can see, actually,
there was a lot of variance.
Some of our models barely
learned anything at all,
and some of them were
extremely successful.
If we look at cross
entropy, maybe we
want to make things
a little bit clearer.
Like the beginning
everything starts high,
so it rescales the display.
So we can zoom in, and we get
things a little bit clearer.
We can also toggle on a
logarithmic scale, which
makes the differences a
little bit more pronounced
and sometimes very useful.
And then we can start
exploring with our tool tips
here and seeing, OK, this
run that was the worst
was learning rate negative 3,
and then both convolutional
and both fully connected.
And this one that was the
best was the same thing

Indonesian: 
Sekarang kita bisa ke demo selanjutnya.
Di sini, kita punya situs
run ini di sisi kiri
punya semua pengaturan hyperparameter ini
yang sudah kita coba.
Kita bisa lihat, misalnya
entropi silang kita
dan lihat bagaimana itu membandingkan
sepanjang run yang berbeda.
Kita punya akurasi di sini.
Bisa lihat, ada banyak variasi.
Beberapa tidak belajar banyak sama sekali,
dan beberapa darinya sangat berhasil.
Jika lihat entropi silang, kita
ingin membuatnya sedikit lebih jelas.
Seperti pertamanya semua mula-mula tinggi,
jadi itu menghitung ulang tampilan.
Kita bisa perbesar, dan mendapat
gambaran lebih jelas.
Kita juga bisa toggle di
skala logaritma, yang
membuat perbedaan sedikit lebih jelas
dan terkadang berguna.
Bisa mulai jelajah dengan
tips alat kita
disini, dan lihat,
run ini yang terburuk
tingkat pembelajaran negatif 3,
dan keduanya konvolusional
dan terhubung sepenuhnya.
Yang ini yang terbaik adalah sama

Japanese: 
では次のデモにいきます
この実行中のサイトの左側に
実証済みのさまざまな
ハイパーパラメーター設定があります
例えば 交差エントロピーを見てみましょう
他の実行済みのもの同志で
比較して見れます
同様に上には正確性があります
実に多くのバラつきがありますね
モデルのいくつかは
全く学習してないですね
でも 非常に順調なものもあります
交差エントロピーを見ると
もう少しハッキリさせたくなるでしょう
最初は すべてが高いので
表示の単位が調整されています
ズームできますので
データが もう少しハッキリします
また 対数尺度でもトグルできます
これで 差異がもう少し明確になり
時には 非常に便利です
それから このツールの使い方を
探っていきましょう
実行済みのもので最低値は
学習レート -3 です
畳み込みと完全結合の両方がそうです

Spanish: 
Vamos a nuestra siguiente demostración.
Aquí, tenemos
las ejecuciones a la izquierda
tiene todas las diferentes configuraciones
con las que experimentamos.
Y ahora podemos ver, por ejemplo,
nuestra entropía cruzada
y empezar a ver cómo
se comparan a lo largo de la ejecución.
Del mismo modo, tenemos la precisión aquí.
Podemos ver que hay mucha varianza.
Algunos de nuestros modelos
casi no aprendieron nada
y algunos son extremadamente exitosos.
Si vemos la entropía cruzada,
estará un poco más claro.
Al principio todo comienza alto
vamos a ajustar el gráfico.
Hacemos un acercamiento y así las cosas
están un poco más claras.
También podemos usar
una escala logarítmica
que hace que las diferencias
sean un poco más pronunciadas
y algunas veces estoy es muy útil.
Podemos empezar a explorar sobre la curva
y ver que esta ejecución fue la peor
y aprendía con una tasa negativa 3
y luego dos circonvoluciones
y dos capas completamente conectadas.

Chinese: 
这样就可以找到所有数据
帮我们进行比较
现在进入下一个展示
这里，左侧是测试站点
有所有我们试验的
不同的超参数设置
比如，现在可以观察交叉熵
并看到它们与其他所有测试相比较
表现如何
类似的，上边这是准确度
可以看到，有许多不同
一些模型基本没学到什么
一些模型非常成功
如果观察交叉熵的话
也许我们想要更加明确
起初，每一条线位置都很高
现在需要重新显示
放大之后，可以看得更清楚
还可以打开对数标尺
让不同变得更加明显
这在一些情况下会很有用
接下来，可以用工具提示进行探索
最差的测试的学习率是-3
两者都是卷积的
两者也完全联通
最好的一次情况相同

Indonesian: 
tapi dengan tingkat
pembelajaran lebih kecil.
Jika kita ingin lakukan
perbandingan lebih jauh,
kita bisa mulai menyaring
dengan pengaturan disini.
Jika kita ingin lihat semua hal
yang hanya punya satu lapisan
konvolusional,
ketik conv sama dengan 1, dan kini
lihat dengan satu
lapisan konvolusional,
sehingga membuatnya lebih mudah
untuk menyelaminya.
Atau kita bisa mencari hal-hal yang hanya
punya tingkat pembelajaran e ke negatif 4,
dan itu termasuk run terbaik kita.
Beberapa fitur lain yang akan dibahas.
Anda juga bisa toggle satu
run dengan klik disini.
Kita juga bisa merubah tampilannya
untuk menunjukkan cara berbeda dalam
menggambarkan waktu.
Sekarang, kita orientasikan
sumbu-x dengan langkah.
Kita bisa lakukannya dengan,
misal, waktu dinding.
Kita bisa lihat, sebenarnya,
sementara semua
ada di langkah, dijalankan
dalam waktu berbeda.
Kita bisa pakai waktu relatif,
ini akan menunjukkan menit dari awal.
Kita lihat, sebenarnya, beberapa
model menghabiskan
lebih banyak waktu run.
Walau langkahnya sama,
yang lebih terhubung sebelumya

English: 
but with a smaller
learning rate.
And if we want to do a
more in-depth comparison,
we can start to filter
by settings here.
So if we want to look
at all the things
that had only one
convolutional layer,
we could type conv
equals 1, and now
we can see just the ones that
had one convolutional layer, so
that makes it a little
bit easier to dive it.
Or similarly, we could search
for only the things that
had the learning rate
of e to the negative 4,
and that includes our best run.
A couple other features
I'll point out.
You can also just toggle one
run at of time by clicking here.
And we can also
change the display
to show us different
ways of visualizing time.
Right now, we're orienting
the x-axis by step.
But we could do it by,
for example, wall time.
And then we can see, actually,
that while they're all
aligned in steps, I ran
them at different times.
We can also use
relative time, so this
will show the number
of minutes from start.
And then we can see, actually,
that some models took a lot
longer to run than others.
So even though they took
the same number of steps,
the models with
more fully connected

Korean: 
습득율이 더 낮습니다
더 깊이 있는 비교를 원한다면
여기 세팅으로 필터링할 수 있습니다
하나의 나선형 레이어만 가지는
모든 것들을 보고 싶다면
conv=1을 입력합니다
하나의 나선형 레이어만
가지는 것들이 보이네요
접근하기가 더 쉽죠
비슷하게, E 습득율이 -4인 것들만
검색할 수도 있습니다
가장 잘 실행되는 것도 포함되죠
몇몇 다른 기능도 보여드릴게요
여길 클릭함으로써
실행 하나를 전환할 수 있습니다
표시 화면을 바꿔서
다른 가시화 시간을 보여줄 수도 있어요
이제, X축을 기준으로 해볼게요
예를 들어서 wall 시간을 바탕으로요
실제로 단계적으로 정렬되면
다른 시간에 실행하는 걸 볼 수 있죠
또한 상대적 시간을 활용해여
시작부터 몇 분 걸렸는지도
볼 수 있어요
그리고 실제로 어떤 모델은
다른 것들보다
실행하는 데 시간이 많이 걸려요
그것들이 같은 수의 단계를 거치더라도
더 완전히 연결된 모델과

Chinese: 
但学习率更小
想做更深入的对比的话
可以通过设置进行过滤
如果想观察
只有一层卷基层的数据
那就输入“conv=1”
这就可以看到
只有一层卷基层的数据了
这样能更加方便细致分析
类似的，也可以搜索学习率只有
e的-4次方的数据
这包括我们最好的一次测试
我还要讲一些其它的功能
你只需点击这里，就可以打开一次测试
也可以修改
展示时间的不同方式
现在，通过步骤标定x轴
但也可以通过墙上时间标定
然后可以看到，尽管在步骤里
它们都是对齐的
但我是在不同时间运行的
也可以使用相对时间
这会显示自开始时的分钟数
我们会发现
一些模型运行的时间要长很多
所以尽管它们的步骤数相同
有更加完全联通、更加卷积的层的模型

Spanish: 
Y la mejor lo mismo, pero con
una tasa de aprendizaje más pequeña.
Y si queremos hacer una
comparación más profunda
podemos ajustar los filtros por aquí.
Si queremos ver todas las que
tenían solo una capa de circonvolución
podemos poner que conv es igual a uno
y así vemos solo las que tenían
una capa de circonvolución
eso hace que sea
un poco más fácil de analizar.
También podríamos buscar solo las
que tiene una tasa de aprendizaje
de "e" elevado a 4 negativo
y eso incluye nuestra mejor ejecución.
Voy a mostrar otras características.
También se puede ver
una sola ejecución haciendo clic aquí.
También podemos cambiar la visualización
para ver diferentes modos
de visualización en el tiempo.
En este momento
tenemos el eje X por pasos.
Pero podríamos ver,
por ejemplo, el tiempo real.
Vemos que si bien todos
están alineados en los pasos
se ejecutan en diferentes momentos.
También podemos verlo en tiempo relativo
mostrará el número de
minutos desde el comienzo.
Podemos ver que algunos modelos
tardaron mucho más tiempo que otros.
A pesar del mismo número de pasos
los modelos con más capas
completamente conectadas

Portuguese: 
mas com a taxa de aprendizado muito menor.
E se quisermos fazer
uma comparação mais profunda,
podemos filtrar por configurações.
Se quisermos ver todas as coisas 
com apenas uma camada convolucional,
podemos digitar conv=1
e agora vemos só aquelas
com uma camada convolucional,
o que facilita uma análise profunda.
Ou também podemos buscar apenas as coisas
que tiveram taxa de aprendizado
até 4 negativo, o que inclui 
nossa melhor execução.
Vou mostrar alguns outros recursos.
Podemos alternar 
uma execução por vez clicando aqui.
E também mudar o mostrador
para nos mostrar jeitos diferentes
de visualizar o tempo.
Agora estamos orientando 
o eixo-x por passo.
Mas poderíamos fazer isso, por exemplo,
por tempo de barreira.
E realmente ver que enquanto 
estão todos alinhados em passos,
os executo em tempos diferentes.
Também podemos usar tempo relativo, 
para ver o número de minutos do início.
E podemos ver que alguns modelos levaram
mais tempo para rodar do que outros.
Mesmo tendo o mesmo número de passos,

Japanese: 
これは同じことなのに
より少ない学習レートで最高です
もっと深く比較したい場合
ここで設定ごとに
フィルターすることができます
畳み込み層が１つだけあるものを
すべて見たい時は
conv=1 と打ちます
畳み込み層が１つのものだけが出ます
より簡単にそれらの中を検証できます
学習レートが -4 のデータだけのものも
同様に検索できます
そこには最高実績が含まれています
他の機能も見てきましょう
ここをクリックすると
その時に実行されたものをトグルできます
可視化する時間帯のディスプレイを
変更して見ることもできます
現在は X 軸を段階ごとで示しています
これを例えば時系列にもできます
すると 実際には 段階ごとに
それぞれ違う時間帯で実行されていますね
相対時間に設定すると
開始からの所要時間を示します
実行時間がとても長いモデルがありますね

Indonesian: 
dan lebih konvolusional berjalan
dua kali lebih lambat.
Kita juga bisa menggambarkan--
semua tampilan lainnya
juga beri lebih banyak informasi.
Jika kita ingin lihat seluruh bias,
kita lihat bagaimana mereka bervariasi
untuk model berbeda.
Mari lihat, conv 1, garis miring
bias, mungkin.
Itu cukup menarik bahwa
model berbeda sebenarnya
punya pola berbeda dalam hal
bias berubah sepanjang waktu.
Mungkin dengan menyelidikinya,
kita bisa tahu model mana yang sebenarnya
berbeda secara struktur.
Di penggambar grafik,
kita bisa menjelajahi run berbeda.
Kita bisa lihat sekarang kita
punya model dengan satu
lapisan konvolusional
dan yang terhubung sepenuhnya.
Tapi kita bisa membandingkannya
dengan model berbeda.
Hal terakhir--
fitur utama TensorBoard yang akan
saya jelaskan
adalah embedding visualizer.
Itu mungkin hal yang terkeren
dari TensorBoard.
Yang pada dasarnya embedding visualizer
lakukan ialah

Korean: 
더 나선을 띄는 레이어는
두 배 정도 느리게 실행됩니다
그리고 모든 화면을 띄워서
정보를 더 얻을 수도 있습니다
모든 바이어스를 보고 싶다면
다른 모델에서는
어떻게 달라지는지 보면 돼요
conv1/bias를 입력하고
다른 모델들이 실제로
시간이 지나며 바이어스를
패턴화하는 다른 방향을 가지는 게
흥미롭네요
이것에 파고든다면
모델이 실제 구조적으로
다르다는 것을 알 수 있어요
비슷하게, 그래프 비주얼라이저에서
다른 실행을 확인할 수 있어요
여기서 이제 우리 모델 중 하나에
하나의 나선형 레이어와 하나의
완전히 연결된 레이어만 있는 것을
볼 수 있습니다
또한, 이걸 다른 모델과
비교할 수 있어요
마지막으로
제가 소개하고픈
Tensorboard의 주요 특징은
임베딩 비주얼라이저입니다
이게 TensorBoard의
가장 멋진 부분입니다
임베딩 비주얼라이저는 기본적으로

Chinese: 
运行的速度会慢一倍
也可以显示所有其他显示
同时给我们更多信息
如果想看所有的偏差
就可以看到随着模型的变化
偏差是如何变化的
输入“conv1/bias”
这有些意思
可以看到不同模型
对偏差随时间的演变
有不同的规律
仔细研究这一点的话，很有可能
学到模型结构上产生区别的方式
类似的，在图表显示器里
可以探索不同测试
可以看到，目前有一个模型
只有一层卷积层
和一层完全联通层
但我们可以将它和其他模型比较
最后，也是我要讲解的
TensorBoard的一个重要功能
就是嵌入显示器
这可能是TensorBoard最酷的一部分
它的功能

Portuguese: 
os modelos com mais camadas convolucionais
e inteiramente conectadas
rodaram duas vezes mais devagar.
E podemos também visualizar todos os 
mostradores, que nos dão mais informações.
Se quisermos ver todas as tendências,
podemos ver como variam 
em modelos diferentes.
Vejamos, conv1/bias, talvez.
É interessante como podemos ver 
que os diferentes modelos
tiveram padrões muito diferentes
na evolução de suas tendências
ao longo do tempo.
E provavelmente por cavar aqui, 
podemos aprender
como os modelos 
são estruturalmente diferentes.
Também, no visualizador de gráfico, 
podemos explorar as diferentes execuções.
Podemos ver aqui que agora temos 
um dos modelos que tiveram
só uma camada convolucional 
e uma inteiramente conectada.
Mas podemos comparar 
com modelos diferentes.
Por fim, uma característica importante
do TensorBoard que vou descrever
é o visualizador incorporado.
E talvez esse seja a parte
mais legal do TensorBoard.
O que o visualizador incorporado faz

Spanish: 
y más circonvoluciones,
se ejecutaron en el doble de tiempo.
También podemos visualizar otras cosas
que nos darán más información.
Si queremos ver todos los sesgos
podemos ver cómo variaron
para los diferentes modelos.
Y vamos a ver, "conv1/bias", tal vez.
Es muy interesante
ver que diferentes modelos
tienen patrones muy diferentes
sobre cómo los sesgos
evolucionan en el tiempo.
Y probablemente, al analizarlo
podríamos ver sus
diferencias estructurales.
Del mismo modo, en el visualizador gráfico
podemos explorar
las diferentes ejecuciones.
Por lo que podemos ver aquí;
uno de los modelos solo tenía
una capa circunvolucional
y solo una capa totalmente conectado.
Podemos compararlo con diferentes modelos.
Lo último de lo que hablaré es sobre
una de las principales características
que es el visualizador embebido.
Y es quizás lo más genial de TensorBoard.
Lo que el visualizador embebido hace,
es permitir tomar

Japanese: 
段階数は同じでも
完全結合や畳み込みがあるモデルほど
実行に２倍の時間がかかります
また 他のディスプレイも
すべて可視化できますし
情報も もっと入ります
すべてのバイアスを見たいなら
いろいろなモデルで
拡散している様子を確認できます
見てみましょう
多分 conv1/bias です
モデルが違うと 時間とともに
バイアスの入るパターンが違ってくるのは
ある意味 面白いです
これを もっと深く見ていけば
モデルが構造的に異なる方法が
学習できるでしょう
グラフビジュアライザーも同様に
違うやり方を探ることができます
ここでは畳み込み層を１つ
完全結合層を１つ持つモデルがあります
しかし 代わりの他のモデルと
比較できます
最後に これからお話しする
TensorBoard の主機能は
埋め込みビジュアライザーです
これは TensorBoard でも
最高峰でしょう
埋め込みビジュアライザーは
基本的に

English: 
and more convolutional layers
ran about twice as slowly.
And then we can also visualize--
all of our other displays
also give us more information.
So if we wanted to
look at all the biases,
we could see how they
varied for different models.
And let's see, conv
1, slash bias, maybe.
And so that's kind
of interesting
that we can see the
different models actually
had very different
patterns for how
the biases evolved over time.
And probably by
digging into this,
we could learn some ways in
which the models are actually
structurally different.
Similarly, in the
graph visualizer,
we can explore the
different runs.
So we can see here
that right now we
have one of the models
that had only one
convolutional layer and only
one fully connected layer.
But we could go and compare it
to different models instead.
So the final thing--
major feature from TensorBoard
that I'm going to describe
is the embedding visualizer.
And it's maybe the coolest
piece of TensorBoard.
What the embedding
visualizer basically does

Indonesian: 
membiarkan Anda mengambil
data dimensi tinggi
dan memproyeksikannya ke
dalam tiga dimensi.
Cara yang mungkin menarik
untuk melakukannya
ialah saat kita mengambil
seperangkat data input kita
dan memetakannya sepanjang
jaringan neural,
lapisan final, dimana embedding
sebenarnya ialah
representasi yang dipelajari dari
cara jaringan neural memroses informasi.
Saya akan menulis kode di layar,
saya takkan bahas secara mendalam.
Tapi saya akan beritahu tutorial bagus
mengenai embedding visualizer
di halaman web.
Intinya, yang kita akan lakukan
adalah kita akan buat variabel yang
akan menahan embedding tiap
seperangkat gambar tes kita.
Kita akan menciptakan
objek konfigurasi yang
punya sedikit informasi,
dimanakah kita bisa
temukan sprite PNG dari semua
gambar MNIST
jadi kita bisa tampilkan
thumbnail di penjelajah?
Dimanakah kita temukan label
sehingga kita bisa mengorganisir contoh
label manakah mereka?
Kita tulis semua ini ke disk
menggunakan FileWriter.
Sekarang, setiap 500 langkah, kita akan
menyimpan checkpoint model.
Checkpoint model ini berisi
seluruh variabel di model kita,

Portuguese: 
é permitir a você pegar dados dimensionais
e os projetar em três dimensões.
Nosso interesse nisso é quando pegamos
nosso conjunto de dados de entrada
e o mapeamos através
da rede neural até a camada final,
essa inserção é a representação aprendida
de como nossa rede neural
processa as informações.
Vou jogar um monte de código na tela
e não vou explicar em profundidade.
Mas há um tutorial maravilhoso sobre 
o visualizador incorporado no website.
Mas basicamente o que vamos fazer é
uma variável que mantém a incorporação
de cada uma das nossas imagens
do conjunto de teste.
Vamos criar um objeto de configuração 
que tenha um pouco de informação,
por exemplo, onde podemos 
encontrar um PNG de duende
dentre todas as imagens MNIST, 
para mostrar miniaturas no navegador?
E onde estamos encontrando 
as etiquetas para organizar os exemplos
por cada uma em que estão?
Então escrevemos isso no disco 
usando FileWriter.
E agora, a cada 500 passos, vamos salvar
um ponto de controle.
E esse ponto de controle contém
todas as variáveis no nosso modelo,

Japanese: 
高次元データを取り込んで
３次元に落とし込みます
ここで とても 面白いと思うのは
入力データセットを取り込んだら
ニューラルネットワークを通して
マッピングするのです
例えば 埋め込まれる最終層は
ニューラルネットワークの情報処理方法の
学習された表現です
なので これから一連のコードを
画面に投入します
あまり詳細に説明しませんが
ウェブサイトにビジュアライザー埋め込みの
とても良いチュートリアルがあります
基本的に これからすることは
各テストセット画像を
埋め込むことができる変数の作成です
そして詳細情報の入れられる
コンフィグレーションオブジェクトを作り
それには 例えば 全 MNIST 画像の
スプライトの PNG がある場所情報で
サムネールをブラウザ内に
ディスプレイできるようにしたり
ラベルがある場所情報で
ラベルごとに例をまとめたりでき
そして それを全て
FileWriter を使うディスクに書きます
そして 500 段階毎に
モデルの確認ポイントを保存します
そのモデル確認ポイントには
モデルのすべての変数が入っていて

Korean: 
높은 차원의 데이터를 다루도록 해주고
그걸 3차원으로 보여줍니다
이걸 하는 데 있어서
정말 관심 가질 부분은
입력된 데이터 세트를 취할 때
이걸 신경 네트워크에 그려넣어요
마지막 레이어에 그 임베딩은 실제로
우리 신경회로가
어떻게 정보를 처리하는지
보여주는 습득된 표현입니다
스크린에서 코드 세트를 사용할 건데요
더 깊이있게 설명하진 않겠습니다
웹사이트에 임베딩 비주얼라이저에 관한
훌륭한 튜토리얼이 있어요
기본적으로 우리가 할 것은
우리 테스트 세트 이미지 각각의
임베딩을 갖고 있는
변수를 만드는 겁니다
그리고 배열 객체를 만들 것입니다
어디서 모든
PNG MNIST 이미지를 찾아
브라우저에 썸네일을 표현할 수 있는지
그런 정보를 담고 있는 객체죠
그리고 어디서 라벨을 찾아서
어떤 라벨인지에 따라
예를 정렬할 수 있는지도요
FileWriter를 이용해
이것을 모두 디스크에 씁니다
그리고 500단계마다
모델 체크포인트를 저장합니다
이 모델 체크포인트는
우리 모델의 모든 변수들과

English: 
is it lets you take
high dimensional data
and then project it down
into three dimensions.
Now the way in which we might
be really interested in doing
this is when we take
our input data set
and we map it through the
neural network, to say,
the final layer, that
embedding is actually
the learned representation
of how our neural network is
processing the information.
So I'm going to throw a
bunch of code on the screen,
and I'm not going to
explain in great depth.
But I will say there's
a wonderful tutorial
on the embedding
visualizer on the website.
But basically, what
we're going to do
is we're going to
make a variable that
will hold the embedding of
each of our test set images.
And then we're going to create
a configuration object that
has a little bit of
information like, where can we
find a sprite PNG of
all the MNIST images
so we can display
thumbnails in the browser?
And where are we
finding the labels
so that we can
organize the examples
by which label they are?
And then we write this all
to disk using the FileWriter.
And now, every 500
steps, we're going
to save a model checkpoint.
And this model
checkpoint contains
all of the variables
in our model,

Spanish: 
datos de altas dimensiones
y proyectarlos en tres dimensiones.
Lo que realmente podría
interesarnos ​​es tomar
nuestro conjunto de datos de entrada
y mapearlos a través de
la red neuronal hasta la última capa
que sería la representación
del aprendizaje
sobre cómo nuestra red neuronal
procesa la información.
Voy a mostrar mucho código en la pantalla
y no lo voy a explicar detenidamente
pero hay un tutorial maravilloso sobre
el visualizador embebido en el sitio web.
Básicamente lo que vamos a hacer
es crear una variable que contenga
cada una de nuestras imágenes de prueba.
Luego creamos un objeto
de configuración con información sobre
dónde encontrar una imagen
PNG de todas las imágenes MNIST
para poder mostrar las imágenes
en miniatura en el navegador.
Y dónde están las etiquetas
para poder organizar
los ejemplos de acuerdo a ellas.
Escribimos todo esto en
el disco utilizando FileWriter.
Y ahora, cada 500 pasos,
va a guardar un punto de control.
Y este punto de control tiene
todas las variables en nuestro modelo

Chinese: 
是让你将高维度数据
投射至三维空间
我们可能感兴趣的方面
是当我们将输入数据组
通过神经网络绘制到最后一层
这种嵌入就是神经网络
如何处理信息的学习代表
我会在屏幕上展示一些代码
我不会详细解释
但是我想说
在网站上有个很棒的视频
讲的就是嵌入显示器
但基本上讲，我们要做的
就是创建一个变量
它能承载每一个测试组图像的嵌入
然后创建配置对象
它有一点点信息
例如在哪里可以找到
所有MNIST图像的精灵PNG
以方便我们在浏览器中显示预览图
以及在哪里我们可以找到标识
通过标识整理例子
我们将这些利用FileWriter全部写入硬盘
现在，每500步
我们就保存一个模型检查点
这个检查点含有模型中
所有的变量

Japanese: 
埋め込み変数も含まれています
そして このディレクトリを指定する
TensorBoard を再びオンにします
こちらが埋め込まれたものです
これはテストセットからの使用が決まった
1024 点の MINIST です
今 見ているのは
埋め込まれた基本構成要素の分析です
最初に３つの基本構成要素を取り入れ
点として三次元の形で配置しました
ラベルによって色分けすると
非常に便利な分け方を
学習しているのが見て取れます
１つ１つが基本構成要素ごとに
分けられています
片方の基本構成要素に
9 と 7 がありますが
この２つの数字は確かに似ています
反対側の基本構成要素には
2 と 3 と8 があります
しかし これよりも
もっと良い方法があります
T-SNE という
個人的に好きな機能です
これはデータセットを再編成しますので
局所的な近似性を保持します
局所的に似ている埋め込みデータ同士を
多角的に示して

Portuguese: 
inclusa a variável de incorporação.
Então ligamos TensorBoard de novo, 
apontando a esse diretório.
E aqui temos nossa incorporação.
São 1.024 pontos do MNIST que decidi
usar do conjunto de teste.
E o que vemos agora é a análise dos
principais componentes da incorporação.
Então pegamos os três componentes 
principais do topo e os definimos
em cópia de três dimensões.
Se colorirmos por etiqueta podemos ver
que aprendeu uma separação útil,
como todas que foram separadas 
em um dos principais componentes.
Há um componente principal,
que tem os 9s e os 7s, o que faz sentido
já que são similares.
Na ponta oposta desse componente 
principal, temos os 2s, 3s e 8s.
Mas podemos fazer até melhor do que isso.
Podemos usar o meu recurso 
preferido, que é T-SNE.
Isso vai reorganizar o conjunto de dados
para preservar a similaridade local.
Então temos essa visualização legal,
que mostra quais pedaços de dados

English: 
including that
embedding variable.
And then, finally, we turn
on TensorBoard once again,
pointing to this directory.
And here we have our embedding.
This is 1,024 points
from MNIST that I decided
to use from the test set.
And what we're
looking at right now
is the principal components
analysis of the embedding.
So we've taken the top
three principal components
and laid out these points in
three dimensional manifold.
So if we color by
label, we can already
see that it's learned a pretty
useful separation, like all
of the ones that have
been separated on one
of the principal components.
And then there's kind of
one principal component
has the 9s and the
7s, which makes sense
since they're kind of similar.
And then on the opposite end
of that principle component,
you have more like
2s and 3s and 8s.
But we can do even
better than this.
We can use my personal
favorite feature here,
which is [INAUDIBLE].
So this is going to
go and reorganize
the data set so that it
preserves local similarity.
And then we get this
really cool visualization
that shows us which
pieces of data

Korean: 
임베딩 변수를 포함합니다
그리고 마지막으로
TensorBoard를 다시 켜서
디렉토리를 가리킵니다
여기 임베딩이 있네요
이건 제가 테스트 세트에서
사용하기로 한
MNIST에서 1,024 포인트입니다
그리고 우리가 지금 보는 것은
임베딩의 주요 요소 분석입니다
최상 세 주요 요소를 가지고
3차원으로 나열해봅시다
라벨 별로 색을 입히면
이미 유용하게 분리된 것을
볼 수 있어요
모든 것들이 주요 요소들 중
하나에 의해
분리된 것으로 보이죠
그리고 중요한 요소로는
9와 7이 있습니다
이것들은 비슷하기 때문이죠
주요 요소 반대 편 끝에는
2, 3, 8이 있습니다
이것보다 더 나은 결과도 얻을 수 있죠
개인적으로 즐겨찾는 기능을
사용할 수 있어요
이것은 [청취 불가]입니다
이것은 데이터 세트를 재정렬해서
근처에 비슷한 게 모이는 걸
유지할 거예요
이렇게 임베딩에서 많은 데이터들이
어떻게 지역적으로 연결되어 있는지

Spanish: 
incluyendo la variable para el embebido.
Finalmente ejecutamos TensorBoard
una vez más apuntando a este directorio
Aquí tenemos nuestro modelo embebido.
Son 1.024 puntos de MNIST
que usé del conjunto de prueba.
Y lo que vemos en este momento
es el análisis embebido
de los componentes principales.
Tomamos los tres componentes principales
y mostramos estos puntos
en tres dimensiones.
Si coloreamos por etiqueta
podemos ver que aprendió
una separación bastante útil
todos los unos están separados
de los componentes principales
y vemos que un componente
principal tiene los nueves y los sietes
que es comprensible,
ya que son algo similares.
Y en el extremo opuesto
de ese componente principal
están los dos, tres y ochos.
Sin embargo, podemos verlo mejor.
Podemos usar una de mis características
favoritas que es T-SNE.
Lo que hace es reorganizar
el conjunto de datos
para conservar similitudes locales.
Y entonces tenemos
esta visualización genial
que nos muestra qué piezas de datos

Indonesian: 
termasuk variabel embedding itu.
Akhirnya, kita hidupkan TensorBoard
sekali lagi,
menunjuk ke direktori ini.
Dan kita pun punya embedding kita.
Ini 1.024 poin dari MNIST yang
saya putuskan untuk
pakai dari seperangkat tes.
Apa yang sedang kita lihat
ialah analisis komponen utama
dari embedding.
Jadi kita ambil tiga komponen utama
dan meletakkan tiga poin ini dalam
manipol tiga dimensi.
Jika kita warnai sesuai label, kita bisa
lihat itu mempelajari separasi
yang berguna, seperti semua
yang telah berpisah dalam salah satu
dari komponen utama.
Ada satu komponen utama
punya 9s dan 7s, yang masuk akal
karena mereka agak serupa.
Di sisi lain dari komponen utama itu,
Anda lebih banyak punya 2s, 3s, dan 8s.
Tapi kita bahkan bisa lakukan lebih baik.
Kita bisa gunakan
fitur favorit saya disini,
yakni [tidak terdengar].
Ini akan mengorganisir
seperangkat data sehingga itu
menjaga kesamaan lokal.
Lalu kita mendapatkan
visualisasi keren ini
yang menunjukkan kita potongan data mana

Chinese: 
包括那个嵌入变量
最后，我们再次打开TensorBoard
指向这个目录
这样就有了嵌入
这是我决定从测试组中借用的
MNIST的1024点
现在看到的
是嵌入的主要构成分析
我们拿前三个主要构成
在一个三维空间里将这些点铺开
如果通过标识上色
就能看到它已经学习到了非常有用的分离
就像在主要构成上所有被分离的点
有一个主要构成
它有9和7
因为它俩很像，所以这可以理解
在这个主要构成的另一侧
主要看到的是2、3、8
但我们可以做得更好
可以用我最喜欢的功能
也就是 --
这样可以重新整理数据组
保留局部相似
还会看到这个很酷的显示
告诉我们那些数据

English: 
were locally connected in the
manifold, in the embedding.
So we can see, for example,
that the 1s got really
nicely clustered on their
own, which makes sense,
since 1s are very
distinct digit.
And we can see that it has
a little bit more trouble,
for example, with the 3s
and the 8s and the 5s,
because those are a little bit
closer and a little bit more
intermingled.
And we can even start to
dive into individual examples
where the model made
a bad prediction.
So if we look, for
example, at the 7,
it's clustered with the 1s,
so that's almost certainly
a test error, whatever
it incorrectly
labels the 7 as a 1.
But as we zoom in on
this particular 7,
it really does kind
of look like a 1.
It's probably the
oneiest 7 that I've seen.
So it makes sense that the
model's making that mistake.
And similarly, if
we look at this 9,
it really looks like a 1.
This 4, I think, really is a 4.
So maybe the model just
has an issue there.
The embedding
visualizer can also
be used for a lot
more than just images.
So it's really useful for
visualizing vocabularies
as well.

Korean: 
멋지게 볼 수 있습니다
예를 들어, 1은
그들끼리 잘 모여 있습니다
1은 매우 구분이 쉬운 숫자니까요
여기 3, 8, 5에는
문제가 약간 있긴해요
이것들은 꽤 가까이 붙어 있고
섞여있기 때문이죠
모델이 나쁜 예상을 보이는
개별적인 예를 자세히 볼 수 있어요
예를 들어 7을 보면
1과 함께 뭉쳐져 있습니다
거의 테스트 에러로써
7을 1로 라벨링하게됩니다
하지만 자세히 보면 이 특정 7은
1처럼 보입니다
이건 제가 본 것 중
가장 1같은 7이네요
모델이 왜 실수했는지 알겠어요
비슷하게 9를 보면
이건 정말 1처럼 보여요
이건 4, 정말 4 같네요
아마 모델이 거기 문제가 있나봐요
임베딩 비주얼라이저는
이미지 외에도 더 사용될 수 있어요
단어를 시각화하는 데도 도움되죠

Chinese: 
在嵌入中是局部联通的
比如，这些1会靠的很近
这是因为
1是非常特别的数位
还可以看到，3、8、5时
它就会遇到些困难
因为这些数字更近
互相有些混合
甚至还可以看看
模型在哪里做出了错误的预测
如果观察7的话
它和1凑在一起
这就肯定是测试错误了
它会将7错误地当做1
但当我们放大观察这个7
它的确看起来像是1
这可能是我见过最像1的7了
所以模型犯这个错误情有可原
类似的，观察9
看起来很像1
这个4，就是4
所以那里也许是模型唯一出问题的地方
嵌入显示器也可以
用于图像以外的领域
可以用在显示词汇

Japanese: 
実に素晴らしく可視化します
例えば 1 は 1 だけで
ちゃんと集まっています
1 は非常にわかりやすい数字ですから
これは納得です
ここは少し問題が見受けられます
例えば 3 と 8 と 5 は
やや似ているので
混ざっています
個々の例を詳しく見ていくと
モデルが間違ったつなぎ方をしています
例えば この 7 は
1 の集合に混じっています
これは たぶんテストエラーで
7 なのに間違って
1 にラベル付けされています
でも この 7 にズームインすると
本当に 1 に似ています
一番 1 っぽい 7 です
モデルが間違えるのも　
うなずけますね
同様に この 9 も
1 に非常に似ています
この 4 は本当に 4 なので
これはモデルの問題ですね
埋め込みビジュアライザーの使用は
画像だけにとどまりません
語彙の可視化にも本当に便利です

Portuguese: 
foram conectados localmente na cópia,
na inserção.
Podemos ver, por exemplo, que os 1s
ficaram bem agrupados, o que faz sentido,
já que 1s são dígitos distintos.
Podemos ver que há um pouco de problema,
por exemplo, com os 3s, 8s e 5s,
porque eles estão um pouco mais 
próximos e misturados.
Podemos até começar a mergulhar
em exemplos individuais,
onde o modelo fez uma previsão ruim.
Se olharmos, por exemplo, neste 7,
está agrupado com os 1s,
então deve ser um erro de teste, 
que etiqueta o 7 como se fosse um 1.
Mas quando aumentamos 
o zoom neste 7, parece ser um 1.
Provavelmente é o 7 
mais parecido com 1 que já vi na vida.
Faz sentido que o modelo esteja
cometendo este erro.
E também, se olharmos esse 9,
realmente parece um 1.
Este 4, acho que realmente é um 4.
Então talvez o modelo só tenha 
um problema aqui.
O visualizador incorporado também pode
ser usado para muito mais do que imagens.
É realmente útil 
para visualizar vocabulários.

Spanish: 
estaban conectados localmente
en el embebido.
Podemos ver, por ejemplo, que
los unos están bien agrupados
lo cual tiene sentido, ya que los
unos son dígitos muy distintivos.
Y podemos ver que tuvo
un poco más de problemas
con los tres, ochos y cincos
ya que están más agrupados
y entremezclados.
Incluso podemos analizar
ejemplos individuales
donde el modelo hizo una mala predicción.
Si nos fijamos,
por ejemplo, en este siete
está agrupado con los unos,
por lo que es casi seguro
un error en la prueba, como sea, clasificó
incorrectamente el siete como un uno.
Pero a medida que nos acercamos
a este siete en particular
realmente parece un uno.
Es el siete más uno que he visto.
Se entiende que
el modelo cometa ese error.
Y del mismo modo,
si nos fijamos en este nueve
se parece a un uno.
Este cuatro creo que
en realidad es un cuatro.
Tal vez el modelo tuvo un problema allí.
El visualizador embebido también se puede
utilizar para mucho más que imágenes.
Es realmente útil para
visualizar vocabularios también.

Indonesian: 
yang terhubung secara lokal di dalam
manipol, di embedding.
Jadi kita bisa lihat, misal, 1s punya
susunan rapi sendiri, yang masuk akal,
karena 1s adalah angka yang unik.
Kita bisa lihat itu punya sedikit masalah,
misal, dengan 3s, 8s, dan 5s,
karena mereka sedikit lebih dekat
dan sedikit lebih membaur.
Kita bahkan bisa mulai menyelami
contoh tersendiri
dimana modelnya membuat prediksi buruk.
Jika kita lihat, misal, ke 7,
itu dikelompokkan dengan 1s,
sehingga itu
kesalahan uji, itu secara tidak benar
melabeli 7 sebagai 1.
Tapi saat kita perbesar ke 7
yang khusus ini,
itu memang agak mirip seperti 1.
Itu mungkin 7 yang paling mirip 1
yang pernah saya lihat.
Masuk akal jika modelnya
membuat kesalahan itu.
Jika kita lihat ke 9 ini,
benar-benar mirip 1.
4 ini, menurut saya, memang 4.
Mungkin modelnya punya masalah disini.
Embedding visualizer juga bisa
digunakan untuk banyak hal selain gambar.
Itu sangat berguna untuk
penggambaran kosa kata juga.

Chinese: 
让我展示一个例子
这是智能回复数据组
每当你的信箱应用
建议你说谢谢时
就是在用这个数据组
还可以看到
这些都是感叹式陈述
例如“请立即确认”、“请收到后确认”
这个接入的感叹句少一些
甚至还可以创建自己的轴线
如果你知道国王皇后的例子
然后一个轴线是国王减去皇后
你发现它学到很多
有关性别的概念
你可以利用嵌入显示器
通过定义轴线为不同词汇之间的差别
互动式地探索类似的关系
我快没时间了
但我想简单讲讲TensorBoard的未来
在接下来的一个季度里
将TensorFlow调试器整合到TensorBoard里
这就意味着

English: 
And I'll actually just
show you an example.
This is the smart
reply data set.
So every time that's
your inbox app
suggests saying
thank you to someone,
it's using this dataset.
And we can see here that we
have exclamatory statements
are over here.
Like please confirm now,
please confirm you got it.
And then this access has
less exclamatory stuff.
And we can even do stuff
like creating our own axes.
So if you know the
king queen example,
where you take a word to
[INAUDIBLE] embedding.
And you set one axis
is king minus queen,
and then you find
it has learned a lot
of gender-related concepts,
you can interactively
explore relationships like that
using the embedding visualizer
by defining your axes
to be the differences
between different words.
So I'm almost out
of time, but I'll
talk a little bit about
the future of TensorBoard.
We're going to be, in
the next quarter or so,
integrating the new TensorFlow
debugger into TensorBoard.
So that means you'll start
to be able to use the graph

Spanish: 
Voy a mostrar un ejemplo.
Este es el conjunto de
datos inteligentes de respuestas.
Cada vez que una aplicación sugiere
que le des las gracias a alguien
usa este conjunto de datos.
Y podemos ver que las oraciones
exclamativas están aquí.
Como, "Confirma por favor ahora",
"Por favor, confirma de recibido".
Este eje tienen oraciones
menos exclamativas.
E incluso podemos crear
nuestros propios ejes.
Si conocen el ejemplo del "rey y la reina"
se toma una palabra para embeberla
y se establece un eje es rey menos reina
y luego ven que ha aprendido mucho sobre
conceptos relacionados con el género.
Se pueden explorar las relaciones como
esas con el visualizador embebido
al definir los ejes para establecer
las diferencias entre diferentes palabras.
Casi se me acaba el tiempo, hablemos
sobre el futuro de TensorBoard.
En el próximo trimestre vamos a integrar
el nuevo depurador de
TensorFlow en TensorBoard.
Con esto podrán
utilizar el visualizador gráfico

Japanese: 
これから例をお見せします
これは SmartReply のデータセットです
これは Inbox アプリが
お礼を言う相手を提案するもので
このデータセットが使用されています
ここには「いますぐ確認してください」や
「届いたものを確認してください」など
感嘆文が確認できます
そして 感嘆が少ない関連文です
独自で軸を作ることもできます
例えば 王様や女王様と知り合いなら
[ 聞き取れず ]を埋め込むための言葉を
取り込みます
そして 王様 - 女王様の軸を
１つ設定します
性別関連のコンセプトも
多く 学習されていますね
埋め込みビジュアライザーを使う
このようなものも
違う言葉で他の軸を定義することで
双方向の関係を探れます
時間がなくなってきたので
TensorBoard の
これからについて話します
これから３か月で TensorBoard に入れる
TensorFlow のデバッグを検査します
すると グラフビジュアライザーの
使用が可能になり

Portuguese: 
Vou mostrar um exemplo.
Aqui o conjunto de dados 
de resposta inteligente.
Toda vez que seu app de e-mail sugerir
dizer obrigado a alguém,
é através deste conjunto de dados.
Podemos ver que temos 
demonstrações exclamativas aqui.
Por exemplo "por favor confirme agora",
"por favor confirme recebimento".
Então este acesso tem 
menos coisas exclamativas.
E pode até fazer coisas 
como criar nossos próprios eixos.
Então se você souber o exemplo rei rainha,
onde você pega uma palavra para incorporar
e você configura um eixo como rei
menos rainha, e percebe que aprendeu muito
sobre conceitos relativos a gênero,
pode explorar interativamente 
relações como esta
usando o visualizador incorporado, 
definindo seus eixos para serem
diferenças entre palavras.
Estou quase estourando o tempo,
mas vou falar um pouco
sobre o futuro do TensorBoard.
No próximo trimestre integraremos
o debugger TensorFlow no TensorBoard.
Isso significa que seremos capazes 
de usar o visualizador de gráfico

Korean: 
실제로 예를 하나 보여드릴게요
이건 스마트 답신 데이터 세트예요
메시지함 앱에서 매번
누군가에게 감사하라고 제안할 때마다
데이터 세트를 이용하는 거예요
여기 감탄문이 있는 것도 보이시죠
지금 확인하세요!
받았는지 확인하세요, 처럼요
그리고 느낌표가 적은 것도 있고요
우리만의 좌표축을 만들 수도 있어요
king queen 예제를 아신다면
[청취 불가] 임베딩에 단어를
넣는 건데요
한 축은 왕에서 여왕을 빼는 거고요
그럼 성별과 관련된 개념을
많이 습듭할 거예요
임베딩 비주얼라이저를 활용해
다른 단어들 사이에서 축을 정의하면서
상호적으로 관계를 탐색할 수 있어요
시간이 거의 다 되었는데
TensorBoard의 미래에 대해
잠깐 얘기해드릴게요
다음 분기 정도에 저희는
새 TensorFlow 디버거를
TensorBoard에 병합할 거예요
그럼, 그래프 비주얼라이저를 이용해

Indonesian: 
Saya akan memperlihatkan
sebuah contoh kepada Anda.
Ini seperangkat data balasan pintar.
Tiap kali aplikasi kotak masuk Anda
sarankan berterima kasih ke seseorang,
itu memakai seperangkat data ini.
Kita bisa lihat bahwa kita punya
pernyataan kalimat seru di sini.
Tolong konfirmasi sekarang,
konfirmasi jika Anda sudah dapat.
Lalu akses ini punya pernyataan
yang tidak terlalu berseru.
Kita bahkan bisa lakukan hal seperti
membuat sumbu kita sendiri.
Jika Anda tahu contoh raja ratu,
Anda ambil kata
[tidak terdengar] embedding.
Anda atur satu sumbu
yakni raja tanpa ratu,
lalu Anda tahu itu belajar banyak
konsep tentang gender, Anda bisa
secara interaktif
menjelajahi hubungan seperti itu
menggunakan embedding visualizer
dengan mendefinisikan sumbu Anda
menjadi perbedaan
kata-kata yang berbeda.
Waktu hampir habis, saya
akan bahas sedikit mengenai rencana
TensorBoard mendatang.
Kita akan, sekitar kuartal berikutnya,
mengintegrasi debugger
TensorFlow baru ke TensorBoard.
Itu artinya Anda akan mulai bisa
pakai penggambar

Portuguese: 
para ter uma visão imediata de onde há
quaisquer NaNs ou infinidades no gráfico.
E se há, quando aparecem?
Ou usar o visualizador de gráfico 
para clicar em tensores individuais
e visualizá-los.
Também estamos trabalhando em plug-ins.
Eu disse que estamos criando
uma op de sumário nova,
que pode gravar qualquer tipo
de dado no TensorFlow.
E a ideia é que as pessoas 
contribuam com visualizações.
Serão realmente específicas 
para domínios de problemas específicos.
Se você for a distill.pub,
verá que Chris Olah e sua equipe
fizeram visualizações incríveis
para inspecionar modelos 
de escrita a mão ou de fala-texto.
E queremos incorporar essas visualizações
bem específicas a domínios no TensorBoard,
facilitando a adição de plug-ins.
E finalmente, estamos criando o que chamo
de TensorBoard de escala de organização.
Agora, como você viu, TensorBoard é algo
que uma pessoa liga localmente,
na sua própria máquina.
Vamos criar uma instância
de dimensão de produção, escalável,
para que toda a sua organização
ou grupo de pesquisa

Spanish: 
para tener una vista inmediata sobre
dónde hay valores inválidos
o infinitos en su gráfico
y cuándo aparecen.
O podrán utilizarlo para hacer clic en
los tensores individuales y visualizarlos.
También trabajamos mucho con los plug-ins.
Si recuerdan, vamos a añadir
una nueva operación de resumen
que pueda escribir
cualquier tipo de datos a TensorFlow.
Y la idea es que podamos tener personas
contribuyendo en las visualizaciones.
Serán muy específicos para
dominios de problemas particulares.
Si van a distill.pub, podrán ver
que Chris Olah y compañía
han hecho visualizaciones
sorprendentes para
la inspección de los modelos
de escritura a mano
o para modelos de generación
de texto y voz.
Y queremos incorporar
estas visualizaciones
de dominio específicas en TensorBoard
y vamos a hacerlo fácilmente
agregando plugins.
Y por último, estamos
creando algo que llamo
organización a escala de TensorBoard.
En este momento, como vieron,
TensorBoard es local para una persona
en su propia máquina.
Y vamos a crear una solución
escalable de tamaño productiva
para que toda la organización
o su grupo de investigación pueda

Japanese: 
グラフ内のどんな数字でも
じかに見れるようにすることができます
もしそうなら いつ出てきますか？
もしくはテンソルをクリックして可視化させる
グラフビジュアライザーを使うことができます
一連のプラグイン作業もやります
僕は TensorFlow に
どんな種類のデータでも書き出せる
新サマリーオペレーションを
追加すると言ったのを覚えてますか
つまり 皆さんが可視化に
貢献できるようになります
その人たちは特定の問題分野で
実に能力を発揮するでしょう
distill.pub にいけば
手書きを検査したり
テキスト読みあげの検査を行う
素晴らしい可視化モデルを作成した
クリス・オラフと仲間たちに会えます
我々は こういう領域に限定した可視化を
TensorBoard に
組み込めるようにしたいのです
それをプラグインの追加だけで
できるようにしたいです
やっと TensorBoard スケールを
体系化するものを作ります
現在の TensorBoard では
人が機械を現場でオンにしますが
測定可能な生産サイズの実証を
作成しますので

Indonesian: 
grafik untuk lakukan hal seperti
mendapatkan tampilan segera
dimana ada NaN atau infinit
di grafik kita.
Jika demikian,
kapan mereka muncul?
Anda bisa pakai penggambar
grafik untuk klik tensor tersendiri
dan menggambarkannya.
Kita juga lakukan pengembangan plug-in.
Saya bilang kami menambah summary op
baru yang bisa menulis data
apapun di TensorFlow.
Idenya ialah kita bisa
mulai mendorong orang-orang
mengkontribusikan visualisasi.
Mereka akan fokus pada masalah
domain yang khusus.
Jika Anda ke distill.pub, Anda akan
lihat Chris Olah dan rekan telah
membuat visualisasi menakjubkan
untuk menginspeksi model tulis tangan
atau untuk menginspeksi
model ujaran ke teks.
Kita ingin bisa memasukkan visualisasi
khusus domain ini ke dalam TensorBoard,
dan kita akan lakukan itu dengan
mempermudah penambahan plugin.
Akhirnya, kita membuat sesuatu
yang saya sebut skala
organisasi TensorBoard.
Sekarang, TensorBoard
ialah hal yang orang secara
lokal hidupkan, di mesin mereka sendiri.
Kita akan buat contoh
besar dan berukuran produksi
sehingga keseluruhan organisasi Anda
atau keseluruhan grup riset bisa

English: 
visualizer to do things like
get an immediate view of where
there are any NaNs or infinities
anywhere in your graph.
And if so, when did they appear?
Or you'll be able
to use the graph
visualizer to click
on individual tensors
and visualize them.
We're also doing a bunch
of work on plug-ins.
If you remember, I said
we're adding a new summary
op that can write out any
kind of data in TensorFlow.
And the idea there
is that we can
start to have people
contribute visualizations.
They'll be really specific to
a particular problem domains.
So if you go to
distill.pub, you'll
see that Chris Olah
and company have
made amazing visualizations for
inspecting handwriting models
or for inspecting
speech to text models.
And we want to be able to
incorporate these really
domain-specific visualizations
into TensorBoard,
and we're going to do that by
making it easy to add plugins.
And finally, we're
creating something
I'll call organization
scale TensorBoard.
Right now, as you
saw, TensorBoard
is something that
one person locally
turns on, on their own machine.
And we're going to create a
scalable, production-sized
instance so that your
entire organization
or your entire
research group could

Chinese: 
你可以开始使用图表显示器
来获取图表任意位置中
有关NaN或无限的即时显示
如果可以的话，它们何时会出现？
或者你可以用图表显示器
点击每个张量
对它们进行显示
我们也在做许多插件程序
如果你还记得
我说过我们会添加新的概要运算
它可以写出TensorFlow中的任何数据
也就是说，可以开始让人们
贡献显示
这些贡献会针对具体领域的问题
如果你登录distill.pub
就能看到克里斯·欧拉和他的同事
已经为检查手写模型及语音到文本模型
制作出绝妙的显示
我们想要在TensorBoard中
加入这种非常针对具体领域的显示
我们的办法是
让添加插件更加轻松方便
最后，我们还在创建
我称作组织级TensorBoard
像你现在看到的
TensorBoard是个人
在自己的机器上开启的
我们将要创建
一个可规模化的、量产级别的版本
方便整个组织或整个研究团队

Korean: 
그래프에서 NaN이나
무한수가 어디 있는지
즉시 볼 수 있는 것입니다
언제 나타나는지 볼 수 있죠
또한, 개별 tensor를 선택하고
그것을 가시화하는 데 사용할 수 있어요
또한, 저희는 플러그인도 작업 중이에요
저희가 TensorFlow에
어떤 데이터든지 쓸 수 있는
새로운 summary op를
추가하려는 거 기억하시죠
사람들이 가시화에 기여하게 하는 게
기본 아이디어입니다
특정 문제 도메인에 매우 근접하겠죠
distill.pub에 가면
Chris Olah와 회사에서
손글씨 확인 모델과
입말을 글로 바꾸는 모델에
놀라운 가시화를 적용한 것을
볼 수 있어요
그리고 이 도메인 특정 가시화를
TensorBoard에 통합하고 싶습니다
그리고 플러그인을 추가함으로써
그걸 이루려고 합니다
마지막으로 저희는 TensorBoard
기관 스케일이라는 걸 개발하고 있습니다
지금 보시다시피,
TensorBoard는 한 사람이
자기 기기에서만
지역적으로 사용할 수 있어요
저희는 스케일을 조절하고
제품 사이즈를 조정하여
기관 전체에서 사용하거나
전체 연구 그룹에서 사용해

Chinese: 
共同使用TensorBoard
并轻松分享结果，保留历史记录
我就讲这么多
代码和幻灯片都在这个链接里
在我的GitHub也可以查看
搜索Dandelion Mane
我们还会推特发布这个链接
接下来，有请马丁·维克
毋庸置疑，马丁是这个团队里最帅
着装最讲究，最聪明的成员
他也是我的老板
[笑声]
他拥有TensorFlow所有的开源
他会介绍新的API
这些API让MNIST代码编辑更加简单
比我给的例子更加轻松便捷
非常感谢
[掌声]
[音乐]

Korean: 
하나의 TensorBoard를 공유하고
시간이 흐름에 따른 결과를
쉽게 공유하고 저장하도록 할 겁니다
제 강의는 여기까지고요
이 코드와 슬라이드는 링크에 있습니다
제 GitHub
Dandelion Mane에도 있어요
이 링크도 올려드릴게요
다음으로 Martin Wicke를
소개할게요
Martin은 팀에서 가장 잘 생기고
옷을 잘 입고, 가장 똑똑한 분이에요
제 상사이기도 하죠
그는 TensorFlow 오픈 소싱
모든 종류를 소유하고요
새 API에 대해서 얘기해주실 거예요
이 API들은 모든 MNIST 코드를
제 예제보다 쉽고 덜 복잡하게 해줍니다
정말 감사합니다

English: 
share a single
TensorBoard and then
share results easily and
keep a history over time.
So that's it for my talk.
The codes and slides
are on this link.
It's also on my
GitHub, Dandelion Mane,
and I think we'll
tweet this link out.
And so next I'm going to
introduce Martin Wicke.
Martin is undoubtedly the
most handsome, best dressed,
and most intelligent
person on the team.
And he's also my boss.
[LAUGHTER]
And he owns all of
TensorFlow open sourcing
and he's going to tell
us a bit about new APIs
that make doing all of this
MNIST code much easier and much
less complicated
than in my example.
Thank you very much.
[APPLAUSE]
[MUSIC PLAYING]

Spanish: 
compartir un TensorBoard único
y compartir los resultados
con facilidad y mantener un historial.
Eso es todo por mi parte.
El código y las diapositivas
están en este enlace.
También está en mi GitHub,
Dandelionmane
y vamos a poner Twitter este enlace.
A continuación voy
a presentar a Martin Wicke.
Martin es, sin duda,
el más guapo, el mejor vestido
y la persona más inteligente en el equipo.
Y también es mi jefe.
Y administra todo el código
abierto de TensorFlow.
Nos va a hablar un poco
acerca de nuevas API
que hacen que todo este código
MNIST sea mucho más fácil
y mucho menos complicado
que en mi ejemplo.
Muchas gracias.

Indonesian: 
berbagi TensorBoard tunggal lalu
berbagi hasil dengan mudah dan
menjaga histori sepanjang waktu.
Itulah pembahasan saya.
Kode dan slide ada di tautan ini.
Itu juga ada di GitHub saya,
Dandelion Mane,
dan kita akan tweet tautan ini.
Selanjutnya saya akan
memperkenalkan Martin Wicke.
Tak diragukan lagi Martin
orang paling tampan,
berbusana rapi dan paling pintar di tim.
Dia juga bos saya.
Dia punya seluruh open source TensorFlow
dan dia akan beritahukan kita
sedikit tentang API baru
yang memudahkan menulis kode MNIST ini
dan lebih sederhana daripada
di contoh saya.
Terima kasih banyak.

Portuguese: 
possam compartilhar um único TensorBoard
e compartilhar resultados facilmente,
mantendo um histórico ao longo do tempo.
Então é isso.
Os códigos e slides estão nesse link.
E também no meu GitHub, Dandelion Mane.
E acho que vamos tuitar o link também.
Agora vou apresentar Martin Wicke.
Martin é sem dúvida o homem mais 
bonito, bem-vestido e inteligente no time.
E também meu chefe.
Ele detém todo o código aberto 
do TensorFlow e vai falar um pouco
sobre novos APIs que tornam todo 
este código MNIST muito mais fácil
e muito menos complicado 
do que no meu exemplo.
Muito obrigado.

Japanese: 
組織全体でグループ全体で
単独の TensorBoard を共有できます
結果を簡単に共有したり
常に履歴を残したりもできます
これで全部です
コードとスライドは
こちらのリンクにあります
私の GitHub や Dandelion Mane や
ツイートにもリンクが出ています
続いてマーティン・ウィッケをご紹介します
マーティンは明らかに
このチームの中で
一番カッコよくて おしゃれで
頭のいい人です
僕の上司なんです
彼はすべての TensorFlow を持ち
オープンソースにしています
新しい API について教えてくれます
MINIST コードをすべて
僕の例よりも
ずっと簡単で単純に実行させる API です
ありがとうございました
