Eager Execution (TensorFlow Dev Summit 2018) TensorFlow English Chinese (Simplified)

Eager Execution (TensorFlow Dev Summit 2018)YouTube↗ IA↗(long shot)
Science & Technology 31.4K views 284 likes 9 dislikes 30 Mar 2018

TensorFlow 615K subscribers N/A YouTube↗

Click to Play Video

♪ (music) ♪ (clapping)

My name is Alex,

and I'm here to tell you about <i>Eager Execution,</i>

今天我想给大家介绍一下<i> Eager Execution</i>

which I think you've heard in the last two talks now.

这个名字大家在前两个演讲中应该已经听过了

But I'm here to tell you what it's actually about.

但是我会给你们更到位的介绍

This new, imperative, object-oriented,

这个必要且以对像为本

pythonic way of using TensorFlow,

使用TensorFlow 的Pythonic全新方式

that we're introducing to you today

我们今天要向你们介绍一下

as part of TensorFlow core.

这是TensorFlow核心的一部分

So, you know because you're here, or because you're watching the livestream,

你们在这里，或已经知道或者因为你们正在观看直播

I hope, that <i>TensorFlow</i> has been

我希望<i>TensorFlow</i>

this graph execution engine for machine learning,

已经成为机器学习的图像执行引擎

that lets you run graphs at like high scale

让你们大规模执行图像

and all sorts of other nice things.

以及其他很棒的东西

And why did we choose to go with graphs in the first place?

我们当初为什么选择图像呢？

Since now I'm going to tell you about <i>Eager Execution,</i>

现在我要给大家介绍<i> Eager Execution</i>

where we move beyond what we can achieve with graphs,

这能使我们超越用图像做的东西

I think it's a good idea to recap why we bothered.

我认为回顾一下什么东西困扰着我们是个好主意

And a really good reason why you want

这是一个很好的理由你想要你们的计算

to have your computation represented as a platform-independent graph

作为一个独立于平台的图像

is that once you have that, it's very easy to differentiate the graph.

一旦你们有了这个就会很容易区分图像

And I went to grad school

当我念研究院

before auto diff was standard in machine learning toolkits

在auto diff 还是机器学习工具包的标准之前

and I do not wish that on any one.

我并没有希望能夠这样做

Like, it's... life is much better now trust me

就像是...現在生活得更好相信我

Also, if you have a platform-independent,

此外，如果你有一个独立于平台

abstract representation of your computation,

计算的抽象表示

you can just go and deploy it to pretty much anything you want.

你们只需去部署几乎任何想要的东西

You can run it on the TPU. You can run it on the GPU.

可以在TPU上运行它可以在GPU上运行它

You can put it on a phone; you can put it on a Raspberry Pi.

把它放在手机上亦可以把它放在Raspberry Pi

There are like all sorts of cool deployment scenarios

就像是各种很棒的部署方案

you're going to hear about today.

你们今天会听到的

And it's really valuable to have this kind of platform-independent view.

这种独立于平台的视图真的很有价值

Also, compilers work with data flow graphs internally,

此外，编译器也可以内部处理数据流图

and they know how to do all sorts of nice optimizations

它们知道该怎样处理各种不错的优化

that rely on having a global view of your computation,

依靠你们的计算的全球视野

like constant folding, common subexpression elimination,

例如不断的折叠常见的公共子表达式消元

like data laying and things like that.

像数据laying和类似的东西

And a lot of these optimizations are really deep learning specific.

很多优化真的是特定深度学习

We can choose how to properly lay out your channels and your height,

我们可以选择如何正确地布置你的渠道和你的高度

and width and stuff.

宽度和其他东西

So, your convolutions are faster.

你们的卷积的速度就可更快

And finally, a key reason that's very important to us at Google,

最后对我们Google来说这是一个很重要的关键原因

and I hope important to you as well

我希望对你们也很重要

is that once you have a platform-independent

一旦你们有一个独立于平台的

representation of your computation,

you can just deploy it, and distribute it across hundreds of machines

你们就可以进行部署并分发它到数百台机器

or a TPU-pod, like they showed earlier.

或TPU-pod，像之前展示一样

And this is a very seamless process.

这是一个无缝的过程

So, since graphs are so good,

由于图像的质量非常好

what made us think that now it's a good idea to move beyond them

这使我们认为现在超越它们是一个好主意

and let you do <i>eager execution</i>?

并让你们执行<i>eager execution</i>?

Good place to start is that you don't actually

良好的开端是

have to give up automatic differentiation.

你们实际上不须放弃自动分化

I'm sure like you're familiar with like other frameworks, like <i>Pythons</i>

我相信你们都会熟悉其他框架例如<i>Pythons</i>

<i>Autograph</i> that let...

<i>Autograph</i>...

sorry <i>Autograd,</i>

<i>Autograd</i>才对

that let you differentiate dynamic code and...

让你们区分动态代码...

You don't need to have an a priori

你们不需要

of your computation differentiated.

具区别的计算的先验

You can just build up a trace as you go,

只需建立一个轨迹

and then walk back the trace to compute gradients.

然后沿轨迹往回走来计算渐变

Also, if you don't stop to build a platform...

此外，如果你们不停止建立一个平台...

like this computational graph,

像这计算图像

you can iterate a lot more quickly.

就可以更快地重复

You can play with your model as you build it.

当你建立时，也可以玩你的模型

You can inspect it.

You can poke and prod at it.

戳一下它及刺它

And this can let you just be more productive

这可以让你们更高效

when you're like making all these changes.

当你想进行所有这些改变时

Also, you can run your model for debuggers and profilers

此外，也可以对调试器及分析器运行你的模型

and add all sorts of analysis tools to them, to just really understand

对它们添加各种分析工具

how they are doing what they are doing.

去真正理解他们怎样做正在做的事情

And finally, if we don't force you to represent your computation

最后，如果我们不强迫

in a separate way than the host programming language you are using,

你们以不同的方式做计算表示而继续用正在使用的

you can just use all

你们可以使用

the machinery of your host programming language to do control flow and data flow,

全部主机编程语言的机器以处理控制流和数据流

and complicated data structures,

和复杂的数据结构

which for some models is key to being able to make your model working at all.

对某些模型来说这使让模型能够运作至为关键

So, I hope you're not wondering, "How do I get to use this?"

我希望你不要想， “我该如何使用它呢？”

And the way you use this is super easy.

其实使用方式非常简单

You import TensorFlow and you call

首先你要导入TensorFlow

<i>tf.enable_eager_execution</i>

调用<i>tf.enable_eager_execution</i>

And once you do that,

这样做之后

what happens is anytime you run a TensorFlow operation,

每次你要运行TensorFlow操作

like in this case a <i>.matmul,</i>

就像在这种情况下<i>.matmul</i>

instead of TensorFlow building a graph

而不是TensorFlow稍后构建图像

that later when executed is going to run that matrix multiplication,

被执行时将会运行那个矩阵乘法

we just immediately run that matrix multiplication for you

我们会立即运行那矩阵乘法

and give you the result.

并给你们结果

And you can print it,

然后你们就可以打印结果

you can slice it, you can dice it,

也可以进行slice 也可以进行dice

you can do whatever you want with it.

可以随心所欲地做任何事情

And because things are happening immediately,

因为事情立即发生

you can have highly dynamic control flow

你们可具备高度动态的控制流

that depends on the actual values of the computation you're executing.

这取决于正在运行的计算的实际值

And here is just a simple

这只是一个我撰写的

Wolfe conditions line search example that I wrote.

有关沃尔夫条件线搜索的简单例子

And it doesn't matter, it just matters; it has like <i>while loops</i>

这没关系，这只是很重要它有点像<i>while loops</i>

that depend on complicated values

它取决于复杂的数值

that are computer-based on the computation.

这是基于计算机的计算

And this runs just fine on whatever device you have.

它在任何设备上都会运行得很好

And together with this<i> enable_eager_execution</i> thing,

并与这<i>enable_eager_execution</i>东西一起

we're also bringing you a few symbols in TensorFlow

我们也给你带来 TensorFlow的几个符号

that make it easier for you to write code that's going to work,

这使你们更容易编写可以运行的代码

both when building graphs and when we're executing eagerly.

无论是在建立图像或要急切地运行时

And we're also bringing you a new way of doing gradients,

我们也给你带来一种制造渐层的新方法

because I'm sure you're familiar now with how we do gradients

我相信你们现在很熟悉我们在正常的 TensorFlow

in normal TensorFlow.

怎样做出渐层效果

Where you just create your variable, you create your loss function,

你们刚刚在哪里创建了变量创建你们的损失功能

and I hope you can think of a better loss function than this one.

我希望你们能夠想一个比这更好的损失功能

And then you call <i>tf.gradients</i> to differentiate it.

然后你们要调用<i>tf.gradients</i> 去区分它

But when you have <i>eager execution</i>, we try to be as efficient as we possibly can

但当你们有<i>eager execution</i> 我们就尽可能地提高效率

And if you're going to... one thing to think about is

如果你们打算...... 有一点需要考虑

that if you're going to differentiate a computation,

如果你们要区分一个计算

you need to keep track in memory of information

就需要保持跟踪在记忆中的信息

about what happened so far,

迄今为止所有发生的事情

like your activations and things like that.

例如你们的激活及那样的事情

But I don't want you to pay for the cost of this tracking

当你们不是在计算渐层时

when you're not computing gradients because performance is really

我不想你们为此追踪付出代价因为表现是真的

like the whole reason why we're doing this

就像我们这样做的全部原因

is because we want to use these big, nice pieces of hardware

因为我们想用这些大件且精美的硬件

that train models super fast.

超级快地训练那些模型

So, when <i>eager execution</i> is enabled,

当<i>eager execution</i>启用时

when you want to compute gradients, and you use this little context manager

当你们想计算渐层使用这个上下文管理器

to keep a tape active, and the tape just records

保持卷带活跃而卷带可录制

all the operations you execute, so we can play it back

所有执行的操作当你们计算渐层时

when you've computed the gradients. Otherwise, the API is the same.

可以重复播放否则，API还是相同的

Also, writing training loops in <i>eager</i>,

另外，在<i>eager</i>撰写训练循环

as Derrick pointed out,

正如Derrick指出

is very easy and straightforward.

非常简单且直接

You can just use a <i>Python for loop</i>

你们只需使用<i>Python for loop</i>

to iterate over your data sets and data sets work in <i>eager</i> just fine.

重复你们数据集<i> eager</i>的数据集就很好

And they work with the same high performance you get

它们的表现与图像执行机器

in the graph execution engine.

表现出相同的高水平

Then you can just do your predictions,

那么你们可以只做预测

compute your gradients, supply your gradients

计算你们的渐层为你们的渐层供给

and do all the things you're used to doing.

并做所有习惯做的事情

But really the interesting thing about <i>eager execution</i>

但有关<i>eager execution</i>真正有趣的是

is not when you're just writing this code as finished,

在你们完成撰写这代码时

就是完成了

that we already know works,

我们已经知道那程序了

but when you're still developing, when you want to do things like debug.

但是当你还在撰写时想做类似调试的事情时

when <i>eager execution</i> is enabled, you can just take any model code--

当<i>eager execution</i>启用时可以采用任何模型代码 --

and I used my simple, silly gradient example here--

我使用我的例子这里渐层的例子--

add notes to like drop into the <i>Python debugger</i> anywhere you want.

添加一些笔记，像在你想要的任何地方放入<i>Python调试器</i>

And once you're in the <i>Python debugger</i>,

一旦放入<i>Python调试器</i>后

you have the full power of debugging available.

你们就可全力采用调试

You can print the value of any <i>tensor</i>, you can change the value of any <i>tensor</i>.

可以打印任何<i>tensor</i>值可以更改任何<i>tensor</i>值

You can run any operation you want on any <i>tensor</i>.

可以在任何<i>tensor</i>上运行任何操作

And this will hopefully empower you

这将会允许你们

to really understand what's going on in your models

真正理解模型里发生什么事情

and really be able to fix any problems you have.

并真正能够修复任何问题

You can also take <i>eager execution</i> code and profile it,

也可以采用<i>eager execution</i>代码并分析它

using whatever profiling tool you are most familiar and comfortable with.

使用任何你最喜欢且最熟悉的分析工具

So, here I have a little [inaudible] model that just does a .<i>matmul</i>

在这里我有一个小型模型刚刚完成了<i>matmul</i>

and a <i>bias_add</i>.

以及<i>bias_add</i>

And let's pretend I don't know which of these operations

假设我不知道这些操作中的哪一个

is going to be the bottleneck. Which one is lower?

将会成为瓶颈，哪一个更低呢？

And I'm sure you all know the answer that the <i>matmul</i> is a lot more expensive.

我相信你们都知道那个<i>matmul</i> 要贵得多

But here you can just run your code through your <i>Python profiler</i>

在这里你可以通过<i> Python profiler</i>运行那个代码

like you would do with any other programming job,

就像你使用其他编程一样

and find out that the <i>matmul</i> is like 15 times more expensive

并找出针对我在这里的批量<i> matmul</i>像贵了15倍

for my batch size here than my <i>bias</i> addition.

比添加了我的<i>bias</i>

并且顺便说一下

by the way those examples are run on the Google collaboratory thing,

那些运行在Google合作实验室的东西

which is this...

就是这个...

completely public-shared, GPU-capable interface

完全是公开共享支持GPU的界面

for Jupiter notebooks that are like hosted on Google Cloud.

亦可在Jupyter notebook运行就像托管在Google Cloud一样

It's pretty cool and I think we have a demo on <i>eager</i>

这真的很酷，我想我们有一个<i>eager</i>演示

that's hosted on that. And you can play out with later,

这是托管在那里的你们可以稍后再试一下

or if you're on livestream, you can play out of it now

或者如果你们使用直播

if you can find the link.

如果你们能找到链接现在就可以玩了

But together with <i>eager</i>,

但是与<i>eager</i>在一起

we're bringing you a lot of new APIs

我们带来了很多全新的 APIs

that make it easier for you to build TensorFlow graphs

这让你们更容易构建TensorFlow图像

and to execute models.

并执行各种模型

And these APIs are compatible

这些API都是

with both <i>eager execution</i> and graph building.

与<i>eager execution</i> 及图像构建兼容的

So one that's been a recurring low priority feature request

就一直是一个经常性的低优先级功能提议

is how to customize gradients in TensorFlow.

如何在TensorFlow中自定义渐层

And I'm sure you are familiar with a few of the tricks that people have,

我相信你们对其他开发人员的伎俩也很熟悉

like <i>stop gradients</i> and <i>functions</i> and things like that.

例如<i>stop gradients</i>及<i>functions</i> 或其他类似的东西

But we're introducing a new API that works in both <i>eager</i> and graph execution

但是我们正在推出一种全新的API 可于<i>eager</i>及图像执行中运行

And what I like about this example is that it's a thing that's been asked by many,

这个例子我喜欢的部份是这是很多人问的问题

many people, how to do it.

很多人，怎样去做

If I want to run my forward pass

如果我想做正推法

and then in the backward pass, take the <i>gradient</i> of a particular <i>tensor</i>

然后是逆推法用在特定<i>tensor</i>的<i>渐层</i>上

and clip it, clip it's <i>norm</i> to keep it small to prevent it from exploding.

剪辑它，这是<i>norm</i>以保持它细小以防止激增

And it just takes six lines of code

这只需要六行代码

to make a version of <i>tf.identity</i> that in the backward pass

使用逆推法制作<i>tf.identity</i>的版本

clips its gradient, and I think this is really cool.

剪取它的渐层我认为这真的很酷

And I look forward to seeing what you guys can do with this

我期待着看看你们能采用这个所做到的东西

when you're doing more than six lines of code

当你们不只是撰写六行代码

and solving all sorts of new, interesting research problems.

并解决各种全新的有趣的问题

A big, big change when programming with <i>eager</i> from <i>graph</i>

当使用<i>eager</i>而不是<i>graph</i>编程时发生了重要的变化

that I really want you to stop and think about

我真的希望你们停下来并思考一下

is that we're trying to make everything as pythonic

我们正在尝试让一切尽可能变成pythonic

and object-oriented as possible.

以及对象为主

So, variables in TensorFlow are...

TensorFlow中的变量是...

usually are a complicated thing to think about.

通常是一件复杂的事情

But when <i>eager execution</i> is enabled, it's much simpler.

但当<i>eager execution</i>启用时就变得更简单

A TensorFlow variable is just a <i>Python</i> object.

一个TensorFlow变量只是一个<i>Python</i>对象

You create one, you have it.

你创建一个就能拥有

You can write, you can change its value, you can read its value.

你可以撰写，可以改变它的值可以读取它的值

When the last reference to it goes away, you get your memory back,

当最后一个参考值消失时就能取回你的记忆了

even if it's your GPU memory.

即使放在GPU内存

So, if you want to share <i>variables</i>, you just reuse those objects.

如果你想分享<i>变量</i> 只需重用那些对象

You don't worry about <i>variable</i> scopes or any other complicated structure.

不用担心<i>变量</i>的范围或任何其他复杂的结构

And because we have this object-oriented approach to variables,

因为我们有这个对象为主的变量方法

we can look at some of the APIs in TensorFlow

我们可以看看一些 TensorFlow中的APIs

and like rethink them in a way that's a little more object-oriented

并且重新思考它们为多一点以对象为主

and easier to use.

且更易于使用

而且非常...

one that really stood out to us as needing an overhaul

真正引起我们注意的是

was the <i>metrics</i> API.

<i>metrics</i> API需要彻底检修

So, we're introducing this new <i>tfe.metrics</i> package,

因此我们向大家介绍这个全新<i>tfe.metrics</i>包

where each metric has two methods,

每个指标有两种方法

one that updates the value and one that gives you the result.

一个将会更新数值而一个给你们结果

And hopefully, this is an API that everyone is going to find familiar to use

希望所有开发人员都可以熟悉使用这个API

and please don't try to compare this with the other metrics API.

但请不要试图把这个与其他指标API进行比较

We're also giving you a way to do object-oriented saving

我们也给你一个方法保存对象为主的

of TensorFlow models.

TensorFlow模型

If you've tried looking at TensorFlow checkpoints now,

如果现在你们看看 TensorFlow 检查点

you know that they depend on variable names.

这些你们知道是依赖变量名称的

And variable names depend not just on the name you gave to a variable,

变量名称不只是依赖你们给变量的名称上

but on all other variables which are present in your graph.

还有所有在图像中的变量

This can make it a little hard for you to save and load subsets of your model

这可能对保存及加载模型的子集有点难

and really control what's in your checkpoint.

并真正控制检查点里的东西

So we're introducing a completely object-oriented

因此我们介绍了一个完全对象为主的

<i>Python</i> object-based saving API,

<i>Python</i>对象为主保存API

在那里你们...

it's like <i>Python pickle</i>, like any variable that's reachable

就像是<i>Python pickle</i> 就像任何的变量一样

from your model gets saved and your model gets saved.

可从被保存的模型中获得并且你的模型亦被保存

You can save any subset of your model.

你们可以保存模型的任何子集

You can load any subset of your model.

可以加载模型的任何子集

You can even use this <i>tfe.checkpoint</i> object to build things you want to save

甚至可以使用这个<i>tfe.checkpoint</i>对象建立你们想要保存的东西

that have more than a model.

这不仅是一个模型

And here we have an optimizer and a <i>global_step</i>

在这里我们有一个优化器及一个 <i>global_step</i>

but really you can put whatever you want in there.

但是你们真的可以放任何东西在那里

And the idea is that this object graph that eventually goes down to variables

这个想法就是这个对象图最终变为变量

is something you can save and load. So you can have your [GAN]

就是你们可以保存和加载的东西使你们可以拥有[GAN]

and save and load your discriminators and your generators

保存并加载你的鉴别器

separate from each other.

而与发生器彼此分开

Then you can take your discriminator and load it backup

然后你们可以拿走鉴别器并加载备份

as like another newer network that you can use in another part of a model.

就像另一个更新的网络一样你们可以在模型的另一部分中使用

And this should give you a lot more control to get a lot more out

这应该给你们更多控制并得到更多

of TensorFlow checkpointing.

TensorFlow 检查点

But the real question that everybody asks me when I tell them

当我告诉其他开发人员我正在<i>eager execution</i>下功夫

that I work on <i>eager execution</i> is, Is it fast?

所有人都会问我它的速度快吗？

Because graphs...

因为图像...

have this high performance promise.

具有这个高性能的承诺

So, how fast can it make this thing that runs <i>Python</i> code all the time?

它能以多快的速度每时每刻运行<i>Python</i>代码?

And the answer is that we can make it fast enough.

答案是我们使它足够快

For models that are highly computationally intensive,

对于计算密集型模型

you pretty much don't see any <i>Python</i> overhead,

你们几乎看不到任何使用<i>Python</i> 额外付出的时间

and we're as fast as graph TensorFlow.

我们跟TensorFlow图像一样快

sometimes slightly faster, in reasons that I don't fully understand,

有时稍微快一点由于我无法理解的原因

even for highly dynamic models,

即使对于高度动态的模型

you have comparative performance with anything else you can find.

与任何能夠找到的东西比较其表现不会更差

And please don't get attached to these numbers.

请不要附加这些数字

We have many more benchmarks in our codebase.

在我们的代码库中有更多的基准

And we're optimizing <i>eager</i> performance very aggressively,

我们正在非常积极地优化<i>eager</i>的表现

but I hope that the message you'll get out of this is that if your model

我希望你们得到的信息是

can keep a GPU busy,

如果你们的模型使GPU保持繁忙

if you're doing large convolusions, large matrix multiplications,

如果你们正在做大规模的卷积大型矩阵乘法

there is almost no cost in experimenting and doing your research and model building

使用 <i>eager execution</i> 做实验做研究和模型建设

with <i>eager execution</i> turned on.

几乎没有成本

But when you're doing smaller things,

但是当你们做更小的东西时

there are some overheads and I want to go over them.

就需付出额外的时间这个我想再复审

But again don't get attached to them because we're being very aggressive

再说一次不要理会它们

about optimizing this.

因为我们非常积极地进行优化

If you just run a <i>no op</i> in TensorFlow,

如果你只是在TensorFlow中运行<i>no op</i>

like an identity,

像identity一样

it takes almost a microsecond to execute it.

它只需几微秒去执行

If you run that with <i>eager execution</i> turned on,

如果你们使用 <i>eager execution</i>打开它

there's an extra microsecond of overhead.

就只需额外的几微秒

If you're tracing gradients,

如果你们正在追踪渐层

there are another 3 microseconds of overhead that you get.

But if you're just enqueuing something on the GPU stream,

如果只是GPU 流排队

that alone takes like single-digit microsecond.

就只需一位数字的微秒

So, if you can execute enough computation to keep a GPU busy,

如果你们能够执行足够多的计算以保持GPU繁忙

you're unlikely to see anything bad from using <i>eager execution</i>,

就不会看到任何使用<i>eager execution</i>的坏处

and again these numbers are improving very quickly.

再说一次这些数字正在迅速改善

Please don't get too attached to them.

不要太依靠它

But there is this large ecosystem of TensorFlow code libraries,

有一个有关TensorFlow的代码库

models, frameworks, checkpoints

模型，框架，检查点的大型生态系统

that I don't think anyone wants to give up.

我不想任何人放弃

And I don't want you to give up if you want to use<i> eager execution</i>.

如果你们想使用<i> eager execution</i> 我不想你们放弃

So, we're also thinking really hard

我们亦认真地想

about how you can interoperate between <i>eager</i> and <i>graph</i>.

你们怎样在<i>eager</i>和<i> graph</i>之间进行互相操作

One way is to like call into <i>graphs</i> from <i>eager</i> code.

一种方法是从<i>eager</i>代码调用<i>graphs</i>

And you can do that with <i>tfe.make_template</i>

你们可以用<i>tfe.make_template</i> 来做到这一点

which has this create graph <i>function</i> argument

这创建了图像<i>函数</i>参数

when you pass through to it with build a graph,

当你们通过它来建立一个图像

for that little <i>Python function</i> that you wrote.

为那个你们撰写的小型<i>Python function</i>

And then you can use it an manipulate and call the graph from <i>eager execution</i>.

然后你们可以使用它作manipulate 并从<i>eager execution</i>调用图像

We also have the reverse,

我们也可作相反的操作

which is how to call into <i>eager</i> from a graph.

从图像调用<i>eager</i>

Let's say you have a big graph that you understand everything in it,

假设有一张大图你们已经了解它的一切

but there's a little chunk of your computation

但计算中的一小块

that you really don't know how to express.

你真的不知道如何表达

And either you don't know, or you don't want to bother expressing it,

或者你真的不知道

in using like TensorFlow graphs.

或者你不想使用像TensorFlow图表表示

So you can wrap it in a <i>tfe.py_func</i>

那么你们可以把它包在<i>tfe.py_func</i>

and what you get in there when the <i>Python function</i> is executing

在那里你们得到的是当<i>Python function</i>执行时

are <i>eager tensors</i>, that you can run any TensorFlow op in,

就是<i>eager tensors</i> 你们可以运行任何TensorFlow操作

including convolutions and other things that are not available in <i>my_py</i>.

包括卷积以及其他在<i>my_py</i> 不可用的东西

But you can also look at the values

你们也可以看看其他数值

and inspect and use dynamic control flow in there.

并检查和使用那里的动态控制流

So, I hope with these two things together,

我希望这两件东西

you can really reuse <i>eager</i> and <i>graph</i> code across.

使你们真的重用<i>eager</i> 及<i>graph</i>代码

But really the easiest way to get <i>eager</i> and <i>graph</i> compatibility

使<i>eager</i>及<i>graph</i>变得兼容的最简单方法是

is to just write model code that's going to work in both ways.

撰写一些模型代码在两种方式中运行也行

And if you think about it,

如果你考虑一下

once your model is fully written, debugged and [tested],

一旦你们的模型完成撰写调试和测试

there's not much there that tells you whether you need to build a graph

就未能告诉你们是否需要构建图像

or to execute <i>eagerly</i>.

或执行<i>eagerly</i>

So write, iterate, debug in <i>eager</i>

编写，重复和调试<i>eager</i>

and then import that same code into a graph,

然后导入相同的代码到图像

put it in <i>Estimator,</i> deploy it on a TPU pod,

把它放在<i>Estimator</i> 将其部署在TPU pod

deploy it on a GPU,

将其部署在GPU

distribute it and do whatever you want.

分发它并做任何你想做的事情

And like this is what we've done in our example models

这就是我们在示例模型中要做的事

and there's going to be a link in the end of the presentation,

在演讲结束时有一条链接

so you don't need to like worry about writing this down.

所以你们不需要担心不需要写下来

So, here is some practical advice for you.

这里有一些实用的建议

Write code that's going to work well

编写一些在执行<i>eagerly</i> 及建立图像时

when executing <i>eagerly</i> and when building graphs.

能够很好地运作的代码

And to do that, use the <i>Keras layers.</i> They're great.

要做到这一点，可使用<i>Keras layers</i> 它们真的很棒

They're object-oriented; they're pythonic.

它们以对象为主且是pythonic的

They're easy to understand, manipulate and play around with.

它们易于理解，操纵和玩弄

Use the <i>Keras model</i> to stitch those layers together,

使用<i>Keras model</i> 将这些层面缝在一起

that will guide you in saving and loading and training and all sorts of things

这将指导你们自动保存加载训练以各种各样的事情

automatically if you want, but you're not forced to use those.

只要你们愿意的话但是你们不会被迫使用

Use <i>tf.contrib.summary</i> instead of <i>tf.summary</i>.

使用 <i>tf.contrib.summary</i> 而不是 <i>tf.summary</i>

They will move to the tensor board open source package very soon.

它们很快将会移到Tensor board 开源软件包

So, if you're watching this on video,

如果你们正在观看视频

it probably already happened.

或者它已经移走了

Use the <i>tfe.metrics</i> instead of the <i>tf.metrics</i>,

使用<i>tfe.metrics</i> 而不是<i>tf.metrics</i>

because these are object-oriented, friendlier to use,

因为这些都对象为主且易于使用

and friendlier in <i>eager</i>.

更易于在<i>eager</i>使用

And use the object-based saving,

并使用对象为主的保存

which is a much nicer user experience anyway.

无论如何更好的用户体验

So, I hope you're going to want to do this all the time.

所以我希望你们会想一直这样

If you do all of this,

如果你们这样做

it's highly likely your code is going to work super well

这很可能你们的代码

in both <i>eager execution</i> and graph building.

在<i>eager execution</i>及图像构建方面将会超级棒

So now, I'd like to take some time

现在我想花一些时间

to tell you why you should enable <i>eager execution</i>.

告诉你们应该启用<i> eager execution</i>的原因

You know like a real good...

你们知道就像很好的...

important reason for us that led us to build this in the first place

重要原因促使我们当初建立这个

is that if you're new to machine learning,

如果你们是机器学习的新手

or you're new to TensorFlow and you want to learn,

或者是TensorFlow的新手但是你们想学习

being able to play with these objects and manipulate them directly

能够使用这些对象并直接操作它们

is just a much nicer experience than having to build a graph

比建立一个图像并在稍后的对话中进行交互

and interact with later in a session.

是一个更好的经验

It's a lot more intuitive,

这是更直观的

lets you understand what's going on much better.

让你们明白发生什么事情好得多

So I've shown you, just by all means go straight into your execution,

我已经向你们展示了一切且直接进入执行的地方

play around with it

and figure out how to get graphs later.

并找出如何在稍后获得图像

Also, if you're a researcher and you're quickly iterating over models.

如果你是一位研究人员正在很快地重复这些模型

You're changing their internal properties and...

正在修改它们的内部属性...

you're comparing them and you're trying to do models that are non trivial

比较它们正在试做一些很棒的模型

that we in the TensorFlow team were not thinking about

而我们TensorFlow团队

when we designed TensorFlow.

在设计TensorFlow时未曾想到的

<i>Eager execution</i> will make it much easier for you to understand what's going on,

<i>Eager execution</i>使你们更容易了解正在发生的事

to debug what's going on,

调试正在发生的事

to be productive in advance.

事先提高生产力

So, if you're a researcher this is for you.

如果你是一位研究员这就是给你们的东西

Also, if your model's not working and you want to understand why,

此外如果你们的模型未能运作你想了解箇中原因

being able to enable <i>eager execution</i> and then [start through] it in a debugger,

能够启用<i>eager execution</i> 然后在调试器中开始

change some values, play around with it.

修改一些数值，运行它

Understand that is priceless, and that has saved me a lot of time.

就会明白这是无价的这为我节省了很多时间

Similarly, if you want to profile a model using like the full power

同样，如果你想剖析一个模型使用任何你喜欢的工具

of whatever tool you like to use to profile <i>Python</i>,

来剖析<i>Python</i>

<i>eager execution</i> is your friend.

<i>eager execution</i>就是你的朋友

Also, there are some models like recursive RNN's

此外，还有一些模型例如recursive RNN

that are just much easier to express

在静态数据流图像中

if you don't need to put your entire computation

如果你不需要整个计算

in a static data flow graph.

这个更容易表示

If you're working on one of those models,

如果你正在研究其中一种模型

<i>eager execution</i> is also a choice for you.

<i>eager execution</i>亦是其中一个选择

But really the reason I think you should enable this

我认为你们应该启用这个的真正原因是

is that it's fun.

这真的很有趣

It's a very nice and intuitive way of interacting with TensorFlow,

与TensorFlow交互是一个非常好的直观方式

and I hope you're going to have a lot of fun experimenting with it.

我希望你们乐在其中

So now, I would like to point to a few things.

现在我想指出一些事情

Some of my colleagues, sitting over there now,

现在我的一些同事坐在那里

they're going to be in the demo room during the break

在休息期间他们将会到演示室

with laptops, with [collabs]

带上笔记本电脑

that are like Jupiter notebooks

就像jupyter notebooks

to let you type and try<i> eager</i> mode there.

让你们键入并尝试<i>eager</i>模型

Please go give it a try.

请去试玩一下

Or if you're watching this on the livestream,

如果你正在看直播

type that short link--

键入那条短链接 -

hopefully it will stay on the screen long enough for you to type it--

希望它会留在屏幕上足够长的时间让你们输入

and play with it right now.

立即使用它

It's really nice.

这真的很棒

We have a <i>Getting Started Guide</i> on TensorFlow

我们有一个TensorFlow<i> 入门指南</i>

that should be live now.

那应该现在上线了

<i>programmers_guide/eager</i>

<i>programmers_guide/eager</i>

that tells you what you need to know about <i>eager execution</i>

告诉你们有关<i>eager execution</i> 你们需要知道的事

and what you need to know about starting to use TensorFlow

有关开始使用TensorFlow 你们需要知道的事

using <i>eager execution</i>.

以及<i>eager execution</i>的使用

We also have a ton of example models,

我们也有很多示例模型

like from RNNs to [inaudible] to all sorts of things,

从RNNs到各种各样的东西

that are available behind that link.

就在那个链接后面

And I encourage you to look at them and see

我鼓励你们看看

how it's easy to write the model

怎样轻松地编写模型

and how easy it is to also reuse the same code from graphs

以及从图像中重复使用相同的代码

for deployment.

进行部署是多么容易

We have deployment for graphs for all models

我们有所有模型的图像部署

except for the highly dynamic ones

除了高度动态的模型

that are just really hard to write in a graph form.

这以图像形式撰写真的很难

And give it a try.

If you give it a try,

如果你们试试看

let us know how it went.

让我们知道它怎么样

We're super excited to share this with you.

我们非常兴奋能夠与你们分享

I hope you're going to have a great time playing with this.

并希望你们玩得很愉快

♪ (music) ♪

♪ (音乐) ♪

Similar videos:

TensorFlow Hub (TensorFlow Dev Summit 2018)
TensorFlow
15.7K views 237 likes 0 dislikes 30 Mar 201852% match

Swift for TensorFlow - TFiwS (TensorFlow Dev Summit 2018)
TensorFlow
31.9K views 501 likes 5 dislikes 30 Mar 201849% match

Machine Learning in JavaScript (TensorFlow Dev Summit 2018)
TensorFlow
103.2K views 2.7K likes 35 dislikes 30 Mar 201848% match

Keynote (TensorFlow Dev Summit 2018)
TensorFlow
41.4K views 457 likes 13 dislikes 30 Mar 201846% match

tf.data: Fast, flexible, and easy-to-use input pipelines (TensorFlow Dev Summit 2018)
TensorFlow
45.5K views 505 likes 12 dislikes 30 Mar 201846% match

TensorFlow Extended (TFX) (TensorFlow Dev Summit 2018)
TensorFlow
11.7K views 98 likes 0 dislikes 30 Mar 201845% match

Training Performance: A user’s guide to converge faster (TensorFlow Dev Summit 2018)
TensorFlow
14.9K views 201 likes 3 dislikes 30 Mar 201843% match

Applied AI at The Coca-Cola Company (TensorFlow Dev Summit 2018)
TensorFlow
13.8K views 205 likes 6 dislikes 30 Mar 201843% match

TensorFlow Lite (TensorFlow Dev Summit 2018)
TensorFlow
9.4K views 118 likes 1 dislikes 30 Mar 201841% match

Real-World Robot Learning (TensorFlow Dev Summit 2018)
TensorFlow
12.7K views 259 likes 3 dislikes 30 Mar 201841% match

TensorFlow Dev Summit 2018 - Livestream
TensorFlow
42.6K views 619 likes 5 dislikes 30 Mar 201839% match

TensorFlow Dev Summit 2019 Livestream
TensorFlow
40.9K views 612 likes 8 dislikes 06 Mar 201937% match

Introducing TensorFlow 2.0 and its high-level APIs (TF Dev Summit '19)
TensorFlow
305.4K views 4.4K likes 0 dislikes 06 Mar 201935% match

TensorFlow Dev Summit 2019 Keynote
TensorFlow
48.7K views 749 likes 37 dislikes 06 Mar 201934% match

TensorFlow Lite (TF Dev Summit ‘19)
TensorFlow
22.9K views 320 likes 2 dislikes 06 Mar 201933% match

TensorFlow Dev Summit 2019 Highlights #MachineLearning
TensorFlow
42.7K views 283 likes 10 dislikes 11 Mar 201932% match

Reinforcement Learning in TensorFlow with TF-Agents (TF Dev Summit '19)
TensorFlow
32.3K views 559 likes 20 dislikes 06 Mar 201932% match

Debugging TensorFlow with TensorBoard plugins (TensorFlow Dev Summit 2018)
TensorFlow
17.3K views 272 likes 8 dislikes 30 Mar 201832% match

TensorFlow Federated (TFF): Machine Learning on Decentralized Data (TF Dev Summit ‘19)
TensorFlow
16.6K views 274 likes 3 dislikes 07 Mar 201929% match

TensorFlow Dev Summit 2020 Livestream
TensorFlow
41.3K views 1K likes 15 dislikes 11 Mar 202029% match

Upgrade your existing code for TensorFlow 2.0 (Coding TensorFlow)
TensorFlow
46.4K views 627 likes 26 dislikes 26 Feb 201928% match

TensorFlow Dev Summit 2020 Keynote
TensorFlow
31.8K views 398 likes 7 dislikes 11 Mar 202028% match

TensorFlow Datasets (TF Dev Summit '19)
TensorFlow
19.3K views 292 likes 4 dislikes 06 Mar 201928% match

tf.function and Autograph (TF Dev Summit ‘19)
TensorFlow
22.1K views 352 likes 9 dislikes 06 Mar 201928% match

What's new in TensorBoard (TF Dev Summit '19)
TensorFlow
23.4K views 485 likes 3 dislikes 06 Mar 201927% match

TensorFlow Probability: Learning with confidence (TF Dev Summit '19)
TensorFlow
38.1K views 891 likes 8 dislikes 06 Mar 201924% match

Swift for TensorFlow: The Next-Generation Machine Learning Framework (TF Dev Summit '19)
TensorFlow
30.9K views 516 likes 7 dislikes 06 Mar 201924% match

Join us at TensorFlow Everywhere
TensorFlow
1.9K views 36 likes 1 dislikes 10 Feb 202124% match

Saving and Loading Models (Coding TensorFlow)
TensorFlow
60.7K views 971 likes 77 dislikes 25 Oct 201822% match

TensorFlow: an ML platform for solving impactful and challenging problems
TensorFlow
80.9K views 1.9K likes 20 dislikes 30 Mar 201822% match

Settings Privacy About Contact Donate