NumPy

So yeah, that's a cleaner, more dynamic way of doing inputs times the weights plus the bias for a layer in Python.

Now we're still going to transition to doing this with NumPy and doing vectors and matrices and stuff like that, but this is a cleaner way.

And if you're following along in some other language, obviously the answer is to use loops.

So now the next thing I want to touch before we get into the NumPy stuff is we're still getting a lot of questions on weights and biases.

So I just want to clear that up as quickly as possible.

So weights and biases are these knobs that I say we tune, but really down the line, it's going to be the optimizer that tunes these values in an attempt to fit to some data.

So these are just two different tools that help in two different ways and and that's it So anyways, I think this will make more sense as we especially get into Activation functions and like rectified linear.

It should be unbelievably obvious what bias can do for you But anyway, just for now hopefully you can see that there are two different tools doing two different things and if we have millions of these little tools that we can sort of tweak we can change the overall kind of outputs and Now, with that in mind, let's get into transitioning into more real mathematics rather than this stuff.

Actually, there's two reasons we're going to use this NNFS package.

The first is for stuff like NumPy.

So our goal and our hope here is that everybody can follow along and get the same values as we do, at least if they want to.

Obviously, again, if you're following along in another language or maybe you want to change things and not do things exactly the same way as I'm doing, which is totally fine, but if you want to confirm that you're doing things correctly, you need to be able to repeat the results that we get.

So it won't work very well just as a heads up.

But you'll also need to always be doing that.

So instead, what we're going to do is we're going to import nnfs and then do nnfs.init. And besides setting the random seed, the other thing nnfs init is doing for us is it's setting a default data type for NumPy to use.

So for whatever reason, the dot product for NumPy, we only found this out after getting many people in the document and finding some people were getting slightly different values, and it was very weird.

Those values should be pretty close to what's in the book.

It actually isn't exactly, but this isn't using NumPy.

So the values should line up, I think, when we're using NumPy.

We'll confirm that when we get there.

But so the NNFS, first of all, we're not even initializing the NNFS package, but that is part of what the init package is doing.

So that's the raw Python implementation.

And again, if you're coming from some other language, you would need to implement this in your language.

But now the next thing that we're going to do is convert this to NumPy.

To read in a map, you can use the end map module and just say we have Okay, so what this does is it opens up the fits file, looks in the fits headers, and then loads in a map.

A really important point I want to make around here is that the way that maps work in pixel is by pixel basically extends the NumPy array.

So if you're familiar with working with NumPy arrays, then pixel is really fun to use.

because anything that you can do to a numpy array, it inherits all of the properties of numpy array, but it extends on top of that by adding this WCS object, which we just talked about as a world coordinate system object.

So this particular command is going to load in the FITS header.

All right, so once this is loaded in, we're going to print out the shape and dtype or data type of the sample array.

And you can see it's a two-dimensional array with shape 1505 and 3521, which means that there's 1,505 pixels along the y-direction and 3,521 along the x-direction.

And this is, you know, the most basic structure that you can have in an ND map, which is an extension of a NumPy array.