Placeholder Image

Subtitles section Play video

  • [MUSIC PLAYING]

  • JOSH GORDAN: OK, so we have a bunch of cool topics,

  • and we'll definitely hit the Getting Started

  • resources in a moment, but because we

  • talk about mnist a lot, and very basic problems

  • in computer vision a lot, I wanted to actually start

  • the talk by sharing a couple of my favorite recent examples,

  • all of which have complete code in TensorFlow 2.0.

  • So even if you're new to TensorFlow,

  • and these concepts can take a long time to learn--

  • like to talk about neural machine translation,

  • you would need to take a class--

  • you can still try the code.

  • And most of them are 50 lines or less.

  • And they run very quickly.

  • So anyway, they're great.

  • Anyway, TensorFlow 2.0 is currently in alpha.

  • It is all about ease of use, which is the number one

  • thing I care about.

  • And it's ease of use at all levels.

  • So both for novices that are totally starting out,

  • as well as PhD students that want

  • to be able to do their research in a slightly easier way.

  • I'm not going to spend too much time on this slide.

  • I just wanted to call out the most important thing

  • about TensorFlow is the user and the contributor community.

  • And as of now we've had over 1,800 people

  • contribute code to the code base,

  • which is huge if you think about how many seats that would

  • fill up here.

  • So thank you very much to everyone who has contributed,

  • and the many more who have done docs

  • and have done teaching and meetups and stuff like that.

  • So it's super cool.

  • Anyway, the alpha of TensorFlow 2 is available today.

  • Also going to fly through this slide.

  • And what you should know is, every single example linked

  • from the following slides will automatically

  • install the correct version of TensorFlow at the very top.

  • And they'll all run in Colaboratory, which is the best

  • thing since the microwave.

  • And if you run it in Colab, there's

  • nothing to install on your local machine.

  • So if you want to try out the latest version of TensorFlow

  • 2.0, you literally can follow these links

  • and with a single click you'll be in Colab

  • and you're good to go.

  • So before we get into Hello World,

  • I wanted to very quickly talk about things like Deep Dream.

  • So what deep learning is, is really representation learning.

  • And we don't have as much time as I'd

  • like to go into that in great detail.

  • But there's been a couple pieces of really amazing work

  • in the last few years.

  • And on the left we're seeing a psychedelic image generated

  • by a program called Deep Dream.

  • And what's really interesting, I just

  • wanted to say that the goal of Deep Dream

  • was not to generate psychedelic images.

  • It was to investigate how convolutional neural networks

  • are so effective at classifying images.

  • And it was discovered that every neuron in every layer of a CNN

  • learns to detect different features when you train it

  • on a large corpus of training data.

  • And you can use TensorFlow to write a loss function

  • to try and maximally excite one of those neurons.

  • So anyway, the TLDR is, the fact that we can take an image

  • and supersaturate it with dogs is

  • possible as an artifact of training a CNN

  • on a large database of images.

  • Anyway, there's a notebook there where you can try it out.

  • It runs very quickly in Colab.

  • And like less than 50 lines of code.

  • It's surprisingly short.

  • Once you know the idea, the implementation in TensorFlow 2

  • is super easy.

  • On the right is an example called

  • Style Transfer, which I'm going to fly through.

  • But it comes from exactly the same idea.

  • It's given that we've trained an image classifier

  • on a very large amount of data.

  • What else can we do with it?

  • And it exploits very similar ideas, Deep Dream.

  • Another really, really cool example

  • that I wanted to share with you is for something

  • called neural machine translation.

  • And this is like 50 lines of code,

  • give or take, that out of the box

  • will train you an English to Spanish translator.

  • And the only input you need to provide-- this

  • is totally open source.

  • We're not hitting the Google Translate API.

  • The reason I like this example, it's

  • all the code you need to implement a mini version

  • of Google Translate.

  • The simplest possible Hello World version

  • of Google Translate can be done in 50 lines.

  • And the one thing I wanted to mention very briefly

  • is I'm a little bit envious of people that

  • are bilingual and trilingual.

  • I have English and barely high school Spanish.

  • And so translation has always interested in me.

  • And the way that the translation example works,

  • it uses something called a sequence to sequence model.

  • Briefly, what that does is it takes a sentence in English

  • or the source language, and it maps it down

  • to a vector, which you can actually see and print out

  • in the code and explore.

  • And that vector is just an array of numbers.

  • That's called an encoder.

  • There's a second neural network--

  • it's two natural networks working parallel--

  • there's a second network called a decoder.

  • The only input to the decoder is that vector,

  • and the decoder produces a sentence

  • in the target language.

  • And what this means is that the encoder takes a sentence

  • and it compresses it.

  • So before, we saw that deep learning can

  • be seen as representation learning

  • because as an artifact of training

  • a network on a large corpus of images

  • to train an image classifier, we find neurons

  • that learn to recognize different shapes and objects

  • and textures.

  • And here we can think about deep learning

  • as compression, because we can take a sentence which

  • contains a huge amount of information and map it down

  • to a short list of numbers.

  • And the reason I wanted to mention this trilingual aspect

  • is you can actually come up with something called

  • an interlingual representation, just by modifying this example.

  • Say we wanted to translate from English to Spanish and also

  • from French to Spanish.

  • Just by modifying this code to include

  • a small number of French to Spanish sentences in the input

  • data that you provide, that vector

  • that comes out of the encoder will encode a sentence

  • either in English or in French into the same representation.

  • And what that means is, you're finding a way

  • to represent concepts independently of language.

  • And I know this is a little bit out of scope

  • for Hello TensorFlow World, which we'll get to in a sec.

  • But the reason I want to mention things like this

  • is there's incredible opportunities

  • at the intersection of deep learning and other fields.

  • So for example, if you were a linguist,

  • perhaps you're not super interested

  • in the details of the TensorFlow implementation,

  • but what you could do is look at this interlingual

  • representation that we get almost for free,

  • and investigate it.

  • And right there, that would be a killer PhD paper or thesis

  • or something like that.

  • And so when we put these fields together,

  • we get super, super cool things.

  • I'm taking way too long.

  • I'm going to skip this entirely.

  • I just wanted to mention we can also take an image

  • and using the same encoder decoder architecture,

  • map the image into a vector and reusing the decoder, which

  • maps from vectors to sentences that we have in the translation

  • tutorial, almost copying and pasting it,

  • we can learn to caption an image.

  • And this tutorial has a little bit more code,

  • but it's the same idea.

  • It's absolutely mind-blowing.

  • So there's a lot of value in learning about deep learning,

  • and it has a lot of potential impact.

  • Also we have two really excellent resources

  • for total beginners.

  • The first is linear regression, finding the best fit

  • line, which is probably the most boring thing ever,

  • but it's a perfect way to learn about gradient descent

  • and even back propagation if you wanted to.

  • And what's awesome is the gradient descent

  • and back propagation concepts that you learn about

  • in linear regression are exactly the same concepts

  • that apply to every other model you see in TensorFlow.

  • And then, as always, we have a great collection of Hello World

  • examples on the website.

  • And we just launched a Udacity course and a Coursera course

  • that will go into the Hello World

  • examples in much more depth than we have time for here.

  • So Paige-- who I've learned a lot from, by the way--

  • is going to tell us about the differences between TensorFlow

  • 1 and TensorFlow 2.

  • PAIGE BAILEY: Absolutely.

  • Thank you, Josh.

  • So--

  • [APPLAUSE]

  • Excellent.

  • So who here tried to use TensorFlow around 2015, 2016?

  • Show of hands.

  • So a few of you.

  • And if you tried using it then, you probably

  • saw something very similar to what you see on the screen

  • there.

  • And if you're coming from the scikit learn world,

  • this doesn't feel very Pythonic at all, right?

  • So you're defining some variables.

  • You're assigning some values to them,

  • but you can't immediately use them.

  • You have to initialize those variables.

  • You have to start these weird things called queue runners,

  • and you have to do it all from this sess.run statement.

  • So creating sessions, defining variables,

  • but not being able to use them immediately,

  • this wasn't straightforward.

  • And the user experience, we found,

  • with the original version of TensorFlow

  • left a lot to be desired.

  • So we've learned a lot since TensorFlow 2.0,

  • or since TensorFlow 1.0, I should say.

  • We've learned that there's a lot to be gained through usability.

  • So we've adopted Keras as the default higher-level API.

  • We've decided to pursue eager execution by default.

  • And this means that you can do crazy things,

  • like add two numbers together and immediately get a response.

  • We've also made a big push towards clarity

  • by removing duplicate functionality,

  • by making consistent intuitive syntax across all of our APIs.

  • So instead of having thousands of endpoints, some of which

  • do very similar things, and none of which

  • have standardized conventions, now everything

  • feels a little bit more consistent.

  • And instead of having a large series of tf.foo,

  • we now have things like tf.signal.foo or tf.math.foo.

  • We've also decided to improve the compatibility

  • throughout the entire TensorFlow ecosystem.

  • So instead of having multiple ways to save models,

  • we've standardized on something called saved model.

  • And I think we'll see an architecture slide later

  • in the presentation speaking to that.

  • We've also made a huge push towards flexibility.

  • We have a full lower-level API, so if you

  • like using the lower level ops you're

  • still having that capability we've made everything

  • accessible in tf.rawops.

  • And we've had inheritable interfaces added for variables,

  • check points, layers, and more.

  • So if you like staying at a high level, we support that.

  • If you want to go a little bit lower,

  • you can do subclassing with Keras,

  • and if you want to go even lower,

  • you have access to the full capabilities

  • with TensorFlow Raw Ops.

  • This is all with one API.

  • And I think to talk a little bit more about it,

  • Josh is going to mention how much we love Keras,

  • and love its subclassing capabilities.

  • JOSH GORDAN: Which is completely true.

  • Thank you so much.

  • OK, so I know I'm talking fast, but we have a lot of content

  • to cover.

  • Basically one of the huge changes of TensorFlow-- well,

  • we did this technically in TensorFlow 1.x,

  • but this is the standard for 2.0.

  • So we've standardized on the Keras API,

  • and we've extended it.

  • Briefly, because we might not get to the slide,

  • if you go to keras.io, that is the reference implementation

  • for an open source deep learning API spec.

  • Keras is basically an API without an implementation.

  • It's a set of layers that describes

  • a very clear way to implement your neural networks.

  • But traditionally, Keras runs on top of other frameworks.

  • So if you do PIP install Keras, you get Keras with TensorFlow

  • behind the scenes, and you never see TensorFlow.

  • And this is a perfectly fine way to get

  • started with machine learning.

  • In fact, you can do like 90% of what

  • you need to do just with that.

  • It's phenomenally good.

  • In TensorFlow, if you do PIP install TensorFlow,

  • you get the complete Keras API and some additional stuff

  • that we've added.

  • There's no need to install Keras separately.

  • Briefly, I just want to show you two APIs.

  • And it says for beginners and experts,

  • but you can do 95% of ML, including

  • some of the cool examples I showed you,

  • with the beginner's API.

  • The beginner's API, this is called Sequential.

  • And we're defining a neural network as a stack of layers.

  • And I know people that I've worked

  • with deep learning before have almost certainly seen this.

  • There's a couple important points.

  • You might not realize it, but what

  • you're doing here when you're defining a sequential model

  • is you're defining a data structure.

  • Because your model is a stack of layers.

  • Keras or TensorFlow, depending on which way

  • you're running this, can look at your layers

  • and make sure they're compatible.

  • So it can help you debug.

  • And what this means is if you define a model this way,

  • you're not likely to have errors in the model definition itself.

  • Your errors are going to be conceptual errors.

  • They're not going to be programming errors

  • when you define your model.

  • And that's very valuable.

  • Here's how that looked in TensorFlow 1,

  • and here's how that looked in TensorFlow 2.

  • Or here's how that looks now.

  • So this hasn't changed at all.

  • And if you're familiar with it, great.

  • We've added a second style, and this

  • is called model subclassing.

  • And I love this, but it's very different.

  • So this basically feels like object oriented

  • NumPy development.

  • So many libraries do something similar to this.

  • The idea came from Chainer a few years back.

  • And what we're doing is we're extending a class provided

  • by the library.

  • Here we call it model.

  • In the constructor-- so if you're coming from Java,

  • this will be great-- in the constructor

  • we define our layers.

  • And in the call method we define the forward pass of our model.

  • And what's nice is the call method is, in TensorFlow 2,

  • this is just regular imperative Python,

  • exactly how you would always write it,

  • and it works the way you'd expect.

  • This makes it super easy to debug,

  • and my friend Sarah, she works on custom activation functions.

  • If Sarah wants to quickly try her activation function,

  • you can write it as you would expect.

  • And this is a huge difference from TensorFlow 1.

  • This is phenomenal.

  • For people reading at home, you can

  • look at the slide and the article link

  • from that to learn a lot more about that.

  • Anyway, both types of models, if you're familiar with Keras,

  • can be trained using model.fit, as you always would.

  • Or if you would like, you can use

  • what we call the gradient tape.

  • And so this is a perfect way, if you're doing research

  • or if you're a student and you want

  • to learn about back prop and gradient descent,

  • if you'd like to know what the gradients of your loss function

  • are with respect to the weights, you can simply print them out.

  • If you print out grads there, you

  • will just get a list of showing all the gradients, which

  • makes them extremely easy to modify and log and debug.

  • It's great.

  • So this style of code gives you complete flexibility,

  • which is awesome.

  • But you're much more likely to have programming errors.

  • So basically, if you do model.fit,

  • it works out of the box, it's fast, It's performing,

  • you don't have to think about it.

  • You can focus on the problems that you care about.

  • If you wanted to research and write from scratch,

  • you can, but there's a cost.

  • The other cost that I wanted to mention

  • is actually tech debt, which is not something

  • you might think of off the bat.

  • So deep learning aside, if you implement your model

  • using the sequential API, I can look

  • at any code written that way.

  • For instance, if I'm helping a student debug, and immediately

  • see what the bug is because there's

  • a standard, conventional way to write it.

  • If I have students that write code this way

  • and they come to me with a problem,

  • it can take me 15 minutes to find it.

  • And if you think about what happens

  • to code that you write in a company,

  • if you have deep learning code that

  • lives for five years worked on by 50 engineers,

  • there's a huge cost to this style.

  • And so I know this is obvious, but basically software

  • engineering best practices apply to deep learning too.

  • So we have the style, but use it when you need it.

  • More details on Keras versus TensorFlow.

  • Briefly, another really awesome thing

  • about Keras API in TensorFlow is distributed training.

  • So most of the work that I care about happens on one machine.

  • Like, what I'm personally excited by

  • is like a really clear implementation of GaN.

  • A friend of mine is working on cycle GaN.

  • We'll have a tutorial available soon.

  • But for people training large-scale models

  • in production, we've greatly simplified distributed

  • training in TensorFlow too.

  • So here's a Keras model, and these are the lines of code

  • that you need to run that model using data parallelism on one

  • machine with many GPUs.

  • And that's it.

  • So assuming you have a performing input pipeline,

  • which, to be honest, takes time to write

  • and is an engineering discipline,

  • but once you have that done, distributing your model

  • is very easy.

  • And we're working on additional distribution strategies

  • for different machine and network configurations

  • just to encapsulate this logic so you

  • can train your models quickly and focus on the problems

  • that you care about.

  • Another thing that's really special about TensorFlow

  • is I want to call out the documentation.

  • So if you visit tensorflow.org, this

  • is just a screenshot of one of our tutorials.

  • You'll see most of the editorials

  • have these buttons at the top.

  • One is view on GitHub, which will give you the Jupyter

  • notebook.

  • The other is run in Colab.

  • And all of the tutorials for the alpha version of TensorFlow 2

  • run end to end out of the box with no code changes.

  • And this is important because it means they're easy to use

  • and they're reproducible.

  • So what they do is they install the right version

  • of TensorFlow.

  • They download any data sets you need.

  • So in this GaN example, they'll download--

  • I actually forget the name of the university.

  • The paper, I believe, is from Berkeley,

  • but I'm not sure that's where the data set is hosted.

  • Anyway, we thank them in the tutorial.

  • They'll download the data set.

  • They'll train a model.

  • They'll display the results that you see,

  • and from there you have a great starting point that you

  • can modify and hack on.

  • OK.

  • And now Paige will tell you more about TensorFlow 2.

  • PAIGE BAILEY: Excellent.

  • Thanks, Josh.

  • So as we mentioned before, we've tried

  • to standardize and to provide compatibility

  • throughout the entire TensorFlow ecosystem.

  • If you were here a little bit earlier,

  • you saw a really cool demo from the TensorFlow Lite team,

  • where you had object segmentation

  • and you were able to have a human being dance

  • and immediately have their body shape sort of transposed

  • and make it look like I could dance,

  • even though that's usually not so much the case.

  • The way that this is standardized

  • is through something called saved model.

  • So with historic TensorFlow, so TensorFlow 1.x,

  • there were a variety of ways to save your models.

  • And it made it very, very difficult to port it

  • to different locations where you might want to use them.

  • So for example, mobile or embedded devices or servers.

  • Now, as part of the standardization with TensorFlow

  • 2.0, you can take your saved model

  • and deploy it to TensorFlow Serving, TensorFlow

  • Lite for mobile and [INAUDIBLE] embedded devices, TensorFlow JS

  • for deep learning in the browser or on a server,

  • and then also for other language bindings.

  • We offer support for Rust, for Java, for Scala, and many more.

  • So as I mentioned, you can use TensorFlow on servers,

  • for edge devices and browsers.

  • We have an entire training workflow pipeline,

  • including data ingestion and transformation with TF data

  • and feature columns.

  • From model building with Keras, premade estimators,

  • if you would still like to use those, and then also

  • custom estimators or custom Keras models.

  • For training we've defaulted with eager execution,

  • so you'll be able to get your responses immediately

  • instead of doing that frustrating thing

  • with initializing variables and starting queue runners,

  • as I mentioned before.

  • You can visualize all of it with TensorBoard

  • and then export again, as with the saved model.

  • If you haven't already seen it-- and this is really,

  • really cool--

  • TensorBoard is now offered fully supported in Google Colab

  • so you're able to start it to run

  • it to inspect and to visualize your models,

  • all without those sort of frustrating local host

  • commands.

  • This support is also additive for Jupyter notebooks,

  • so if you want to use this with Google Cloud instances

  • or with Jupyter notebooks locally, you absolutely can.

  • We've also included built-in performance profiling

  • for Colab.

  • This is for GPUs and also for TPUs.

  • So you're able to understand how your models are interacting

  • with hardware and then also ways that you

  • can improve your performance.

  • We heard you loud and clear that the documentation could

  • be improved, so a big push for 2.0

  • has been improving documentation,

  • adding API reference docs.

  • We'll also be having a global docs sprint in collaboration

  • with our Google developer experts and GDC groups

  • later this year.

  • And if you're interested in collaborating

  • for documentation, we would love to have it.

  • Please submit it as a pull request to TensorFlow/examples

  • on GitHub.

  • We also understand that developers and researchers need

  • great performance, and we did not

  • want to sacrifice that as part of TensorFlow 2.0.

  • So since last year, we've seen a 1.8 training speed up

  • on NVIDIA Teslas.

  • That's almost twice as fast as some earlier versions

  • of TensorFlow.

  • We've seen increased performance with Cloud TPUs,

  • and then also great performance in collaboration

  • with our partners at Intel.

  • Not just for training, though.

  • If you're interested in inferencing for TensorFlow

  • Lite, we've brought down the speed for edge TPUs

  • to just two milliseconds for quantized models.

  • So underneath the hood, TensorFlow Lite and TensorFlow

  • are all about performance.

  • We've also extended the ecosystem in a number of ways.

  • When TensorFlow was first open sourced in 2015,

  • it was a single repository for numerical computing.

  • And now it's grown into an entire ecosystem.

  • So if you're interested in Bayesian modeling,

  • you can use something like TensorFlow Probability.

  • If you're interested in reinforcement learning,

  • you can use TensorFlow Agents.

  • If you're interested in text processing you can use TF Text.

  • If you're interested in privacy or insecure computing

  • you can use Federated or Privacy.

  • We also have a variety of other projects--

  • about 80 right now.

  • And if you're interested in any of them,

  • I strongly suggest you go and take a look

  • at the TensorFlow GitHub.

  • And now the question I'm sure all of you

  • are very, very interested in is how do I upgrade?

  • All of this sounds great.

  • How do I make sure that all of my historic legacy models

  • continue to run with TensorFlow 2.0?

  • And the answer is, we've tried to make

  • it as easy as we possibly can.

  • We have an escape to backwards compatibility mode

  • as part of tf.compat.v1.

  • We have migration guides and best practices that have all

  • been placed on tensorflow.org/alpha.

  • We've also created something called tf_upgrade_v2.

  • It's a conversion utility that you

  • can run from the command line.

  • And it takes your existing model and imports the code to 2.0.

  • Not to 2.0 syntax, but it makes all

  • of the changes that would be required in order for it

  • to run compatible with 2.0.

  • So what does that look like?

  • All you would have to do is take your model,

  • export it as a Jupyter Notebook or as a Python file,

  • and then run it from the command line with tf_upgrade_v2,

  • the input file name, and then what you want the output

  • file name to be.

  • You can do this even for a directory of files.

  • The files then cycle through and you

  • get something that looks a little bit like this.

  • It's a report.txt file that tells you

  • all of the API endpoints that have been renamed,

  • all of the keywords that have been added,

  • and then all of the instances that

  • need to have this escape to backwards compatibility mode.

  • So prefixed with tf.compat.v1.

  • Once all of that's done, you should

  • be able to run your model as expected

  • and see no performance regressions.

  • And if you do, please file an issue.

  • That's a bug, and we would be delighted to resolve it.

  • I'd also like to highlight one of the projects

  • that our Google developer experts

  • has created called tf2up.ml.

  • So if you don't want to run the upgrade utility

  • from your command line, you're free to take a GitHub URL,

  • use tf2up, and see it displayed with the changes

  • in line in a browser window.

  • This is really, really cool.

  • Strongly suggest taking a look.

  • So our timeline for TensorFlow 2.0.

  • Right now we're in alpha.

  • We expect to launch an RC release very soon,

  • and we should have an official release

  • before the end of the year.

  • You can also track all of this progress publicly on GitHub.

  • We've tried to increase the transparency, and also

  • the collaboration that we see from the community

  • as much as we possibly can, because TensorFlow 2.0 really

  • is all about community.

  • And if you have questions about any of the projects

  • or about any of the issues that you care about,

  • we would love to hear them.

  • And we would love to prioritize them appropriately.

  • And now to talk a little bit about under-the-hood activities

  • for TensorFlow.

  • JOSH GORDAN: Thanks, Paige.

  • Due to talking fast, we might now actually have some time.

  • So I will ask-- this is very basic,

  • but I think a question that a lot of people

  • ask is, what exactly is TensorFlow?

  • And if I asked you that, what I would have said when I first

  • heard about it is, like, right, that's

  • an open source machine learning library.

  • Great, but what is it really?

  • What does the code look like?

  • How is it implemented, and what problems is it actually solving

  • that we care about?

  • And rather than give you the next slide, which

  • is a lot of text and the answer, the way

  • to start thinking about this question

  • is actually with Python.

  • So if you think about scientific computing in general--

  • and this is the whole field, not just machine learning.

  • Let's say you're doing weather forecasting,

  • and as part of weather forecasting,

  • you need to multiply a whole bunch of matrices.

  • Probably you're writing your code in Python.

  • But if you think about it, how much slower is Python than C

  • for multiplying matrices?

  • Ballpark?

  • And like a horribly non-reproducible rough

  • benchmark would be Python's about 100 times slower than C.

  • And that's the difference between six seconds and 10

  • minutes, which is also the difference between running

  • on a treadmill or having a drink,

  • sitting in an airplane flying to California.

  • So Python is horribly slow, and yet it's extremely popular

  • for performance-intensive tasks.

  • One of the huge reasons why is NumPy.

  • And what NumPy is, it's a matrix multiplier implemented in C

  • that you can call from Python.

  • And this gives you this combination

  • of Python ease of use but C performance.

  • And most deep learning libraries have the same inspiration.

  • So TensorFlow is a C++ back end.

  • But usually-- not always, but usually, we

  • write our code in Python.

  • On top of NumPy, what TensorFlow and other deep learning

  • libraries add is the ability to run on GPUs.

  • So in addition to being in C, you can multiply your matrices

  • on GPUs.

  • And if you take a deep learning class

  • you'll end up learning that the forward and backward paths

  • in neural networks are both matrix multiplications.

  • So we care about this a lot.

  • All deep learning libraries, they

  • add automatic differentiation.

  • So you get the gradient so you know

  • how to update the variables of your model.

  • And TensorFlow adds something special.

  • And there's a lot of text on the slide in details, whatever,

  • you can look at later.

  • But when you write a program in TensorFlow in Python,

  • one thing we care a lot about-- and I

  • know there are a lot of mobile developers here--

  • is we want to run it on devices that don't have a Python

  • interpreter.

  • Examples of that would be a web browser or a phone.

  • And so what TensorFlow does is your TensorFlow program

  • is compiled to what we call a graph.

  • And it's a data flow graph.

  • The word TensorFlow, tensor is a fancy word for an array.

  • Scalar is a tensor, an array's a tensor, matrix is a tensor,

  • a cube of numbers is a tensor, it's an n-dimensional array.

  • Flow means data flow graph.

  • Your TensorFlow program gets compiled

  • behind the scenes in TensorFlow 2--

  • you don't need to know the details of this

  • unless you're interested-- into a graph.

  • And that graph can be run on different devices.

  • And what's interesting is it can be accelerated.

  • So just so you know, because I've

  • been talking about NumPy a lot, TensorFlow 2,

  • if you feel like it, works basically the same way

  • as NumPy.

  • The syntax is slightly different,

  • but the ideas are the same.

  • So here I'm creating some data, a tensor instead of a NumPy

  • array, and I'm multiplying it by itself or whatever,

  • and it just works like regular NumPy.

  • I should mention that instead of being NumPy and [? D ?] arrays,

  • TensorFlow tensors are different data type,

  • but they all have this really nice NumPy method.

  • So for any reason you're tired of TensorFlow,

  • you just call a NumPy and you're back

  • in NumPy land, which is awesome.

  • But TensorFlow can do something really special and cool,

  • thanks to a really amazing group of compiler engineers that

  • are working on it.

  • So here's just some random code I wrote in TensorFlow,

  • and I'm taking some layer and I'm calling it on some data.

  • And I have this horrible non-reproducible benchmark

  • that I ran at the bottom there using timeit,

  • and staring into the sun, I think this took about 3/100

  • of a second to run.

  • And in TensorFlow 2.0, we can accelerate this code further.

  • And the way this works is there's

  • only one line of code change.

  • So if you look closely here, I've just added an annotation

  • and I've added a second benchmark.

  • So if we go back one slide, that's before.

  • Whoops.

  • Let's go-- perfect.

  • So here's before and here's after.

  • And with just that annotation, this

  • is running something like eight or nine times faster.

  • And your mileage will vary depending on the type of code

  • that you accelerate.

  • You won't always get a performance benefit,

  • but the only non-standard Python syntax

  • that you need to be aware of optionally in TensorFlow 2

  • is just the sanitation.

  • So you don't need to worry about--

  • if you learned TensorFlow 1, this

  • is really valuable knowledge, because there's so

  • many papers with really awesome implementations in TensorFlow

  • 1.

  • But the only nonstand-- you don't

  • need to worry anymore about like sessions, place holders, feed

  • dictionaries, that's just not necessary.

  • This is the only thing.

  • Otherwise it's regular Python.

  • And the way this works behind the scenes--

  • I'm showing you this just for fun.

  • You can totally ignore it.

  • I personally never look at this because I'm not

  • a compilers person.

  • But it works with something called AutoGraph.

  • And AutoGraph is a source-to-source Python

  • transformer.

  • And basically it generates a version

  • of this code which can be accelerated to a greater extent

  • by the back end.

  • And we can actually see what's generated.

  • We can print out AutoGraph.

  • And basically what we're looking at

  • is more or less assembly code for that function

  • we just wrote.

  • But in TensorFlow 2, you get this for free, which I think

  • is a really awesome thing.

  • And it's super cool.

  • That said, the fact that we need a compilers engineer to write

  • something as powerful and amazing as this points us--

  • I mean, you might want to think--

  • is we're really starting to run into the wall with Python.

  • And Python is by far my favorite language of all time.

  • It's going to be probably the standard for machine learning

  • for many years to come.

  • But there's a huge amount of value in investigating

  • compiled languages like Swift.

  • And if you're a Swift developer, there's

  • an excellent implementation of TensorFlow in Swift,

  • which you can learn and all the same concepts that you learned

  • about in Python will apply in Swift.

  • Likewise, TensorFlow JS is incredible.

  • If you're a JavaScript developer,

  • there's no need to learn Python.

  • You can just go directly in JavaScript.

  • And this is something really special about TensorFlow.

  • OK, due to, as I said earlier, talking way too fast because I

  • thought this talk was longer than it was,

  • here is the best way to learn about TensorFlow 2.

  • Right now all of our tutorials are hosted

  • on tensorflow.org/alpha.

  • If you're new to TensorFlow and you're a Python developer,

  • you should ignore everything else on the website.

  • Just go to Alpha and this will give you

  • the latest stuff for 2.

  • Everything else is outdated and totally not necessary.

  • Because this is complicated, I put some keywords there.

  • And if you see any of those keywords in a book or a video

  • or tutorial, just skip it.

  • It's outdated, and we should be finished with TensorFlow 2

  • in a few months, at which point we will roll the entire website

  • over to the new stuff.

  • So that's absolutely key.

  • Speaking of things that are coming up soon,

  • here are two awesome books.

  • And I want to mention, just so you know what you're getting,

  • I'm not going pronounce the names.

  • I mentioned earlier I'm terrible at languages.

  • I can't pronounce French at all.

  • They're both brilliant, awesome people.

  • The first is the second edition of the Hands-On Machine

  • Learning book.

  • The first uses TensorFlow 1, so I'd

  • recommend skipping that one.

  • This one is coming out in a few months.

  • The GitHub repo is available now.

  • It's excellent, so you can start with this.

  • The second book, I'll pronounce this one.

  • It's Francois Chollet.

  • Hope I got it right.

  • And then Aurelien Geron, which I probably got wrong.

  • The second book doesn't use TensorFlow at all.

  • It uses the Keras reference implementation.

  • Every concept you learn in that book will work in TensorFlow 2

  • just by changing the import.

  • So you don't waste your time at all.

  • It's an outstanding reference.

  • And yeah.

  • We'll be around after if we can answer any questions

  • or help with anything.

  • So thank you very much.

  • [MUSIC PLAYING]

[MUSIC PLAYING]

Subtitles and vocabulary

Click the word to look it up Click the word to find further inforamtion about it