And welcome to a tutorial on facial recognition with the face recognition package.

So to get started, you should be able to just do a pip install face recognition, but depending on your operating system, depending on whether or not you want to use Cuda and so forth, there's many different paths that you could take for the installation.

So check out the textbook version of this tutorial.

If Pip install face recognition just doesn't do it for you.

So with that, what I want to do is basically just to kind of an overview of the package and how to use it.

The package itself is actually extremely simple.

And there's really, like, three calls you need to make to the package.

The rest is just boilerplate kind of stuff that you need to do around the code team, make use of it.

So to get started, basically, I'm going to be working in the following directory.

So this is the code that I'm gonna be working on just as a reminder.

Never name your code the same thing as the package you're gonna be using.

You don't call this face recognition dot pie, then we're gonna have to directories.

One directory is known faces, and inside of there is more directories.

Uh, in this case, we just have one.

It's called Syntex.

Now each directory in the known Faces directory is goingto have basically a directory of an identity that you wish to identify.

So just as a reminder, face detection is just finding a face right in imagery or videos or whatever.

Facial recognition is identifying that face.

So face recognition goes a step further the text face, and then it recognizes that face tells you who that person is or whatever.

So inside of this directory, Centex, we've got three images.

None of these images, the greatest in the world.

But you can see here we've got this one.

This one's kind of goofy because it has obviously got that e g headset on.

But the face itself is actually a pretty good face.

And then this one is not very good.

The eyes are covered up in all that.

So not the greatest images, but kind of it'll get the job done.

So, uh, you can do whatever you want.

All these images are on the text based version of Detroit You can use my images if you want, but I really encourage you to use your own images, grab some images online or whatever, do whatever you intended to do it face facial recognition.

So those are the known faces that I have.

And then there's also a directory of unknown faces.

In this case, we don't know the identities.

So it's just a bunch of images, both of me and of Daniel.

Uh, and the idea is to see, can we recognize her own face?

This one's an interesting one, because it is the deep fake of Snowden face on my face.

Hey, wait.

Um Okay, so this is also some depicts, so this will be very interesting to see which ones that detects or or non or what?

Uh, anyway, so that's how everything set up.

You've got the face recognition directory that you're gonna work and you've got known faces, identities and the images of each of those identities.

They've unknown faces, which is just a bunch of images that might have many phases.

So in this case, we only had all these images.

There's actually one person, although there is like in this one, there's you know there's a face back here, the back of a person's head, another face here and so on.

So I mean, there can be multiple faces, but most of these just have one face.

I guess this has a lot of faces as well.

Anyway, it doesn't have to be all like the unknown faces don't really need a single identity, But for known faces, he's really need to be just one face.

That is the identity of whoever this directory is.

Okay, So once you've got those things set up field for deposit, if you need a second to set everything up, otherwise we can get started.

So, um, you just move some stuff around, so the first thing we're going to use right it makes it imports and then set some constants.

So our import face recognition, That's the package that we intend to use.

Reimport s our import CV to.

So you'd also have to pick and stole python dash open CV.

I always forget which one it is.

Uh, it was stolen.

I think it's It's either open C v dash.

So must be open C v dash part.

So, uh, stole it on as probably it.

Uh, I guess I upgraded, but that probably just broke the whole tutorial.

Uh, my life.

Okay.

So continuing long once we have those things.

So, yeah, O esto iterated over directories CV to to do image tests.

We're gonna use CV to draw rectangles and label the images and stuff like that.

So now we're going to have a known faces, dirt, and that will be known faces.

And then we will have an unknown faces.

Er so unknown faces.

You're unknown faces.

They were gonna have a tolerance.

Now, this is a degree of, um, try another word besides tolerance.

But the the lower the tolerance, the less chance we're gonna have for, like, false positives.

So if you said are very, very low tolerance, But you only have, like, one or two pictures of the identity.

Chances are it's never gonna make a match.

So the default with face recognition of 0.6 if you want to make more matches, but you're willing to risk being incorrect on the match that you make, you can set tolerance to be like 1.0, very high.

But if you want a Onley match, if it's a freak.

A for sure thing, said the tolerance to be quite low.

I have found 0.6 to be pretty good, but as we'll see, we'll probably have issues with that, both missing predictions and then as we try to lower, it's quite challenging.

Ideally, you would have, like 100 images off, you know, somebody's face in different lighting conditions and looking up in every all directions and stuff like that.

But it's actually it's still pretty darn good.

Even if you have, like what I just used here some pretty crummy images.

So Okay, so that's tolerance again.

The higher you go, the more likely you are to make matches, but you're likely to get a lot of false positives.

The lower you go, the more likely you are to get.

I guess you would call false negatives, right?

So you're gonna mismatches.

So now, uh, runs a frame underscore thickness.

This will be in pixel values.

Basically, we're gonna draw square around the head.

How many pixels you want them to be?

Just really just good.

That's gonna depend on how big of an image or using in our case will go to.

I'm gonna use three.

Uh, And then we'll do font thickness that will also said that to be, too.

And then model I'm gonna use CNN.

So convolution a ll neural network.

You can also use hog, which is I was once a hierarchical, um, hissed a gram something Radiance.

Mr.

Graham oriented radiance.

I don't know, something like that.

Anyway, it doesn't matter.

What it stands for is like kind of the older way of doing object detection.

So you can use either one you want.

I suspect hog is gonna run better on the CPU.

So if you're only on a CPU, you didn't install the Cuda de Lib, Then I might suggest that you use hog instead.

That's quite literally H o G, um, or feel free to take it with both.

CNN will still run on the CPU.

It just might be kind of slow.

So, um okay, so once we've got that, the next thing we're ready to do is start loading and faces.

So, to do image facial recognition, we need to be able to do kind of two things, right?

We're gonna detect the face and then for every unknown face that we happen to find we need something to compare it to.

So the first step that we're gonna do is load in all of our known faces, Um, so that we have something for the unknown faces to compare to.

So, uh, well, come down here and we will just Frank's just debugging information loading known faces.

And basically, we're gonna have to list.

We're gonna say known faces.

These will be the actual encoded faces.

You'll know what I'm saying.

Minute and then known names.

These will be the name's associate ID with those faces.

So as we populate this out later, when we go to compare the unknown faces, we'll see.

Does the encoded unknown faces match any of the encoded known faces?

If so, at what index value did we find one?

And then we will just reference the known names list at that exact same index.

And that's boom.

The identity.

So so known faces no names.

And now we want to do is generate over all the new faces and store that information.

So four name in os dot list dir uh, known faces dirt.

So that gives us the name.

Now, remember, that was the identity directory.

Now we need to generate over all the images in that directory.

So we're gonna say four books or file name in OS not list dir.

And we will say known faces dir on, then slash name.

And this also needs to be Ah, variable.

Cool.

You also could use the West I path.

Thought joined.

Um, I haven't really decided which one I like better is using, like, f strings for pats or os dot path.

Not join.

I mean, it's like it's meant for this, but unless I've had the joint came before, we could do really nice f strings like this.

So I find this to be quite legible.

So anyway, if anybody knows a good reason why not to use their strings for pads, let me know.

Um, okay, So once we load in that file name, uh, we want to find him.

We're gonna say image equals.

So this is the first call.

That's a unique face recognition call face recognition dot face, um, underscore and coatings.

And we want to do this for the actual image.

Ah, that we bring in and we have brought in the image.

So So?

Actually, we want to say is, uh, So really, this will be our encoding wth e image is going to be face recognition.

Don't, uh, load image file.

And then here Here's what we're gonna do.

We'll do another extreme, uh, known faces.

Your face is sure, um, name and then the file name.

Funny.

So then we load the image with facial recognition.

We encode that image, and then we're gonna add these tour lists.

We're gonna say known faces dot upend the encoding, and then known names got upend the, uh, name.

Cool.

Okay, so now that we've got that, uh oh.

And also, when we do facing coatings, this is going to encode all of the faces that it finds.

So, um, what we actually want to do is we're gonna say the encoding will be at the zero with index, so we only want the first face it finds so again, your identity images.

So these ones here really ought to just have one face, and it should be your identity, right?

So every you should only have one face in these images.

Each of those faces really needs to be, um, the identity here.

I mean, it should be pretty obvious, but in case that's not obvious.

Um, there you go.

So, uh, so when we encode the images, it's gonna find all of the faces unless you specify otherwise, which we'll show you in a little bit.

Um, so we're gonna say at the index zero.

That's the face that we're interested in.

So So now we want to dio is so we've got the known faces so we can compare to them.

Now we want to do is want literate over all of the unknown images, find all of the faces and then for each face, compare that face to each of the known faces.

So okay, lots of lots of looping about to occur.

So now we're gonna say is print.

Uh, process is unknown, Uh, and cool.

So what we're gonna do is we need Thio iterated over.

First the Unknown faces directory.

So four file name in os dot list Duerr unknown faces dirt and again, we don't have identities, so we don't need to generate over those directories.

But instead, what we're going to say is print, huh?

I swear it Hit the caps lock, print, file name.

Just so we know where we are now we want to do is load in that file name.

So we're gonna image equals face recognition dot load, image file and we want to load in on that path.

So again, f string, we're going to say unknown faces dir slash uh, filing lips.

Don't forget this file name.

Cool.

So we're loading in that file.

So we've got the image now we want to do is we want to actually find, um, all of the faces inside of that image.

Now, this is not something we did before because we're kind of just assuming we already know there's only gonna be one image and so on, but in this case, for us A locations and what this is going to do is do face detection for us, find all of all of the locations for faces, and it's just gonna find the coordinates.