
Korean: 
안녕하세요, 전 아쉬스입니다
전 ML 툴킷에 대해 이야기할 겁니다
먼저 텐서플로우가 정말 훌륭한 기술임을
언급하고 싶습니다
Google에서는 이미 강력한 시스템이죠
검색 순위, 광고 경매와
YouTube 추천
번역, 사진 등등에 이르기까지 말입니다
휴대폰에서 TPU 클러스터에
이르는 플랫폼에서
수십억 개의 파라미터를 가진
복잡한 모델을
훈련시킬 수 있고
문제를 해결할 수도 있습니다
하지만 텐서플로우는
저수준의 프레임워크입니다
이전 발표에서 마크가 언급했듯이
레이어, 에스티메이터
로스 등과 같은 고등 파라미터
그리고 연구자와 개발자들이
커스텀 모델 건축을
만들기 쉽도록 하는 매트릭스에 대한
작업을 하고 있습니다
하지만 텐서플로우에서 여전히 빠진 점은
바로 사용 가능한 알고리듬입니다
많은 개발자가 바라는 것은
그들의 작업 흐름으로
빠르고 쉽게 통합할 수 있는
패키지화 된 해결책이죠
따라서 저희가 텐서플로우에
바탕을 두고 만든

Spanish: 
Hola soy Ashish
y voy a hablarles acerca de ML Toolkit.
Permítanme empezar diciendo que TensorFlow
es realmente una tecnología sorprendente.
En Google, ya está ayudando a los sistemas
a categorizar búsquedas,
la subasta de anuncios
recomendaciones YouTube, traducción,
fotos y mucho, mucho más.
Podemos entrenar modelos complicados
con cientos de millones de parámetros
y resolverlos en plataformas
que van desde los teléfonos móviles
hasta los agrupamientos de TPUs.
TensorFlow es un estructura
de muy bajo nivel.
Como dijo Martin anteriormente,
estamos trabajando en parámetros
de alto nivel como capas,
estimadores, pérdidas y métricas
para facilitar
a los investigadores y desarrolladores
la creación de modelos 
arquitectónicos personalizados.
Pero lo que aún le falta a TensorFlow
son algoritmos que funcionen solos
sin configuración.
Lo que quieren muchos desarrolladores
es tener soluciones listas
que se integren rápida y fácilmente
a sus procesos de trabajo.
Así que me alegra decirles
que ahora tenemos un toolkit

Indonesian: 
Hai, saya Ashish.
Saya akan bicara
tentang ML Toolkit.
Saya awali dengan berkata,
TensorFlow benar-benar
sebuah teknologi
yang menakjubkan.
Di Google, ini sudah
dukung sistem
pemeringkatan pencarian,
lelang iklan, rekomendasi
YouTube, Translate,
Photos, dan banyak lagi.
Kami bisa melatih
model rumit dengan ratusan
miliar parameter
dan memecahkannya
di platform, dari ponsel
hingga gugus TPU.
Bagaimanapun, TensorFlow benar-
benar kerangka tingkat rendah.
Seperti disebut Martin
sebelumnya,
kami kerjakan parameter
tingkat tinggi seperti layer,
estimator, loss,
dan metrik untuk
mudahkan peneliti
dan pengembang
menciptakan model
arsitektur terkustomisasi.
Namun, yang masih
kurang dari TensorFlow
adalah algoritma yang
bekerja secara berbeda.
Yang pengembang
sangat inginkan
yaitu solusi jadi
yang bisa mereka padukan
dengan cepat dan mudah
dalam alur kerja mereka.
Jadi, saya senang memberitahu
kalian, kini kami

Chinese: 
[音乐]
阿诗诗·阿加瓦尔：大家好，我是阿诗诗
我会讲一下ML工具包
作为开始
我要说"TensorFlow"
真的是一个很棒的技术
在谷歌
它已经在为很多系统提供能源
从搜索排名，广告拍卖，YouTube的推荐
到翻译，照片，以及更多
我们可以用数百亿的参数
训练复杂的模型
然后用从手机到
热接收器装置集群上的平台解决
然而，TensorFlow只是很底层的框架
正如马丁在早期的谈话中提到的
我们正在研究高水平的参数
像层次，估计，损失和指标等
使研究人员和开发人员
更容易创建自定义模型架构
然而，TensorFlow 还缺少
开箱可用的算法
许多开发者真正想要的
是可以快速
轻松地融入他们的工作流程的
打包的解决方案
所以我很高兴地告诉你

Japanese: 
こんにちは アシシュです
ML Toolkitについてお話しします
まず TensorFlowは
本当にすばらしい
技術だと言わせてください
Googleでは 既に
検索ランキング ads auction
YouTubeのおすすめ
翻訳やフォト等のシステムに至るまでを
これを利用しています
何千億ものパラメーターの
複雑なモデルを訓練して
携帯電話から 
TPUのクラスタに至るまで
プラットフォームで活用されています
しかし TensorFlowは 非常に
低レベルのフレームワークです
先程マーチンが述べたように
layer、estimator、losses
metricなどの
ハイレベルのパラメーターを開発し
研究者やデベロッパーが
カスタムモデルアーキテクチャを
作成する手助けになるよう作業しています
しかし TensorFlowに
いまだに欠けているのは
画期的なアルゴリズムです
デベロッパーが本当に必要としているのは
彼らのワークフローに
簡単に統合できる
パッケージソリューションです
ですから 今回

English: 
[MUSIC PLAYING]
ASHISH AGARWAL: Hi, I'm Ashish.
I'll be talking
about ML Toolkit.
So let me start by saying
that TensorFlow is this really
amazing piece of technology.
At Google, it's already
powering systems
ranging from search ranking,
ads auction, YouTube
recommendations, Translate,
Photos, and many, many more.
We can train complicated
models with hundreds
of billions of
parameters and solve them
on platforms ranging from mobile
phones to cluster of TPUs.
However, TensorFlow is this
really low-level framework.
As Martin mentioned
in an earlier talk,
we are working on high-level
parameters like layers,
estimators, losses,
and metrics to make
it easier for researchers
and developers
to create custom
model architectures.
However, what's still
missing from TensorFlow
is algorithms that
work out of the box.
What a lot of
developers really want
is packaged solutions that
they can quickly and easily
integrate into their workflows.
So I'm happy to
tell you that now we

Portuguese: 
Oi, eu me chamo Ashish.
Vamos tratar do ML Toolkit.
Queria começar dizendo
que o TensorFlow é realmente
uma tecnologia impressionante.
Na Google, ela já supre sistemas
que vão do ranqueamento de buscas,
leilão de anúncios,
recomendações do YouTube,
Tradutor, Fotos e muito mais.
Podemos treinar modelos complexos
com centenas de bilhões de parâmetros
e resolvê-los em plataformas
que vão de celulares a grupos de TPUs.
Porém, o TensorFlow é
uma estrutura de baixo nível.
Como Martin indicou, estamos
trabalhando em parâmetros de alto nível,
como camadas, estimadores,
perdas e métrica,
para facilitar aos pesquisadores
e desenvolvedores
a criação de arquiteturas modelares
sob medida.
Mas o que ainda falta ao TensorFlow
são algoritmos capazes
de operar imediatamente.
O que muitos desenvolvedores buscam
são soluções prontas,
que possam ser rápida e facilmente
integradas em seus fluxos de trabalho.
Pois é meu prazer anunciar
que agora temos um toolkit

Japanese: 
機械学習アルゴリズムの
ツールキットを
TensorFlow上に構築できたことを
報告します
線形そして
ロジスティック回帰、 k平均
データの教師なし学習クラスタ用
Gaussian混合モデル
WALS行列因数分解といった
コンピューターシステム用として
人気のある協調アルゴリズムから始め
ベクターマシンをサポートし
SDCA（Dual Coordinate Ascent ）などの
最新鋭のアルゴリズムまでも
これはコンテクストの最適化
ランダムフォレストや決定木
ネットワークの
様々なアーキテクチャ用です
これらはどれも
GitHubで入手できます
そして 私たちは常にサイトの改善と
更新をしていきます
次に アルゴリズムを
いくつかハイライトしていきます
そうすることで
これらのアルゴリズムの
既存および今後の機能を
理解します
k平均から始めましょう
ここに標準レイアウトの
インタラクティブアルゴリズムを搭載しました
ランダムおよび
k-means++ initialization
フルバッチとミニバッチの双方を
サポートしています

English: 
have a toolkit of really popular
machine-learning algorithms
that we have built right
on top of TensorFlow.
So starting with linear and
logistic regression, k-means
and Gaussian mixture models
for unsupervised clustering
of data, WALS matrix
factorization,
which is a popular collaborative
[INAUDIBLE] algorithm
for the computer systems,
support vector machines, all
the way to state of
the art algorithms
like SDCA, Stochastic
Dual Coordinate Ascent,
for context optimization, random
forest and decision trees,
and various architectures
of deep networks.
Now, all these are
available on GitHub,
and we are constantly working
on improving and expanding
the site.
Next I'll highlight a
few of these algorithms
to give you a better sense
of the existing and upcoming
features for these algorithms.
Starting with k-means.
So here we implemented the
standard layouts iterative
algorithm, along with random
and k-means++ initialization.
We support both full batch
and mini batch training modes,

Spanish: 
con algoritmos de aprendizaje automático
muy populares
que hemos construido en TensorFlow.
Empezando con modelos de regresión
lineal y logísticos, KMeans
y modelos Gaussianos mixtos para
agrupamiento no supervisado de datos,
matriz de factorización WALS,
que es un algoritmo colaborativo popular
para sistemas computacionales,
máquinas de vectores soporte,
los algoritmos más avanzados
como SDCA,
Stochastic Dual Coordinate Ascent,
para optimización de contexto,
bosque aleatorio y árboles de decision
y varias arquitecturas de redes profundas.
Todo esto está disponible en GitHub
y trabajamos constantemente
en la mejora y expansión del sitio.
Voy a enforcarme en algunos algoritmos
para darles una mejor idea
de lo existente y lo que viene
en cuanto a los rasgos
de estos algoritmos.
Empecemos por KMeans.
Aquí implementamos los diseños
estándar del algoritmo iterativo
junto con la inicialización aleatoria
y de KMeans++.
Soportamos los modos de entrenamiento
tanto de lotes completos como de mini

Indonesian: 
punya perangkat algoritma
pembelajaran-mesin populer
yang kami bangun
di atas TensorFlow.
Jadi, mulai dengan regresi linear
dan logistik, k-means,
dan model campuran Gaussian
untuk penggugusan data
unsupervised, faktorisasi matriks WALS,
yang adalah algoritma
kolaboratif populer
untuk sistem komputer,
dukungan mesin vektor,
hingga pernyataan
algoritma seni,
seperti SDCA, Stochastic
Dual Coordinate Ascent,
untuk optimisasi konteks, random
forest dan pohon keputusan,
dan aneka arsitektur
deep network.
Kini semua ini
tersedia di GitHub
dan kami terus bekerja
perbaiki dan kembangkan
situsnya.
Lalu saya soroti
beberapa algoritma ini
untuk beri kalian gambaran
tentang fitur-fitur
terkini dan mendatang
dari algoritma ini.
Mulai dari k-means.
Di sini kami terapkan
algoritma berulang layout
standar dengan inisialisasi
acak dan k-means++.
Kami mendukung mode latihan
batch penuh dan batch kecil,

Korean: 
굉장히 인기있는
머신 러닝 알고리듬의 툴킷을
만들었다는 사실을
알리게 되어 정말 기쁩니다
선형 및 로지스틱 회귀분석에서
시작해서 k-means
데이터의 자율적 클러스터링을 위한
가우시안 혼합 모델
WALS 행렬 인수분해도 포함하죠
이는 인기 있는 통합적
[청취불가] 알고리듬으로
컴퓨터 시스템을 위한 것이고
벡터 머신을 지원하며
최첨단 알고리듬까지 포함하죠
예컨대 SDCA, 즉 스토캐스틱
듀얼 코디네이트 어센트가 있죠
이는 맥락 최적화
랜덤 포레스트와 결정 나무
그리고 다양한
딥 신경망 건축을 위한 것이죠
이제 이 모든 것이 깃허브에 있고
사이트를 계속해서
향상시키고 확장해 나가기 위해
노력 중입니다
다음으로 이 알고리듬의
현존하는 또 앞으로
나올 특징이 무엇인지
알려드리기 위해 이 알고리듬을
설명해 보겠습니다
k-means로 시작하죠
여기 표준 레이아웃
반복 알고리듬과 더불어
랜덤 그리고 k-means++
초기설정을 실행했습니다
풀 배치와 미니 배치
훈련 모드를 모두 지원하고

Chinese: 
我们现在有一个工具包
里面有很流行的机器学习算法
我们把它建立在了TensorFlow的顶部
所以，从处理无监督聚类的数据的
线性和逻辑回归
k-均值和高斯混合模型
备受欢迎的计算机系统协同算法
沃尔什矩阵分解
支持向量机
一直到用于环境优化的艺术算法
如SDCA，即随机双坐标上升
随机森林和决策树
和深层网络的其他各种结构
现在
这些都可以在GitHub上找到
我们正在不断努力
改善和扩大网站
接下来，让您更好地了解这些算法
它们现有和即将到来的功能
我将重点介绍这些算法中的一部分
首先是k-均值
在这里
我们应用了标准的布局迭代算法
以及随机和k-均值++初始化。
我们支持全批和小批量的培训训练模式

Portuguese: 
de algoritmos populares
de aprendizado de máquina
que construímos com base no TensorFlow.
Começando com a regressão
linear e logística, k-means
e modelos de mistura gaussiana
para agrupamento
não supervisionado de dados,
fatoração matricial WALS,
que é um popular algoritmo
colaborativo de filtragem
para sistemas de computação,
máquinas de vetores de suporte,
até algoritmos de ponta,
como SDCA, a Ascensão
Coordenada Dual Estocástica,
para otimização contextual,
árvores decisórias e florestas aleatórias
e diversas arquiteturas
de redes profundas.
Tudo isso está disponível no GitHub
e estamos trabalhando constantemente
para melhorar e expandir o site.
Quero destacar alguns desses algoritmos,
para lhes dar uma melhor noção
das características atuais
e futuras desses algoritmos.
Começando pelo k-means.
Aqui implementamos o algoritmo iterativo
de layouts padrão,
em conjunto com a inicialização
randômica e k-means++.
Nós damos suporte
aos modos de treinamento
de lote completo e minilotes

Japanese: 
またユーザーが
距離関数特定できるようにしています
コサインあるいはユークリッド
平方距離などですね
一方 GMMでは
Gaussianの混合として
データをモデル化します
よりパワフルなモデルですが
訓練するのも
ずっと難しくなります
インタラクティブ EMアルゴリズムを使い
これで ユーザーは
平均、共分散、混合
組み合わせから訓練を選択できます
次に WALSがあります
これは加重交互最小二乗法を
使用した行列因子分解です
これも後で説明します
ここに非常にまばらな行列があります
例えば ユーザーが
ビデオに与えた評価が
与えられたとします
行列は希薄で
すべてのビデオが各ユーザーによって
評価されたわけではありません
さて ここで皆さんは
次にユーザーにビデオを勧めるときに
ユーザーの類似度やビデオの類似度を
知りたいでしょう
たいていはこの巨大行列を
２つの密要素の積に
因数分解します

Chinese: 
也允许用户指定距离函数
如余弦或欧几里德平方距离
然后是GMMs
以高斯分布的混合形式
为数据建立模型
这些都是更强大的模型
也更难培养
对于这些
我们使用了迭代EM算法
我们允许用户从一系列的训练方法中选择
包括协方差，混合重量等
接下来，我们有WALS
采用加权交替矩阵分解的最小二乘法
我稍后会再次讨论这个话题
所以在这里，你得到一个非常稀疏的矩阵
比如，您可以得到
用户对视频的评分
注意矩阵是稀疏的
所以不是所有的视频
都会得到所有用户的评分
现在你想要解决诸如
你应该向用户推荐哪个视频
或者找到用户相似或视频相似性的问题
现在，这通常是通过把这个巨大的矩阵
分解为由两个密集的因素组成的产品

Portuguese: 
e também permitimos ao usuário
especificar funções de distância,
tais como as distâncias quadradas
euclidianas e do cosseno.
As GMMs, por outro lado,
modelam os dados
como uma mistura de gaussianas.
Estes são modelos muito mais robustos
e também mais difíceis de treinar.
Para eles, usamos
um algoritmo iterativo EM
e deixamos o usuário escolher
a partir de uma combinação de médias,
covariâncias e pesos das misturas
para serem testados.
Em seguida, temos a WALS,
que é a fatoração matricial
por meio dos Mínimos Quadrados
Ponderados Alternados.
Também voltarei a isso
mais adiante em minha palestra.
Aqui, você se vê diante
de uma matriz muito esparsa.
Por exemplo, poderiam ser avaliações
que usuários deram a determinados vídeos.
Note-se que a matriz é esparsa,
então nem todos os vídeos
são avaliados por cada usuário.
E você quer responder questões como
qual vídeo recomendar ao próximo usuário
ou como encontrar similaridade
entre usuários ou entre vídeos.
Isso normalmente é feito
fatorando essa imensa matriz
em um produto de dois fatores,
dois fatores densos.

Spanish: 
y también que el usuario
especifique funciones de distancia
como el coseno o
distancias cuadráticas Euclidianas.
Por su parte, los GMM
modelan los datos 
como una mezcla de Gaussianos.
Estos modelos son mucho más poderosos
y más complicados de entrenar.
Para estos, 
usamos un algoritmo iterativo EM
que permiten al usuario escoger
una combinación de medias,
covarianzas y ponderaciones para entrenar.
Luego, tenemos WALS, 
que es una factorización de matriz
que usa "Mínimos Cuadrados
Ponderados Alternados."
Voy a volver a este tema
luego durante esta charla.
Aquí, se da una matriz muy dispersa.
Por ejemplo, se dan ciertas calificaciones
que los usuarios han dado a los videos.
La matriz es dispersa,
por lo tanto no todos los videos
han sido calificados por los usuario.
Y ahora queremos contestar preguntas
tales como "¿Qué video se debe recomendar
ahora al usuario?",
o encontrar similitudes entre usuarios
o entre videos.
Por lo general, esto se hace
factorizando una matriz gigante
a un producto de dos factores.

Indonesian: 
kami juga izinkan pengguna
tentukan fungsi jarak
seperti jarak kosinus dan
Euclidean kuadrat.
Lalu GMM, di sisi lain,
memodelkan data
sebagai percampuran
dari Gaussian.
Model ini jauh lebih kuat
dan lebih sulit
dilatih.
Untuk ini, kami gunakan
suatu algoritma EM berulang
dan kami izinkan pengguna
pilih kombinasi rerata,
kovarian, campuran
bobot untuk dilatih.
Lalu kami punya WALS,
yakni faktorisasi matriks dengan
kuadrat terkecil
alternatif tertimbang.
Saya akan kembali ke sini
dalam presentasi saya.
Di sini kau diberi
matriks yang sangat tersebar.
Contohnya, kau bisa
mendapat peringkat
yang diberikan
pengguna pada video.
Perhatikan matriks ini
tersebar, jadi tak semua video
diperingkat
oleh tiap pengguna.
Kini kau mau
jawab pertanyaan,
seperti video mana yang harus kauanjurkan
pada pengguna berikutnya
atau temukan kemiripan
antarpengguna atau antarvideo.
Ini dilakukan khusus dengan
faktorisasi matriks besar ini
menjadi produk dari 2 faktor,
2 faktor padat.

Korean: 
사용자가 코사인이나
유클리드 제곱 거리와 같은
거리 기능도 구체화할 수
있도록 했습니다
반면에 GMM은
가우시안 혼합으로 데이터를
모델화하죠
강력한 모델들이 정말 많고 훈련시키기도
힘듭니다
이 경우 반복 EM 알고리듬을 사용하죠
또한 사용자가 훈련시킬 수
있는 평균, 공변량
믹스쳐 웨이트의 조합 중
선택할 수 있도록 했습니다
다음으로 WALS는 행렬 인수분해로
가중 대안 최소 자승을 사용하죠
나중에 다시 언급하겠습니다
여기 아주 듬성듬성한 행렬이 있죠
예컨대 사용자가 비디오에 대해 제공한
점수라고 볼 수 있겠죠
행렬이 듬성듬성하다는 것은 각 사용자가
모든 비디오를 평가하는 건
아니라는 의미겠죠
이제 이러한 질문에 대답하면 됩니다
사용자에게 다음에는
어떤 비디오를 추천해야 할까
사용자-사용자 유사성이나
비디오-비디오 유사성을 찾는 법 등이죠
이것은 보통 이 큰 행렬을
두 가지의 밀집한 팩터의 산물로
인수분해함으로써 만들어집니다

English: 
and we also allow the user
to specify distance functions
like cosine or Euclidean
square distances.
Now GMMs, on the other
hand, model the data
as a mixture of Gaussians.
These are much more powerful
models, and also harder to
train.
For these, we use an
iterative EM algorithm,
and we allow the user to choose
from a combination of means,
covariances, mixture
weights to train on.
Next, we have WALS, which is
matrix factorization using
Weighted Alternating
Least Squares.
I will be revisiting this
later in my talk, as well.
So here, you are given
a very sparse matrix.
For example, you
could be given ratings
that users have
provided on videos.
Note that the matrix is
sparse, so not all the videos
are being rated by each user.
And now you want
to answer questions
like, which video should you
recommend next to the user,
or to find user-user similarity
or video-video similarity.
Now, this is typically done by
factorizing this huge matrix
into a product of two
factors, two dense factors.

Japanese: 
また アルゴリズムが示すように
このロスは加重し
ダウングレードすることができます
例えば元の入手に評価がない場合
またスパムを回避したり
全体のロスで人気のあるエントリが
埋もれるのを防ぎます
この値は非常に非コンベックスです
しかし いくつかの要素を固定すると
他の要素に密接な分析が得られます
反復的に訓練するときに
まず Vを固定して
Uを計算し
Uを固定し
Vを計算するといった具合です
次に SVMがあります
決定境界を見つけて
マージンを最大化します
ヒンジロスを使って
ソフトマージンのメソッドを開発していて
現在の実装はリニアSVMで
L1 と L2 の正則化です
SVMは非リニアカーネルだと
より強力になり
より複雑な決定境界が可能です
私たちはカーネル近似トリックで
非リニアカーネルを提供します
次に SDCAがあります

Korean: 
이 알고리듬이 나타내듯이
이 손해는 가중되었고 원래 인풋에서
평가되지 않은 것은
다운그레이드 하라고 할 수 있고
혹은 스팸을 피하거나
전체 손실에서
인기있는 입력을 빼라고 할 수 있죠
따라서 이 값은 굉장히 볼록하지 않죠
하지만 일부 팩터를 고치면 다른 팩터를 위한
분석적 해결책이 있다는 것이 밝혀졌죠
훈련은 반복적 방식으로 진행됩니다
먼저 V를 고정시키고 U를 계산해서
U를 고정하고 V를 계산하는 식이죠
다음으로 SVM이 있죠
이는 마진을 최대화하는 결정 경계를
찾는 겁니다
저희는 힌지 로스를 이용한
소프트 마진 방법을 이용하고
현재 실행은 L1과 L2
규제화를 사용한
선형 SVM입니다
SVM은 비선형 커널을 이용해서
더욱 강력해졌고
훨씬 더 복잡한 결정 경계를
할 수 있게 됐죠
따라서 저희는 커널 근사치 트릭을
사용해서 선형 커널을
제공하도록 노력하고 있습니다
다음은 SDCA이죠

English: 
Note also that, as the
algorithm indicates,
this loss is weighted, which
allows you to, say, downgrade
things that were unrated in
the original input, or to avoid
spam, or popular entries from
drowning out the total loss.
So this value is
highly nonconvex.
However, it turns out, that if
you fix some of the factors,
there's a close analytical
solution for the other factor.
And so the training
works in an iterative way
where you, first,
fix V, compute U,
then fix U, compute
V, and go on.
Next, we have SVMs.
So these work by finding
a decision boundary that
maximizes the margin.
We are working with soft margin
methods using a hinge loss,
and the current implementation
is of linear SVMs
with L1 and L2 regularization.
Note that SVMs become much
more powerful with a nonlinear
kernel, which allows a much more
complicated decision boundary.
So we are working on providing
nonlinear kernels using
the kernel approximation trick.
Next, we have SDCA.

Indonesian: 
Perhatikan juga, seperti
algoritma tunjukkan,
loss ini tertimbang sehingga
kau bisa, misalnya, turunkan
video yang tidak diperingkat
dalam input asli atau cegah
agar spam atau entri populer
tak tenggelamkan loss total.
Jadi, nilai ini
sangat nonkonveks.
Namun ternyata bila kau
perbaiki beberapa faktor,
terdapat solusi analitis
yang mungkin untuk faktor lainnya.
Jadi, latihan ini
bekerja berulang,
yakni kau pertama-tama
perbaiki V, hitung U,
lalu perbaiki U,
hitung V, lalu meneruskan.
Berikutnya,
kita punya SVM.
Cara kerjanya, temukan
batas keputusan yang
maksimalkan margin.
Kita sedang gunakan metode
soft margin dengan hinge loss
dan penerapannya saat ini
adalah SVM linear
dengan regularisasi L-1 dan L-2.
Perhatikan bahwa SVM jadi
lebih kuat dengan kernel
nonlinear yang mungkinkan
batas keputusan yang jauh lebih rumit.
Jadi, kita coba buatkan
kernel nonlinear dengan
trik perkiraan kernel.
Berikutnya, kita
punya SDCA.

Spanish: 
Noten también que, 
tal y como lo indica el algoritmo,
esta pérdida está ponderada
lo que permite, digamos,
degradar cosas que estaban sin calificar
en la entrada original, o evitar
correo no deseado o que las entradas
populares se pierdan totalmente.
Este valor es altamente no-convexo.
Pero resulta que si arreglas 
algunos de los factores
hay una solución analítica
cercana para el otro factor.
Entonces el entrenamiento
es un proceso iterativo
donde primero arreglas "V",
calculas "U"
luego arreglas "U", calculas "V"
y así sucesivamente.
Luego, tenemos los SVM.
Su trabajo es encontrar
un límite de decisión
que maximice el margen.
Estamos trabajando con métodos
de margen suave usando función de pérdida
y la implementación actual 
es para SVMs lineales
con regularización L1 y L2.
Hay que notar que los SVM son
mucho más poderosos
con núcleo no lineal, lo que permite
límites de decisión mucho más complicados.
Estamos trabajando para proporcionar
núcleos no lineales
usando una aproximación de núcleo.
Luego tenemos SDCA.

Chinese: 
还要注意的是
算法表明
损失是有权重的
这可以允许你
对未经评级的原始输入进行降级
或者避免垃圾邮件或热门输入等
淹没掉总体损失
因此此值是高度非凸的
然而，事实证明
如果你解决了一些因素
会产生一个对其他因素的
类似的理论解决方案
因此，训练工作以一个迭代的方式运行
首先，你要修复V，计算U
然后修复U，计算V，并继续
接下来是支持向量机
工作原理是要找到一个最大限度地提高幅度的
决策边界
我们正在使用的是运用的是
使用铰链损失的软损失方法
目前通过线性支持向量机
及L1和L2正规化实现
注意，支持向量机变得更强大的非线性内核
允许一个更复杂的决策边界
因此，我们正在致力于通过内核逼近技巧
提供非线性内核
接下来，我们讲一下SDCA

Portuguese: 
Note-se também que,
como indica o algoritmo,
essa perda é ponderada,
o que lhe permite reduzir
coisas que não foram avaliadas
na entrada original
ou evitar spam ou então que registros
populares inundem a perda total.
Esse problema é altamente não convexo.
Acontece, porém, que,
ao corrigir algum dos fatores,
surge uma solução analítica
próxima para o outro fator.
E assim o treinamento opera
de um modo iterativo,
em que você primeiro corrige V, computa U,
então corrige U, computa V,
e assim por diante.
Em seguida, temos as SVMs.
Elas operam encontrando
um limiar decisório
que maximiza a margem.
Operamos com métodos
de margens leves que usam hinge loss
e a implementação vigente
é de SVMs lineares
com regularização L1 e L2.
Note-se que as SVMs
se tornam muito mais robustas
com um núcleo não linear, que permite
um limiar decisório muito mais complexo.
Operamos, pois, para oferecer
núcleos não lineares,
utilizando o truque
de aproximação ao núcleo.
A seguir, temos a SDCA.

Japanese: 
ここには L1 と L2正則化した
コンベックス損失関数があります
そしてSDCAは最後の関数をデュアルフォームに
変更するというトリックを使用します
実際 多くの問題は
デュアルフォームに解決すると
遥かに効率的です
このアルゴリズムは
リニアおよび
ロジスティック回帰をすべて
SVMに至るまで動かすことができます
ランダムフォレストと
決定木もあります
ランダムフォレストは
[不明瞭]決定木であり
決定木はフィーチャースペースの
階層的パーティショニングを
作成することで機能します
現在 私たちの訓練方法は
「非常にランダムな
フォレストトレーニング」と呼ばれ
よりよい並列化とスケーリングが可能で
また勾配ブースティングされた
決定木について作業中です
これも大変人気があります
さて異なるアルゴリズムについて
お話ししました
ここで本当にユーザーに使いやすく
していきたいと思います
これらはいずれもハイレベルの
scikit-learnにインスパイアされた
estimator APIを通じたものです
k平均クラスタリングの例です
k平均クラスタリング
オブジェクトの作成から始め

Chinese: 
在L1和L2正规化里
有一个凸损失函数
SDCA使用一个巧妙的花招
把这一功能转化为对偶形式
事实证明，对于许多问题
用对偶形式求解都是非常有效的
而且结果表明，该算法可以
支持从线性和逻辑回归
到支持向量机等的模型
我们还有随机森林和决策树
随机森林是决策树
它的工作原理是
创建特征空间的层次分区
目前，我们的训练方法
“极随机森林训练”
允许更好的并行化和缩放
我们通过梯度提升决策树工作
这个也非常非常受欢迎
所以我谈到了不同的算法
现在我们想让它真的
可以很容易的为用户所用
所有这些都是通过高水平的
scikit-学习启发的预测API
一个例子是 k-均值聚类
你首先要创建一个k-均值聚类对象

Indonesian: 
Lalu kau punya
fungsi loss konveks
dengan regularisasi L-1
dan L-2, serta SDCA
gunakan trik bagus untuk ubah
fungsi terakhir ini
menjadi bentuk ganda.
Ternyata dalam banyak hal,
pemecahan masalah
dengan bentuk ganda lebih efisien.
Dan ternyata
algoritma ini
mampu menyokong model,
dari regresi linear dan logistik
hingga SVM.
Dan ada random forest
dan pohon keputusan.
Random forest
berbentuk pohon keputusan
dan pohon keputusan
membuat
sekat hierarkis
dari ruang fitur.
Kini kami sebut
metode ini
"latihan random forest
ekstrem" yang
berikan paralelisasi
dan skala lebih baik
dan kami berusaha
dapatkan pohon
keputusan gradient boosted
yang juga sangat terkenal.
Saya sudah bicarakan
aneka algoritma.
Kini kami ingin membuatnya
benar-benar mudah dipakai
oleh pengguna.
Semua ini diekspos lewat
API estimator terinspirasi
scikit-learn
tingkat sangat tinggi.
Ini contoh bagaimana
membuat penggugusan k-means.
Kau mulai dari membuat objek
penggugusan k-means

English: 
Now here, you have a
convex loss function
with L1 and L2
regularization, and SDCA
uses a neat trick of
transforming this last function
into a dual form.
And it turns out that,
for many problems,
solving it in the dual form
is much more efficient.
And it turns out
that this algorithm
can power models from linear
and logistic regression all
the way to SVMs.
We also have random
forest and decision trees.
Random forest are
[INAUDIBLE] decision trees,
and decision trees
work by creating
a hierarchical partitioning
of the feature space.
Currently our training
method is what
we call "extremely random
forest training," which
allows better
parallelization and scaling,
and we are also working
on having gradient
boosted decision trees, which
are very, very popular also.
So I talked about the
different algorithms.
Now we want to make it
really, really easy for users
to use them.
All of these are exposed via
very high level scikit-learn
inspired estimator APIs.
Here's an example for how when
[INAUDIBLE] k-means clustering.
So you start by creating a
k-means clustering object,

Korean: 
L1과 L2 규제화와 함께
볼록 로스 기능이 있고
SDCA는 이 마지막 기능을
이중 형태로 변환시키는
아주 멋진 기술을
사용합니다
많은 문제의 경우
이중 형태로 푸는 것이
훨씬 더 효율적이죠
또한 이 알고리듬은
선형과 로지스틱 회귀분석에서
SVM으로까지 모델을
강력하게 만들 수 있습니다
또한 랜덤 포리스트와 결정 나무가 있죠
랜덤 포리스트는 [청취불가] 결정 나무이고
결정나무는 특징 공간을
위계적으로 분할하는 거죠
현재 저희의 훈련 방법은
"극도의 랜덤 포리스트
훈련"이라고 부릅니다
더 나은 병렬화와 스케일링을
가능하게 해주죠
저희는 또한 기울기 부양
판단 트리를 만들려고
노력 중이죠. 이 또한 아주 인기가 많습니다
다양한 알고리듬에 대해 설명했습니다
사용자들이 이것을 쉽게 사용하길
원합니다
이 모든 것은 고등 사이킷 런을
통해 노출되었죠
에스티메이터 API이죠
k-means 클러스팅을 언제 어떻게
[청취불가]에 대한 예시가 여기 있습니다
k-means 클러스터링 대상을
만들면서 시작하는 거죠

Spanish: 
Esta es una función de pérdida convexa
con regularización L1 y L2,
y como ven, SDCA
usa una nueva manera de transformar 
la última función a una forma dual.
Y resulta que, por muchos problemas,
resolverlo en forma dual 
es mucho más eficiente.
Y resulta que este algoritmo
puede potenciar modelos 
de regresión logística y lineales a SVM.
También hay bosques aleatorios
y árboles de decisión.
Los bosques aleatorios 
son [INAUDIBLE] árboles de decisión
y los árboles de decisión funcionan
creando un partición jerárquica
del espacio.
Actualmente, a nuestro
método de entrenamiento
es "entrenamiento
de bosque aleatorio extremo"
el cual permite un mejor
paralelismo y escalado.
También estamos trabajando
en árboles de decisión impulsados
por gradiente, que son muy populares.
Ya hablé de los distintos algoritmos.
Ahora queremos hacer que usarlos
sea muy fácil para los usuarios.
Todos ellos están disponibles
mediante estimador de APIs
inspirados en un "scikit" de aprendizaje
de muy alto nivel.
Aquí hay un ejemplo de cómo
usar agrupamiento de KMeans.
Empiezas por crear el objeto
de agrupamiento de KMeans

Portuguese: 
Aqui, tem-se uma função de perda convexa
com regularização L1 e L2
e a SDCA usa um belo truque,
transformando esta última função
em um formato dual.
Acontece que, para muitos problemas,
a solução no formato dual
é muito mais eficiente.
E acontece que esse algoritmo
pode suprir modelos
de regressão linear e logística
até alcançar as SVMs.
Também temos florestas aleatórias
e árvores decisórias.
Florestas aleatórias são
[inaudível] árvores decisórias
e árvores decisórias operam criando
uma partição hierárquica
do espaço disponível.
Atualmente, nosso método de treinamento
é de "floresta extremamente aleatório",
que permite melhor paralelização e escala,
e também buscamos obter árvores decisórias
alavancadas pelo gradiente,
que também são muito populares.
Já tratei dos diferentes algoritmos.
Agora queremos facilitar bastante
para que os usuários os utilizem.
Todos esses são expostos por meio de
APIs estimadoras de alto nível
inspirados em scikit-learn.
Aqui está um exemplo de como
quando [inaudível] agrupamento k-means.
Você começa criando um
objeto de agrupamento k-means,

English: 
and here you can pass
in a bunch of options,
like the number of clusters,
how you want to train,
how you want to
initialize, and so on.
Next, you call the fit function
and pass it your input,
and that's it.
Not tons of logos
behind the scenes.
It creates the graph for you.
It'll run training iterations,
configure the runtime
until the training is done.
When you're finally
ready, you can
start inspecting the model
parameters like the clusters,
and start running inference,
here finding the assignment
to clusters, and so on.
So I talked about
high-level APIs,
but you also want to
maintain the flexibility
and extensibility that
TensorFlow promises.
So these are not opaque
objects that are only
accessible via this API.
They, in fact, allow the
users to inspect the graphs,
and also to be able to embed
these graphs into larger
training models.
So here's a training-- here's
a [? trial ?] example that
embeds k-means as a layer
in a bigger, deeper network.
You start with an
input, you run k-means,
and get your graph for k-means.

Indonesian: 
dan di sini kau bisa
masukkan banyak pilihan,
seperti jumlah gugus,
bagaimana kau mau melatih,
bagaimana kau mau
memulai, dan seterusnya.
Berikutnya, kaupanggil fungsi fit
dan berikan input-mu ke situ
lalu selesailah.
Tak perlu banyak logo
di balik layar.
Grafik sudah dibuatkan untukmu.
Itu lakukan ulangan latihan,
atur waktu proses
hingga latihan selesai.
Saat kau siap,
kau bisa
mulai periksa model
parameter, seperti gugus,
dan mulai jalankan inferensi,
temukan tugas di sini
untuk diguguskan,
dan seterusnya.
Saya sudah bicarakan API lanjut,
tapi kau mau
pertahankan fleksibilitas
dan mudahnya pengembangan
yang dijanjikan TensorFlow.
Jadi, ini bukan objek buram yang hanya
bisa diakses
lewat API ini.
Ini justru mungkinkan
pengguna memeriksa grafik
dan bisa masukkan
grafik ini dalam model
latihan yang lebih besar.
Ini suatu latihan,
ini contoh uji coba yang
lekatkan k-means sebagai layer
pada jejaring yang lebih besar, dalam.
Kau mulai dengan sebuah input,
kau jalankan k-means,
dan dapatkan grafik k-means.

Japanese: 
複数のオプションを渡します
例えば 複数のクラスターや
その訓練方法
初期化の仕方などですね
次に fit関数を呼び出して
inputに渡します
以上です
logoでいっぱいではありませんね
これでグラフを作ってくれます
訓練が済むまで
ランタイムを設定し
トレーニング反復を実行します
最後に準備が出来たら
クラスターなどの
モデルパラメーターを検査し
running inferenceを実行し
クラスターへの
割り当てを検索したりします
ハイレベルのAPIについて
お話ししましたが
TensorFlowが約束する
柔軟性や拡張性も欲しいですね
これはAPIでしかアクセスできない
不透明なオブジェクトではありません
実際 ユーザーがグラフを検査でき
これらのグラフをより大きな
訓練モデルに埋め込み可能です
訓練の例をお見せします
k平均をより大きく
深いネットワークに埋め込みます
まず入力し k平均を実行し
k平均のグラフを入手します

Portuguese: 
e daí se pode passar
a uma série de opções,
como o número de agrupamentos,
como pretende treinar,
como quer inicializar e assim por diante.
Em seguida, você chama a função Fit
e passa a sua entrada.
E é isso.
Nada de toneladas de logos ocultos.
Ele cria o grafo para você,
executa iterações de treinamento,
configura o tempo de execução
até o fim do treinamento.
Quando você estiver pronto,
pode inspecionar os parâmetros do modelo,
como os agrupamentos,
e executar a inferência,
para encontrar a atribuição
para os agrupamentos e por aí afora.
Tratei de APIs de alto nivel,
mas você também quer preservar
a flexibilidade e a extensibilidade
que o TensorFlow promete.
Esses são objetos não opacos,
apenas acessíveis por meio dessa API.
Eles, na verdade, permitem
aos usuários inspecionar os grafos
e também a integrar esses grafos
a modelos de treinamento maiores.
Aqui está um treinamento,
um exemplo de treinamento,
que integra k-means como uma camada
numa rede maior e mais profunda.
Você começa com uma entrada,
executa k-means
e recebe o seu grafo para k-means.

Korean: 
여러 옵션을 정할 수 있습니다
클러스터의 숫자나 어떻게 훈련시킬지
어떻게 시작하고 싶은지
등에 대해서 말이죠
다음으로 핏 기능을 불러와서
인풋을 넣으면
그게 다입니다
특별한 것 전혀 없죠
그래프를 만들어 줍니다
훈련 반복을 실행하고
실행시간을 컨피겨해 줄 겁니다
훈련이 끝날 때까지 말이죠
마침내 준비가 되면
클러스터와 같은 모델 파라미터를
조사하기 시작할 수 있죠
추론을 실행하기 시작하고
여기에서 클러스터로의 할당을
찾을 수 있는 등 많습니다
고등 API에 대해 이야기했습니다
하지만 텐서플로우가
약속한 융통성과 확장성을
유지하고 싶으시겠죠
이는 이 API를 통해서만
접근할 수 있는
이해하기 힘든 대상이 아닙니다
사실 사용자가 그래프를
조사할 수 있게 해주고
또한 이 그래프를 더 큰
훈련 모델에 임베드할 수 있게
해 주는 겁니다
여기 훈련의 예시가 있습니다
k-means를 더 크고 깊은 네트워크에서
레이어로 임베드한 경우죠
인풋에서 시작해서
k-means를 실행하고
k-means애 대한 그래프가 나오는 거죠

Chinese: 
在这里你会可以通过一系列
诸如集群数量，训练方法
初始化方法等等的选项
接下来
你会调用的拟合函数
并通过它的输入来决定
而不是成千上万的屏幕下的标志
它为你创建出图形
它将运行训练迭代
配置运行时间
直到训练完成
当你终于准备好时
您可以开始检查模型参数，如集群
并开始运行推理
在这里找到分配给集群的任务等等
到现在，我谈到了高阶API
但你也希望能保持
TensorFlow承诺的灵活性和可扩展性
所以这些不是不透明的
仅能通过此API访问的对象
事实上，它们可以允许用户检查图形
并且也能够把这些图
嵌入较大的训练模型
这里有一个训练—一个例子
将k-均值嵌入到更大，更深的网络中
你从输入开始，运行k-均值
得到用于k-均值的图形

Spanish: 
y aquí se puede entrar a muchas opciones
como la cantidad de agrupamientos,
cómo quieres entrenarlos
cómo los vas a inicializar, etcétera.
Luego, llamas la función "fit"
y la pasas por tu entrada
y eso es todo.
No hay muchos logos detrás de cámara.
Crea la gráfica por ti.
Ejecuta iteraciones de entrenamiento,
configura el tiempo de ejecución
hasta que al aprendizaje esté hecho.
Cuando estés listo puedes inspeccionar
los parámetros del modelo,
igual que con los agrupamientos
y empezar a ejecutar inferencias,
encontrando la asignación
a los agrupamientos.
Ya hablé de las API de alto nivel
pero también querrán mantener
la flexibilidad
y extensibilidad que promete TensorFlow.
Estos no son objetos opacos
que sólo son accesibles via esta API.
En realidad permiten al usuario
inspeccionar las gráficas
y también se pueden incluir estas gráficas
a modelos de entrenamiento más grandes.
Este es un entrenamiento,
una prueba como ejemplo
que incluye KMeans como una capa
en una red más grande y profunda.
Empiezas con la entrada,
ejecutas KMeans
y obtienes la gráfica para KMeans.
También te devuelve
la operación de entrenamiento

English: 
It also returns your training
op to drive the clustering,
and the output is the input
transformed to a distance
to cluster space.
Next, you feed this to
your dense stack of layers,
you create your
supervised loss, you
run STD to get a
final DNN training op.
Now you have these
two training ops,
you can join them to
create a single training
op that can drive the core
training of these two models.
Here's a code
snippet for the same.
So you start by creating
this k-means object,
and you'll inspect
the training graph.
It returns you a training
op and the output.
Next, you feed your
output into dense layers,
and you create your model
architecture as usual.
Finally, you get the training op
to drive your supervised loss,
or your dense stack.
And finally, use TensorFlow's
group operation to group
together these ops, so
that you have a single op
to drive the co-train.
So just to recap
the talk so far,
I talked to you about
the different algorithms
that are available now.
I showed you examples for how
to use high-level APIs to access
them, and also talked about
flexibility and extensibility

Portuguese: 
Ele retorna a operação de treinamento
para impulsionar o agrupamento.
E a saída é a entrada
transformada em uma distância
até o espaço do agrupamento.
Adiciona-se isso à sua densa
pilha de camadas,
cria sua perda supervisionada,
executa STD para obter
uma operação de treinamento DNN final.
Com as duas operações,
pode-se uni-las para criar
uma operação de treinamento para induzir
o treinamento principal
desses dois modelos.
Aqui, um trecho de código
para a mesma coisa.
Você começa criando esse objeto k-means
e inspeciona o grafo de treinamento.
Ele retorna uma operação
de treinamento e a saída.
Depois você insere
sua saída em camadas densas
e cria normalmente
sua arquitetura modelar.
Por fim, a operação de treinamento
induz sua perda supervisionada
ou sua pilha densa.
Finalmente, use a operação de grupo
do TensorFlow
para agrupar essas operações
e ter uma única conduzindo
o co-treinamento.
Para recapitular até aqui,
falei dos diferentes algoritmos
disponíveis atualmente.
Mostrei exemplos de como usar
APIs de alto nível para acessá-los,

Spanish: 
para manejar el agrupamiento
y el resultado es la entrada transformada
en la distancia al espacio agrupado.
Luego, alimentas con esto
tus capas más densas,
creas tu pérdida supervisada
ejecutas STD para obtener una operación
de entrenamiento DNN final.
Ahora ya tienes estas dos operaciones
puedes unirlas para crear una sola
que pueda conducir el entrenamiento
de estos dos modelos.
Este es un fragmento del código
para eso mismo.
Empiezas por crear este objeto de KMeans
e inspeccionas
la gráfica de entrenamiento.
Te regresa una op de entrenamiento
y el resultado.
Luego, alimentas con el resultado
las capas densas
y creas la arquitectura de tu modelo
como siempre.
Por último obtienes la op de entrenamiento
para conducir la pérdida supervisada
o las capas densas.
Finalmente, usas la operación
de TensorFlow
para agrupar estas ops
y tener una sola
que conduza el co-entrenamiento.
Resumiendo, hasta ahora
les hablé sobre los diferentes algoritmos
disponibles ahora.
Les mostré ejemplos de cómo usar
APIs de alto nivel para acceder a ellos
y también les hablé sobre 
la flexibilidad y extensibilidad

Indonesian: 
Ini kembalikan operasi latihan
untuk dorong penggugusan
dan output adalah input
yang diubah menjadi jarak,
menjadi ruang gugus.
Lalu umpankan ini
pada tumpukan layer padat,
kaubuat supervised loss-mu,
jalankan STD untuk dapat
operasi latihan DNN final.
Kau punya dua operasi latihan,
kau bisa gabungkan
menjadi satu operasi
latihan yang bisa dorong
latihan inti dari kedua model ini.
Ini cuplikan kode
untuk yang sama.
Kau mulai dengan buat
objek k-means ini
dan kau akan periksa
grafik latihan.
Kau akan dapatkan
operasi latihan dan output.
Lalu umpankan output-mu
pada layer padat
dan kaubuat model
arsitektur seperti biasa.
Lalu muncul operasi latihan
untuk dorong supervised loss
atau tumpukan padatmu.
Akhirnya, pakai operasi kelompok
TensorFlow untuk
kelompokkan operasi ini
agar kau dapat satu
operasi untuk dorong co-latihan.
Meringkas presentasi ini,
saya sudah bicarakan
aneka algoritma
kini tersedia.
Saya tunjukkan contoh bagaimana
pakai API tingkat tinggi untuk akses
dan bicarakan fleksibilitas
dan kemudahan pengembangan

Korean: 
또한 클러스터링을 할 수 있는
훈련 운영으로 돌아 갑니다
그리고 아웃풋은
클러스터 공간으로의 거리로 변환된
인풋인 거죠
다음으로 이를 밀집한
레이어 층으로 보내고
지도 손실을 만들며
마지막 DNN 훈련 운영을
얻기 위해 STD를 실행하죠
그럼 이 두 훈련 운영이 있고
하나의 훈련 운영을
만들기 위해 합치면 됩니다
이는 이 두 모델의
핵심 운영을 보일 수 있죠
같은 종류의 코드 조각이 있죠
k-means 객체를
만드는 것으로 시작해서
훈련 그래프를 조사하게 되는 겁니다
훈련 운영과 아웃풋으로 돌아가게 되죠
다음으로 아웃풋을
밀집한 레이어로 보내고
평소처럼 모델 건축을 만드는 거죠
마지막으로 훈련 운영이
지도 손상이나 밀집 스택으로
보내도록 하는 거죠
마지막으로 텐서플로우의
집단 운영을 사용하십시오
이 운영을 함께 묶고
함께 훈련하도록 하는
단일 운영이 생기는 겁니다
지금까지를 요약해 보면
현재 이용할 수 있는
다양한 알고리듬에 대해
말씀드렸죠
고등 API를 사용하고 접근하는
예시를 보여 드렸고
이러한 알고리듬의
융통성과 확장성에 대해서도

Japanese: 
そして 訓練オペレーションを返して
クラスタリングを実行し
出力はクラスタースペースへの
距離に変換されたinputです
次にこれをレイヤーの
デンススタックに詰め込み
監視ロスを作成し
STDを実行し
最終 DNN訓練オペレーションを得ます
これで２つの訓練オペレーションができました
これらを一緒にして
単一の訓練オペレーションを作成し
これら2モデルのコア訓練を実行できます
コードスニペットがあります
k平均オブジェクトを作成し
訓練グラフの検査を行います
これで training opと出力を返します
次に出力をdenseレイヤーに入れて
いつも通りモデルアーキテクチャを
作成します
最後に監視ロス
あるいはデンススタックから
training opを入手します
最後にTensorFlowの
group operationを使い
これらのオペレーションを統合し
Co-trainを実行する
単一のオペレーションを得られます
これまでのトークをまとめると
現在入手可能な異なる
アルゴリズムについてお話ししました
ハイレベルのAPIの利用法の例を示し
これらのアルゴリズムの
柔軟性や

Chinese: 
它会返回你的训练OP来驱动聚类
输出是将输入转换为
聚类空间的距离
下一步，你把这个放到密集的堆栈层
创建你的监督缺失
运行STD得到最后的DNN训练OP
现在你有这两个训练OP
你可以把他们加入到一起
创建一个单一的训练OP
可以驱动这两个模型的核心训练
这里有一个相同的代码段
所以你通过创建这个k-均值对象而开始
检查训练图
它将返回你的训练OP和输出
下一步，你把你的输出放到密集层
照常创建你的模型建筑
最后，您得到驱动您的监督损失
或密集堆栈的训练OP
最后，使用TensorFlow的组操作
把这些OP集合到一起
你会得到一个单一的OP
来驱动这个联合列车
现在我总结一下到目前为止的陈述
我跟大家谈了现在可用的
不同算法
展示了如何使用高级API访问它们的例子
并讨论了这些算法的

Indonesian: 
algoritma ini.
Lalu ingin saya
tekankan fakta
bahwa algoritma ini
didukung
penerapan terdistribusi.
Untuk beri gambaran
tentang kerumitan di
balik beberapa baris
bit dan kode ini,
saya akan dalami
tentang penerapan
salah satu algoritma.
Umumnya, arsitektur distribusi
akan lakukan
hal yang sama.
Kau akan punya seperangkat
server parameter yang
akan simpan semua parameter
secara terpecah-pecah.
Kau akan punya banyak
tiruan worker
yang akan jalankan
langkah latihan
dengan banyak batch input.
Pada tiap tahap, tiruan worker
akan ambil beberapa parameter.
Ini jalankan hitungan pada input
untuk hitung nilai baru
parameter.
Akhirnya, ini akan
write back pembaruan
pada server parameter.
Mari kita lihat WALS lagi.
Ringkasnya, dengan WALS, kau mau
memfaktorisasi matriks yang sangat
tersebar menjadi faktor padat.
Seperti saya bilang, algoritma
latihan libatkan perbaikan
salah satu faktor,
menghitung yang lainnya
dalam latihanmu.
Sekarang saya mau bisa beri
skala pada input berukuran

English: 
of these algorithms.
Next, I want to
highlight the fact
that all these
algorithms are backed
by distributed implementations.
Just to give you a better
sense of the complexity hidden
behind these few lines
of byte and code,
I will dig deeper into
the implementation
of one of the algorithms.
So, in general, the
distribution architecture
is going to do the same.
You'll have a set of
parameter servers, which
will store all the
parameters in a sharded way.
You will have a bunch
of worker replicas
that will be running
training steps,
with many batches of inputs.
In each step, the worker replica
would fetch some parameters.
It will run compute on the
input to compute the new value
of the parameters.
And finally, it will
write back these updates
to the parameter server.
So let's look at WALS again.
Just to recap,
with WALS, you want
to factorize a really sparse
matrix into dense factors.
And as I told you,
the training algorithm
involves fixing
one of the factors,
computing the other
one in your training.
Now I want to be able to scale
to inputs that are terabytes

Korean: 
언급했습니다
다음으로는 이 모든 알고리듬이
분산된 실행에 의해 지원된다는 사실을
강조하고 싶습니다
이 모든 라인의 바이트와
코드 뒤에 숨겨진
복잡성에 대한 이해를 도와드리기 위해
이 알고리듬 중 하나의
실행을 더 자세히
설명하겠습니다
일반적으로 분산 건축은
똑같을 겁니다
파라미터 서버의 세트가 있고
이는 샤딩된 방식으로
이 모든 파라미터를 저장하겠죠
워커 복제품이 많을 겁니다
훈련 단계를 실행하겠죠
많은 배치와 인풋으로 말입니다
각 단계에서 워커 복제품은
일부 파라미터를 패치할 겁니다
파라미터의 새 값을 계산하기 위해
인풋에서 계산을
실행하겠죠
마지막으로 파라미터
서버로의 업데이트를
다시 쓸 겁니다
그럼 WALS을 다시 보겠습니다
요약컨대 WALS로는
듬성듬성한 행렬을 밀집한 팩터로
인수분해하고 싶은 거죠
말씀 드렸듯 이 훈련 알고리듬은
팩터 중 하나를 고치고
훈련 중 다른 하나를 계산합니다
이제 테라바이트 크기의 인풋을
스케일하고 싶은 거죠

Chinese: 
灵活性和可扩展性
接下来，我想强调一个事实
所有这些算法
都支持分布式实现
为了给大家更好地理解感觉
隐藏在这几行字节和代码背后的复杂性
我将深入到
执行其中之一的算法
一般来说，分布式体系结构
做法大致相同
你会有一个参数设置服务器
里面以一个分散的方式存储着所有参数
您将有一组工人副本
将与许多批次的投入一起
运行训练步骤
在每个步骤中
工人副本将获取一些参数
它将在输入上运行计算
去算出参数的新值
最后，它会将这些更新
写入参数服务器
让我们再来看下WALS
我总结一下，运用WALS
你希望能将非常稀疏的矩阵因式
分解成致密的因素
正如我所说
训练算法涉及固定其中一个因素
在你的训练中计算另一个
现在我希望能够有

Portuguese: 
e também falei da flexibilidade
e da extensibilidade desses algoritmos.
A seguir, quero destacar
que todos esses algoritmos são apoiados
por implementações distribuídas.
Apenas para dar uma
melhor noção da complexidade
oculta por trás de umas poucas
linhas de código Python,
vou cavar fundo na implementação
de um desses algoritmos.
De modo geral, a arquitetura
de distribuição fará o mesmo.
Você terá uma série
de servidores de parâmetros,
que armazenarão todos os parâmetros
de maneira fragmentada.
Terá uma réplicas de operadores
que executarão etapas de treinamento,
com muitos lotes de entradas.
A cada etapa, a réplica de operador
recolherá alguns parâmetros,
executará compute na entrada
para computar o novo valor dos parâmetros
e, por fim, registrará essas atualizações
no servidor de parâmetros.
Demos uma nova olhada no WALS.
Recapitulando, com WALS,
você fatora uma matriz esparsa
em fatores densos.
E como disse, o algoritmo de treinamento
implica corrigir um dos fatores,
computando o outro em seu treinamento.

Japanese: 
拡張性についてお話ししました
次にこれらのアルゴリズムすべてが
分散実装で支えられていることを
強調したいと思います
これらのバイトやコードの背景に隠された
複雑さを理解してもらうために
１つのアルゴリズムの実装について
詳しく説明します
一般的に配信アーキテクチャは
同じになります
パラメーターサーバーのセットがあり
すべてのパラメーターを
断片的に保存します
訓練ステップを実行する
一連のWorker Replicaが
一連の入力と共に得られます
各ステップでWorker Replicaは
いくつかのパラメーターを入手し
そのパラメーターの新たな値を計算するために
入力に対して計算を行います
最後にパラメーターサーバーに
これらのアップデートを書き込みます
再び WALSを見てみましょう
WALSでは
まばらな行列を
密要素に因数分解します
先に述べたように
訓練アルゴリズムで
要素のひとつを固定し
もうひとつの要素を計算します
入力はテラバイト規模になります

Spanish: 
de estos algoritmos.
Ahora, quiero resaltar el hecho
de que todos los algoritmos
están respaldados
por implementaciones distribuidas.
Para dar una mejor idea
de la complejidad escondida
detrás de estas pocas líneas
de código de Python
voy a indagar en la implementación
de uno de estos algoritmos.
En general, 
la arquitectura de distribución
hace lo mismo.
Tendrán una serie de servidores
de parámetro
que guardan todos los parámetros
de forma fragmentada.
Tendrán bastantes réplicas trabajadoras
ejecutando pasos de entrenamiento
con muchos lotes de entradas.
En cada paso, la réplica 
recogerá algunos parámetros.
Ejecutará la computación sobre la entrada
para computar el nuevo valor
de los parámetros.
Y finalmente, escribirá nuevamente
esas actualizaciones
al servidor de parámetro.
Veamos WALS otra vez.
Resumiendo, con WALS lo que se busca
es factorizar una matriz muy dispersa
en factores densos.
Como dije, el algoritmo de entrenamiento
tiene que ver con arreglar
uno de los factores
y computar el otro en el entrenamiento.
Ahora quiero poder escalar a entradas
de tamaño terabyte

Japanese: 
そして要素には何億もの
行と何百もの列があります
どのように機能するでしょうか？
RAMのすべてと計算
情報のボトルネックを
注意深く考慮する必要があります
まず明らかなのは
これらの要素のサイズを考えると
それらを
Parameter Server Shard間で
分配する必要があります
Uを取り 断片化します
次に計算量を考えると
多くのWorkerReplicaが
必要ですね
WorkerReplicaの
シャーディングには
row slicing を使います
つまり 各ミニバッチは
入力の行のサブセットであり
該当するUの行を計算します
しかし まだ問題がありますね
Uへのアップデート
V要素すべてに依存します
先に述べたように Vは大きく
テラバイトもあり得ます
データのテラバイト
各ステップでコピーする必要があります
さてどのように機能するでしょうか？
この時点で ちょっとした
マジックを使用します

English: 
in size, and you
want factors that
have hundreds of millions of
rows and hundreds of columns.
So how do you make this work?
So we have to carefully think
about all the RAM, compute,
and info bottlenecks.
The first obvious
thing is, given
the size of these factors, you
will have to distribute them
across parameter server shards.
So you take a U, split them
across all these shards.
Next thing, given the
amount of compute involved,
you want a bunch
of worker replicas.
The sharding scheme that we
use for these worker replicas
is row slicing.
And what that means
is, each mini batch
is a subset of
rows of the input,
and we compute the
corresponding rows of U.
Note, however, there's
still a problem.
Each update to U depends
on the full V factor.
And as I said, V could be
large, it could be terabytes.
So what this entails
is that you might
be copying terabytes of data
to each worker in each step.
So how do we get around that?
So at this point, we use
some [INAUDIBLE] magic.

Chinese: 
百万兆字节规模大小的输入
你想要有上百万行上百列的元素
那么你怎么做这项工作呢？
我们必须仔细考虑所有的RAM，计算
和信息瓶颈
第一件显而易见的事情是
考虑到这些因素的大小
你必须将它们
分发到参数服务器分块
所以你采取了U
要把这些因素分到所有这些分块中
下一步，考虑到所涉及的计算量
你需要一堆工人副本
我们使用的对这些工人副本的切分方案
是连续切片
这意味着
每个小批量都是输入行的子集
我们要计算U相应的行
但是，仍然有一个问题
每次更新取决于全V因子
就像我说的，V可能很大
可能是百万兆字节
这可能需要你为每个工人
在每一步上都要复制百万兆字节
那么，我们如何避免这个呢？
在这一点上，我们要使用一些魔法

Spanish: 
y lo que querrán son factores
que tengan cientos de millones de filas
y cientos de columnas.
¿Y cómo se hace para que funcione?
Debemos pensar con cuidado
sobre el RAM, el cómputo
y los bloqueos de información.
La primera obviedad
es que por el tamaño de estos factores,
tendrán que distribuirlos
en shards de parámetros de servidor.
Se toma una "U", se divide entre
todos estos shards.
Luego, dada la cantidad 
de cálculos involucrados
querrán un montón de réplicas.
El esquema de shards que usamos
para estas réplicas
es de cortado de filas.
Y lo que eso significa es
que cada mini lote
es un subconjunto 
de filas de la entrada
y calculamos las filas
correspondientes de "U".
Hay que notar que todavía
hay un problema.
Cada actualización de "U" 
depende del factor "V".
Y como lo dije, "V" puede ser grande,
pueden ser terabytes
y lo que esto implica es que podrían
estar copiando terabytes de datos
a cada réplica en cada paso.
¿Cómo evitamos esto?
En este punto, usamos algo de magia.

Indonesian: 
terabit dan kau mau faktor yang
punya ratusan juta baris
dan ratusan kolom.
Bagaimana kaulakukan ini?
Kita harus pertimbangkan RAM
dengan seksama, hitung,
dan informasikan hambatan.
Hal pertama
yang jelas, mengingat
ukuran faktor ini, kau
harus mendistribusikannya
lewat kepingan
server parameter.
Kauambil U, pisahkan
melalui semua kepingan ini.
Lalu, mengingat jumlah
yang perlu dihitung,
kau mau banyak
tiruan worker.
Skema pemecahan yang dipakai
untuk tiruan worker
adalah irisan baris.
Dan artinya
setiap batch kecil
adalah subperangkat
baris dari input
dan kita hitung
baris U yang berkaitan.
Perhatikan juga,
masih ada masalah.
Tiap pembaruan U bergantung
pada faktor V penuh.
Seperti saya bilang, V mungkin
besar, seukuran terabit.
Yang diperlukan
adalah kau mungkin
menyalin data seukuran terabit
ke tiap worker, pada tiap tahap.
Bagaimana kita bergerak ke situ?
Pada tahap ini, kita pakai
sedikit keajaiban.

Portuguese: 
Agora quero expandir em escala
para entradas em terabytes
e você busca fatores
que têm centenas de milhões de linhas
e centenas de colunas.
Como você faz isso funcionar?
Temos de considerar toda a RAM,
a computação e os gargalos de informação.
É óbvio que, em razão
do tamanho desses fatores,
é preciso distribui-los entre fragmentos
do servidor de parâmetros.
Pegue então um U e divida-o
entre todos esses fragmentos.
Depois, pela quantidade
de computação envolvida,
você busca uma série de
réplicas de operadores.
O esquema de fragmentação
para essas réplicas de operadores
é o fatiamento de linha.
E isso implica que cada minilote
é um subconjunto de linhas da entrada
e computa as linhas correspondentes de U.
Note-se, porém,
que ainda temos um problema.
Cada atualização em U
depende do fator V pleno.
E como eu disse, V poderia
ser grande, em terabytes.
Isso implica que você poderia
ter de copiar terabytes de dados
para cada operador a cada etapa.
Como evitamos isso?
Nesta altura, utilizamos um pouco
de mágica de álgebra linear.

Korean: 
수 백만 개의 행과 수백개의 열이 있는
팩터를 원하는 겁니다
어떻게 하면 될까요?
모든 RAM, 계산, 그리고 정보 병목을
신중하게 생각해야 합니다
분명 한 점은
이 팩터의 크기를 봤을 때
파라비터 서버 샤드에
걸쳐서 분산해야 한다는 점이죠
U를 가지고 이 모든 샤드에
걸쳐 나누는 겁니다
다음으로는 포함되는
계산의 양을 봤을 때
워커 복제품이 많이 필요하죠
이러한 워커 복제품을 위해 우리가 사용하는 샤딩 스킴은
열 자르기입니다
즉 각 미니 배치가
인풋 열의 서브세트이고
그에 상응하는 U의 열을 계산하는 거죠
하지만 여전히 문제가 있습니다
U로의 각 업데이트는
전체 V 팩터에 달려 있죠
말씀드렸듯 V는
테라바이트만큼 클 수 있습니다
따라서 이것이 야기하는 것은
각 단계마다 워커에게 테라바이트 크기의 테이터를 복사해야 한다면
과연 이 문제를 어떻게 풀어야 하나요?
이 시점에서 약간의
[청취불가] 마술을 쓰는 거죠

Chinese: 
事实上，你可以计算某些摘要
我们把它叫做G
有了G以后
你对U的更新只依赖于V的几行
这些都是对应的非零输入的条目的专门的行
所以这很伟大
这意味着
你只需要每一步复制兆字节数据
而不是百万兆字节
在这一点上，我们可以运行
TensorFlow的聚集操作
得到所需的行
然后我们使用写入的高度优化的自定义C++内核
运行计算
最后，我们用TensorFlow的分散操作
来把这些更新写回到参数服务器分区中
那么这个能运行得多好呢？
我们相信我们的实现是真正的高性能
我们做了一些测试
在一般情况下
对单台机器
我们的运行在模型的质量和速度与scikit相当
甚至对于中等大小的问题
工作更快
但TensorFlow真正的亮点
是它能够在几十万台机器上

Spanish: 
Resulta que, se pueden calcular
ciertos resumenes
llamémoslos "G". Y dados los "G",
las actualizaciones de "U"
solo dependen de unas cuantas filas
de "V". Y estas son específicamente
las filas que corresponden
a las entradas de no-ceros.
Esto es genial.
Lo que eso significa es que,
en vez de copiar terabytes
puedes solo copiar megabytes
de datos por paso.
En este punto, podemos correr
la operación de TensorFlow de juntar
y obtener las filas requeridas.
Luego calculamos usando núcleos C++
altamente optimizados y personalizados
que escribimos.
Y finalmente, usamos la operación
de esparcir de TensorFlow
para volver a escribir estas
actualizaciones
en los shards de servidor de parámetro.
¿Qué tan bien funciona esto?
Creemos que nuestras implementaciones
son de muy alto rendimiento.
Hicimos una evaluación comparativa
y en una sola máquina
nuestras implementaciones en general
se ven a la par de "scikit" en cuanto
a calidad de modelo y velocidad
incluso funcionan más rápido
con problemas de grado moderado
también.
Pero TensorFlow brilla realmente

Japanese: 
実はある程度のサマリーを計算できます
これをGとしましょう
各Gに対して Uへのアップデートは
Vの行の一部に依存し
これらは特に
非0の入力に対応しています
すばらしい
つまりテラバイトをコピーするのではなく
各ステップのデータのメガバイトだけを
コピーすればいいです
この時点で TensorFlowの
gather operationを実行し
必要な行を入手します
最適化したカスタム C++ カーネルを
使用して
計算し書き込みます
最後にTensorFlowの
scatter operationを使い
これらのアップデートを その
Parameter Server Shardsに書き込みます
どのように機能するでしょうか？
この実装は本当に
ハイパフォーマンスだと思います
ベンチマークを行い
シングルマシンでは
私たちの実装は
一般的に
スキット当たりで見ると
モデルクオリティと速度で
中程度サイズの問題でも
より速くなります
TensorFlow のすばらしい点は
何十万ものマシンを通じても

Indonesian: 
Ternyata kau bisa
hitung beberapa ringkasan,
sebut saja G. Karena G,
pembaruanmu terhadap U
hanya bergantung pada beberapa baris
V. Dan ini khususnya
baris yang berkaitan dengan
entri input yang bukan nol.
Jadi, ini hebat.
Artinya, alih-alih
menyalin hingga terabit,
kau bisa menyalin data megabit
langkah demi langkah.
Kini bisa dijalankan
operasi pengumpulan TensorFlow
dan kita dapatkan
baris yang dibutuhkan.
Lalu kita hitung dengan kernel
C++ terkustomisasi optimal
yang telah kita buat.
Akhirnya, kita pakai
operasi sebar TensorFlow
untuk write back pembaruan
keping server parameter.
Seberapa baik hasilnya?
Kami yakin, kinerja penerapan kami
sangatlah tinggi.
Kami sudah bandingkan
dan pada mesin tunggal,
penerapan kami
secara umum tampak
setara scikit dalam hal
mutu dan kecepatan model,
bahkan seringkali lebih cepat
untuk masalah tingkat menengah
juga.
Namun, keunggulan TensorFlow
yaitu kemampuan berjalan tanpa batas
melintasi ratusan ribu

English: 
It turns out, you can
compute certain summaries,
let's call them G. And
given G, your updates to U
only depend on a few rows of
V. And these are specifically
the rows that correspond to the
non-zero entries of the input.
So this is great.
What that means is that,
instead of copying terabytes,
you can just copy
megabytes of data per step.
At this point, we can run
TensorFlow's gather operation
and get the required rows.
We then compute using highly
optimized custom C++ kernels
that we wrote.
And finally, we use
TensorFlow's scatter operation
to write back these updates to
the parameter server shards.
So how well does this work?
We believe our implementations
are really high performance.
We did some benchmarking,
and on single machine,
our implementations,
in general, look
on par with scikit in terms
of model quality and speed,
often even working faster
for moderate-sized problems,
as well.
But where TensorFlow
really shines
is being able to run seamlessly
across hundreds of thousands

Korean: 
특정 요약을 계산할 수
있다고 밝혀 졌습니다
이를 G라고 부르면 G가 있을 때
U로의 업데이트는
V의 일부 열에만 달려 있다는 것이죠
구체적으로 인풋에서 0이 아닌 입력에
상응하는 열을 가르키죠
훌륭하죠
이는 테라바이트를 복사하는 대신에
단계 당 메가바이트만
복사하면 된다는 의미입니다
이 시점에서 텐서플로우의 게더 함수를 실행할수있고
필요한 열을 받을 수 있죠
그리고 나서 저희가 써 놓은
최적화된 커스텀 C++ 커널을 사용해서
계산하면 되죠
마지막으로 텐서플로우의
스케터 운영을 사용해서
이 업데이트를 파라미터
서버 샤드로 다시 쓰는 거죠
얼마나 잘 될까요?
저희는 우리가 만든것이
정말 고성능이라고 믿고 있습니다
벤치마킹을 약간 했고 하나의 머신에서
우리가 만든것이
대체적으로 품질과 속도면에서
사이킷과 유사하고
웬만한 문제들은
훨씬 빨리 해결
합니다
텐서플로우가 멋진 것은
수 십만 개의 머신에서
아무런 문제 없이 운영될 수

Portuguese: 
Acontece que você pode
computar alguns sumários,
vamos chamá-los de G.
Dado G, suas atualizações em U
dependem apenas de algumas linhas de V,
e essas são justamente as linhas
que correspondem
aos registros não zero da entrada.
Isso é ótimo.
Isso significa que,
em vez de copiar terabytes,
você pode copiar apenas
megabytes de dados a cada etapa.
Nesta altura, podemos executar
a operação gather do TensorFlow
e obter as linhas desejadas.
Computamos, então, usando núcleos C++
sob medida, altamente otimizados,
que nós escrevemos.
Finalmente, usamos
a operação scatter do TensorFlow
para registrar essas atualizações
nos fragmentos do servidor de parâmetros.
E isso funciona mesmo?
Acreditamos que nossas implementações
são realmente de alto desempenho.
Fizemos um pouco de análise comparativa
e, numa única máquina,
nossas implementações geralmente
se equiparam com o scikit
em termos de qualidade
do modelo e velocidade,
por vezes operando até mais rápido
para problemas de tamanho moderado.
Mas o TensorFlow realmente se destaca

Japanese: 
シームレスであることです
実際 多くのケースで
見てきたものよりも遥かに大きなモデルの
訓練が可能です
例えば ランダムフォレストでは
何十億ものノードをツリーを訓練できました
NIPSに これに関する論文があります
SDCAについては Googleの
高度に最適化された内部のものよりも
何十億もの例について
ロジスティック回帰の実装について
10x から50x 高速です
WALSに関しては
4億行×6億列の大きな行列について
12時間未満で因数分解できます
これは初期のMapReduceに基づいた
実装よりも
50x 大きいです
さて まとめますと
非常にハイパフォーマンスで
拡大可能なMLアルゴリズムの
実装が得られ
これは画期的なTensorFlowです
これで スキットの簡易さと

Indonesian: 
mesin.
Pada banyak kasus,
kami bisa melatih
model yang lebih besar daripada
yang pernah kami lihat.
Misal dengan random forest,
kami bisa latih ribuan pohon
dengan miliaran simpul.
Dan kami punya artikel
di NIPS yang membahas itu.
Dengan SDCA, kami lihat konvergensi
10 hingga 15 kali lebih cepat daripada
internal Google
yang sangat teroptimisasi,
penerapan pada
regresi logistik
dengan miliaran contoh.
Dengan WALS, kami bisa memfaktorisasi
matriks besar, 400 juta baris
dengan 600 juta kolom
menjadi faktor dengan 500 kolom
dalam kurang dari 12 jam.
Ini 50 kali lebih besar daripada yang
bisa dilakukan dengan penerapan
berbasis MapReduce.
Jadi, kami punya penerapan
terdistribusi dan meluas
yang unggul dari beragam algoritma ML
yang bekerja secara berbeda
di TensorFlow.
Ini membawa
kemudahan scikit

English: 
of machines.
In fact, in many cases,
we are able to train
models that are much
larger than what
we had seen in [INAUDIBLE].
For example, with
random forest, we
were able to train thousands of
trees with billions of nodes.
And we have a paper at
NIPS that talks about that.
With SDCA, we saw 10x to 50x
faster convergence compared
to Google's highly optimized
internal [INAUDIBLE]
implementations on logistic
regression for [INAUDIBLE]
with billions of examples.
With WALS, we are
able to factorize
a huge matrix, 400 million
rows by 600 million columns,
into factors with 500
columns in under 12 hours.
Note that this is
50x larger than what
we could do with an early
MapReduce-based implementation.
So, in summary, we have really
high performance distributed
and extensible implementations
of different ML algorithms
that are working out of
the box in TensorFlow.
These bring together
the ease of scikit

Chinese: 
无缝运行
事实上，在许多情况下
我们能够训练
远远大于我们所见到的模型
例如，用随机森林
我们能够训练
有数十亿的节点的决策树
我们在NIPS上有一篇文章
讲述了这个内容
用SDCA，我们看到数十亿
比谷歌高度优化的
对逻辑回归的内部实现
快10倍到50倍的例子
运用WALS
我们可以把一个巨大的矩阵
分解成4亿行6亿列
500列的元素可以在12小时以下完成
注意，这是50倍于我们可以用
早期的基于MapReduce运行可以实现的量
总而言之，我们有超高性能
分散和可扩展的不同ML算法
在TensorFlow中开箱可用
这些算法把scikit

Spanish: 
al ejecutarse sin problemas
en cientos de miles de máquinas.
De hecho, en muchos casos podemos entrenar
modelos que son mucho más grandes
que lo que hemos visto en [inaudible]
Por ejemplo, con el bosque aleatorio
podemos entrenar miles de árboles
con millones de nodos.
Y tenemos un artículo en NIPS
que habla sobre eso.
Con SDCA vimos la convergencia
más rápida (de 10 a 50 veces)
comparada con [inaudible]
la altamente optimizada por Google
las implementaciones en regresión
logística para [inaudible]
con millones de ejemplos.
Con WALS, podemos factorizar
una matriz gigante, 400 millones de filas
por 600 millones de columnas
en factores con 500 columnas
en menos de 12 horas.
Hay que notar que esto es
50 veces más grande
que lo que podríamos hacer
con una implementación
basada en MapReduce.
En resumen, tenemos implementaciones
de los algoritmos ML
extensibles y muy bien distribuidas
que funcionan solas son configurar
en TensorFlow.
Esto trae consigo la facilidad
de "scikit"

Portuguese: 
por executar perfeitamente
em centenas de milhares de máquinas.
Na verdade, em muitos casos,
conseguimos treinar modelos muito maiores
do que os que vimos em [inaudível].
Por exemplo, com a floresta aleatória,
conseguimos treinar
milhares de árvores com bilhões de nós.
Temos um artigo na NIPS que trata disso.
Com SDCA, vimos uma convergência
de 10 a 50 vezes mais rápida,
se comparada com as
implementações [inaudível] internas
altamente otimizadas da Google
de regressão logística para [inaudível],
com bilhões de exemplos.
Com WALS, conseguimos fatorar
uma matriz imensa,
400 milhões de linhas
por 600 milhões de colunas,
em fatores com 500 colunas
e em menos de 12 horas.
Isso é 50 vezes maior
do que o que podíamos fazer
com uma implementação anterior
baseada no MapReduce.
Em resumo, temos implementações
de diferentes algoritmos ML
distribuídas e extensíveis
com um desempenho realmente elevado,
capazes de operar
imediatamente no TensorFlow.

Korean: 
있다는 점입니다
사실 많은 경우 저희가 [청취불가]에서 본
것보다 훨씬 더 큰 모델을
훈련시킬 수 있습니다
예컨대 렌덤 포리스트로
수십억개의 노드가 있는
수천개의 나무를 훈련시킬 수 있었죠
NNIPS의 논문에서
이에 대해 언급했습니다
SDCA로는 10배에서 50배
더 빠른 수렴을 봤죠
Google의 굉장히 최적화된
내부 [청취불가]에 비해서 말이죠
[청취불가]를 위한
로지스틱 회귀분석에 대한 실행도
수억가지 예시가 있죠
WALS로 저희는 굉장히 큰 행렬
즉, 4억 개의 열과 6억 개의 행을 가진 행렬을
12시간 내에 500개의 행을 가진
팩터로 인수분해할 수 있었죠
초기 지도 감소를 기초로 한 실행으로
할 수 있었던 것보다
50배 정도 큰 겁니다
요약컨대 저희는
상당한 고성능을 분포했고
텐서플로우에서 바로 사용할 수 있는
다양한 ML 알고리듬의
구현을 확장했습니다.
이는 텐서플로우의 힘과 스케일가능성으로

Portuguese: 
Elas combinam a facilidade do scikit
com a potência e a escala do TensorFlow
e colocam o TensorFlow
mais perto de se tornar
uma solução ML completa.
Espero que, a esta altura,
vocês estejam empolgados para começar,
então aqui estão alguns links
para o núcleo e para a documentação.
A aqui uma série de estimadores
prontos para serem usados.
Sendo assim, obrigado.

Korean: 
카이킷의 용이성을 합쳤고
텐서플로우가 좀더
완전한 ML 해결책으로
한걸음 더 다가가게 해 주었습니다
이 시점에서 여러분들이
이를 시작하게 되어 기쁘며
코어와 문서에 대한 링크가
여기 있습니다
이미 사용 준비가 된 여러가지
에스티메이터도 있습니다
감사합니다
[박수]
[음악재생]

Spanish: 
con el poder y la expansibilidad
de TensorFlow
y lleva a TensorFlow un paso
más cerca de ser
una solución ML más completa.
Espero que en este punto
ya tengan ganas de empezar
así que estas son algunos links
al núcleo y la documentación
y algunos estimadores
listos para usarse.
Con eso, gracias.

English: 
with the power and
scalability of TensorFlow
and moves TensorFlow one
step closer to being a more
complete ML solution.
I am hoping, at
this point, you guys
are excited to get
started, so here
are some links to core
and documentation,
and here are a
bunch of estimators
that are ready to use.
With that, thank you.
[APPLAUSE]
[MUSIC PLAYING]

Indonesian: 
dengan kekuatan
dan skala TensorFlow
dan mendorong TensorFlow
selangkah lebih dekat
menjadi solusi ML lengkap.
Saya harap saat ini, kalian
tertarik untuk mulai, jadi ini
beberapa tautan
inti dan dokumentasi
dan ini sekumpulan estimator
yang siap pakai.
Dengan demikian, terima kasih.

Japanese: 
TensorFlowのパワーと
スケーラビリティ
TensorFlowを一歩
ML solutionの完成へと近づけました
興味を持っていただき
すぐにも皆さんに使われるように
コアとドキュメントへの
リンクが提示します
ここにはすぐに利用できる
たくさんのestimatorがあります
以上 ありがとうございました

Chinese: 
与TensorFlow的可扩展性和能力
集合在一起
使Tensorflow接近一个
更完整的ML解决方案
我希望，在此刻
你们大概会对这件事情的开始很激动
所以这里有一些核心链接和文档
还有有一堆预测
可以随时使用
谢谢大家
[掌声]
[音乐播放]
