{"notes":[{"id":"classic-cnns/overfeat","category":"classic-cnns","legacyPath":"","legacySlug":"","legacyPaths":[],"title":"OverFeat","subtitle":"One Net to Catch Them All","author":"Z. Yuan","paperDate":"2013-12-21","publishedOn":"2025-10-18","world":"external/overfeat","paperTitle":"OverFeat: Integrated Recognition, Localization and Detection using Convolutional Networks","paperUrl":"https://arxiv.org/abs/1312.6229","bibliography":{"title":"OverFeat: Integrated Recognition, Localization and Detection using Convolutional Networks","authors":["Pierre Sermanet","David Eigen","Xiang Zhang","Michael Mathieu","Rob Fergus","Yann LeCun"],"url":"https://arxiv.org/abs/1312.6229","pdfUrl":"https://arxiv.org/pdf/1312.6229v4","codeUrl":null,"preprint":{"id":"1312.6229","submittedOn":"2013-12-21","url":"https://arxiv.org/abs/1312.6229"},"publication":null,"citation":"@misc{classiccnnsoverfeat2013,\n  title = {{OverFeat: Integrated Recognition, Localization and Detection using Convolutional Networks}},\n  author = {Pierre Sermanet and David Eigen and Xiang Zhang and Michael Mathieu and Rob Fergus and Yann LeCun},\n  year = {2013},\n  eprint = {1312.6229},\n  archivePrefix = {arXiv},\n  url = {https://arxiv.org/abs/1312.6229}\n}\n","citationPath":"/content/papers/citations/classic-cnns/overfeat.24bd64ee73bc.bib"},"thumbnail":{"src":"/content/papers/assets/d52a811beca4cb19a17ff9c1e4d1fb5c130f8426db67edfc11b7f5ebec4e525e.png","width":988,"height":1594},"locale":"en","path":"/content/papers/en/classic-cnns/overfeat.04ffc09ffd36.md","headings":[{"id":"defining-the-problem","text":"Defining the Problem","depth":2},{"id":"solving-the-problem","text":"Solving the Problem","depth":2},{"id":"the-classification-network","text":"The Classification Network","depth":3},{"id":"why-sliding-windows-arent-expensive","text":"Why Sliding Windows Aren't Expensive","depth":3},{"id":"the-output-is-too-sparse","text":"The Output Is Too Sparse","depth":3},{"id":"multiple-scales-take-the-max-then-average","text":"Multiple Scales: Take the Max, Then Average","depth":3},{"id":"from-classification-to-drawing-boxes","text":"From Classification to Drawing Boxes","depth":3},{"id":"accumulate-dont-suppress","text":"Accumulate, Don't Suppress","depth":3},{"id":"detection-picking-negatives-on-the-fly-during-training","text":"Detection: Picking Negatives on the Fly During Training","depth":3},{"id":"discussion","text":"Discussion","depth":2},{"id":"classification","text":"Classification","depth":3},{"id":"localization","text":"Localization","depth":3},{"id":"detection","text":"Detection","depth":3},{"id":"conclusion","text":"Conclusion","depth":2}],"anchorAliases":{},"guide":null,"relatedReading":[{"id":"object-detection/yolov1","relation":"referenced","topic":""},{"id":"segmentation/fcn","relation":"referenced","topic":""}]},{"id":"object-detection/yolov1","category":"object-detection","legacyPath":"object-detection/1506-yolov1","legacySlug":"1506-yolov1","legacyPaths":[],"title":"YOLOv1","subtitle":"You Only Look Once","author":"Z. Yuan","paperDate":"2015-06-08","publishedOn":"2024-08-01","paperTitle":"You Only Look Once: Unified, Real-Time Object Detection","paperUrl":"https://arxiv.org/abs/1506.02640","bibliography":{"title":"You Only Look Once: Unified, Real-Time Object Detection","authors":["Joseph Redmon","Santosh Divvala","Ross Girshick","Ali Farhadi"],"url":"https://arxiv.org/abs/1506.02640","pdfUrl":"https://arxiv.org/pdf/1506.02640","codeUrl":null,"preprint":{"id":"1506.02640","submittedOn":"2015-06-08","url":"https://arxiv.org/abs/1506.02640"},"publication":{"venue":"CVPR","year":2016,"kind":"conference","url":"https://openaccess.thecvf.com/content_cvpr_2016/html/Redmon_You_Only_Look_CVPR_2016_paper.html"},"citation":"@misc{objectdetectionyolov12015,\n  title = {{You Only Look Once: Unified, Real-Time Object Detection}},\n  author = {Joseph Redmon and Santosh Divvala and Ross Girshick and Ali Farhadi},\n  year = {2015},\n  eprint = {1506.02640},\n  archivePrefix = {arXiv},\n  url = {https://arxiv.org/abs/1506.02640}\n}\n","citationPath":"/content/papers/citations/object-detection/yolov1.a6add3d1501c.bib"},"thumbnail":{"src":"/content/papers/assets/de2999633c20d235ccf6c7c3f0b2d7488ca55b32be8a406c1c988b0d117c1408.jpg","width":1028,"height":692},"locale":"en","path":"/content/papers/en/object-detection/yolov1.9f7b079eb08f.md","headings":[{"id":"problem-definition","text":"Problem Definition","depth":2},{"id":"solution","text":"Solution","depth":2},{"id":"model-architecture","text":"Model Architecture","depth":3},{"id":"loss-function","text":"Loss Function","depth":3},{"id":"inference-scenario","text":"Inference Scenario","depth":3},{"id":"step-1-sort","text":"Step 1: Sort","depth":4},{"id":"steps-2-and-3-select-and-suppress","text":"Steps 2 and 3: Select and suppress","depth":4},{"id":"repeat-the-selection-and-suppression","text":"Repeat the selection and suppression","depth":4},{"id":"discussion","text":"Discussion","depth":2},{"id":"inference-speed","text":"Inference Speed","depth":3},{"id":"comparison-with-other-methods","text":"Comparison with Other Methods","depth":3},{"id":"limitations","text":"Limitations","depth":3},{"id":"conclusion","text":"Conclusion","depth":2}],"anchorAliases":{"one-image-one-grid":"model-architecture","network-and-training":"loss-function","experimental-results-and-discussion":"discussion","how-fast":"inference-speed","where-does-speed-cost-accuracy":"comparison-with-other-methods"},"guide":null,"relatedReading":[{"id":"object-detection/yolov2","relation":"next","topic":"One-stage detection from YOLO to multiscale prediction"}]},{"id":"segmentation/fcn","category":"segmentation","legacyPath":"segmentation/1411-fcn","legacySlug":"1411-fcn","legacyPaths":[],"title":"FCN","subtitle":"Fully Convolutional Networks","author":"Z. Yuan","paperDate":"2014-11-14","publishedOn":"2024-09-11","paperTitle":"Fully Convolutional Networks for Semantic Segmentation","paperUrl":"https://arxiv.org/abs/1411.4038","bibliography":{"title":"Fully Convolutional Networks for Semantic Segmentation","authors":["Jonathan Long","Evan Shelhamer","Trevor Darrell"],"url":"https://arxiv.org/abs/1411.4038","pdfUrl":"https://arxiv.org/pdf/1411.4038","codeUrl":null,"preprint":{"id":"1411.4038","submittedOn":"2014-11-14","url":"https://arxiv.org/abs/1411.4038"},"publication":{"venue":"CVPR","year":2015,"kind":"conference","url":"https://arxiv.org/abs/1411.4038"},"citation":"@misc{segmentationfcn2014,\n  title = {{Fully Convolutional Networks for Semantic Segmentation}},\n  author = {Jonathan Long and Evan Shelhamer and Trevor Darrell},\n  year = {2014},\n  eprint = {1411.4038},\n  archivePrefix = {arXiv},\n  url = {https://arxiv.org/abs/1411.4038}\n}\n","citationPath":"/content/papers/citations/segmentation/fcn.1c65fe1c14c6.bib"},"thumbnail":{"src":"/content/papers/assets/1a8a4d2936086814cc5bd26819653959fe4cc29c64c5cba2009f8b8e43c87842.jpg","width":1224,"height":684},"locale":"en","path":"/content/papers/en/segmentation/fcn.05e555100992.md","headings":[{"id":"defining-the-problem","text":"Defining the Problem","depth":2},{"id":"solving-the-problem","text":"Solving the Problem","depth":2},{"id":"model-architecture","text":"Model Architecture","depth":3},{"id":"upsampling","text":"Upsampling","depth":3},{"id":"multi-scale-fusion","text":"Multi-Scale Fusion","depth":3},{"id":"training-dataset-and-strategy","text":"Training Dataset and Strategy","depth":3},{"id":"evaluation-metrics","text":"Evaluation Metrics","depth":3},{"id":"discussion","text":"Discussion","depth":2},{"id":"pascal-voc-results","text":"PASCAL VOC Results","depth":3},{"id":"nyudv2-results","text":"NYUDv2 Results","depth":3},{"id":"sift-flow-results","text":"SIFT Flow Results","depth":3},{"id":"conclusion","text":"Conclusion","depth":2}],"anchorAliases":{},"guide":null,"relatedReading":[{"id":"feature-fusion/unet","relation":"next","topic":"Dense prediction and encoder-decoder skip connections"}]}],"text":"In 2012, AlexNet won both the classification and the localization tracks of the ImageNet competition.\n\nHow they did classification was written up in the paper, and everyone had read it. Localization? At the time, nothing published explained how they did it.\n\nPierre Sermanet and colleagues from Yann LeCun's lab at New York University released this paper in December 2013, and it was later published at ICLR 2014. In the introduction they state plainly that this is the first paper to clearly explain how convolutional networks can do localization and detection on ImageNet. Their system won the localization track of the 2013 competition and also entered classification and detection with the same network.\n\nAlong with the paper, they released the trained model as a feature extractor, named simply OverFeat.\n\n## Defining the Problem\n\nThe paper tackles three tasks, each harder than the last, and each one part of the next:\n\n1. **Classification**: each image has a single label. You get 5 guesses, and one correct guess counts as correct.\n2. **Localization**: again 5 guesses, but each must come with a box as well as a class. A guess counts only if the class is right and the box's intersection over union (IoU) with the ground truth is at least 50%.\n3. **Detection**: an image can contain any number of objects, possibly none. It's scored by mAP, and false boxes are penalized.\n\nIn ImageNet's classification data, the object is usually in the center and fills most of the image, but plenty of objects still vary widely in size and position. The most direct approach is a sliding window: run the network at every position and every scale of the image.\n\nThat raises two problems.\n\nThe first is computation. An image has to be cut into thousands upon thousands of windows, and running the full convolutional network on each one is expensive.\n\nThe second is that windows and objects don't line up. Many windows capture only part of an object, say just the dog's head; that's enough for the classifier to recognize a dog, but not enough to tell you where the whole dog is. The authors say this yields “decent classification but poor localization and detection.”\n\nSo the authors propose three ideas: do multi-scale sliding windows efficiently inside the network; have each window predict not only a class but also the position of the object's box relative to the window; and finally, accumulate the evidence from all the windows.\n\n## Solving the Problem\n\n### The Classification Network\n\nOverFeat's classification network is similar to AlexNet, with a few differences: no contrast normalization, non-overlapping pooling regions, and larger feature maps in the first and second layers.\n\nThe paper actually provides two versions. The **fast model** has an $11\\times11$ first layer with stride 4; the **accurate model** switches the first layer to $7\\times7$ with stride 2, and also has one more layer and more feature maps. Their parameter counts are about the same (145 million for fast, 144 million for accurate, versus about 60 million for AlexNet), but the accurate model has nearly twice as many connections.\n\nDuring training, the image's shorter side is resized to 256 and random $221\\times221$ crops are taken; at this stage the network is treated as a non-spatial model whose final output is a $1\\times1$ classification vector. Only at test time does it switch to sliding over the whole image.\n\n### Why Sliding Windows Aren't Expensive\n\n[![Two rows of diagrams. Top row: a 14×14 input goes through a 5×5 convolution and 2×2 pooling, then the classifier's 5×5, 1×1, and 1×1 convolutions, ending in a 1×1 output. Bottom row: the input is enlarged to 16×16, every feature map along the way gains an extra yellow border, and the output is 2×2](/content/papers/assets/cd9ddd6b129a1c495df34121de190dc6244cb4d520df8eca6fcf86f44e85a94d.png)](/content/papers/assets/cd9ddd6b129a1c495df34121de190dc6244cb4d520df8eca6fcf86f44e85a94d.png)\n\n*Figure 5 from the paper, excerpted from [**page 8 of the v4 PDF**](https://arxiv.org/pdf/1312.6229v4#page=8). The top row uses the training input size and outputs a single position; the bottom row uses an enlarged test-time input, and the output becomes $2\\times2$. Yellow marks the extra computation from enlarging the input. The channel dimension is omitted.*\n\nStart with the top row. A $14\\times14$ input becomes $10\\times10$ after a $5\\times5$ convolution, and $5\\times5$ after pooling; the classifier's first layer takes in the whole $5\\times5$ and outputs a single position, and the two layers after it are both $1\\times1$.\n\nThe classifier was originally made of fully connected layers. The authors' observation: a fully connected layer that takes a fixed-size input is equivalent to a convolution kernel of the same size, and the fully connected layers after it are equivalent to $1\\times1$ convolutions. That way, the whole network consists only of convolutions, pooling, and ReLU.\n\nNow the bottom row. With the input enlarged to $16\\times16$, every layer's feature map gains an extra border, and the final output becomes $2\\times2$, which is the classification result for 4 windows. Overlapping regions are computed only once; the only extra computation is the yellow border.\n\nThat's the natural advantage of doing sliding windows with a convolutional network: run it once over the whole image and you get answers for every window, without cutting out each window and computing it separately.\n\n### The Output Is Too Sparse\n\nRunning everything in one pass has a price, though. From the input to the last convolutional layer, the accurate model goes through a stride-2 convolution and three pooling layers, shrinking by a total factor of $2\\times3\\times2\\times3=36$. In other words, the classifier produces only one output every 36 pixels of the input image.\n\nThe better a window lines up with the object, the more confident the network is; looking only once every 36 pixels, it can easily miss the best-aligned position. The authors found that such sparse output does even worse than AlexNet's approach of a fixed 10 crops.\n\nTheir solution is to avoid throwing away resolution at the last pooling step. The last pooling was originally a $3\\times3$ non-overlapping max pooling; now they shift the pooling's starting point by $\\Delta=0, 1, 2$ pixels, run it once for each, send each result through the classifier separately, and finally interleave the results back together:\n\n[![A one-dimensional illustration. (a) is the unpooled layer 5 feature map of length 20; (b) uses red, green, and blue for the three poolings with offsets 0, 1, and 2, each merging 3 cells into 1 and producing 6 cells; (c) shows the three pooled feature maps; (d) the classifier slides over them with a 5-cell window, giving 2 outputs per set; (e) the three sets of outputs are interleaved into a 6-cell output map](/content/papers/assets/d672122ea6ddf57393ed938154239f60084b8afebb1434624615cbd3e2b890ac.png)](/content/papers/assets/d672122ea6ddf57393ed938154239f60084b8afebb1434624615cbd3e2b890ac.png)\n\n*Figure 3 from the paper, excerpted from [**page 6 of the v4 PDF**](https://arxiv.org/pdf/1312.6229v4#page=6). The example uses the vertical dimension at scale 2 and is drawn to scale.*\n\nLet's work through the figure. The unpooled layer 5 feature map has length 20; for each offset we pool over groups of 3 cells, then slide the 5-cell-wide classifier across:\n\n```python\nlayer5 = 20        # length of the unpooled layer 5 feature map (the example in Figure 3 of the paper)\npool, window = 3, 5\n\ndef starts(offsets):\n    \"\"\"Start of each classifier window, in layer 5 pixels.\"\"\"\n    out = []\n    for d in offsets:\n        pooled = (layer5 - d) // pool          # pooled length at this offset\n        for k in range(pooled - window + 1):   # the classifier slides over with a window of 5\n            out.append(d + pool * k)\n    return sorted(out)\n\ncoarse, fine = starts([0]), starts([0, 1, 2])\nprint(\"Δ=0 only:\", coarse, \"→ one output every\", (coarse[1] - coarse[0]) * 12, \"input pixels\")\nprint(\"Δ=0,1,2:\", fine, \"→ one output every\", (fine[1] - fine[0]) * 12, \"input pixels\")\n```\n\n```text\nΔ=0 only: [0, 3] → one output every 36 input pixels\nΔ=0,1,2: [0, 1, 2, 3, 4, 5] → one output every 12 input pixels\n```\n\nEach offset leaves 6 cells after pooling, and the classifier gets 2 outputs from them, exactly the lengths of (c) and (d) in the figure; interleaving the three sets gives the 6 cells of (e).\n\nBefore the last pooling, the network has already shrunk by a factor of $2\\times3\\times2=12$, so two adjacent cells in layer 5 are 12 pixels apart in the input. With $\\Delta=0$ alone, the classifier steps 3 cells at a time, which is 36 pixels; with all three offsets, every cell gets an output, and the spacing shrinks to 12 pixels.\n\nThe authors also put it another way: apply the last pooling and the classifier once at every possible offset, then interleave the results.\n\n### Multiple Scales: Take the Max, Then Average\n\nThat was a single scale. For actual classification, the authors resize the image to 6 sizes, from $245\\times245$ to $461\\times569$, run the procedure above at each size, and run it again on the horizontally flipped image. The final classification takes three steps:\n\n1. For each scale and flip, take each class's maximum over all positions.\n2. Average the results across scales and flips.\n3. Take the top 1 or top 5 from the averaged class vector.\n\nThe authors sum up how the two halves of the network are used: the feature extraction layers in front convolve the whole image in one pass, which is most efficient; the classifier behind them works the other way around, taking a fixed $5\\times5$ input and searching exhaustively over every position and every scale of the layer 5 feature maps.\n\n### From Classification to Drawing Boxes\n\nLocalization requires one more thing: besides saying “what's here,” each window also has to say “where the object's box is.”\n\nAfter layers 1 to 5 of the classification network, the authors attach a separate regression network: two fully connected layers with 4096 and 1024 channels, followed by an output of 4 numbers representing the four edges of the box. Like the classifier, it's computed once for each of the $3\\times3$ offsets. The last layer has a separate copy for each class, 1000 in all.\n\nDuring training, layers 1 to 5 stay fixed and only the regression network is trained, with an $\\ell_2$ loss between the predicted box and the ground truth. Object boxes that overlap the input window by less than 50% aren't used for training: most of the object lies outside the window, so it's better handled by other windows that contain it.\n\nThe regression network is also trained at multiple scales. The authors say this makes predictions agree across scales, which greatly boosts the confidence after merging, so a few scales are enough. The ratio between scales is about 1.4, much larger than the 1.05 to 1.1 typical in pedestrian detection, which also lets the system run faster.\n\n### Accumulate, Don't Suppress\n\nEvery scale and every position produces a box, adding up to thousands of them. The authors use a greedy merging algorithm to boil them down to a few:\n\n1. At each scale, take the top $k$ classes the model is most confident about.\n2. Collect the boxes predicted for these classes at all positions and all scales.\n3. Repeatedly find the two closest boxes and merge them into one (averaging their coordinates), until the closeness of every pair falls below the threshold.\n\nCloseness is computed from the distance between the two boxes' centers and their intersection area. After merging, a box's confidence is the sum of the classification scores of all the windows merged into it.\n\n[![Four rows of images featuring a bear in a waterfall. The first row shows the classifier's output at each position for each scale; the second row raises the resolution of the output; the third row shows the many boxes the regression network predicts at each position, mostly concentrated on the bear; the final image has just one box, around the bear](/content/papers/assets/d52a811beca4cb19a17ff9c1e4d1fb5c130f8426db67edfc11b7f5ebec4e525e.png)](/content/papers/assets/d52a811beca4cb19a17ff9c1e4d1fb5c130f8426db67edfc11b7f5ebec4e525e.png)\n\n*Figure 6 from the paper, excerpted from [**page 9 of the v4 PDF**](https://arxiv.org/pdf/1312.6229v4#page=9). From top to bottom: the class and confidence at each position, the output after raising the resolution, the boxes predicted by the regression network, and the merged result.*\n\nIn the third row of this figure, most of the regressed boxes crowd onto the bear. A few “turtle” and “whale” boxes show up along the way, but their classification confidence is at most 0.11 and 0.12, and their positions are widely scattered, so merging doesn't add them up and they end up below the threshold. The bear boxes, by contrast, have high confidence (about 0.5 on average per scale) and consistent positions, so they merge into a single box with very high confidence.\n\nThe authors contrast this with traditional non-maximum suppression (NMS): NMS keeps only the highest-scoring box and throws the rest away, while here consistent boxes add to each other's scores, so scattered false positives coming from the pure classifier are easier to weed out.\n\n### Detection: Picking Negatives on the Fly During Training\n\nThe main difference between detection and localization is that detection has to be able to say “there's no object here,” which means one more class for the background.\n\nThe traditional approach is to start training on randomly chosen negatives, then add the negatives the model gets most wrong back into the training set, repeating for several rounds (bootstrapping). The authors find this both complicated and prone to letting the collection of negatives fall out of step with training. So instead, during training they pick a few negatives from each image on the spot, some random and some that the model finds most confusing. It costs more computation, but the procedure is much simpler; and since the feature layers have already been trained on the classification task, fine-tuning for detection doesn't take long anyway.\n\n## Discussion\n\n### Classification\n\n| Setting (validation set) | Top-1 | Top-5 |\n| --- | ---: | ---: |\n| AlexNet, 1 model | 40.7 | 18.2 |\n| Fast model, 1 scale, $\\Delta=0$ only | 39.28 | 17.12 |\n| Fast model, 1 scale, three offsets | 39.01 | 16.97 |\n| Fast model, 6 scales, three offsets | 38.12 | 16.27 |\n| Accurate model, fixed 10 crops | 35.60 | 14.71 |\n| Accurate model, 4 scales, three offsets | 35.74 | 14.18 |\n| 7 accurate models, 4 scales, three offsets | 33.96 | 13.24 |\n\n*Table: Error rates (%) excerpted from Table 2 of the paper.*\n\nAt a single scale, the three offsets bring only a small improvement (17.12% → 16.97%); the authors say they matter more with multiple scales. Going from 1 scale to 6, top-5 error falls from 16.97% to 16.27%. The accurate model with multi-scale sliding beats the fixed 10 crops by about half a percentage point (14.71% → 14.18%).\n\nOn the competition test set, OverFeat reached 14.2% top-5 error with a vote of 7 fast models, ranking fifth among 18 teams; the best result that year using only ILSVRC13 data was 11.7%. After the competition, they brought it down to 13.6% with bigger models.\n\n### Localization\n\nThe authors compare several settings on the ILSVRC12 validation set:\n\n- A single center crop only: about 40% error.\n- Combining predictions from all positions at two scales: 31.5%.\n- Going up to four scales: 30.0%.\n- A separate regression head for each class (per-class regressor) turns out much worse than one head shared by all classes: 44.1% versus 31.3%. The authors suspect that each class has too few training examples with boxes, while the parameters grow 1000-fold.\n\nOn the competition test set, OverFeat won the 2013 localization track with an error rate of 29.9%.\n\n### Detection\n\nDuring the competition, OverFeat's detection system placed third with 19.4% mAP; the winner, UvA, had 22.6%. After the competition, they trained longer and added lower-resolution input at each scale as context, raising mAP to 24.3%, ahead of every result at the time.\n\nThe authors also point out two things. First, the top two entries both used image segmentation to generate candidate regions, cutting the number of windows to examine from about 200,000 to 2,000; the literature indicates that this reduces false positives, whereas OverFeat uses dense sliding windows. Second, NEC and UvA fine-tuned on the detection validation set and OverFeat didn't; the validation and test sets differ enough in distribution from the training set that this step alone improves results by about one percentage point.\n\n## Conclusion\n\nOverFeat demonstrated something nobody had yet written down clearly: classification, localization, and detection can share a single convolutional network, and sliding windows can be computed cheaply inside a convolutional network. Its localization result was the best of 2013, and its detection result also reached the state of the art after the competition.\n\nThat record didn't last long. R-CNN first generates candidate regions with selective search, then runs the convolutional network once on each region; a later version of its paper added the same ILSVRC 2013 detection benchmark and [reported 31.4% mAP](https://arxiv.org/abs/1311.2524), versus OverFeat's 24.3%. The same paper also acknowledges that OverFeat is about 9 times faster (about 2 seconds per image), because its sliding windows don't require image-level warping, so overlapping computation can be shared.\n\nIn its related work, the later YOLO describes OverFeat this way: it performs sliding-window detection efficiently, but it's still a disjoint system, optimized for localization rather than detection; each prediction sees only local information and needs significant post-processing to produce coherent detections. YOLO instead has the network look at the whole image at once and output every box directly.\n\n\n> [!TIP]\n> \n> For YOLO, and for FCN, which likewise treats fully connected layers as convolutions so that a classification network outputs a whole prediction map, see our notes:\n> \n> - **[[15.06] YOLOv1: You Only Look Once](/blog/papers/object-detection/yolov1)**\n> - **[[14.11] FCN: Fully Convolutional Networks](/blog/papers/segmentation/fcn)**\n\n\nLooking back, you can already see traces of many of YOLO's and FCN's techniques in this paper: treating fully connected layers as convolutions, computing the whole image in one pass, regressing boxes directly on feature maps. It's just that OverFeat, in 2013, still split these into several separate steps.\n\nIf you've read YOLO, it's worth coming back to compare it with this paper; you'll see more clearly what exactly YOLO changed.\n","imageSizes":{"/content/papers/assets/cd9ddd6b129a1c495df34121de190dc6244cb4d520df8eca6fcf86f44e85a94d.png":{"width":1016,"height":576},"/content/papers/assets/d672122ea6ddf57393ed938154239f60084b8afebb1434624615cbd3e2b890ac.png":{"width":662,"height":324},"/content/papers/assets/d52a811beca4cb19a17ff9c1e4d1fb5c130f8426db67edfc11b7f5ebec4e525e.png":{"width":988,"height":1594}}}