
Korean: 
안녕하세요, 여러분
전 프란체스코이고
케라스 API를 텐서플로우로
통합하는 것에 대해 발표하겠습니다
먼저 케라스가 뭘까요?
텐서플로우가 무엇인지 아신다면
아마 케라스도 아시겠지만
혹시 모르시는 분들을 위해
설명하겠습니다
케라스는 딥 러닝 모델을
만드는 것을 더 쉽고 빠르게
만들어 줍니다
딥 러닝 툴박스로 사용하기 쉽고
복잡함을 줄이며 인지 부하량을
줄인다는 개념이죠
딥 러닝을 사용하기 쉽게 만들면
더 많은 분들이 접근할 수
있도록 만드는 것이죠
따라서 케라스의 핵심은
딥 러닝을 모두의 손에
넣는 것입니다
미래에는 딥 러닝이
모든 개발자의 툴박스의
일부분이 될 것이라고 믿습니다
전문가와 연구자를 위한
도구만이 아닐 겁니다
모든 사람들의 손에 있을 겁니다
이는 텐서플로우와 같은 플랫폼과
케라스와 같은
API로 가능하게 되는 거죠
케라스는 라이브러리나
코드 베이스가 아닌 것으로

Japanese: 
FRANCOIS CHOLLET: 
みなさん、こんにちわ
僕はフランソワです。
これから TensorFlow に
Keras API を統合するお話をします。
まず始めに、Keras とは何でしょう。
もし TensorFlow をご存知なら
Keras のことも知っていると思います。
万が一、ご存じない方のことも考慮して
説明いたします。
Keras はディープラーニングモデルを
容易に迅速に構築する API です。
ディープラーニングツールボックスで
簡単に使用することができます。
複雑さを軽減し、認識負担を軽減します。
ディープラーニングの使用が容易になったら
一体どんなことが起こるのでしょうか。
より多くの人へのアクセスが
可能になります。
Keras の主要な概念は、
ディープラーニングを
多くの人々の手に渡るようにするためです。
将来、ディープラーニングは
あらゆる技術者のツールボックスの
一部になっているでしょう。
またエキスパートやリサーチャーだけの
ツールにはならないでしょう。
多くの方々の手に渡ると思います。
TensorFlow のような
プラットフォームや
Keras のような API を通じて、
実現すると思います。

Indonesian: 
Hai semuanya!
Saya Francois, dan
saya beritahu
tentang penggabungan API Keras
ke dalam TensorFlow.
Jadi pertama-tama, apa itu Keras?
Jika Ada tahu tentang TensorFlow,
Anda mungkin tahu tentang Keras
bagi yang belum tahu,
Keras adalah API yang
membuat model deep-learning
lebih mudah dan lebih cepat.
Jadi ini adalah perangkat
deep-learning yang sangat mudah digunakan
mengurangi kerumitan,
mengurangi beban kognitif.
Jika Anda dapat membuat
deep-learning mudah digunakan
maka Anda juga bisa membuatnya 
diakses lebih banyak orang.
Jadi ide Keras adalah
membuat deep-learning
bisa dimiliki oleh semua orang.
Kita percaya bahwa, 
di masa depan, deep-learning
akan menjadi bagian dari 
setiap alat bagi pengembang.
Ini tidak hanya akan menjadi alat
bagi para ahli dan peneliti.
Ini akan menjadi milik
semua orang.
Dan hal itu akan terjadi dengan
platform seperti TensorFlow
dan API seperti Keras.
Jadi Keras sebaiknya tidak dianggap
sebagai perpustakaan

Chinese: 
（音乐）
大家好！
我是 Francois，
我将跟你们讲讲如何将 Keras API
整合入 TensorFlow
首先，Keras 是什么呢？
如果你听过 TensorFlow，
你应该也知道 Keras，
不过，以防万一，
我还是要介绍一下
Keras 是一种
可以让构建深层学习模型
更加容易和快捷的 API
所以，它是一个深度学习的工具
为了使用的简便性
降低复杂性
减少认知负荷
如果你使得深度学习变得容易，
那么它也会被更多人接受
所以，Keras的关键理念就是
让每个人都能掌握深度学习
我们相信，在不久的将来，
深度学习将成为每个开发者的工具盒
它不仅仅会成为专家和研究者们的工具，
它会被大家利用
TensorFlow 这样的平台
和 Keras 这样的 API 也同样
所以，对 Keras 比较好的理解是

Portuguese: 
Olá a todos.
Sou o François e irei falar
sobre a integração
do API Keras ao TensorFlow.
Antes de tudo, o que é o Keras?
Se você conhece o TensorFlow
também deve conhecer o Keras,
mas vou explicar aos que não conhecem.
Keras é um API que torna a criação
de modelos de aprendizagem profunda
mais fácil e rápida.
É uma caixa de ferramentas
para aprendizagem profunda
focada em facilidade de uso,
redução da complexidade e carga cognitiva.
E tornar a aprendizagem profunda
mais fácil de usar
a deixa acessível para mais pessoas.
A ideia principal do Keras é tornar
a aprendizagem profunda acessível.
Acreditamos que, no futuro,
a aprendizagem profunda
será parte das ferramentas
de qualquer desenvolvedor.
Não será uma ferramenta apenas
de experts e pesquisadores.
Estará disponível para todos.
E isso acontecerá com plataformas
como o TensorFlow e APIs como o Keras.

Spanish: 
Hola a todos.
Soy Francois y les voy a contar
sobre la integración de la API Keras
a TensorFlow.
Pero antes que nada, ¿qué es Keras?
Si conocen TensorFlow,
probablemente conozcan Keras, 
pero por si acaso
para los que no sepan.
Keras es una API
que hace más fácil y rápida
la construcción de modelos
de aprendizaje profundo.
Es un toolbox de aprendizaje profundo
que intenta que el uso sea fácil,
reducir la complejidad
y la carga cognitiva.
Si el aprendizaje profundo es más fácil,
lo que ocurre es que también
es accesible para más personas.
La idea principal con Keras
es que el aprendizaje profundo
esté al alcance de todos.
Creemos que, en el futuro,
el aprendizaje profundo
será parte de los recursos
de todos los desarrolladores.
No será una herramienta
solo para expertos e investigadores.
Estará al alcance de todos.
Y esto sucederá
con plataformas como TensorFlow
y APIs como Keras.

English: 
[MUSIC PLAYING]
FRANCOIS CHOLLET: Hi, everyone.
I'm Francois, and
I'll be telling you
about the integration of the
Keras API into TensorFlow.
So first of all, what is Keras?
If you know about
TensorFlow, you probably
also know about Keras,
but just in case,
for those who don't know.
Keras is an API that makes
building deep-learning models
easier and faster.
So it's a deep-learning toolbox,
and it's all about ease of use,
reducing complexity,
reducing cognitive load.
And if you make deep learning
easier to use, what happens
is that you're also making
it accessible to more people.
So the key idea with Keras
is to put deep learning
into the hands of everyone.
We believe that, in the
future, deep learning
will be part of every
developer's toolbox.
It will not just be a tool
for experts and researchers.
It will be into
everyone's hands.
And this will happen with
platforms like TensorFlow
and APIs like Keras.
So Keras is better
understood not as a library

Spanish: 
Keras se entiende mejor
no como una librería o un código base.
Es más una especificación de API.
Y es una especificación que tiene
varias implementaciones distintas.
Están las implementaciones Theano,
que fue el lanzamiento original de Keras,
hace dos años.
Obviamente hay
una implementación TensorFlow.
Y luego habrá más en el futuro.
Por ejemplo, Microsoft está trabajando
en una nueva implementación CNTK de Keras.
Entonces hasta ahora,
la implementación TensorFlow existía
como repositorios separados
de código abierto, con muchos usos.
Y lo que estamos haciendo ahora
es meter la API de Keras
directamente dentro del proyecto Keras,
dentro del proyecto TensorFlow.
Creemos que es un gran paso
para que TensorFlow y el aprendizaje
profundo sean accesibles.
Lo que sucede concretamente
es que estamos trayendo a TensorFlow
este módulo de compatibilidad de Keras,
tf.keras,
que es una implementación
de la especificación Keras
construida desde cero para TensorFlow.
Como parte de este movimiento,

Chinese: 
它不同于图书馆、代码库
而是一种 API 规格
而且，
它有几种不同的实施
Theano
是两年前发布的
最初的 Keras
当然，还有 TensorFlow
在将来还会有更多
比如，Microsoft
正在研究一种 Keras 实施
迄今为止，TensorFlow 的实施
分开了（听不清）很多用户
我们现在所做的是将 Keras API
直接带入 Keras 项目
带入 TensorFlow 项目
我们相信那是朝
让所有人认知 TensorFlow 和 深度学习
迈出了一大步
具体来说，
我们要将 Keras 兼容模型 tf.keras
带入 TensorFlow
这是一个 Keras 规格的实施
这是从 TensorFlow 基础建立而来的
作为这个行动的一部分

Indonesian: 
atau sebagai kode dasar.
Ini lebih dari spekulasi API.
Dan ini merupakan spekulasi
API yang memiliki
beberapa hasil berbeda.
Ada spekulasi Theano,
yang mana Keras yang asli
telah merilis [Tidak Jelas]
dua tahu yang lalu.
Ada sebuah implementasi
TensorFlow, tentunya.
Lalu akan ada lebih banyak
implementasi kedepannya
Contohnya, Microsoft bekerja
untuk sebuah [Tidak Jelas]
implementasi Keras.
Maka hingga sekarang,
implementasi TensorFlow
memisahkan sumber terbuka
dengan banyak kegunaan.
Dan apa yang kita lakukan sekarang
adalah membawa API Keras
langsung ke proyek Keras,
kedalam proyek TensorFlow.
Kita percaya itu sebuah langkah besar
yang akan membawa TensorFlow dan
deep-learning mudah diakses.
Jadi apa yang sebenarnya terjadi adalah
kita membawa TensorFlow,
modul yang cocok dengan
Keras ini, tf.keras
yang merupakan
sebuah implemantasi dari
spekulasi Keras
yang dibangun dari dasar
untuk TensorFlow.
Dan sebagai bagian dari
pergerakan ini, kita

English: 
or as a code base.
It's more of an API spec.
And it's an API spec that
has several different
implementations.
There's the Theano
implementations,
which was the original
Keras [AUDIO OUT] released
two years ago.
There's a TensorFlow
implementation, of course.
And then there will be more
implementations in the future.
For instance, Microsoft is
working on a [INAUDIBLE]
implementation of Keras.
And so until now, the
TensorFlow implementation
separates [INAUDIBLE]
with lots of uses.
And what we are doing now is
that we are bringing the Keras
API directly into
the Keras project,
into the TensorFlow project.
We believe that's a
big step towards making
TensorFlow and deep learning
accessible to everyone.
So what's concretely
happening is
that we are bringing into
TensorFlow this Keras
compatibility module,
tf.keras, which
is an implementation
of the Keras spec
that's built from the
ground up for TensorFlow.
And so as part of
this move, we're

Korean: 
이해하는 편이 낫습니다
API 스펙에 더 가깝죠
여러 가지 다른 실행을 가지고 있는
API 스펙입니다
테라노 실행이 있습니다
원래의 케라스로 [청취불가] 2년 전
발표됐죠
물론 텐서플로우 실행도 있습니다
앞으로는 더욱 더 많은 실행이 있겠죠
예컨대 마이크로소프트는
[청취불가]를 개발하고 있죠
케라스 실행이죠
지금까지 텐서플로우 실행은
다른 사용으로 [청취불가] 구분했습니다
그리고 지금 저희가 하는 일은
케라스 API를
케라스 프로젝트에 직접 가지고 오는 것이죠
텐서플로우 프로젝트로 말이죠
이는 텐서플로우와 딥 러닝이
모든 사람들에게
접근가능하도록 만드는
큰 걸음이라고 믿습니다
구체적으로 말하면
이 케라스 호환성 모듈인
tf.keras를
텐서플로우로 가져오는 거죠
이는 케라스 스펙의 실행으로
처음부터 텐서플로우를 위해
만들어 진 것이죠
이 움직임의 일부로써

Portuguese: 
O Keras é melhor entendido não como
uma biblioteca ou código base.
É mais uma API spec.
E é uma API spec com várias
implementações diferentes.
Existem as implementações Theano
que era a iteração original do Keras,
lançado dois anos atrás.
Há a implementação TensorFlow, claro.
E teremos outras implementações no futuro.
Por exemplo, a Microsoft está trabalhando
em uma [inaudível]
implementação do Keras.
E até agora, a implementação
do TensorFlow existe
em código aberto em repositórios
com vários usuários.
O que estamos fazendo agora
é trazer a API Keras
diretamento ao projeto Keras
dentro do projeto TensorFlow.
Acreditamos que é um grande passo
para tornar o TensorFlow
e a aprendizagem profunda acessíveis.
O que está acontecendo de fato
é que estamos trazendo para o TensorFlow
esse módulo de compatibilidade
do Keras, tf.keras,
que é uma implementação do Keras spec,
criada do zero para o TensorFlow.
Como parte disso, estamos introduzindo

Japanese: 
Keras はライブラリやコードベース、
として理解されるよりも
API スペックと呼んだ方が
しっくりきます。
異なる複数の実装を持つ
API スペックです。
Theano 実装があります。
２年前に Keras オリジナル
（音声なし）が発表したものです。
もちろん、TensorFlow 実装も
あります。
将来的には、より多くの実装が
発表される予定です。
例を挙げると、Microsoft 社が
Keras 対応の実装を準備しています。
今日、TensorFlow の実装は
（聞き取り不可能）として存在し、
（聞き取り不可能）
多機能を備えています。
現在、取り組んでいるのが
直接 Keras API を Keras プロジェクト、
TesorFlow プロジェクトに
導入することです。
それは TensorFlow とディープラーニングを
多くの人の手に渡るようにするための
大きな一歩だと思います。
では、具体的にどんなことが起こるのか
見ていきましょう。
TensorFlow 内にこの Keras 互換モジュール、
tf.keras を導入しようとしています。
これは Keras スペックの
実装の１つです。
TensorFlow 用にゼロから
構築されたものです。
この動きに対応して、

Spanish: 
estamos introduciendo nuevas
estructuras de datos a TensorFlow
como capas, que Martin acaba de presentar.
Y también modelos, que son contenedores
para gráficos de capas.
Estas eran
las estructuras de datos de Keras,
y ahora serán compartidas
entre el TensorFlow central
y este módulo tf.keras.
Como esta implementación de Keras
se construyó desde cero
sobre las estructuras ya compartidas,
es totalmente compatible con todas
las funcionalidades de TensorFlow.
Eso significa que también es compatible
con características [se corta el audio]
de la API experimental
que Martin presentó.
Si son usuarios de Keras,
esto es lo que significa para ustedes.
Primero, les da acceso a más flexibilidad.
Ahora pueden combinar muy fácilmente
las funcionalidades puras de TensorFlow
con las de Keras
para que puedan construir modelos
más fuertes y flexibles.
Y además, tendrán acceso a características
muy avanzadas y poderosas

English: 
introducing into core
TensorFlow new data structures
like layers, which
Martin just introduced.
And also models,
which are containers
for graphs of layers.
So these used to be
Keras data structures,
and now they will be shared
between core TensorFlow
and this tf.keras module.
So, because this
Keras implementation
is built from the
ground up on top
of the shell of
the structures, it
is fully compatible with all of
the TensorFlow functionality.
That means it's also compatible
with [AUDIO OUT] features that
has the experiment API
that Martin introduced.
So if you're a Keras user,
here's what this means for you.
First, it gives you access
to more flexibility.
You become able to very
easily mix and match
pure TensorFlow functionality
with Keras functionality.
So you can build more
powerful, more flexible models.
And what's more, you gain
access to really advanced,
really powerful features
through the [INAUDIBLE]

Portuguese: 
no coração do TensorFlow,
novos dados estruturais
como camadas, conforme Martin
acabou de explicar.
E também modelos, que são containers
para gráficos de camadas.
Esses costumavam ser os
dados estruturais do Keras
e agora serão divididos entre
o core TensorFlow
e o módulo tf.keras.
Como essa implementação Keras
é construída da base
para o topo da camada de estruturas
ela é totalmente compatível com
a funcionalidade do TensorFlow.
Isso significa que também é compatível
com [inaudível] características
que possuem o API experimental
introduzido pelo Martin.
Se você é um usuário Keras,
aqui está o que isso significa para você.
Primeiramente,
te dará maior flexibilidade.
Você será capaz de facilmente
misturar e combinar
funcionalidades puras do
TensorFlow com as do Keras.
De forma que você poderá construir
modelos mais poderosos e flexíveis.
E além disso, ganhará acesso a funções
muito avançadas e poderosas

Indonesian: 
memperkenalkan inti struktur
data baru TensorFlow
seperti lapisan, yang mana
telah diperkenalkan Martin
Dan juga model, 
yang merupakan wadah
untuk grafik lapisan.
Jadi ini biasanya digunakan,
struktur data Keras,
dan sekarang mereka akan dibagi
antara inti TensorFlow
dan modul tf.keras ini.
Jadi, karena implementasi Keras ini
dibangun dari dasar hingga puncak
struktur kerangka,
ini sepenuhnya cocok dengan semua
fungsi TensorFlow.
Artinya ini juga cocok dengan
[AUDIO TIDAK JELAS] fitur yang
memiliki eksperimen API
yang diperkenalkan Martin.
Jadi jika Anda pengguna Keras,
ini artinya bagi Anda.
Pertama, ini memberikan Anda
akses agar lebih fleksibel.
Anda menjadi bisa dengan mudah
untuk mencampur dan mencocokkan
fungsi alami TensorFlow
dengan fungsi Keras.
Jadi Anda dapat membangun lebih
kuat, model lebih fleksibel.
Dan lebih lagi, Anda dapat
mengakses untuk benar-benar maju,
benar-benar fitur yang bermanfaat
melalui [Tidak Jelas]

Korean: 
텐서플로우 코어에
새로운 데이터 구조를 소개하는 것입니다
마틴이 소개한 레이어 같은 거죠
모델도 마찬가지죠
이는 레이어의 그래프를 위한
컨테이너입니다
이는 케라스 데이터 구조였지만
지금은 코어 텐서플로우와
tf.keras 모듈 사이에서
공유되고 있는 거죠
이 케라스 실행이
구조의 쉘 위에 처음부터
만들어졌기 때문에
모든 텐서플로우 기능과
완전히 호환됩니다
즉 마틴이 소개해 준 API 실험이
가지고 있는 [청취불가] 피쳐와도
호환이 가능한 것입니다
따라서 케라스 사용자라면
이런 의미가 있죠
먼저 더 많은 융통성을
가지게 될 것입니다
텐서플로우의 순수 기능과
케라스의 기능을
아주 쉽게 섞을 수 있게 된 거죠
따라서 더욱 강력하고
융통성 있는 모델을 만들 수 있습니다
게다가 [청취불가]를 통해
정말 진보되고
강력한 피쳐에
접근할 수 있게 되는 겁니다

Japanese: 
TensorFlow のコア部分に新しい
データストラクチャーを導入しています。
先程マーティンが紹介したように、
レイヤーなどです。
またレイヤーグラフ用のコンテナーとなる
モデルについてもです。
Keras のデータストラクチャーとして
これらは使用されます。
TensorFlow のコア部分とこの
tf.keras モジュール間でシェアされます。
この Keras 実装がゼロから構築され、
ストラクチャーの骨組みの上部に
位置しているので
TensorFlow 機能の全てに
互換性があります。
また（音声なし）に対しても
互換性があります。
マーティンが紹介したように、
実験的 API を持っています。
あなたが Keras ユーザーだったら、
このような利点があります。
第一に、アクセスがより
柔軟になります。
TensorFlow 機能と Keras 機能を
非常に簡単にミックスしたり、
また調整することが可能になります。
よりパワフルで、よりフレキシブルな
モデルを構築する事ができます。
加えて、まさに高度でパワフルな特色に
（聞き取り不可）を通じて
アクセスすることができます。

Chinese: 
我们将要引入新数据结构到 TensorFlow 的核心
比如 Martin 刚才介绍的层
还有模型
包含了图画层面
这些曾经是 Keras 的数据结构
现在它们将在 TensorFlow 核心
以及 tf.keras 模型之间分享
那么，由于这个 Keras 实施
建立在
结构外壳的基础之上，
它和所有的 TensorFlow 的功能兼容
这意味着它也和（听不清）兼容
Martin 介绍的那个试验 API
所以，如果你是 Keras 的用户
这对你的意义是
首先，它给你带来更高的灵活性
你可以很容易地混合并且匹配
纯粹的 TensorFlow 功能和 Keras 功能
那么，你可以建立更多
强大的，更灵活的模型
还有，你可以通过（听不清）
Martin 介绍的 TensorFlow 训练 API

English: 
TensorFlow training API
that Martin mentioned.
You gain access to very quick
and easy distributed training
for Keras models.
You gain access to training
on Cloud ML, distributed
hyperparameter training, which
is really, really powerful,
and you can very easily
deploy your Keras modules
to production with
TensorFlow serving.
If you're a
TensorFlow user, what
does this change mean to you?
Basically, it gives you access
to the full scope of the Keras
API to make your life
easier without leaving
your existing
TensorFlow workflow.
So you can just start
using the Keras API
at no loss of flexibility.
You don't have to
adopt all of Keras,
you can just adopt the layers
you need, for instance.
And also, it gives you
access to any existing piece
of open source Keras code.
You can just go on GitHub,
copy some piece of Keras code,
drop it into your codebase,
and, by just changing imports,
it will just work.
So this gives you access to
a lot of existing open source
code that you can start
leveraging into your TensorFlow
workflow.

Indonesian: 
API pelatihan TensorFlow
yang disebutkan Martin sebelumnya.
Anda mendapat akses cepat dan
mudah disampaikan pelatihan
untuk model Keras.
Anda mendapatkan akses untuk
training di Cloud ML,
menyampaikan pelatihan 
hyperparameter, yang sangat hebat
Anda dapat dengan mudah
menyebarkan modul Kerasmu
sebagai produksi dengan
pelayanan TensorFlow.
Jika Anda adalah pengguna
TensorFlow, apa artinya
perubahan ini bagi Anda?
Dasarnya, ini memberikan Anda akses
cakupan penuh API Keras
untuk membuat kehidupan 
Anda lebih mudah
tanpa meninggalkan alur
TensorFlow Anda.
Anda dapat memulainya
menggunakan API Keras
tanpa kehilangan fleksibilitas.
Kau tak harus adopsi
semua Keras,
Anda bisa mengadopsi lapisan
yang Anda butuhkan, misalnya
Dan juga, memberikan Anda
akses ke setiap bagian
sumber terbuka kode Keras.
Anda bisa hanya dengan GitHub,
salin beberapa bagian kode Keras
letakkan pada kode dasar Anda, dan
dengan mengganti makna,
hal itu akan bekerja
Ini memberikan Anda akses ke
banyak kode sumber terbuka
yang dapat Anda mulai pengaruhi
ke alur kerja TensorFlow Anda

Japanese: 
マーティンが言及した
TensorFlow トレーニング API になります。
Keras モデル用の分布トレーニングに
迅速・容易にアクセスすることができます。
分布されたハイパーパラメータトレーニングの
Cloud ML にアクセスすることができ、
これは非常にパワフルなものです。
TensorFlow Serving を通じて、
Keras モジュールを非常に簡単に
プロダクションに配置させる
ことができます。
TensorFlow ユーザーだったら、
この変化は
どんな意味をもたらすでしょうか。
基本的に、現存する TensorFlow 
ワークフローを離れることなく
日常生活を容易にし、Keras API の
真髄にアクセスすることが可能です。
フレキシビリティを低減させることなく
Keras API を使い始めることができます。
Keras のすべてを
適用する必要はありません。
必要なレイヤーだけを
適用すればいいのです。
現存するオープンソース Keras コードの
一部にアクセスも可能です。
GitHub へ行き、
Keras コードの一部をコピーして
コードベースに落とし、
インポーツを変えることで作動します。
これで既存する多くのオープンソースコードに
アクセスすることができ、
それを TensorFlow ワークフロー内に
レバレッジし始めることが可能です。

Korean: 
마틴이 언급한
텐서플로우 훈련 API이죠
케라스 모델을 위한
아주 빠르고 쉬운 분산 훈련에
접근할 수 있습니다
클라우드 ML, 분산된 하이퍼파라미터
훈련에 접근할 수도 있죠
이는 아주 강력하고
텐서플로우 서빙을 위해 케라스 모듈을 생산으로
아주 쉽게 배치할 수 있습니다
여러분이 텐서플로우 사용자라면
이 변화가 여러분께
어떤 의미가 있을까요?
기본적으로 케라스 API의
전체 범주에 접근할 수 있습니다
현존하는 텐서플로우
작업흐름을 멈추지 않은 채 말이죠
여러분의 삶을 더 쉽게 만들어 줍니다
융통성을 잃지 않고도
바로 케라스 API를
사용하기 시작해도 되는 거죠
모든 케라스를 사용할 필요없이
예컨대 필요한 레이어만
사용하면 되는 겁니다
또한 현존하는 오픈 소스
케라스 코드는 어떠한 것이라도
접근할 수 있죠
깃허브에 가서 케라스 코드 몇 개를 복사하고
코드베이스에 넣고 나서
들여오기만 바꾸면
바로 작동할 겁니다
따라서 텐서플로우 작업흐름으로 연결하기
시작할 수 있는 현존하는
많은 오픈 소스 코드에
접근할 수 있습니다

Chinese: 
获取更高级的，更强大的特征
你可以获得
Keras 模型便捷简易的分布训练
获得 Cloud ML 的训练
以及超参数分布训练，真的非常强大
你可以很容易地部署 Keras 模型
用于 TensorFlow 服务
如果你是 TensorFlow 的用户
这个变化对你意味着什么呢？
基本上，它会让你得以访问全部 Keras API
让你的工作更轻松
而无需抛开现有的 TensorFlow 工作事项
所以，你可以利用 Keras API
而不失灵活性
你不必全部采用 Keras
比如，你可以仅仅采用需要的层
它还能让你访问任何现存的
Keras 的开源代码
你可以到 Github，拷贝一些 Keras 代码
将它放入你的代码库中
只需要调整输入，
就行了
所以这使得你可以访问
很多开放的开源代码
你可以把它放入你的 TensorFlow
工作流程中。

Portuguese: 
através do [inaudível] API de treinamento
do TensorFlow mencionada pelo Martin.
Você ganhará acesso a treinamentos rápidos
e bem distribuídos para modelos Keras.
Você terá acesso a treinamentos
no Cloud ML
treinamento hiperparâmetro,
que é muito poderoso
e você poderá muito facilmente
empregar seus módulos Keras
para produção com o TensorFlow Serving.
Se você é um usuário do TensorFlow,
o que essa mudança significa para você?
Basicamente, você terá acesso
a todo o escopo da API Keras
para facilitar sua vida sem sair
do seu fluxo de trabalho no TensorFlow.
Você poderá começar a usar a API Keras
sem perder flexibilidade.
Não será preciso adotar
tudo o que há no Keras
você pode adotar somente
as camadas que precisar.
E também dará acesso a qualquer parte
de código Keras em código aberto.
Você pode ir ao GitHub,
copiar algumas linhas de código
jogar na sua base de código e apenas mudar
as importações, que irá funcionar.
Isso te dará acesso a muitos
dos códigos abertos existentes
que você poderá levar
para seu fluxo de trabalho.

Spanish: 
a través de la API de capacitación
de TensorFlow que Martin mencionó.
Tendrán acceso a capacitación
de forma rápida y fácil
para los modelos de Keras.
Tendrán acceso a capacitación en Cloud ML,
capacitación en hiperparámetro,
que es en verdad muy poderosa
y se pueden utilizar fácilmente
los módulos de Keras
para producir con el servidor TensorFlow.
Si son usuarios de TensorFlow,
¿qué significa este cambio para ustedes?
Básicamente, les da acceso
total a la API de Keras
que hará sus vidas más fáciles
sin dejar su flujo actual en TensorFlow.
Así que pueden empezar a usar
la API de Keras
sin perder flexibilidad.
No tienen que usar todo Keras,
pueden usar solo las capas que necesiten,
por ejemplo.
Y también les da acceso
a cualquier porción
del código abierto de Keras.
Solo deben entrar a GitHub,
copiar algo del código de Keras,
pegarlo en tu código base
y, solo cambiando las importaciones,
funcionará.
Esto les da acceso
a mucho código abierto existente
que pueden empezar a aprovechar
en su flujo de trabajo en TensorFlow.

Japanese: 
もう少し具体的に見てみましょう。
例を挙げて、
Keras と TensorFlow を使った時の
ワークフローを見てみましょう。
そしてビデオ質問回答モデルを見ながら、
Keras を使用して、この問題を解決する
モデルを定義してみましょう。
そして分布された設定内でハイレベル
TensorFlow トレーニング API を使って、
再トレーニングしてみましょう。
これが課題です。
ここに複数のビデオがあります。
秒単位の４枚のフレームから成る
サンプルです。
ビデオあたり約10 秒なので、
１ビデオ約 40 枚のフレームになります。
ビデオについての質問をします。
ビデオでは何が起こっているのか、
何が写っているのかについてです。
ここには、女性が車の中に物を
収納しているビデオがあります。
女性は何をしているのでしょう、
と質問します。
身につけているシャツの色は何か
答えは１単語になるはずです。
そこでディープラーニングモデルを
構築します。
インプットとして、ビデオをフレーム
シークエンスとして取ります。

Portuguese: 
Para deixar as coisas mais claras,
vou dar um exemplo
de como seu fluxo de trabalho
ficará ao usar Keras com TensorFlow.
E veremos um modelo de busca de respostas
e usaremos o Keras para definir
um modelo para resolver este problema,
e iremos retreiná-lo usando a API
de treinamento de alto nível do TensorFlow
em uma configuração distribuída.
Esse é o problema que iremos trabalhar.
Temos alguns vídeos, que são amostras
de cerca de quatro frames por segundo
cerca de 10 segundos por vídeo,
temos por volta de 40 frames por vídeo.
E estamos fazendo perguntas sobre o vídeo,
sobre o que está acontecendo nele
e sobre o seu conteúdo.
Aqui temos uma mulher
guardando objetos em um carro.
Você pode perguntar:
"O que a mulher está fazendo?
Qual a cor de sua camisa?"
E a resposta deve ser uma única palavra.
Estamos construindo um modelo
de aprendizagem profunda
que receberá como informação
o vídeo como uma sequência de frames

English: 
So to make things a
bit more concrete,
I will walk you
through an example
of what your workflow will
look like when using Keras
with TensorFlow.
And we'll be looking at a
video question answering model,
and we'll be using
Keras to define a model
to solve this
problem, and we will
retrain it using the
high-level TensorFlow training
API in a distributed setting.
So this is a problem
that we'll be looking at.
We have some videos, which
are sampled about four frames
per second, roughly
10 seconds per video,
so we have about 40
frames per video.
And we are asking
questions about the video,
about what's going on in the
video, and about the contents.
Here we have this video
of a woman packing objects
into a car.
You can ask, what
is the woman doing?
What's the color of her shirt?
And the answer should
be a single word.
So we'll build a
deep-learning model
that it will take as inputs the
video as a sequence of frames,

Chinese: 
更具体一点讲，
我会给你们展示一下
当你在 TensorFlow 上使用 Keras 时
工作流程是怎样的
让我们来看看视频问题的回答模型
用 Keras 定义一个模型
来解决这个问题
我们会在分布设置中
利用高阶 TensorFlow 的培训 API
对它进行重新训练
这就是我们要研究的问题
这里有些视频
大概是4个画幅每秒取样
差不多10秒一个视频
所以，我们每个视频大概有40画
我们会问关于视频的问题
关于视频内容
这个视频里，一位女士
正把东西打包进车
你可以问，她在做什么？
她衣服的颜色是什么？
回答得是一个词
所以，我们构建了一个深度学习模型
它将以画面顺序作为视频的输入

Korean: 
좀더 구체적으로 설명하기 위해
텐서플로우로 케라스를 사용하면
작업흐름이 어떻게 보이는지 예시를
보여 드리겠습니다
비디오 질의응답 모델을
보여 드릴 것이고
이 문제를 해결하는 모델을
정의하기 위해
케라스를 사용할 것입니다
또한 분산 세팅에서
고능 텐서플로우 훈련 API를
사용해서 유지하겠습니다
이것이 저희가 보게 될 문제입니다
비디오가 있는데 1초당
약 프레임 4개로 표집했고
각 비디오는 약 10초이며
따라서 비디오 당
약 40개의 프레임이 있습니다
비디오에 대해 질문을 하고
비디오에서 무슨 일이
일어나는지 내용에 대해 묻겠습니다
한 여성이 차에 짐을 싣는
비디오가 있죠
이 여성이 무엇을 하는지 물어볼 수 있죠
셔츠의 색깔은 무엇인가?
대답은 단어 하나이어야 하죠
따라서 딥 러닝 모델을 만들텐데
프레임 시퀀스로 비디오에
인풋을 할 것이고

Indonesian: 
Jadi untuk membuatnya lebih konkrit,
Saya akan memberi Anda contoh
seperti apa alur kerja kalian
saat menggunakan Keras
dengan TensorFlow.
Dan kita akan melihat video 
dengan model menjawab pertanyaan
dan kita akan menggunakan Keras
untuk mendefinisikan sebuah model
untuk menyelesaikan masalah
& kita akan melatihnya lagi
dengan latihan level tinggi
API TensorFlow dalam sebuah
pembagian pengaturan.
Jadi ini adalah sebuah masalah yang
yang akan kita hadapi.
Kita memiliki beberapa video, yang
digambarkan dengan empat bingkai
selama satu detik, kasarnya
10 detik per video,
jadi kita punya sekitar 40
bingkai per video.
Dan kita bertanya tentang video tersebut,
tentang apa yang terjadi di video,
dan tentang isinya.
Disini kita punya video ini,
seorang perempuan membawa
sesuatu ke mobil.
Apa yang dia lakukan?
Apa warna bajunya?
Dan jawabannya bisa dalam satu kata.
Jadi kita membangun
model deep-learning
yang akan menjadi input video
sebagai bingkai yang urut

Spanish: 
Para ser un poco más concreto,
les mostraré un ejemplo
de cómo se verá su proceso de trabajo
cuando usen Keras
con TensorFlow.
Veremos un video modelo
de pregunta-respuesta
y usaremos Keras para definir un modelo
para resolver este problema
y lo reciclaremos usando la API
de capacitación de alto nivel
de TensorFlow, en un entorno distribuido.
Este es un problema que analizaremos.
Tenemos algunos videos,
que tienen unos cuatro cuadros
por segundo, y aproximadamente
10 segundos por video,
así que tenemos 40 cuadros por video.
Y hacemos preguntas sobre el video,
sobre lo que sucede y los contenidos.
Aquí tenemos un video de una mujer
empacando objetos en un auto.
Podemos preguntar qué hace la mujer
y de qué color es su remera
y la respuesta debería ser
una sola palabra.
Construiremos un modelo
de aprendizaje profundo
que tomará como entrada
el video como secuencia de cuadros,

Spanish: 
así que como 40 cuadros en orden,
y la pregunta,
y el modelo debería devolver
una palabra, la respuesta.
Si haces la pregunta:
"¿qué hace la mujer?"
Está empacando.
Es muy interesante porque si solo
tomamos un cuadro
e intentamos hacer que un CNN,
por ejemplo, responda la pregunta,
el problema es
que a partir de un solo cuadro
ella también
podría estar desempacando, ¿no?
Y la razón por la que sabemos
que está empacando
es el orden de los cuadros.
En el segundo cuadro
la alfombra está fuera del auto.
En el siguiente está adentro.
Entonces esperamos que los modelos
puedan aprovechar este orden
para responder correctamente
este tipo de preguntas.
De más está decir que este es un problema
muy, muy difícil.
Hace solo unos años, 3 o 4 años,
antes de TensorFlow y antes de Keras,
esto solo habría sido accesible
para algunas compañías grandes
o para laboratorios de investigación
bien financiados,
especialmente si se quería
que los modelos
aprendan de un cluster de GPUs.
Y ahora con TensorFlow como plataforma

Portuguese: 
por volta de 40 frames por vez,
e a questão, e o modelo deverá
devolver apenas uma palavra, a resposta.
Se você fizer essa pergunta,
"O que a mulher está fazendo?"
Está guardando objetos.
É realmente interessante,
se você pegar apenas um frame
e tentar treinar a [inaudível],
por exemplo, para responder a questão
o problema é que de apenas um frame
ela poderia estar tirando os itens, certo?
E o motivo pelo qual você sabe que
ela está guardando é a ordem dos frames.
No segundo frame o tapete está
fora do carro, no seguinte, está dentro.
Então esperamos que todo o modelo
de planejamento seja capaz de entender
esta ordem para responder corretamente
este tipo de questão.
Não é nem preciso dizer que isso
é um problema dificílimo.
Há apenas alguns anos, três ou quatro anos,
antes do TensorFlow e do Keras
isso seria acessível a apenas
algumas grandes companhias
ou laboratórios de pesquisa
muito bem financiados
especialmente se você quisesse
treinar seu modelo em um grupo de GPUs.

Chinese: 
所以40个画幅的次序
模型应该输出一个单词，即回答
所以，如果你问这个女人在做什么
她在弄包裹
这很有意思
因为，如果你只是
用一个画幅并尝试训练（听不清）
例如，回答这个问题
问题是，如果只从单个画面看，
她也可能在拆包裹，对吗？
但你知道她其实是在打包
因为画幅的次序
看看第二个画幅
毯子在车外
下一个画幅，在车内
我们期望所有的计划模型
能够衡量画幅的顺序
从而正确回答这类问题
不用说，这是一个相当艰巨的问题
几年以前，三到四年以前
在 TensorFlow 之前，在 Keras 之前
只有为数不多的大公司或者
资金非常充足的研究室
才能做到这一点
尤其是
如果你想在一组 GPU 上做模型训练
现在有了 TensorFlow 作为平台

Korean: 
약 40개의 프레임이 차례로
나오고 질문이 있고
이 모델은 한 단어, 즉 대답을 아웃풋 하겠죠
따라서 이 여성이 무엇을
하고 있냐는 질문을 물으면
짐 싸고 있죠
사실 흥미로운 건
프레임이 하나만 필요하고
[청취불가]를 훈련하려는 거죠
예컨대 질문에 대답을 하기 위해
이 문제는 이 프레임
하나에서만 나오는 거죠
이 여성은 짐을 풀고
있을 수도 있죠
이 여성이 실제로 짐을 싸고
있다는 사실을 아는 이유는
프레임의 순서 때문이죠
두 번째 프레임을 보시면
러그가 차 밖에 있죠
다음 프레임에서는 차 안에 있습니다
따라서 모든 플래닝 모델이
이러한 유형의 질문에
올바르게 대답하기 위해
이 순서를 연결할 수 있을 것으로
예상됩니다
이것이 아주 어려운
문제임은 말할 필요도 없죠
몇 년 전, 3, 4년 전만 해도
텐서플로우나 케라스가 있기 전에는
이는 소수의 큰 회사나
재정지원을 아주 잘 받는
연구실에만 접근 가능했습니다
특히 모델을 GPU 클러스터에서
훈련받길 원한다면 말이죠
이제 플랫폼을 텐서플로우로 쓰고

Indonesian: 
jadi sekitar 40 bingkai berurutan
dan pertanyaannya,
dan model outputnya harus
satu kata, jawabannya.
Dan jika Anda bertanya,
apa yang dilakukannya?
Dia sedang berkemas
Ini menarik,
karena jika Anda hanya
membawa satu bingkai dan
mencoba melatih sebuah kabinet
misalnya, untuk menjawabnya,
masalahnya hanyalah dari satu bingkai,
dia bisa juga sedang mengeluarkan
barang dari mobil, kan?
Alasan Anda bahwa
dia sebenarnya berkemas
adalah karena urutan bingkai.
Jika Anda lihat bingkai 2,
permadani diluar mobil.
Di bingkai 3,
itu ada didalam.
Kita harap semua
model rencana bisa
mempengaruhi urutan ini
untuk menjawab dengan benar
jenis pertanyaan seperti ini.
Jadi tak perlu banyak kata,
ini adalah sebuah masalah sulit.
Dalam beberapa tahun
lalu, tiga atau empat
tahun lalu sebelum TensorFlow,
sebelum Keras
ini hanya bisa diakses untuk
perusahaan besar atau laboratorium
riset yang didanai penuh,
khususnya jika Anda ingin
membuat model Anda
melatih pada sebuah kelompok GPU.
Dan sekarang dengan TensorFlow
sebagai sebuah platform

Japanese: 
約 40 枚のフレームが順番に並び、
質問があります。
モデルは１単語、
答えをアウトプットするはずです。
それでは「女性は何をしているか」
という質問をしてみましょう。
「彼女は物を収納しています」
これは興味深いことです、
なぜならたった１枚のフレームを取り出して
（聞き取り不可）をトレーニング、
いわば質問に答えようとしているからです。
問題は１つのフレームから、
彼女が荷物を取り出している
可能性もあるわけですよね。
彼女が荷物を収納しているのは、
フレームの順序がそうだからであって、
２番目のフレームを見れば、
絨毯は車の外にあります。
次のフレームでは、
絨毯は車の中にあります。
プラニングモデルすべてが
このタイプの質問に正確に回答できる順序を
レバレッジできることを期待しています。
言うまでもありませんが、
これは非常に難しい課題です。
数年前、３年か４年ほど前
TensorFlow や Keras が
まだ出ていない時に、
わずか一握りの大企業か、
潤沢な資金を持つリサーチラボだけに
アクセスが許されていました。
特に、自分のモデルをGPU のクラスターで
トレーニングしようとした場合でした。
今はプラットフォームとして
TensorFlow を

English: 
so about 40 frames in
order, and the question,
and the model should output
one word, the answer.
And so if you ask this question,
what is the woman doing?
She's packing.
It's actually interesting
because, if you only
take one frame and try
to train a [INAUDIBLE],
for instance, to
answer the question,
the problem is that
just from one frame,
she could also be
unpacking as well, right?
And the reason you know
she's actually packing
is because of the
order of the frames.
If you look at the second frame,
the rug is outside the car.
In the next frame,
it's inside the car.
And so we expect all
the planning model
to be able to leverage this
order to correctly answer
this type of question.
So needless to say, this is a
tremendously difficult problem.
And just a few years
ago, three or four years
ago before TensorFlow,
before Keras,
this would only have been
accessible to a handful
of large companies or in very
well-funded research labs,
especially if you wanted
to make your model
train on a cluster of GPUs.
And now with TensorFlow
as a platform

Portuguese: 
E agora, com TensorFlow como plataforma
e Keras como API
estamos tornando estes difíceis
problemas acessíveis a qualquer um
com básica [inaudível]
capacidade de programação.
Estamos colocando todo o poder da
aprendizagem profunda nas mãos de todos.
Este é um modelo que você pode
usar para resolver este problema.
No nível mais alto, ele tem dois ramos.
Um para codificar as entradas
do vídeo em um único vetor
e outro para codificar a questão,
uma sequência de palavras
em um único vetor.
Então temos um vetor com
informações sobre todo o vídeo
e um vetor com informações
sobre toda a questão.
E então concatenamos esses dois vetores.
E ele nos dará um único vetor que codifica
informações sobre todo o problema
a combinação do vídeo com a questão.
Essa é a beleza e a magia
da aprendizagem profunda
você tem informações perceptivas,
como um vídeo, por exemplo
você tem um significado semântico,
e o incorpora à informação. [inaudível]

Indonesian: 
dan dengan Keras sebagai 
sebuah API yang kita buat
tiga masalah sulit ini bisa 
diakses semua orang
hanya dengan kemampuan
dasar penulisan.
Jadi kita membawa seluruh kelebihan
deep-learning kepada semua orang
Ini model yang akan Anda
gunakan menyelesaikan masalah
Pada level tinggi, 
dia memiliki dua cabang.
Ada salah satu cabang yang artinya
mengkodekan input video
kedalam sebuah garis vektor
dan satu cabang yang lain artinya
membuat kode pertanyaan,
jadi urutan kata-kata,
menjadi sebuah garis vektor.
Jadi kami memiliki satu garis,
termasuk informasi
tentang seluruh video,
satu vektor,
termasuk informasi untuk
seluruh pertanyaan.
Lalu kita menggabungkan
dua garis vektor ini.
Dan ini memberikan kita
satu garis vektor
yang mengodekan informasi
tentang seluruh masalah,
tentang kombinasi video
dan pertanyaannya.
Dan kecantikan itu serta
keajaiban deep-learning
adalah menginput persepsi
Anda, seperti video,
misalnya, Anda mencari makna semantik,
dan Anda meletakkan input persepsi

Spanish: 
y Keras como una API,
estamos haciendo que estos tres problemas
sean accesibles para todos
con habilidades básicas en script.
Estamos haciendo popular
todo el poder del aprendizaje profundo.
Este modelo podría usarse
para resolver este problema.
En un primer nivel, tiene dos ramas.
Hay una rama destinada a codificar
la entrada de videos como un solo vector
y la otra rama está destinada
a codificar la pregunta,
una secuencia de palabras,
como un solo vector.
Tenemos un vector, con información
del video entero,
un vector con información
de la pregunta entera.
Y luego concatenamos estos dos vectores.
Y nos da un solo vector
que codifica información
sobre todo el problema,
sobre la combinación
del video y la pregunta.
Y esa es la belleza y la magia
del aprendizaje profundo.
Es que toma entradas perceptuales
como un video, por ejemplo,
toma significado semántico,
e incorpora esta entrada perceptual
[se corta el audio]

Chinese: 
有了 Keras API，我们
正让这三个难题可以让每个
拥有基本的（听不清）脚本功能的人
有能力解决
那么，我们就把深度学习的能力
赋予了每个人
这个模型，你可能会用来解决这个问题。
在高阶，
它有两个分支
其中一个是为了
将视频输入编码成
单矢量
另一个是将问题编码
编词成单矢量
那么，有单矢量
包含了全部视频信息，
另外一个包含了全部问题
然后我们再连接两个载体
这给了我们一个单矢量
编码了全部问题的信息
结合了视频和问题
绝妙之处就在于此，
而深度学习的魔力在于
知觉输入，比如视频，
语义，
嵌入知觉输入

Korean: 
API를 케라스로 사용해서
이 세 가지 문제를
기본 [청취불가]
스크립트 능력만 있으면
어느 누구라도 접근할 수
있도록 만들고 있습니다
따라서 저희는 딥 러닝의 파워 전체를
모든 이의 손에 쥐어주는 겁니다
이 문제를 해결하기 위해
사용할 수 있는 모델이 여기 있습니다
고등 수준에서는 두 가지 브랜치가 있죠
하나의 브랜치는 비디오 인풋을
단일 벡터로 인코딩하도록 되어 있고
다른 브랜치는 질문
따라서 단어 순서를
단일 벡터로 인코딩 하도록
되어 있습니다
따라서 전체 비디오에 대한
정보를 포함하는
하나의 벡터가 있고
전체 질문에 대한 정보를
포함하는 하나의 벡터가 있는 거죠
그리고 나서 이 두 벡터를
연결시키는 거죠
전체 문제에 대한 정보를 인코딩 하는
하나의 벡터를 주는 거죠
즉 비디오와 질문의
조합에 대한 정보이죠
이것이 바로 딥 러닝의
미와 마술적인 힘이죠
즉 비디오와 같은 지각적 인풋을 가지고
예컨대 의미를 가져 오고
이 지각적 인풋 [청취불가]을
임베드 하는 거죠

Japanese: 
API として Keras を使って
基本的な（聞き取り不可）
スクリプト能力を通じて
これらの３つの困難な課題を
多くの人の手に渡るようにしているのです。
そしてディープラーニングの最大限の能力を
すべての人に届けるようにしています。
この課題を解決するためのモデルが
ここにあります。
ハイレベルには２つのブランチがあります。
ビデオインプットをシングルベクトルに
エンコードする１つのブランチがあります。
もう１つのブランチは、
質問つまり単語のシークエンスを
シングルベクトルに
エンコードするものです。
ビデオ全体の情報を含めたベクトルがあり、
もう１つのベクトルは、
質問すべてに関する情報を含めたものです。
その後、これらの２つのベクトルを
連鎖させます。
そうすると、課題全てに関する情報と
ビデオと質問のコンビネーションに
関する情報をエンコードする、
シングルベクトルが出ます。
ディープラーニングの
素晴しい魅力を挙げると、
ビデオのような
知覚インプットを得ることができ
意味的な価値を得ることができ、
またこの知覚インプット
（聞き取り不可）を埋め込むことができます。

English: 
and with Keras as
an API, we're making
these three difficult
problems accessible to anyone
with just basic [INAUDIBLE]
scripting capabilities.
So we are putting the full
power of deep learning
into the hands of everyone.
So here's a model that you
would use to solve this problem.
At the high level,
it has two branches.
There's one branch that's meant
to encode the video inputs
into a single vector
and one branch meant
to encode the question,
so a sequence of words,
into a single vector.
So we have one vector,
including information
about the entire
video, one vector,
including information
about the entire question.
And then we concatenate
these two vectors.
And this gives us
one single vector
that encodes information
about the entire problem,
about the combination of
the video and the question.
And that's kind of the beauty
and the magic of deep learning
is that you take perceptual
inputs, like a video,
for instance, you
take semantic meaning,
and you're embedding this
perceptual input [AUDIO OUT]

Chinese: 
就是把语义嵌入几何空间
把意思转化成矢量
就可以发现
这些几何空间有趣的转换
那就是深度学习的绝妙之处
所以，在我们例子里
我们将要用这个矢量编码全部的问题
我们将要在上面训练全部连接的（听不清）
它会得出一个预定义词汇上的 Sofmax
因此
最有可能得到的词汇
正是问题的答案
所以，如果你现在看看更高水平的细节
我们如何将一个视频转变成一个单一矢量呢？
我们又如何将一个问题转成矢量呢？
对这个视频，
我们把它作为一系列画面
每一幅都是一张图片
RGB，它有高度、宽度、厚度，颜色深浅度等
其他顺序，你可以用
（听不清）将每个画幅转化成单矢量。
本质上说，你是利用了
预先训练的网络的条件库，
而后，做一些引导提取一个矢量

Korean: 
이 의미를 기하학적 공간에
임베드 하는 겁니다
의미를 벡터로 변환시키고
그런 후 이러한 기하학적 공간의
흥미로운 전환을 배울 수 있는 거죠
이것이 딥 러닝의 진정한 미입니다
이 경우에는 이 벡터를 가지고
전체 문제를 코딩할 겁니다
완전히 연결된 [청취불가]를
가장 위에 훈련시킬 겁니다
이미 정해진 어휘력에
소프트맥스로 마무리 되고
따라서 이 어휘에서
가장 높은 확률을 가진 단어가
이 질문에 대한 대답이 되겠죠
이제 더 높은 수준의
세부사항을 보고 싶다면
어떻게 비디오를 단일 벡터로 바꿀까요?
질문을 어떻게 벡터로 바꿀까요?
비디오의 경우, 프레임의 연속으로써
비디오로 시작하고 있죠
따라서 각 프레임은
단지 이미지일 뿐입니다
빨간색, 녹색, 파랑
그리고 높이와 너비, 깊이와 색깔 깊이가 있죠
프레임의 다른 시퀀스는 각 프레임을
단일 벡터로 변환시키기 위해
[청취불가]를 사용하면 됩니다
본질적으로 미리 훈련된 네트워크의
조건적 베이스를 사용하고
그 프레임의 시각적 내용을 인코딩한

Indonesian: 
Dan Anda memasukkan artinya
kedalam ruang geometri.
Anda merubah maknanya
kedalam garis vektor
lalu Anda dapat mempelajari
perubahan menarik
dari ruang geometris ini.
Jadi itu sebenarnya
keindahan deep-learning
Jadi kita akan mengolah garis ini
dan mengkodekan seluruh masalah.
Dan kita akan melatih [Tidak jelas]
yang terhubung di puncaknya.
Dan itu akan berakhir dengan
sebuah Softmax
melalui kosa kata yang sudah
dikenal, dan jadi kata dengan
tingkat kemungkinan tertinggi
dalam kosa kata ini
akan menjadi jawaban atas pertanyaan ini.
Jika Anda ingin melihat
level detil lebih tinggi,
Bagaimana kita merubah video
menjadi satu garis?
Bagaimana kita merubah
pertanyaan jadi satu garis?
Jadi untuk video, kita akan
memulai dengan video
sebagai sebuah urutan bingkai.
Jadi setiap bingkai hanyalah sebuah gambar
Itulah RGB, memiliki sebuah puncak,
keluasan , kedalaman, yang berwarna.
Urutan bingkai lain, Anda menggunakan
sebuah lemari untuk merubah
setiap bingkai menjadi satu vektor.
Jadi utamanya Anda menggunakan
kondisi dasar dari sebuah
jaringan pra-dilatih, dan Anda
menarik untuk mengekstrak
satu vektor yang

Portuguese: 
E você incorpora esse significado
em um espaço geométrico.
Você está transformando
significado em vetores
e poderá aprender interessantes
transformações desse espaço.
Essa é a real beleza
da aprendizagem profunda.
No nosso caso, pegaremos o vetor
e codificaremos o problema inteiro.
E treinaremos um totalmente
conectado [inaudível] acima.
E irá acabar com uma rede softmax
sobre um vocabulário predefinido
e a palavra com a maior probabilidade
deste vocabulário será a resposta.
Se você quiser um maior nível de detalhe,
como transformamos um vídeo em vetor?
Como transformamos
uma questão em um vetor?
Para o vídeo, começaremos com o vídeo
como uma sequência de frames.
Cada frame é apenas uma imagem.
É RGB, tem altura, largura,
profundidade e profundidade de cor.
Na outra sequência de frame,
você usará uma [inaudível]
para transformar cada frame
em um único vetor.
Basicamente você está usando uma
base condicional de uma rede pré-treinada

Japanese: 
そしてこの意味をジオメトリック
スペース内に埋め込みます。
意味をベクトルに変換します。
これらのジオメトリックスペースの
興味深い変形を学ぶことができます。
これこそがディープラーニングの
魅力となります。
このケース場合は、このベクトルを取得し
そして課題全体をエンコードします。
そして上部でフルコネクトされた
（聞き取り不可能）をトレーニングします。
事前定義された語彙に関しては、
Softmax で終了します。
この語彙の中で
非常に確率の高い単語は、
質問の答えになるでしょう。
ディテールのより高いレベルを見たい場合
どうやってビデオをシングルベクトルに
変換することができるでしょうか。
どうやって質問をベクトルに
変換するのでしょうか。
ビデオに関しては、ビデオを
フレームシークエンスとして使います。
ですから、それぞれのフレームは
ただのイメージになります。
RGB であり、それには高さ、幅、
奥行き、色の濃度があります。
別のフレームシークエンスは、
それぞれのフレームをシングルベクターに
変換することが理にかなっています。
基本的には、事前に仕込まれた
ネットワークの条件的ベースを使い

Spanish: 
Incorpora este significado
al espacio geométrico.
Convierte significados en vectores
y luego se pueden aprender
transformaciones interesantes
de estos espacios geométricos.
Esa es la belleza real
del aprendizaje profundo.
En nuestro caso, tomaremos este vector
y codificaremos todo el problema.
Estaremos enseñando a un [inaudible]
totalmente conectado.
Y terminará con un SoftMax
por sobre un vocabulario predefinido,
por lo que la palabra con más probabilidad
en este vocabulario
será la respuesta a la pregunta.
Ahora, si quieren mirar con más detalle,
¿cómo convertimos un video
en un solo vector?
¿Cómo convertimos la pregunta
en un solo vector?
Para el video, empezaremos con el video
como una secuencia de cuadros.
Cada cuadro es solo una imagen.
Es RVA, tiene una altura,
un ancho, profundidades de color.
La otra secuencia de cuadros,
se usa un [inaudible] para transformar
cada cuadro en un vector.
En esencia, se usa la base condicional
de una red pre-entrenada
y se trabaja un poco
para obtener un vector

English: 
And you're embedding this
meaning into geometric space.
You're turning
meaning into vectors
and then you can learn
interesting transformations
of these geometric spaces.
So that's really the
beauty of deep learning.
And so in our case, we'll
be taking this vector
and coding the entire problem.
And we will be training a fully
connected [INAUDIBLE] on top.
And it will end
up with a softmax
over a predefined
vocabulary, and so the word
with the highest probability
in this vocabulary
will be the answer
to the question.
So now if you want to look
at a higher level of detail,
how do we turn a video
into a single vector?
How do we turn a
question into a vector?
So for the video, we're
starting out with the video
as a sequence of frames.
So each frame is just an image.
So it's RGB, it has a height,
a width, a depth, color depths.
The other sequence
of frame, you use
a [INAUDIBLE] to transform each
frame into a single vector.
So essentially you're
using the conditional base
of a pre-trained
network, and you
do some pulling to
extract one vector that

English: 
encodes the visual
contents of the frame.
And so what you get out
of this is the video
anchored as a
sequence of vectors,
where each vector encodes the
visual contents of one frame.
And then you take the sequence
and you run it through an LSTM.
So you probably know
what an LSTM is,
but basically it's a
[INAUDIBLE] type of network
that can process sequences
and takes into account order.
And this LSTM will output
a single vector encoding
information about
the entire video.
To turn a question
into a vector,
we are following a
very similar process.
We represent a
question as a sequence
of integers, each integer
standing for a word.
And then we map each
word to a word vector
via a process called embedding.
So we get out of this a
sequence of word expressed
as a sequence of vectors.
We run it through
a different LSTM
layer, which will encode
the entire question
as a single vector.
So in Keras, here's
the architecture

Portuguese: 
e irá extrair um vetor que codifica
o conteúdo visual do frame.
O que você consegue disso é o vídeo
ancorado como uma sequência de vetores
onde cada vetor codifica o conteúdo
visual de cada frame.
E você pegará essa sequência
e a rodará em um LSTM.
Você deve saber o que é um LSTM
mas basicamente é uma
[inaudível] tipo de rede
que pode processar sequências
e colocá-las em ordem.
E essa LSTM irá gerar um único vetor
codificando informações sobre o vídeo.
Para transformar uma questão em vetor,
seguiremos um processo similar.
Representamos uma questão
como uma sequência de números inteiros
cada um representando uma palavra.
E então mapeamos cada palavra
em uma palavra do vetor
através de um processo chamado embedding.
Então teremos uma sequência de palavras
expressas como uma sequência de vetores.
Nós rodamos em uma camada LSTM diferente,
que codificará toda a questão em um vetor.

Korean: 
하나의 벡터를 추출하기 위해
풀링을 하는 거죠
따라서 여러분이 이 비디오에서
얻을 수 있는 것은
벡터 시퀀스에 기반을 둔 거죠
각 벡터가 프레임 하나의
시각적 컨텐츠를 인코딩하는 거죠
이 시퀀스를 가지고 LSTM을 통해
운영하면 되는 겁니다
LSTM이 무엇인지는 아마 아시겠지만
기본적으로 [청취불가]
유형의 네트워크로
시퀀스를 처리할 수 있고
순서를 포함해서 고려하죠
또한 이러한 LSTM은
비디오 전체에 대한
단일 벡터 인토딩 정보를
아웃풋할 것입니다
벡터에 대한 질문으로 전환하기 위해
아주 유사한 과정을 거칠 겁니다
질문을 정수 시퀀스로 표현되고
각 정수는 단어 하나를 나타내죠
그리고 나서 각 단어를
단어 벡터로 맵핑하는 겁니다
임베딩이라는 과정을 통해서 말입니다
따라서 벡터 시퀀스로 표현된
단어 시퀀스를 가져오게 되죠
다른 LSTM 레이어를 통해 실행하고
이는 전체 질문을 단일 벡터로
인코딩하겠죠
케라스에서 이 모델을
실행하기 위해 사용할 법한

Indonesian: 
mengkodekan konten visual bingkai.
Jadi yang Anda dapatkan dari video ini
adalah sebagai urutan garis vektor,
dimana setiap garis vektor mengkodekan
konten visual suatu bingkai.
Lalu Anda ambil urutan Anda
dan Anda jalankan lewat sebuah LSTM.
Jadi Anda mungkin sudah tahu LSTM,
tapi pada dasarnya itu
adalah jenis jaringan
yang dapat memproses urutan
dan mengambilnya dalam urutan akun.
Dan LSTM ini akan mengeluarkan
sebuah garis vektor yang mengkode
informasi tentang seluruh video.
Untuk merubah pertanyaan
jadi garis,
kita mengikuti sebuah proses
yang sangat mirip.
Kita membuat satu pertanyaan
sebagai suatu uturan
bilangan bulat, dan setiap bilangan
bulat mewakili satu kata.
Lalu kita memetakan tiap
kata jadi satu garis kata
melalui proses yang disebut embedding.
Jadi kita keluar dari suatu urutan
kata yang diungkapkan ini
sebagai satu urutan garis.
Ini dilakukan lewat lapisan LSTM
yang berbeda, yang akan menkodekan
seluruh pertanyaan ini
menjadi sebuah garis vektor.
Jadi dalam Keras, inilah bangunannya

Spanish: 
que codifique
los contenidos visuales del cuadro.
Lo que se saca de esto es el video
anclado como una secuencia de vectores,
donde cada vector codifica
los contenidos visuales de un cuadro.
Y luego se ejecuta la secuencia
a través de una red LSTM.
Probablemente sepan lo que es
una LSTM
pero básicamente es
un tipo de red recurrente
que puede procesar secuencias
y tiene en cuenta el orden.
Y esta LSTM devolverá un solo vector
con información codificada
sobre el video completo.
Para la pregunta...
Para transformar una pregunta en vector
seguimos un proceso muy similar.
Se representa la pregunta
como una secuencia de enteros,
cada uno representando una palabra.
Y luego se une cada palabra
a un vector de palabra
a través de un proceso
llamado incrustación.
Lo que sacamos de esto
es una secuencia de palabras
expresada como una secuencia de vectores.
Lo ejecutamos con otra capa
de la red LSTM
que codificará la pregunta completa
como un solo vector.
En Keras, esta es la arquitectura

Chinese: 
编码画幅的视觉内容
而你从中得到的是
这个视频作为一系列矢量而固定
每个矢量编码一画幅的视觉内容
然后，获取序列，在 LSTM 里运行
我想你应该了解 LSTM，
基本来说，它是一种（听不清）类型的网络
能够处理序列并考虑到顺序
LSTM
会输出一个编码全部视频信息的单矢量
要将一个问题转成矢量
流程很相似。
我们将一个问题
表现为一个整数序列，
每个数字代表一个单词
然后我们将每个单词定位到词汇矢量
通过一个嵌入程序
那么，我们就可以得到
表现为序列矢量的单词序列
我们通过另外一个 LSTM 层面运行
它会把整个问题
编码成单矢量。
所以，在 Keras，这就是

Japanese: 
フレームの可視的コンテンツを
エンコードする１ベクトルを抽出します。
何を得たのかと言うと、
ベクトルのシークエンスとして
固定されたビデオになります。
そこではそれぞれのベクトルがフレームの
可視化コンテンツを符号化します。
シークエンスを入手し、
LSTM を通じてそれを動かします。
たぶん LSTM が何かを
知っていると思います。
基本的には、ネットワークの
（聞き取り不可能）タイプになります。
シークエンスを処理し、
正しい順番に選び取ります。
この LSTM はビデオ全体の情報を符号化して
シングルベクトルをアウトプットします。
質問をベクターに変換するには、
非常によく似たプロセスを辿っています。
質問を整数のシークエンスと
見なします。
それぞれの整数は単語を意味します。
それぞれの単語を単語ベクトルに対応させ、
埋め込みと呼ばれる処理を通じて配置します。
これを取り除きます。
ベクトルのシークエンスとして
表現された単語のシークエンスです。
異なる LSTM レイヤーを通じて、
作動させます。
それはシングルベクトルとして
質問全てを符号化します。

Japanese: 
Keras には、
このモデルを実装するために使う
アーキテクチャーがあります。
これは前のグラフを
非常にシンプルにしたものです。
ビデオエンコーダーには、基本的にはビデオを
5D Tensor として始めます。
ですから、第一の軸線は
バッチ軸線になります。
それからタイム軸線があります。
フレームをエンコードする
3D Tensor があります。
Inception v3 network を
適用します。
それはベクトル、１フレームごとに
１フィーチャーベクトルを抽出するための、
5D Tensor の各フレームに対して、
ImageNet で事前トレーニングしたものです。
その他に、可視化ベクトルの
シークエンスが得られます。
これは LSTM レイヤーを通じて
作動するものです。
パーツを埋め込んだ質問については、
質問を配置するための
埋め込み用レイヤーを使うだけです。
整数シークエンスを
ベクトルシークエンスに入れます。
そして LSTM レイヤーを通じて
それを作動させます。
最終的に、これら２つのベクトルを
一緒にするために
連鎖処理を行ないます。
そして複数の濃いレイヤーを積み重ねます。

Portuguese: 
No Keras, essa é a arquitetura que
usaremos para implementar este modelo
e é literalmente apenas uma simples
tradução do gráfico anterior.
Para o codificador de vídeo, começaremos
com um vídeo como tensor 5D.
O primeiro eixo será o do lote,
e em seguida o eixo do tempo.
Então você tem um tensor 3D,
que codifica um frame.
E então aplicaremos uma rede Inception v3
pré-treinada no ImageNet
para cada frame do tensor 5D
para extrair um vetor,
uma característica do vetor, por frame.
Disso tiraremos uma sequência
de vetores visuais
que irá rodar em uma camada LSTM.
E para a parte de incorporação da questão,
estamos usando uma camada de embedding
para mapear nossa questão.
Uma sequência de números inteiros
convertida em sequência de vetores
e a rodamos em uma camada LSTM.
Finalmente, usaremos uma operação concat
para juntar os dois vetores
e juntamos algumas camadas densas.

Korean: 
건축이 여기 있습니다
이는 말 그대로 이전 그래프의
아주 단순한 통역일 뿐이죠
비디오 인코더의 경우 기본적으로
비디오를 5D 텐서로 시작합니다
첫 번째 축은 배치 축일 것이고
그 다음에 시간 축이 있죠
프레임을 이코딩하는 3D 텐서도 있죠
따라서 우리는 인셉션
v3 네트워크를 적용할 것이고
이는 각 프레임 당 하나의
피쳐 벡터를 추출하기 위해
이미지네트에서 5D 텐서의
모든 프레임으로 미리 훈련된 것입니다
이를 통해 시각적 벡터의 시퀀스를 얻고
이는 LSTM 레이어를 통해 실행되겠죠
그리고 질문 임베딩 부분의 경우
그저 질문을 매핑하기 위해
임베딩 레이어를 사용하는 겁니다
정수 시퀀스를 벡터 시퀀스로 바꾸고
이를 LSTM 레이어를 통해
실행하는 거죠
마지막으로 concat 운영을 사용해서
이 두 벡터를 같이 가져오고
몇 가지 밀집한 레이어를 쌓아두는 거죠

Chinese: 
我们将用来实施模型的构造
实际上只是前一个图画的
简单转换
所以，对于视频编码而言，基本上
是以5D张量开始
第一个轴是批轴
然后是时间轴
3D 张量
编码一个框架
接着应用一个初始 v3 网路，
在 ImageNet 上进行预先训练5D张量的每个画幅
以提取一个矢量，每个画幅一个特征矢量
由此，我们得到了
一系列视觉向量，
将会在 LSTM 层里运行
至于嵌入问题部分，
我们简单地利用嵌入层来定位问题
一个序列的整数成为一个序列向量
我们将它在 LSTM 层里运行
最后，我们用 concat 操作
连接两个向量
我们堆叠了几个密集层

Indonesian: 
yang akan kita gunakan untuk
mengimplementasikan model ini,
dan itu hanyalah
sebuah terjemahan sederhana
dari grafik sebelumnya.
Untuk mengkodekan video,
pada dasarnya kita
mulai dari video sebagai tensor 5D.
Poros yang pertama akan 
menjadi tumpukan poros.
Lalu Anda memiliki poros waktu.
Lalu Anda memiliki tensor 3D,
yang menkodekan sebuah bingkai.
Jadi kita akan mengaplikasikan
jaringan awal v3,
pra-latihan pada ImageNet untuk 
setiap bingkai dari tensor 5D
untuk mengekstrak satu garis vektor,
satu fitur vektor, per bingkai.
Jadi keluar dari ini, kita
memiliki satu urutan
garis visual, yang akan dijalankan
melalui sebuah lapisan LSTM.
Dan untuk pertanyaan bagian embedding
Kita menggunakan lapisan embedding
untuk memetakan pertanyaan kita.
Jadi suatu urutan bilangan bulat
menjadi suatu urutan garis vektor,
kita menggunakannya
lewat lapisan LSTM
Akhirnya, kita menggunakan sebuah
operasi penggabungan
untuk menyatukan dua garis vektor ini,
dan kita susun beberapa lapisan tebal

Spanish: 
que usaríamos para implementar
este modelo,
y es literalmente
una traducción muy simple
del gráfico anterior.
Para el codificador de video, básicamente,
empezamos desde el video
como un tensor 5D.
El primer eje será el eje de lotes.
Luego está el eje de tiempo.
Luego hay un tensor 3D,
que codifica un cuadro.
Luego aplicaremos una red Inception v3,
entrenada previamente en ImageNet
a cada cuadro del tensor 5D
para extraer un vector por cuadro.
De esto sacamos una secuencia
de vectores visuales
que se ejecutarán a través
de una capa de red LSTM.
Y para la parte de incrustación
de la pregunta,
es simple, usamos una capa de incrustación
para mapear nuestra pregunta.
Entonces una secuencia de enteros
a una secuencia de vectores,
y lo ejecutamos a través de una capa LSTM.
Finalmente, usamos una concatenación
para juntar estos dos vectores
y apilamos algunas capas densas.

English: 
that we would use to
implement this model,
and it's literally just
a very simple translation
of the previous graph.
So for the video
encoder, basically, we
are starting from the
video as a 5D tensor.
The first axis will
be the batch axis.
Then you have the time axis.
Then you have a 3D tensor,
which encodes a frame.
And so we will apply an
Inception v3 network,
pre-trained on ImageNet to
every frame of the 5D tensor
to extract one vector, one
feature vector, per frame.
And so out of this,
we get a sequence
of visual vectors, which will
run through an LSTM layer.
And for the question
embedding part,
we are simply using an embedding
layer to map our question.
So a sequence of integers
into a sequence of vectors,
and we run that
through an LSTM layer.
Finally, we use a
concat operation
to bring together
these two vectors,
and we stack a few dense layers.

Chinese: 
最终得到一个预定义词汇的 Sofmax
通过编码为 one-hot 矢量的目标答案
训练它。
那么实施是怎样的呢？
很简单。
你可以看到，
这里只用了五行来编码视频。
第一行，
只是确定了视频输入的框架
它是5D张量
通过一个形状参数，
你不必明确批量大小
所以，第一个轴设定为 none，是时间轴
将它设定为 none 是因为想让它可行
我们想小一些的能够处理
任意框架数的视频
有了单一框架的形状，
单一的框架是150x150RGB图画
那么，它的张量就是150，150x3
下一行，
我们要在一行内，
例示初始v3网络

Portuguese: 
E acabaremos com uma softmax
sobre um vocabulário pré-definido.
Você está treinando essa resposta alvo
codificada como um único vetor.
Como o que se parece
uma implementação? É bem simples.
O que você está vendo aqui é o codificador
de vídeo em apenas cinco linhas.
Durante a primeira linha, você apenas
especifica a forma da entrada do vídeo.
É um tensor 5D.
Com um argumento shape,
você não específica o tamanho do lote.
O primeiro eixo, sem definição,
é o eixo do tempo.
É sem definição porque
queremos que seja viável.
Queremos que seja capaz de processar
vídeos com qualquer número de frames.
Então você tem a forma de um único frame.
Um frame é uma imagem RGB 150 por 150,
então o tensor é 150, 150 por 3.
Na próxima linha, fazemos em uma linha
a instanciação de uma rede Inception v3

Korean: 
결국 미리 정해진 어휘에 대한
소프트맥스를 가지게 되죠
그리고 원 핫 벡터로
인코딩된 표적 대답 단어로
이를 훈련하고 있는 거죠
그럼 이 실행은 어떻게 생겼을까요?
아주 간단합니다
여기에서 보시는 것은 단지 5줄에서의
비디오 인코더입니다
첫 번째 줄에는
비디오 인풋의 모양을 구체화하고 있고
따라서 5D 텐서가 되겠죠
모양 아규먼트로 배치 사이즈는 실제로
구체화하지 않습니다
첫 번째 축은 시간 축으로
아무 것도 없다고 정했죠
실행가능하길 원하므로
아무것도 없는 것으로 정했죠
작은 것이 어떠한 숫자의
프레임의 비디오도
처리할 수 있길 바라는 거죠
그리고 나서 단일 프레임의 모양이 있죠
단일 프레임은 150 x
150 삼원색 이미지이고
150 x 150 x 3 텐서인 거죠
다음 라인에서
단일 라인은 인셉션 v3
네트워크의 예시를 들고 있죠
이는 자동으로

English: 
And we end up with a softmax
over a predefined vocabulary.
And you are training that with
a target answer word encoded
as a one-hot vector.
So what does
implementation look like?
It's very simple.
What you're seeing here
is the video encoder
in just five lines.
During the first
line, you're just
specifying the shape
of your video input.
So it's a 5D tensor.
With a shape argument,
you do not actually
specify the batch size.
So the first axis, set
to none, is a time axis.
So it's set to none because
we want it to be viable.
We want the small one
to be able to process
videos of any number of frames.
And then you have the
shape of a single frame.
So a single frame is
150 by 150 RGB image,
so it's a tensor
that's 150, 150 by 3.
In the next line,
what we are doing
in a single line
is instantiating
an Inception v3 network
that will automatically

Indonesian: 
Dan kita berakhir dengan sebuah
Softmax melampaui kosakata yang dikenal.
Dan Anda melatihnya dengan sebuah
sasaran kata jawaban yang terkodekan
sebagai sebuah garis panas vektor.
Jadi seperti apa implementasinya?
Ini sangat sederhana.
Yang Anda lihat
adalah pembuat kode video
hanya dalam lima baris.
Selama baris pertama, Anda hanya
menetapkan bentuk input video Anda,
Jadi itu adalah Tensor 5D
Dengan satu argumen,
Anda sebenarnya
tidak menetapkan sejumlah ukuran.
Jadi sumbu pertama, tentukan
kosong, adalah sebuah poros waktu.
Diatur kosong karena kita
ingin terus berjalan.
Kita ingin yang kecil bisa memproses
video beberapa bingkai.
Lalu Anda memiliki
bentuk sebuah bingkai.
Jadi sebuah bingkai adalah
150 dengan gambar 150 RGB
jadi ini adalah Tensor
yaitu 150, 150 oleh 3.
Dalam baris berikutnya,
apa yang kita lakukan
dalam sebuah garis
adalah memberi contoh
sebuah permulaan jaringan v3
yang akan secara otomatis

Spanish: 
Y terminamos con un SoftMax
por sobre el vocabulario predefinido.
Y se entrena
con una palabra-respuesta meta codificada
como un vector de tipo one-hot.
¿Cómo se ve la implementación entonces?
Es muy simple.
Lo que ven aquí es el codificador de video
en solo cinco líneas.
En la primera línea,
solo se especifica la forma
de la entrada de video.
Es un tensor 5D.
Con un valor de forma,
no hay que especificar el tamaño de lote.
El primer eje, fijado en None,
es un eje de tiempo.
Está fijado en None porque
queremos que sea viable.
Queremos que el más pequeño pueda procesar
videos de cualquier número de cuadros.
Y luego está la forma de un solo cuadro.
Un solo cuadro es de 150 por 150 RVA,
es un tensor de 150, 150 por 3.
En la línea siguiente, lo que hacemos
en una sola línea es ejemplificar
una red Inception v3 que automáticamente

Japanese: 
事前定義された語彙に対して
Softmax で終了します。
ワンホットベクトルとして符号化した、
ターゲットアンサーワードを使って
トレーニングします。
実装はどのように見えるでしょうか。
とてもシンプルです。
ここでご覧になっているのは、
５行で表示されたビデオエンコーダーです。
１番目の行では、
ビデオインプットの Shape を
指定するだけです。
それは 5D Tensor であり、
Shape では、バッチサイズを
指定するわけではありません。
１番目の軸線は、none 仕様で
タイム軸線になります。
none 仕様なのは、実行可能な状態に
しておきたいからです。
どんなフレームの数のビデオも処理できる
小さなものが必要です。
シングルフレームの Shape が
得られます。
シングルフレームは
150 X 150 RGB イメージになります。
150 X 150 X 3 の
Tensor になります。
次の行、シングル行の中で
私達がやっているのは
Inception v3 network を
例示しています。

Spanish: 
cargará pesos pre-entrenados,
así que entrenen en ImageNet.
Y configuraremos esta red
para que haga extracción
de características visuales.
En esencia, no incluiremos
la parte clasificatoria de Inception v3,
solo en la base convolucional.
Y luego tiraremos un poco
de la capa de bloqueo.
Solo se extrae un solo vector,
por entrada de imagen pura.
Luego en la siguiente línea,
estableceremos el CNN
para que no se entrene.
Esto significa que,
durante el entrenamiento,
no estaremos actualizando los pesos.
¿Por qué?
Porque es un modelo pre-entrenado.
Y si se actualizaran los pesos
durante el entrenamiento
para este nuevo problema
de responder la pregunta
probablemente estemos arruinando
las representaciones
que este modelo
ya ha aprendido en ImageNet.
Y no queremos eso.
Así que lo congelamos.
El próximo paso es utilizar
una capa distribuida en el tiempo
para tomar este CNN

Japanese: 
事前に訓練されたウェイトを
自動的にロードします。
つまり、ImageNet 上で
トレーニングします。
このネットワークが可視化フィーチャーを
抽出できるように環境設定します。
基本的には、回旋ベースのみに
Inception v3 の分類されたパートを
導入しているわけではありません。
妨げとなっているレイヤーの頂点に
平均を持ってきて、適用します。
シングルベクトル１つ、露出した
イメージインプットを抽出するだけです。
そして次の行では、トレーニング不可能な
（聞き取り不可能）を設定します。
トレーニング中にウェイトを更新しないのは
どういう意味を持つのでしょうか。
なぜか、それは事前トレーニングされた
モデルだからです。
質問と回答に関する、
この新たな問題をトレーニング中に
そのウェイトを更新するとしたら、
このモデルがすでに ImageNet で
習得した記号を、
台無しにすることになります。
それはしたくありません、
フリーズさせます。
次に、単純にこの
（聞き取り不可能）を取るために
時間分布されたレイヤーを使います。

Korean: 
미리 훈련된 무게를 불러와서
이미지넷에 훈련하는 거죠
이 네트워크가
시각 피쳐 추출을 하도록
컨피겨할 겁니다
근본적으로 인셉션 v3의
클래시파이어 부분을
포함하지 않을 것이고
나선형 베이스에서만 하겠죠
그리고 나서 병목 레이어 위에
보통의 풀링를 조금 적용시킬 겁니다
하나의 단일 벡터, 원래의
이미지 인풋만 추출하는 거죠
이 다음 라인은 [청취불가]를 세팅해서
훈련되지 않도록 하는 거죠
이것의 의미는 훈련 동안에
무게를 업데이트하지는
않을 거라는 말이죠
왜 그럴까요?
간단히 말해 이건
미리 훈련된 모델이니까 그렇습니다
질문에 대답하는
이러한 새로운 문제를 훈련하는 동안
이 모델이 이미
이미지넷에서 배운 표상을
망쳐버릴 수가 있죠
그러길 원하진 않겠죠
그냥 멈추게 하는 겁니다
다음 단계는 시간 분포
레이어를 사용하는 겁니다
근본적으로 이 [청취불가]를
가져오기 위해서죠
또한 비디오 인풋의
시간 축의 매 단계마다

Indonesian: 
memuat berat pra-pelatihan,
jadi mengajar pada ImageNet.
Dan kita akan mengatur jaringan
ini untuk melakukan penarikan
fitur visual.
Jadi intinya kita tidak
akan melibatkan
bagian terpisah dari permulaan v3,
hanya di dasar konvolusional
Dan kita akan mengaplikasikan
beberapa tarikan sedang
pada puncak lapisan yang macet.
Anda hanya perlu mengekstrak
sebuah garis, tanpa input gambar.
Kemudian baris berikutnya ini,
kita mengaturnya
untuk menjadi tanpa dilatih.
Jadi maksudnya adalah,
selama pelatihan,
kita tidak akan meng-update beratnya.
Kenapa?
Karena itu adalah model pra-latihan.
Dan jika Anda ingin memperbarui
beratnya selama pelatihan
masalah baru yang menjawab pertanyaan
kita akan senang
menghancurkan perwakilannya
yang telah dipelajari
model ini di ImageNet.
Jadi Anda tak mau.
Anda hanya perlu membekukannya.
Dan langkah selanjutnya adalah
gunakan lapisan pendistribusian waktu
untuk mengambilnya secara esensial
dan mengaplikasikannya kedalam
setiap langkah suatu poros waktu

English: 
load pre-trained weights,
so train on ImageNet.
And we'll configure this network
to be doing visual feature
extraction.
So essentially we'll
not be including
the classifier part
of Inception v3,
only in the convolutional base.
And then we'll be applying
some average pulling
on top of the bottleneck layer.
You just extract one single
vector, bare image input.
Then this next line, we
are setting [INAUDIBLE]
to be non-trainable.
So what this means is
that, during training,
we will not be
updating the weights.
And why?
Simply because it's
a pre-trained model.
And if you were to update
its weights while training
on this new problem
of question answering,
we will likely be wrecking
the representations
that this model has already
learned on ImageNet.
So you don't want to do that.
You just freeze it.
And so the next step is to
use a time-distributed layer
to essentially take
this [INAUDIBLE]
and apply it to every
step of the time

Chinese: 
它能自动加载预训练的权重
我们要使该网络成型
以提取视觉特征。
本质上，我们不会包含
v3的分级部分
只在卷积基层
接着我们要
在瓶颈层之上应用一些均衡牵引
你只需要提取一个矢量
图像输入
然后，下一行我们要设置（听不清）
为不可训练的
这意味着，在训练过程中
我们不会更新权重
为什么呢？
因为它是预训练模型
如果你在训练时要更新权重
在这个新问题的回答上
我们可能就会破坏
模型已通过 ImageNet 学到的演示
所以你不要那么做
只要冻结它
下一步，运用时间分布层
来（听不清）
并且将其应用于

Portuguese: 
que irá automaticamente carregar pesos
pré-treinados, então treine no ImageNet.
E configuraremos essa rede para extrair
características visuais.
Essencialmente não incluiremos
a parte do classificador do Inception v3
só a base convolucional.
E aplicaremos algumas edições
na camada de estrangulamento
Você deve extrair um único vetor,
entrada de imagem.
Na próxima linha, iremos configurar
[inaudível] para ser não treinável.
O que isso significa é que,
durante o treinamento
não atualizaremos os pesos. Por quê?
Porque é um modelo pré-treinado.
E se você fosse atualizar os pesos
enquanto treina este novo problema
de busca de respostas
provavelmente acabaremos
arruinando as representações
que este modelo já aprendeu no ImageNet.
Você não quer que isso aconteça.
É melhor congelar.
O próximo passo é usar uma camada
time-distributed para esse [inaudível]

Chinese: 
视频输入的时间轴的每一步
此时间分布层
只是采取这个（听不清）
并应用到每一个框架
这一层得到的
只是一个3D 张量，
就是一系列视觉矢量
每个矢量就代表一个框架
最后，我们通过 LSTM 层运行这个序列张量
得到一个单一矢量
就编码了全部视频
你会注意到，
当我们实例化这个
Keras LSTM 层时，
我们只指定了一个参数
也就是 LSTM 层的单位数量
仔细想想，你就会发现这很厉害
因为有许多的高级配置参数
在 LSTM 中
当你使用 LSTM 时
会有很多这样的体验
例如，你要记住
权重的记录应当用
（听不清）初始化

English: 
axis of the video input.
So this time-distributed layer
just takes this [INAUDIBLE]
and apply it to every frame.
And what comes out of
this layer is simply
3D tensor, which is a
sequence of visual frames,
a sequence of visual vectors.
So each vector is
standing for one frame.
And finally, we run
this sequence tensor
through an LSTM layer, and
this gives us one single vector
encoding a [INAUDIBLE] video.
And as you can notice, when we
are instantiating this Keras
LSTM layer, we only
specify one parameter,
which is the number of
units in the LSTM layer.
And if you think about it,
that's quite remarkable,
because there are so many
advanced configuration
parameters in this LSTM layer.
There are a lot of
these practices you have
to follow when using LSTMs.
For instance, you
have to remember
that your record on weights
should be initialized using
[INAUDIBLE] initialization.

Indonesian: 
input video.
Jadi lapisan pendistribusian waktu
hanya memerlukan ini dan
diaplikasikan ke tiap bingkai.
Dan hasil lapisan ini adalah sesederhana
tensor 3D, yang merupakan
urutan bingkai visual,
sebuah urutan garis vektor visual.
Jadi tiap vektor ada untuk satu bingkai.
Dan akhirnya, kita menjalankan
urutan tensor
melalui sebuah lapisan LSTM, dan
ini memberikan kita satu garis vektor
yang mengkodekan video.
Seperti yang bisa Anda perhatikan,
ketika kita membuat contoh lapisan
LSTM Keras, kita hanya 
menetapkan satu parameter,
yang merupakan jumlah
satuan lapisan LSTM.
Dan jika Anda memikirkannya,
ini cukup mudah diingat
karena ada banyak parameter
susunan baru di lapisan LSTM.
Ada banyak praktek yang Anda dapatkan
untuk diikuti saat pakai LSTM.
Sebagai contoh, ingatlah bahwa
Anda merekaman berat yang
seharusnya diatur menggunakan
inisialisasi.

Korean: 
적용하기 위해서 입니다
따라서 이 시간 분포 레이어는
그저 이 [청취불가]만 필요하죠
그리고 매 프레임마다 적용하는 거죠
이 레이어에서 나오는 것은 단순히
3D 텐서로
시각적 프레임의 시퀀스이고
시각적 벡터의 시퀀스이죠
각 벡터는 하나의 프레임을 나타내죠
마지막으로 이 시퀀스 텐서를 실행합니다
LSTM 레이어를 통해서 말이죠
그리고 이는 [청취불가] 비디오를
인코딩하는 하나의 단일 벡터를 줍니다
눈치채셨겠지만 이 케라스
LSTM 레이어를 예시로 들 때
하나의 파라미터만 구체화했죠
이는 LSTM 레이어에서
유닛의 숫자입니다
생각해 보시면 이건 굉장한 것인데
이 LSTM 레이어에는
굉장히 많은 진보된 컨피겨레이션
파라미터가 있기 때문이죠
LSTM을 사용할 때 따라야 할
이러한 실례가 많습니다
예컨대 무게에 대한 기록은
[청취불가] 초기 설정을
사용해서 초기설정되어야
한다는 것을 명심하셔야 합니다

Spanish: 
y aplicarlo en cada paso del eje de tiempo
del video de entrada.
Entonces esta capa toma el CNN
y lo aplica a cada cuadro.
Y lo que sale de esta capa es simplemente
un tensor 3D, que es una secuencia
de cuadros visuales,
una secuencia de vectores visuales.
Cada vector representa un cuadro.
Y finalmente, ejecutamos
este tensor en secuencia
a través de una capa de red LSTM,
y esto nos da un solo vector
codificando un video [inaudible].
Y como pueden ver, cuando ejemplificamos
esta capa LSTM de Keras,
solo especificamos un parámetro,
que es el número de unidades
en la capa de red LSTM.
Y si lo pensamos, es extraordinario
porque hay muchos parámetros
de configuraciones avanzadas
en esta capa de red LSTM.
Hay muchos procedimientos como este
que hay que seguir cuando usamos LSTM.
Por ejemplo, hay que recordar
que el registro de pesos
debe iniciarse usando
la iniciación [inaudible].

Portuguese: 
e a aplica para cada passo
do eixo do tempo de entrada do vídeo.
Essa camada time-distributed pega
esta [inaudível] e aplica para cada frame.
E o que sai dessa camada
é simplesmente um tensor 3D.
Uma sequência de frames visuais,
de vetores visuais.
Cada vetor representa um frame.
E finalmente, rodaremos uma sequência
de tensor em uma camada LSTM
e teremos um único vetor
codificando o vídeo todo.
Como você pode notar, quando estamos
instanciando essa camada LSTM Keras
especificaremos apenas um parâmetro,
que é o número de unidades da camada LSTM.
Se você parar para pensar, é bem notável
porque existem muitas configurações
avançadas de parâmetros nessa camada LSTM.
Há várias dessas práticas
para seguir ao usar LSTMs.
Por exemplo, é preciso lembrar
que o seu registro de pesos
deve ser inicializado usando
uma inicialização ortogonal.

Japanese: 
またビデオインプットの時間軸の
すべてのステップに適用させます。
この時間分布レイヤーは
この（聞き取り不可能）を取り、
そしてすべてのフレームに適用します。
このレイヤーから出てくるものは、
単純に 3D Tensor であり
可視化フレームのシークエンス、
可視化ベクトルのシークエンスです。
それぞれのベクトルは１フレームを
表しています。
ついに、このシークエンス Tensor を
LSTM レイヤーを通じて作動させます。
ビデオ全体をエンコードする、
シングルベクトル１つが得られます。
Keras LSTM レイヤーを
例示している時、
LSTM レイヤー内のユニット数となる、
１つのパラメータを指示するだけです。
それを考慮すると、
これは非常に珍しいことだと分かります。
この LSTM レイヤーの中には数多くの
高度な環境設定パラメータがあるからです。
LSTM を使う時には、
実行しなければならない事柄が
数多くあります。
言い換えれば、初期化する場合は
ウェイトに関する記録は
初期化しなければなりません。

Spanish: 
Y hay que recordar que el sesgo
del [inaudible]
se debe iniciar a 1.
Este tipo de prácticas recomendadas
que realmente hay que seguir si quieren
que el entrenamiento salga bien.
Y un principio fundamental de Keras
es que se implementen
las prácticas recomendadas
para que todas las capas de Keras
tengan bien optimizada
la configuración estándar,
y que tenga en cuenta estas prácticas.
Pueden confiar en que los estándares
de Keras son buenos estándares
y dejar que su modelo se entrene solo
sin necesidad de ajustar
cada uno de estos hiperparámetros.
Las prácticas recomendadas están incluidas
y ustedes solo deben preocuparse
por especificar algunos parámetros
como el número de unidades,
y todo lo demás debería funcionar
apenas instalado.
Para el codificador de la pregunta,
es aún más fácil.
Tenemos solo 3 líneas.
Primero, especificamos
el tensor de entrada para la pregunta.
Todas las preguntas
serán una secuencia
de como mucho 100 enteros.

Chinese: 
此外，（听不清）的偏差
应当初始化到1
如果你想要自己的训练顺利进行
对这些问题就要注意
Keras 的核心原则之一就是
包含最佳实践
所以每一个 Keras 层
都有了优化好的默认配置
考虑了所有最好的实践
你不能仅仅依赖 Keras 的默认为好的默认
就直接在工具盒外训练模型
而不对这些超参数
进行调整。
所以，最佳实践包括了
你只要指定几个关键参数
比如单元数，
其他的就是“开箱即用”了
对于编码，问题就更简单了
我们仅有三行
首先，我们为问题指定输入张量
每个问题就是一个
最多有100整数的序列

Portuguese: 
E é preciso lembrar que a tendência
do [inaudível] deve ser inicializada em 1.
Esse tipo de melhores práticas
você realmente precisa seguir
se quiser que o treinamento corra bem.
E um princípio chave do Keras é que
as melhores práticas sejam incluídas
de forma que cada camada Keras tenha
uma configuração padrão otimizada
que leve em consideração todas
estas melhores práticas.
Você não pode contar com os padrões
Keras para serem bons
e colocar o seu modelo
de treinamento de repente
sem afinar esses hiperparâmetros.
Melhores práticas inclusas
e você só terá que se preocupar
em especificar alguns parâmetros chave,
como número de unidades
e todo o resto deverá
funcionar tranquilamente.
Para o codificador de questões,
é ainda mais simples.
Temos apenas três linhas.
Primeiramente, especificamos o tensor
de entrada para a questão.
De forma que a questão será uma sequência
de 100 números inteiros.

Indonesian: 
Dan Anda harus ingat bahwa 
prasangka dari [Tidak jelas]
seharusnya dijadikan 1.
Jenis praktek terbaik
yang Anda butuhkan
untuk diikuti jika Anda ingin
pelatihan berjalan mulus.
Dan satu prinsip utama Keras adalah
sudah termasuk praktek terbaik,
jadi setiap lapisan Keras memiliki
pengaturan pabrik optimal
yang memasukkan akun praktek
terbaik.
Jadi Anda tak bisa hanya mengandalkan
pengaturan Keras sebagai pengaturan baik
dan untuk mendapatkan model 
Anda terlatih diluar kepala
tanpa mengharuskan Anda
menyempurnakannya setiap
hiperparameter ini.
Jadi sudah termasuk praktek terbaik,
Anda hanya perlu
memperhatikan menentukan
beberapa parameter kunci,
seperti satuan angka, dan 
yang lainnya hanya akan
bekerja mengikuti.
Jadi tentang pertanyaan pembuat kode,
bahkan jauh lebih sederhana.
Kita hanya punya tiga baris.
Pertama, tentukan input
pertanyaan tensor.
Jadi setiap pertanyaan akan urut
dari 100 bilangan bulat.

Korean: 
또한 [청취불가]의 편향은 1로
초기 설정 되어야 한다는 것도
명심하셔야 합니다
이러한 유형의 모범 사례는 훈련이
순조롭게 진행되길 원하신다면
반드시 따라야 합니다
그리고 케라스의 핵심 원리는
모범 사례가 포함되었고
따라서 각 케라스 레이어가
이러한 모범 사례를 고려한
아주 잘 최적화된 기본값
컨피겨레이션을 가지고 있다는 점이죠
.
케라스 기본값이
좋은 기본값이라고 생각하시고
이러한 하이퍼파라미터를
세세히 조절하지 않고
바로 모델이 훈련될 거라고
기대하시면 되죠
모범 사례가 포함되어 있고
약간의 핵심 파라미터를
구체화하는 것만 신경쓰시면 됩니다
예컨대 유닛의 숫자같은 것이죠
나머지는 그냥 그대로 쓰면 됩니다
문제 인코더의 경우 더욱 간단하죠
3줄의 라인 뿐입니다
먼저 문제를 위한
인풋 텐서를 구체화하죠
따라서 모든 질문은
기껏해야 100개의 정수의
시퀀스가 되겠죠

Japanese: 
そして（聞き取り不可能）のバイアスを
１に初期化する必要があります。
トレーニングをスムーズに進めたい場合、
これらの最も有益なタイプの実践は
必要不可欠です。
Keras の重要なキー要素は、
最も有益な実践は、内包されています
それぞれの Keras レイヤーには
最適化されたデフォルト環境設定があり、
これらの最善な実践をすべて考慮しています。
Keras デフォルトは
良いデフォルトのみならず、
これらのハイパーパラメータを探すことなく、
ボックスの外でトレーニングできる
モデルを得る手助けもしてくれます。
最善の実践は含まれています。
ユニット番号のような少数の
キーパラメータを指示するだけで、
どのような事象も
ボックスの外で正確に作動するはずです。
質問エンコーダーについては、
より簡単で、３行からなります。
最初に、質問用のインプット
Tensor を指示します。
全ての質問は、最大で 100 の整数の
シークエンスになります。

English: 
And you have to remember that
the bias of the [INAUDIBLE]
should be initialized to 1.
These type of best
practices that you really
need to follow if you want
training to go smoothly.
And one key
principle of Keras is
that best practices
are included,
so every Keras layer has
well-optimized default
configuration that takes
into account all these best
practices.
So you can't just rely on Keras
defaults to be a good defaults
and to just get your model
to train out of the box
without requiring you
to fine-tune every
of these hyperparameters.
So best practice is
included, and you should just
care about only specifying
a few key parameters,
like the number of units, and
everything else should just
work right out of the box.
So for the question
encoder, it's even simpler.
We just have three lines.
First, we specify the input
tensor for the question.
So every question would
just be a sequence
of at most 100 integers.

Chinese: 
所以，我们将问题限制在100 个单字的长度
接着把所有整数编码到单词矢量
就有了这个嵌入层
注意，我们在此嵌入层上用了掩蔽
也就是说，
如果我们对问题（听不清）
如果问题短于100 个单词
我们只需用0填补剩下的来达到100
这就创建了一个掩蔽
将会在之后传到（听不清）层
那么我们就最终把四矢量序列
编码成单一矢量，通过另一个 LSTM 层
请记住，当我们使用这些预培训的初创网络
加载这些预培训的权重
是非常基础的
因为你处理的数据组相对较小

English: 
So we will be limited to a
question at 100 words long.
And then we embed every
integer into word vector.
We have this embedding layer.
Note that we use masking on
this embedding layer, which
means that, for
instance, if we do
[INAUDIBLE] on our
questions, which
means that, if the questions
are shorter than 100 words,
we will just pad the rest
with zeros to get to 100.
This creates a
mask, which will be
propagated to the [INAUDIBLE]
layer right after that.
And so we finally encode
the sequence of four vectors
into a single vector
via another LSTM layer.
So note that, when we're using
these pre-trained inception
network, it's
absolutely fundamental
to be loading these
pre-trained weights
because you're dealing with
a fairly small data set.

Japanese: 
ですから、質問は 100 文字に
限られます。
そして全ての整数を
ワードベクトルに埋め込みます。
この埋め込み用レイヤーがあります。
この埋め込み用レイヤーに
マスキングを使います。
それが意味するのは、
質問に（聞き取り不可能）をした場合、
もし質問が 100 文字以下であれば、
残り部分にゼロを足して、
100 文字になるようにします。
これはマスクを作ります。
その後すぐに（聞き取り不可能）
レイヤーを伝達する必要があります。
最終的に、別の LSTM レイヤーを通じて
４つのベクトルのシークエンスを
１つのベクトルに埋め込みます。
これらの事前に訓練した、
インセプションネットワークを使う時
これらの事前訓練されたウェイトのロードは、
絶対不可欠であることを
覚えておいて下さい。
なぜなら、いくらか少量のデータセットを
取り扱っており

Spanish: 
Estaremos limitados a preguntas
de no más de 100 palabras.
Y luego incrustamos cada entero
en vectores de palabra.
Tenemos esta capa de incrustación.
Fíjense que usamos enmascaramiento
en esta capa de incrustación,
lo que significa que, por ejemplo,
si le hacemos adiciones a la izquierda
a nuestras preguntas,
es decir, si las preguntas
tienen menos de 100 palabras,
rellenaremos el resto con ceros
para llegar a 100.
Esto crea una máscara, que se propagará
a la capa recurrente justo después de eso.
Finalmente codificamos
la secuencia de 4 vectores
en un solo vector a través
de otra capa de red LSTM.
Así que fíjense que cuando usamos
estas redes Inception pre-entrenadas,
es absolutamente fundamental
ir cargando estos pesos pre-entrenados
porque estamos trabajando
con un grupo de datos bastante pequeño.

Portuguese: 
Ficaremos limitados a uma questão
de no máximo 100 palavras.
E incorporamos cada número inteiro
em um vetor de palavra.
Temos essa camada de embbeding.
Note que usamos um mascaramento
nesta camada de embedding
o que significa, por exemplo, que se
[inaudível] em nossas questões
o que significa que, se as questões
tiverem menos que 100 palavras
iremos completar o resto com
zeros para chegar a 100.
Isso cria uma máscara, que será propagada
ao [inaudível] camada seguinte.
E finalmente codificamos a sequência
de quatro vetores em um único vetor
via outra camada LSTM.
Note que quando estamos usando essas
redes iniciais pré-treinadas
é fundamental carregar esses pesos
pré-treinados porque estamos lidando
com uma base de dados
relativamente pequena.

Indonesian: 
Jadi kita akan dibatasi dengan
sebuah pertanyaan pada 100 kata
Lalu kita meletakkan setiap
bilangan bulat kedalam garis.
Kita memiliki lapisan peletakan.
Kita menggunakan lapisan
penempatan ini, yang mana
artinya, sebagai contoh,
jika kita [Tidak jelas]
pada pertanyaan kita, yang mana
jika pertanyaannya kurang dari 100 kata,
Kita hanya akan menambahkan
kosong kepada sisanya agar bisa 100.
Ini menciptakan sebuah
penutup, yang kemudian
diperbanyak ke lapisan setelah itu.
Dan akhirnya kita mengkodekan
urutan empat garis vektor
kedalam satu garis melalui
lapisan LSTM.
Jadi, saat kita menggunakan
jaringan permulaan pra-latihan
ini hal yang sangat fundamental
untuk memuat berat pra-latihan
karena Anda berurusan dengan
kumpulan data yang cukup kecil.

Korean: 
따라서 제한은 질문은
단어 100개로 제한될 겁니다
또한 모든 정수를 단어 벡터로
임베드 하는 거죠
이 임베딩 레이어가 있죠
이 임베딩 레이어에
마스킹을 사용한다는 점을 명심하세요
다시 말해 예컨대 질문에 [청취불가]를
한다고 치면 이는
질문이 단어 100개보다 짧다면
100에 다르기 위해
나머지는 0으로 채우는 거죠
이것은 마스크를 만들고
이 바로 다음에 [청취불가]
레이어로 전달되겠죠
마침내 4개의 벡터 시퀀스를
또다른 LSTM 레이어를 통해
단일 벡터로 인코드한 겁니다
이러한 미리 훈련된
인셉션 네트워크를 사용할 때
이러한 미리 훈련된
무게를 불러오는 것은
완전히 본질적임을 명심하십시오
왜냐하면 굉장히
작은 데이터 세트를 다루고 있기 때문이죠

Indonesian: 
Satu kumpulan tidak akan
memiliki data cukup
untuk membuat Anda belajar
mengekstrak fitur visual yang menarik
Jadi Anda sangat perlu untuk
membuat jaringan ini terlatih.
Anda perlu memaksimalkan
pengaruh pra-latihan.
Dan akhirnya Anda berakhir
dengan kata jawabannya.
Anda mengambil video vektor
dan vektor pertanyaan.
Anda menggabungkan mereka
dengan operasi penggabungan.
Dan akhirnya, Anda mengaplikasikan
sepasang lapisan tebal,
dan akhirnya Anda memiliki 1000 unit.
Jadi kita punya satu
kosakata jawaban yang mungkin
yang hanya 1000 kata berbeda.
Dan ini adalah langkah dimana
Anda menentukan latihan
mengatur jaringan Anda.
Jadi Anda hanya perlu
memulai sebuah model
yang merupakan wadah 
untuk grafik lapisan,
dan Anda menggunakan mereka
dengan menentukan model inputnya
yang merupakan output.

Korean: 
또한 이 세트만으로는
흥미로운 시각적 피쳐를
추출하는 법을 배우기 위한
데이터가 충분하지는 않습니다
따라서 이 네트워크가
실제로 훈련하도록 만들 필요가 있죠
이러한 미리 훈련된 무게를
꼭 연결해야 합니다
마지막으로 대답 단어는
이렇게 보일 겁니다
비디오 벡터와 질문 벡터를 가지고
구체적 운영으로
이들을 연결하는 것이죠
마지막으로 밀집된
레이어 몇 가지를 응용합니다
결국 천 개의 유닛이 생기겠죠
따라서 단 천 개의 다른 단어인
가능한 대답의 어휘가 생기는 겁니다
네트워크의 훈련
컨피겨레이션을 구체화하는
여기 있죠
그저 모델을 예시로 사용하고
이는 레이어 그래프를 위한 컨테이너이죠
그리고 모델의 인풋과 아웃풋이 무엇인지
단지 구체화함으로써 이들을
예시로 쓰는 겁니다

Portuguese: 
E esse conjunto sozinho não teria dados
o suficiente para te permitir aprender
a extrair características
visuais interessantes.
Então é preciso realmente fazer
essa rede de fato treinar.
Você realmente precisa alavancar
esses pesos pré-treinados.
E finalmente, é assim que você
acaba com uma palavra como resposta.
Você pega o vetor de vídeo e o de questão
e os concatena com uma operação concat.
E por fim, aplica algumas camadas densas
e termina com mil unidades.
Você terá um vocabulário de possíveis
respostas de mil diferentes palavras.
E esse é o passo onde você especificará
a configuração de treinamento da sua rede.
Você estará apenas instanciando um modelo
que é um container de gráfico de camadas
e irá instanciar apenas especificando
quais são os modelos de entrada e saída.

English: 
And this set alone would
not have enough data
to allow you to learn to extract
interesting visual features.
So you really need to make
this network actually train.
You really need to be leveraging
these pre-trained weights.
And so finally this is how you
end up with the answer word.
You are taking the video
vector and the question vector.
You are concatenating them
with just a concat operation.
And finally, you are applying
a couple of dense layers,
and you're ending
up with 1,000 units.
So we'll have a vocabulary
of possible answers
that is just 1,000
different words.
And here's a step where
you're specifying the training
configuration of your network.
So you're just
instantiating a model, which
is a container for
a graph of layers,
and you're instantiating
them by just
specifying what are the
inputs of the model, what
are the outputs.

Japanese: 
このセットだけでは
重要な可視化フィーチャーを抽出するための、
学習を可能にするデータを
充分持てないからです。
ですから、このネットワークを実際に
トレーニングさせたいのであれば
これらの事前訓練されたウェイトを
レバレッジする必要があります。
これが、答えの単語で終了させる方法です。
ビデオベクトルと
質問ベクトルを持っています。
連鎖作業を通じて、これらの連鎖させます。
そして数枚の濃いレイヤーを適用します。
1000 個のユニットで終了させます。
1000 の異なる単語から成る、
潜在的な答えの語彙を得ます。
ネットワーク上でトレーニング環境設定を
指示するステップになります。
レイヤーのグラフのコンテナーである
モデルを初期化しています。
モデルのインプットと
アウトプットが何であるかを指示して、
モデルを初期化します。

Spanish: 
Y este grupo solo no tendría
los suficientes datos
como para aprender a extraer
características visuales interesantes.
Hay que hacer que esta red
se entrene realmente.
Hay que aprovechar realmente
estos pesos pre-entrenados.
Así que finalmente así es como obtenemos
la palabra de la respuesta.
Están tomando el vector del video
y el vector de la pregunta.
Los están concatenando
con solo una operación CONCAT.
Y finalmente, se aplican
algunas capas densas,
y terminamos con 1000 unidades.
Tendremos un vocabulario
de posibles respuestas
que son solo 1000 palabras diferentes.
Y aquí hay un paso donde se especifica
la configuración de entrenamiento
de tu red.
Así que solo estamos
ejemplificando un modelo
que es un contenedor
para un gráfico de capas,
y lo ejemplificamos simplemente
especificando las entradas del modelo
y las salidas.

Chinese: 
这个设置本身不会有足够的数据
让你学会提取有趣的视觉特征
所以你需要让该网络真的进行训练
你需要平衡这些预培训的权重
最后，才会得到回答单词
利用视频矢量和问题矢量
以一个联通操作将它们接合起来
最后，应用几个密集层
得到1000单元
我们有一个可能答案的词汇表
只是1000个不同单词
这是明确网络训练构造的
一个步骤
实例化一个模型
也就是图层的一个容器
通过
明确模型模型的输入输出
就把它们实例化了

English: 
You can add any number of inputs
and any number of outputs.
And you are telling
the model that it
should use the ad
optimizer during training
and this last [INAUDIBLE].
You can notice that, when
specifying our classification
layer with 1,000 units, we did
not specify any activation.
So it's actually a
purely linear layer.
The softmax activation will
be included with the loss.
And so to sum up this entire
code, it's just about 15 lines.
So it's very, very short.
So we are essentially turning
this very complex architecture,
including loading
pre-trained weights,
into just a handful of lines.
So really reducing
complexity and by allowing
you to rely on different
configurations for every layer,
we're already reducing
cognitive load.
You don't have to
care about most
of the parameters of your
LSTM layer, for instance.

Chinese: 
你可以添加任何数量的输入和输出
让模型知道
应当在训练中使用广告优化
这就是最后的（听不清）
你会注意到
用1000单元来指定分类层时，
我们没有指定任何激活
所以它只是一个线性层
SoftMax 的激活将包括在损失中
所以，总结一下全部的代码
大约只有十五行
确实很短。
本质上讲，我们将这个复杂的构造
包括加载预培训权重，
转化为少数几行
真正地降低了复杂性
通过让你在每一层上可依赖不同的配置
减轻了认知负荷
你不必去理会
LSTM 层的大部分参数

Portuguese: 
É possível adicionar qualquer número
de entradas e saídas.
Você estará dizendo ao modelo
que ele deve usar o otimizador
durante o treinamento
e este último [inaudível].
É possível notar que ao especificar nossa
camada de classificação com mil unidades
não especificamos nenhuma ativação.
É, de fato, uma camada puramente linear.
A ativação softmax será
incluída com a perda.
E para resumir este código inteiro,
são apenas 15 linhas.
É bem, bem curto.
Estamos, essencialmente, tornando
essa complexa arquitetura
incluindo carregar pesos pré-treinados,
em apenas um bocado de linhas.
Estamos reduzindo a complexidade
e ao permitir que você possa contar
com diferentes configurações
para cada camada
estamos diminuindo a carga cognitiva.
Não é preciso se preocupar com parâmetros
da sua camada LSTM, por exemplo.

Indonesian: 
Anda bisa menambah nomor input
dan output berapapun.
Dan model yang harus menggunakan
optimizer iklan selama latihan
dan ini terakhir
Anda menyadari bahwa, ketika
menentukan lapisan klasfikasi kita
dengan 1000 unit, kita tidak
menentukan aktivasi apapun
Jadi ini sebenarnya lapisan linier murni.
Aktivasi Sotmax termasuk kekurangannya.
Ringkasnya tentang semua kode ini,
ini hanya tentang 15 baris.
Jadi ini sangat singkat
Jadi kita mengubah susunan rumit ini
termasuk muatan kepentingan pra-muatan
menjadi beberapa baris.
Sangat mengurangi kerumitan
dan dengan membuat Anda
bergantung pada pengaturan
berbeda setiap lapisannya,
kita mengurangi muatan kognitif.
Anda tak perlu merisaukan tentang
parameter lapisan LSTM Anda, misalnya.

Korean: 
몇 개의 인풋이든 아웃풋이든
더할 수 있습니다
이 모델이 훈련과
이 마지막 [청취불가] 동안
광고 최적화를 사용해야 한다고
말하면 되는 거죠
분류화 레이어를
천 개의 유닛으로 구체화할 때
어떠한 활성화도
구체화하지 않은 것을 아셨죠
따라서 이는 순전히 선형 레이어입니다
소프트맥스 활성화가 손해와 포함되겠죠
이 전체 코드를 요약하면
단지 15줄의 라인 정도이죠
아주 짧습니다
근본적으로 저희는 미리 훈련된
무게를 불러오는 것과 같은
이러한 아주 복잡한 건축을
몇 줄 안 되는 라인으로 바꾼 거죠
따라서 복잡성을 줄이고 모든 레이어마다
다른 컨피겨레이션에 의존하도록 함으로써
인지 부하량을 이미 줄인 거죠
예컨대 LSTM 레이어의 대부분의
파라미터에 대해
신경쓸 필요가 없는 겁니다

Spanish: 
Se puede agregar cualquier cantidad
de entradas y de salidas.
Y le estamos diciendo al modelo
que debe usar el AdamOptimizer
durante el entrenamiento
y este último
SoftMax_crossentropy_with_logits.
Pueden notar que cuando especificamos
nuestra capa de clasificación
con 1000 unidades,
no especificamos ninguna activación.
Es una capa puramente lineal.
Esta activación SoftMax
estará incluida en la pérdida.
Para resumir, este es
todo este código, son solo 15 líneas.
Es muy, muy corto.
En esencia, estamos convirtiendo
esta arquitectura sumamente compleja,
incluyendo la carga
de pesos pre-entrenados,
en unas pocas líneas.
Reduce mucho la complejidad
y les permite contar con diferentes
configuraciones para cada capa,
estamos reduciendo la carga cognitiva.
No deben preocuparse
por casi ningún parámetro
de su capa de red LSTM, por ejemplo.

Japanese: 
どんなインプットの数も、
アウトプットの数も加えることができます。
モデルに対して、トレーニング中に
および最後の（聞き取り不可能）では、
オプティマイザーを使用するように
指示しています。
1000 ユニットの分類レイヤーを
指示する際には、
いかなるアクティベーションも指示しません。
実際、それはライナーレイヤーだからです。
softmax アクティベーションには、
ロスが含まれることになります。
このコード全体を要約すると、
15 行ぐらいになります。
とても短いです。
基本的に、事前訓練された
ウェイトロードも含めて
この非常に複雑なアーキテクチャーを
わずかな数行に変換しているのです。
複雑さをまさに軽減し、
それぞれのレイヤーに対する異なる環境設定を
任せることができるのです。
すでに認識ロードを軽減しています。
言い換えれば、LSTM レイヤーの
パラメータの大半を気にしなくていいのです。

Korean: 
그리고 가장 좋은 부분은
이 케라스 설정이 처음부터
텐서플로우를 위해 만들어졌기 때문에
에스티메이터나 실험 등과 완전히
호환가능 하다는 점이죠
따라서 하나의 라인만으로
텐서플로우 실험의
예시를 들 수 있죠
이는 클라우드 ML 등을 위해
훈련하기 위해
분산훈련과 텐서플로우 서빙에도
접근할 수 있도록 해 줍니다
.
따라서 그저 몇 줄의 라인만으로
실험을 실행할 수 있죠
질의 응답 모델로 한 것처럼
사용자의 데이터와 질문 데이터
그리고 대답 데이터를
[청취불가] 데이터
프레임에서 읽는 거죠
[청취불가]에서도 그저
라인 몇 줄만으로
실행을 시작할 수 있죠
이 발표에서 기억하셔야
할 점은 아주 간단합니다
캐라서 API를 가지고
텐서플로우로 가져오는 겁니다
텐서플로우를 위해서
처음부터 만들어진 케라스의
새로운 실행인거죠
그리고 이는 케라스 사용자로써
더 많은 융통성을 줍니다

English: 
And the best part of
it, the most magic part,
is that, because this
implementation of Keras
is built from the ground
up for TensorFlow,
it's fully compatible with
things like estimators
and experiments.
So in just one line, you
can instantiate a TensorFlow
experiment.
And this gives you access
to distributed training
to train on Cloud ML and so on,
and also access to TensorFlow
serving.
So in just a few lines, you can
start running your experiment
as you did with your
question answering model,
reading your viewer data and
question data and answer data
from [INAUDIBLE] data frame.
You can start running
it on [INAUDIBLE]
in just a few lines.
So what you should take away
from this talk is very simple.
We are taking the Keras API.
We are bringing it
into TensorFlow.
It's a new implementation of
Keras built from the ground up
for TensorFlow.
And this gives you, as a
Keras user, more flexibility.

Portuguese: 
E a melhor parte disso, a mágica disso,
é que como da implementação do Keras
é feita do zero para o TensorFlow,
ela é totalmente compatível
com coisas como estimações e experimentos.
Em apenas uma linha, é possível
instanciar um experimento no TensorFlow.
O que dá acesso a treinamento distribuído
no Cloud ML, entre outros
e também acesso ao TensorFlow Serving.
Em apenas algumas linhas,
é possível começar seu experimento
como foi feito com o modelo de
busca de resposta, lendo os dados de vídeo
dados de pergunta e de resposta
do [inaudível] dados de frame.
É possível começar a rodar no [inaudível]
em apenas algumas linhas.
O que você deve tirar desta
palestra é bem simples.
Estamos falando da API Keras.
Estamos a levando para o TensorFlow.
É uma nova implementação feita
do zero para o TensorFlow.
E isso te dá, como um usuário Keras,
mais flexibilidade.

Chinese: 
而它最棒的部分是，
由于此 Keras 的实施
是建立在 TensorFlow 基础上
它和估计量以及实验
完全相容
只要一行，
你就可实例化 TensorFlow
试验
这让你可以分布训练
可以在云ML上训练等等
也可以访问 TensorFlow
服务端
所以，只用几行你就可以开始你的实验
就像你所做的问题回答模型
查阅用户数据和问题数据
以及回答数据，从（听不清）数据框架
你还可以开始用几行
在（听不清）上开始运行
从本演讲中学到的很简单
我们所说的是 Keras API
我们将它带入 TensorFlow
它是一个新的 Keras 实施
建立于 TensorFlow
你作为一个 Keras 用户，会获得更大灵活性

Japanese: 
その魅力、最も魅力的な部分は
Keras のこの実装は TensorFlow 用に
ゼロから構築されています。
エスティメーターや実験などに対して
非常に互換性が高いです。
たった１行で、TensorFlow の実験を
例示することができるのです。
Cloud ML やその他でトレーニングするための
分布トレーニングへのアクセス、
また TensorFlow Serving への
アクセスが可能になります。
（聞き取り不可能）のデータフレームから
ビューアーデータ、質問データ、
回答データを読み取りながら
質問回答モデルで行なったように
たった数行で、実験を始めることができます。
たった数行で（聞き取り不可能）上で
作動させることができます。
このスピーチから何を得ることができるのか、
答えは簡単です。
Keras API を選択します。
それを TensorFlow に導入します。
これは TensorFlow 用にゼロから構築した
Keras の新しい実装です。
Keras ユーザーに
さらなるフレキシビリティを約束し、

Spanish: 
Y la mejor parte, la más mágica,
es que como la implementación de Keras
se construyó desde cero para TensorFlow,
es totalmente compatible
con cosas como estimadores y experimentos.
Así que en una sola línea, se puede
ejemplificar un experimento de TensorFlow.
Y esto les da acceso
a entrenamiento distribuido
para entrenar en Cloud ML y así,
y también acceso a servidores TensorFlow.
En solo unas líneas, se puede empezar
a ejecutar un experimento
como hicieron con el modelo
de respuesta a preguntas,
viendo la información del visor,
de la pregunta y la respuesta
en el panda_dataframe.
Puedes empezar a ejecutarlo en Keras RGB
en solo unas líneas.
Lo que deben conservar
de esta charla es muy simple.
Vamos a tomar la API de Keras.
La vamos a traer a TensorFlow.
Es una nueva implementación de Keras
construida de cero para TensorFlow.
Y como usuarios de Keras,
esto les da más flexibilidad.

Indonesian: 
Dan bagian terbaiknya,
bagian paling ajaib,
adalah karena implementasi Keras ini
dibangun dari bawah untuk TensorFlow,
ini sangat cocok diaplikasikan
dengan hal-hal seperti
penilaian & eksperimen
Jadi hanya dengan satu baris,
Anda bisa memulai sebuah
percobaan TensorFlow.
Dan memberikan Anda akses
mendistribusikan latihan
untuk melatih CloudML dan lainnya,
dan juga mengakses layanan
TensorFlow
Jadi hanya dengan beberapa baris,
Anda mulai menjalankan eksperimen Anda
seperti yg Anda lakukan
pada model tanya jawab
membaca data review dan
pertanyaan dan jawaban
dari bingkai data.
Anda bisa mulai menjalankannya
hanya dalam baris.
Jadi apa yang harus Anda
hindari sangat sederhana.
Kita menggunakan API Keras.
Kita membawanya kedalam TensorFlow
Ini adalah implementasi baru
Keras dibangun dari bawah
hingga ke TensorFlow.
Dan ini memberikan Anda,
pengguna Keras, lebih fleksibel.

Chinese: 
你可以混合并匹配
纯粹的 TensorFlow 功能和 Karas 模型
作为 TensorFlow 用户
你可以获取完全的 Keras API
工作将变得更容易
所以你可预计这些 Keras 兼容模型
是作为 tf.contrib.keras by TF 1.1 存在
最后将会是 TensorFlow 1.2 的 tf.keras
所以，我们相信这是朝 TensorFlow 和深度学习
被每个人掌握
迈出了一大步
这就是我今天所要讲的内容
下面我们会有一些零食给大家
感谢收听本演讲！
（音乐）

English: 
You can start
mixing and matching
pure TensorFlow functionality
with your Keras model.
As a TensorFlow user, this gives
you access to the full Keras
API to make your life easier.
And so you can expect these
Keras compatibility modules
to exist as
tf.contrib.keras by TF 1.1.
And finally, tf.keras
in TensorFlow 1.2.
And so we believe
this is a big step
towards making TensorFlow
and deep learning
accessible to everyone.
So that's it for me.
I believe, next, we
have some snacks.
Thank you for listening.
[MUSIC PLAYING]

Portuguese: 
É possível misturar e combinar
funcionalidades do TensorFlow
no seu modelo Keras.
Como um usuário TensorFlow, terá total
acesso à API Keras para facilitar a vida.
E você pode esperar que esses módulos
de compatibilidade Keras existam
como tf.contrib.keras no TF 1.1.
E, por fim, tf.keras no TensorFlow 1.2.
Acreditamos que é um grande passo
para tornar o TensorFlow
e a aprendizagem profunda
acessível para todos.
É isso.
Acredito que agora temos um lanche.
Obrigado por ouvirem.

Spanish: 
Pueden empezar a combinar
las funcionalidades puras de TensorFlow
con su modelo de Keras.
Como usuarios de TensorFlow,
esto les da acceso a toda la API de Keras
para hacer sus vida más fáciles.
Así que pueden esperar que estos módulos
de compatibilidad de Keras
aparezcan como tf.contrib.keras en TF 1.1.
Y finalmente, tf.keras en TensorFlow 1.2.
Creemos que este es un gran paso
para que TensorFlow
y el aprendizaje profundo
sean accesibles para todos.
Así que eso fue todo.
Creo que ahora sigue un refrigerio.
Gracias por su atención.

Indonesian: 
Anda dapat mencampur
dan mencocokkan fungsi
TensorFlow dengan model Keras Anda.
Sebagai pengguna TensorFlow,
ini memberikan Anda akses
API Keras untuk memudahkan hidup Anda.
Dan Anda dapat mengharapkan
modul kompatabilitas Keras
ada dalam tf.contrib.keras
dengan TF 1.1.
Dan akhirnya, tf.keras di TensorFlow 1.2.
Dan kita percaya langkah besar ini
membuat TensorFlow dan deep-learning
bisa diakses semua orang.
Jadi, sekian dari saya.
Saya percaya, nanti
kita punya makanan ringan.
Terima kasih.

Japanese: 
TensorFlow の機能と Keras モデルを
ミックスし、調整することができます。
TensorFlow ユーザーにとっては、
Keras API へのフルアクセスが約束され、
日常生活を容易にします。
これらの Keras 互換モジュールは、
TF 1.1. によって
tf.contrib.keras として存続し、
また tf.keras は TensorFlow 1.2. 
によって存続します。
TensorFlow と ディープラーニングが
多くの人の手に渡るようになる、
大きな一歩だと思っています。
それではスピーチを終わります。
たぶん小休憩が必要ですね。
清聴ありがとうございました。

Korean: 
순수 텐서플로우 기능성과 케라스 모델을
섞어서 사용하기 시작할 수 있는 거죠
텐서플로우 사용자로써 이는
전체 케라스로 접근할 수 있게 해 주니
삶이 편해지죠
따라서 이러한 케라스 호환성 모듈은
텐서플로우 1.1에 의해
tf.contrib.keras로 존재한다고
기대하시면 됩니다
마지막으로 텐서플로우 1.2에서 tf.keras가 있죠
따라서 저희는 텐서플로우와 딥 러닝이
모든 분들에게 접근가능하도록 하는
큰 한 걸음이라고 믿습니다
이상입니다
제 생각에 다음에는 간식이 있을 겁니다
들어주셔서 감사합니다
[음악재생]
