yolo-you-only-look-once

A real-time object detection algorithm that processes images in a single evaluation, enabling rapid and accurate identification of multiple objects within an image.

YOLO (You Only Look Once)

Hello. So today I'm going to be talking about YOLO, which is a highly influential algorithm and framework used for real-time object detection. This means it has a very wide range of applications, including video surveillance, uh, self-driving cars, face detection during the pandemic to measure temperatures, and that kind of thing. 

So it's, uh, in short, it's a very popular algorithm that's been used a lot in the past several years. The goal here is simply to create bounding boxes around the objects in an image and then also to label these objects according to their class. Now these sorts of object detection methods have been around for several years, but YOLO and its variants seem to capture a desirable mix between speed and accuracy. 

Now the actual definition of mean average precision is a bit more subtle than that, but let's not worry about that for now. So as you can see, out of the models that are capable of what we can call real-time detection or into their speed, YOLO seems to deliver the best performance despite still being less accurate than some of the slower models. 

The reason YOLO is able to achieve this is that it utilizes powerful deep learning architecture while at the same time using the input image data in a highly efficient way. So just to compare with some prior developed models, the deformable parts model, or DPM, uses filters that represent whole objects and parts of objects to create a detection confidence map using a sliding window technique. 

The idea here is that an object is likely present if all of its parts are present, even if they are configured in unusual ways. Now region-based CNNs do kind of the same task but differently. Here you have three separate models: a region proposal model, a CNN that...

That extracts a feature vector and then a support vector machine for each class. Now these three models notably are typically trained separately. And even though there have been many developments on the RNN approach since 2014, the essential idea of region proposal plus classification still applies. 

Now the distinguishing feature of YOLO is that instead of looking at an image multiple times, whether it's to apply the deformable parts filters or to inspect the regions like the RCNN, you only look at the image once. So just to summarize how this scheme works, the first step is to overlay on an input image a grid with s grid cells on each axis. Each grid cell then produces two things. One, it produces a set of bounding boxes centered on a point inside the grid cell with associated confidence scores that an object exists inside each bounding box. And then it also produces a class probability map for each grid cell, which essentially tells what object class is most likely to be in that cell given that an object in fact exists in the cell at all. 

And finally, it combines this information to yield the object detections. So that's the abstracted framework, but how does it actually work in practice? Well, for each grid cell, we compute a set of output vectors. The first vector is a vector of class probabilities. The second is a set of bounding box parameters specifying the X and Y position of the center of the bounding box, as well as the square root of the width and the height of the box. And I'll explain why we take the square root a bit later. And then finally, we also have the confidence score denoting the model's confidence that an object in fact exists in the box. 

Now instead of having just one bounding box, each grid cell will typically have multiple.

Boxes and this just allows the cell to detect more than one object. Now in practice instead of having several vectors we just combine them into one big vector with length B times 5 plus n where n is the number of object classes. Now B is the number of bounding boxes per grid cell and in the original paper the authors use a seven by seven grid with two bounding boxes per cell and 20 classes. So for each grid cell we output a length 30 vector. 

But how exactly does this model just go from an input image to these output vectors? Well simply we just use a CNN on a convolutional neural network. Now this architecture just consists of a stack of convolutional layers that distill an image into a more abstract representation followed by two fully connected layers that transform this into an output vector for each grid cell. And there's three channels in the input just represent the red green and blue channels in the image. 

Cool so now that we have an idea of how the model works let's look at how it is trained. Let's say we are trying to predict uh say this bounding box. Now the center of the bounding box is at this point here so this grid cell will be responsible for it. Well let's say we've predicted this green box here along with the five parameters that define it X Y location the width the height and the confidence. 

And we want to somehow penalize the prediction because it isn't exactly the same as the ground truth. But what would the ground truth values be? Well for the class probabilities this is simply one for the correct class and zero for everything else. Note that this assumes that the classes are mutually exclusive and with later versions of YOLO I think starting with YOLO version three the model is actually capable of multi-label.

Classification where two classes can exist simultaneously such as dog and animal. Um but YOLO V1 just predicts one class so that's cool. 

Now let's see how we calculate the coordinates of the ground truth and predicted boxes. Well X and Y are usually calculated with respect to the top left corner of each individual grid cell and they are also expressed as a proportion of the total grid cell dimensions. Meanwhile the widths and the height are expressed as a proportion of the total image dimensions. Hence these all fall into the zero to one range. 

So just to take a quick example let's say that the coordinates of the point are 16 and 44 pixels respectively from the top left origin of the entire image. Let's say each grid cell is 10 by 10 pixels and the image has seven grid cells on each axis. Then the X and Y values are 0.6 and 0.4 respectively. Or the percentage sign here is just the modulo operator and the width and the height are obtained by dividing by 70.

Um yeah well so what about the confidence well essentially with confidence the question we're asking is does an object appear in the grid cell or not. And confidence is the score attached to the positive answer the third question. 

So let's say that we have these ground truths bounding boxes with these center points and these good cells responsible. Then in every grid cell except for those grid cells the ground truth confidence is set to zero because there isn't an object there. Meanwhile in the green grid cells the ground truth confidence is simply the intersection over union of the predicted and ground truth bounding boxes. 

Just to review what intersection of reunion means uh the intersection between two sets or two boxes in this case is the area of the shared region. So it's the middle figure here while the union is the combined area of both of the boxes without double counting the overlap. So the intersection of reunion of A and B is then simply the intersection divided by the union. That's essentially a measure of the degree of overlap between two boxes or sets more generally. 

So the ground truth confidence is simply the IOU of the predicted and ground boxes. However we know that each grid cell can produce multiple predicted boxes so which one should we choose. Well during training in order to calculate the loss we just use the predicted box that is the highest IOU with the true box. 

Incidentally the authors of the original paper note that by assigning only one predicted box to each ground truth box the different predictors are able to specialize and perform better on certain object classes or aspect ratios or whatever. Now similarly during inference if we have two predictions P1 and P2 then if the IOU between them is greater than

Some threshold we only keep the one that is associated with the higher confidence in the presence of an object. Now this whole process called non-max suppression just trimmed down the predicted boxes to prevent any overlaps between them. 

So now that we know how all of the Box providers are calculated, let's see how they are used in the loss function. Now the total loss function is basically just a sum of two terms: the object class loss, which operates on the class probabilities, and the localization loss, which operates on the bounded box parameters. 

And this is what the class loss looks like. So instead of using a cross entropy or anything like that, we just take the sum squared error between the predicted and ground truth class probabilities summed over all classes and all grid cells. Now this interesting symbol here just means that we're only considering the class loss of a grid cell if an object in fact exists within that grid cell. 

So recall the probability map that I showed earlier. There are plenty of cases where the model has predicted an object class where it's actually a background, and we're actually not counting those cases in the class loss. The class loss only deals with cases where an object has been mistaken for another object and not where there is in fact a background. 

So what about the localization loss? Well, this is also split into a confidence loss and a box coordinate loss. The coordinate loss is summed over all grid cells and all bounding boxes in each grid cell, but it is only counted for those cases where cell I contains an object and box J is deemed responsible for that object. 

So here we sum the squared error of the X and Y coordinates as well as the square root of the width and...

Height we also scale this entire thing according to a parameter Lambda chord and I'll explain why this happens in a bit. Now the confidence loss has a very similar form except that the grid cells which do not contain an object are scaled by a parameter Lambda No Object while those that do in fact contain an object are not scaled and again I'll explain why this happens in a bit. 

So here is the entire loss function. What's apparent is that we're just using squared error to obtain good values for the class probabilities and all of the bounding box parameters. So in this sense object detection is just reduced to a regression problem and this gives YOLO a sense of simplicity. So it really is just regressing all of these values here without anything fancy like you know cross entropy losses or anything like that. 

So uh from this we know that YOLO works very well but what are some of its limitations uh and here I'm talking more specifically about the first version of YOLO. Well first of all of course each cell can only contain one class so if or it can only predict one class should I say. Um so if say one dog and one bicycle appear in the same grid cell then this presents a problem. 

Moreover each grid cell contains a finite specified number of bounding boxes so if there are many objects appear in one grid cell then this also presents a problem. One example is busy Urban environments where there might be you know multiple people in each grid cell. Now the authors note some other limitations which include the fact that bounding box predictions tends to struggle with unusual aspect ratios or configurations of object that it had not sufficiently seen in the training data. 

Furthermore the loss function deals with only with absolute values of x.

Y w and H so it cannot deal with the fact that the same absolute error will matter more in a small box than in a large box. There is no explicit error scaling according to the size of the bounding boxes. But one method the authors developed to tackle this is to use the square root of the width and the height rather than just the width and the height. And this means that as the box size scales linearly, the square root of w and H scale sublinearly, which in effect suppresses differences between large and small boxes.

And now the final consideration is that many cells do not in fact contain an image. The consequences of this are twofold. In training, the confidence scores are liable to be pushed to zero since this is the ground truth for most of the cells in an image. Furthermore, since the coordinate loss is calculated only for cells with objects, it will tend to be underrepresented in the final loss. So in order to address both of these problems, we can scale the No Object confidence scores. We can scale down the No Object confidence scores and scale up the coordinate losses using the Lambda scaling factors. In the original paper, the authors set Lambda No Object to 0.5 and Lambda chord uh to five.

So there we have it. YOLO is a fast and effective object detection framework that works because of its simplicity, using just a single CNN to learn the bounding boxes and class identities of each object in an image. Now the yellow scheme I've introduced here was developed way back in 2015-16, and since then many other versions and improvements have come out. So if you're interested, please take a look at them. But for now, thanks for watching.

Note, that there may be slight differences in text and video. Watch video for the original content.

YOLO (You Only Look Once) Video