And then x[0][0] gets multiplied with w squared,

so you have x[0][0]*w squared, and so on, right?

And eventually, you know, this gets built up to compute this xw,

x[0][0]*w squared + x[1][0]*w + and so on.

And so eventually, you get the cost function.

And so the last term to be added would be x [2][0] where

it gets added to be the cost.

I won't write other format for the cost.

And the nice thing about TensorFlow is that by implementing basically four

prop applications through this computation draft, the computed cost,

TensorFlow already has that built in.

All the necessary backward functions.

So remember how training a deep neural network has a set of forward functions

instead of backward functions.

Programming frameworks like Tensor Flow have already built-in the necessary

backward functions.

Which is why by using the built-in functions to compute the forward function,

it can automatically do the backward functions as well to implement back

propagation through even very complicated functions and compute derivatives for you.

So that's why you don't need to explicitly implement back prop.

This is one of the things that makes the programming frameworks

help you become really efficient.

If you look at the TensorFlow documentation,

I just want to point out that the TensorFlow documentation

uses a slightly different notation than I did for drawing the computation draft.

So it uses x[0][0] w.

And then, rather than writing the value, like w squared,

the TensorFlow documentation tends to just write the operation.

So this would be a, square operation,

and then these two get combined in the multiplication operation and so on.

And then, a final note, I guess that would be

an addition operation where you add x to 0 to find the final value.

So for the purposes of this class, I thought that this notation for

the computation draft would be easier for you to understand.

But if you look at the TensorFlow documentation,

if you look at the computation drafts in the documentation,

you see this alternative convention where the notes are labeled

with the operations rather than with the value.

But both of these representations

represent basically the same computation draft.

And there are a lot of things that you can with just one line of code in programming

frameworks.

For example, if you don't want to use GradientDescent, but

instead you want to use the add-on Optimizer by changing this line of code,

you can very quickly swap it, swap in a better optimization algorithm.

So all the modern deep learning programming framework support

things like this and

makes it really easy for you to code up even pretty complex neural networks.

So I hope this is helpful for

giving you a sense of the typical structure of a TensorFlow program.

To recap the material from this week,

you saw how to systematically organize the hyper parameter search process.

We also talked about batch normalization and

how you can use that to speed up training of your neural networks.

And finally, we talked about programming frameworks of deep learning.

There are many great programming frameworks.

And we had this last video focusing on TensorFlow.

With that, I hope you enjoyed this week's programming exercise and

that helps you gain even more familiarity with these ideas.