Datasets:

JimmyUnleashed
/

FGCV_Aircraft_Dataset

+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+        "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+<head>
+  <meta http-equiv="content-type" content="text/html; charset=utf-8" />
+  <title>FGVC-Aircraft</title>
+  <style type="text/css">
+  html {
+  font-family: Helvetica, Arial, Sans ;
+  }
+  body {
+  max-width: 60em ;
+  margin: 0 auto ;
+  padding: 1em ;
+  }
+  pre {
+  background-color: #fafafa ;
+  border: 1px solid #ccc ;
+  padding: 1em ;
+  }
+  p {
+  line-height: 1.4em ;
+  }
+  </style>
+</head>
+<body>
+<h1>FGVC-Aircraft Benchmark</h1>
+<p><strong>Fine-Grained Visual Classification of Aircraft (FGVC-Aircraft)</strong> is
+a benchmark dataset for the fine grained visual categorization of
+aircraft.</p>
+<ul>
+<li><a href="archives/fgvc-aircraft-2013b.tar.gz">Data, annotations, and evaluation code</a> [2.75 GB | <a href="archives/fgvc-aircraft-2013b.html">MD5 Sum</a>].</li>
+<li><a href="archives/fgvc-aircraft-2013b-annotations.tar.gz">Annotations and evaluation code only</a> [375 KB | <a href="archives/fgvc-aircraft-2013b-annotations.html">MD5 Sum</a>].</li>
+<li>Project <a href="http://www.robots.ox.ac.uk/~vgg/data/fgvc-aircraft/">home page</a>.</li>
+<li>This data was used as part of the fine-grained recognition challenge
+<a href="https://sites.google.com/site/fgcomp2013/">FGComp 2013</a> which ran
+jointly with the ImageNet Challenge 2013
+(<a href="https://sites.google.com/site/fgcomp2013/results">results</a>). Please
+note that <em>the evaluation code provided here may differ</em> from the
+one used in the challenge.</li>
+</ul>
+<p>Please use the following citation when referring to this dataset:</p>
+<p><em>Fine-Grained Visual Classification of Aircraft</em>, S. Maji, J. Kannala,
+E. Rahtu, M. Blaschko, A. Vedaldi, <a href="http://arxiv.org/abs/1306.5151">arXiv.org</a>, 2013</p>
+<pre><code>@techreport{maji13fine-grained,
+   title         = {Fine-Grained Visual Classification of Aircraft},
+   author        = {S. Maji and J. Kannala and E. Rahtu
+                    and M. Blaschko and A. Vedaldi},
+   year          = {2013},
+   archivePrefix = {arXiv},
+   eprint        = {1306.5151},
+   primaryClass  = "cs-cv",
+}
+</code></pre>
+<p>For further information see:</p>
+<ul>
+<li><a href="#quick">Quick start</a>
+<ul>
+<li><a href="#aircraft">About aircraft</a></li>
+</ul></li>
+<li><a href="#format">Data and annotation format</a></li>
+<li><a href="#evaluation">Evaluation</a>
+<ul>
+<li><a href="#metric">Evaluation metric</a></li>
+<li><a href="#code">Evaluation code</a></li>
+</ul></li>
+<li><a href="#ack">Ackwonledgments</a></li>
+<li><a href="#release">Release notes</a></li>
+</ul>
+<p><strong>Note.</strong> This data has been used as part of the <em>ImageNet FGVC
+challenge in conjuction with the International Conference on Computer
+Vision (ICCV) 2013</em>. Test labels were not made available until the
+challenge due to the ImageNet challenge policy. They have now been
+released as part of the download above. If you arelady downloaded the
+iamge archive and want to have access to the test labels, simply
+download the annotations archive again.</p>
+<p><strong>Note.</strong> Images in the benchmark are generously made available <strong>for
+non-commercial research purposes only</strong> by a number of <em>airplane
+spotters</em>. Please note that the original authors retain the copyright
+of the respective photographs and should be contacted for any other
+use. For further details see the <a href="#ack">copyright note</a> below.</p>
+<h1><a id=quick></a> Quick start</h1>
+<p>The dataset contains 10,200 images of aircraft, with 100 images for
+each of 102 different aircraft model variants, most of which are
+airplanes. The (main) aircraft in each image is annotated with a tight
+bounding box and a hierarchical airplane model label.</p>
+<p>Aircraft models are organized in a four-levels hierarchy. The four
+levels, from finer to coarser, are:</p>
+<ul>
+<li><strong>Model</strong>, e.g. <em>Boeing 737-76J</em>. Since certain models are nearly visually
+indistinguishable, this level is not used in the evaluation.</li>
+<li><strong>Variant</strong>, e.g. <em>Boeing 737-700</em>. A variant collapses all the
+models that are visually indistinguishable into one class. The
+dataset comprises 102 different variants.</li>
+<li><strong>Family</strong>, e.g. <em>Boeing 737</em>. The dataset comprises 70 different
+families.</li>
+<li><strong>Manufacturer</strong>, e.g. <em>Boeing</em>. The dataset comprises 41
+different manufacturers.</li>
+</ul>
+<p>The data is divided into three equally-sized <em>training</em>, <em>validation</em>
+and <em>test</em> subsets. The first two sets can be used for development,
+and the latter should be used for final evaluation only. The format of
+the data is described <a href="#format">next</a>.</p>
+<p>The performance of a fine-grained classification algorithm is
+evaluated in term of average class-prediction accuracy. This is
+defined as the average of the diagonal of the row-normalized confusion
+matrix, as used for example in Caltech-101. Three classification
+challenges are considered: variant, family, and manufacturer. An
+<a href="#software">evaluation script</a> in MATLAB is provided.</p>
+<h2><a href=aircraft></a> About aircraft</h2>
+<p>Aircraft, and in particular airplanes, are alternative to objects
+typically considered for fine-grained categorization such as birds and
+pets. There are several aspects that make aircraft model recognition
+particularly interesting. Firstly, aircraft designs span a hundred
+years, including many thousand different models and hundreds of
+different makes and airlines. Secondly, aircraft designs vary
+significantly depending on the size (from home-built to large
+carriers), destination (private, civil, military), purpose
+(transporter, carrier, training, sport, fighter, etc.), propulsion
+(glider, propeller, jet), and many other factors including
+technology. One particular axis of variation, which is is not shared
+with categories such as animals, is the fact that the <em>structure</em> of
+the aircraft changes with their design (number of wings,
+undercarriages, wheel per undercarriage, engines, etc.). Thirdly, any
+given aircraft model can be re-purposed or used by different
+companies, which causes further variations in appearance
+(livery). These, depending on the identification task, may be consider
+as noise or as useful information to be extracted. Finally, aircraft
+are largely rigid objects, which simplifies certain aspects of their
+modeling (compared to highly-deformable animals such as cats),
+allowing one to focus on the core aspects of the fine-grained
+recognition problem.</p>
+<h1><a id=format></a> Data format</h1>
+<p>The directory <code>data</code> contains the images as well as a number of text
+files with the data annotations.</p>
+<p>Images are contained in the <code>data/images</code> sub-directory. They are in
+JPEG format and have a name composed of seven digits and the <code>.jpg</code>
+suffix (e.g. <code>data/images/1187707.jpg</code>). The image resolution is about
+1-2MP. Each image has at the bottom a banner 20 pixels high containing
+<a href="#ack">copyright</a> information. Please make sure to remove this banner
+when using the images to train and evaluate algorithms.</p>
+<p>The annotations come in a number of text files. Each line of these
+files contains an image name optionally followed by an image
+annotation, either a textual label or a sequence of numbers.</p>
+<p><code>data/images_train.txt</code> contains the list of training images:</p>
+<pre>
+0787226
+1481091
+1548899
+0674300
+...
+</pre>
+<p>Similar files <code>data/images_val.txt</code> and <code>data/images_test.txt</code> contain the list
+of validation and test images.</p>
+<p><code>data/images_variant_train.txt</code>, <code>data/images_family_train.txt</code>, and
+<code>data/images_manufacturer_train.txt</code> contain the list of training
+images annotated with the model variant, family, and manufacturer
+names respectively:</p>
+<pre>
+0787226 Abingdon Spherical Free Balloon
+1481091 AEG Wagner Eule
+1548899 Aeris Naviter AN-2 Enara
+0674300 Aeritalia F-104S Starfighter
+...
+</pre>
+<p>Similar files are provided for the validation and test subsets.</p>
+<p>Finally, <code>data/images_box.txt</code> contains the aircraft bounding
+boxes, one per image. The bounding box is specified by four numbers:
+<em>xmin</em>, <em>ymin</em>, <em>xmax</em> and <em>ymax</em>. The top-left pixel of an image has
+coordinate (1,1).</p>
+<h1><a id=evaluation></a> Evaluation</h1>
+<p>The performance of a classifier is measured in term of its average
+classification accuracy, as detailed next.</p>
+<h2><a id=metric></a> Evaluation metric</h2>
+<p>The output of a classification algorithm must be a list of triplets of
+the type (<em>image</em>,<em>label</em>,<em>score</em>), where</p>
+<ul>
+<li><em>image</em> is an image label, i.e. a seven-digit number,</li>
+<li><em>label</em> is an image label, i.e.. an aircraft model variant, family, or manufacturer, and</li>
+<li><em>score</em> is a real number expressing the belief in the judgment.</li>
+</ul>
+<p>When computing the classification accuracy, an image is assigned the
+label contained in its highest-scoring triplet. An image that has no
+triplets is considered unclassified and always count as a
+classification error (therefore it is better to guess at least one
+label for each image rather than leaving it unclassified).</p>
+<p>The quality of the predictions is measured in term of <em>average
+accuracy</em>, obtained as follows:</p>
+<ul>
+<li>The confusion matrix is square, with one row per class.</li>
+<li>Each element of the confusion matrix is the number of time aircraft
+of a given class (specified by the row) are classified as a second
+class (column). Ideally, the confusion matrix should be diagonal.</li>
+<li>The confusion matrix is row-normalized by the number of images of
+the corresponding aircraft class (each row therefore sums to one if
+there are no unclassified images).</li>
+<li>The average accuracy is computed as the average of the diagonal of
+the confusion matrix.</li>
+</ul>
+<p>There are three challenges: classifying the aircraft variant, family, and manufacturer.</p>
+<h2><a id=code></a> Evaluation code</h2>
+<p>The evaluation protocol has been implemented in the MATLAB m-file
+<code>evaluation.m</code>. This function takes the path to the <code>data</code> folder, a
+composite name indicating the evaluation subset and challenge
+(e.g. <code>'manufacturer_test'</code> or <code>'family_val'</code>), and the list of
+triplets, and returns the confusion matrix. For example</p>
+<pre>
+images = {'2074164'} ;
+labels = {'McDonnell Douglas MD-90-30'} ;
+scores = 1 ;
+confusion = evaluate('/path/fgcv-aircraft/data', 'test', images, labels, scores) ;
+accuracy = mean(diag(confusion)) ;
+</pre>
+<p>evaluates a classifier output containing exactly one triplet (image,
+label, score), where the image is <code>'2074164'</code>, its predicted class is
+<code>'McDonnell Douglas MD-90-30'</code>, and the score of the prediction is
+<code>1</code>. In practice, a complete set of predictions (one for each
+image-class pair) is usually evaluated.</p>
+<p>See the builtin help of the <code>evaluation</code> MATLAB functions for further
+practical details. See also <code>example_evaluation.m</code> for examples on how
+to use this function.</p>
+<h1><a id=ack></a> Acknowledgments</h1>
+<p>The creation of this dataset started during the <em>Johns Hopkins CLSP
+Summer Workshop 2012</em>
+<a href="http://www.clsp.jhu.edu/workshops/archive/ws-12/groups/tduosn/">Towards a Detailed Understanding of Objects and Scenes in Natural Images</a>
+with, in alphabetical order, Matthew B. Blaschko, Ross B. Girshick,
+Juho Kannala, Iasonas Kokkinos, Siddharth Mahendran, Subhransu Maji,
+Sammy Mohamed, Esa Rahtu, Naomi Saphra, Karen Simonyan, Ben Taskar,
+Andrea Vedaldi, and David Weiss.</p>
+<p>The CLSP workshop was supported by the National Science Foundation via
+Grant No 1005411, the Office of the Director of National Intelligence
+via the JHU Human Language Technology Center of Excellence; and Google
+Inc.</p>
+<p>A special thanks goes to Pekka Rantalankila for helping with the
+creation of the airplane hieararchy.</p>
+<p>Many thanks to the photographers that kindly made available their
+images for research purposes. Each photographer is listed below, along
+with a link to his/her <a href="http://airliners.net">airlners.net</a> page:</p>
+<ul>
+<li><a href="http://www.airliners.net/profile/dendrobatid">Mick Bajcar</a></li>
+<li><a href="http://www.airliners.net/profile/aldobid">Aldo Bidini</a></li>
+<li><a href="http://www.airliners.net/profile/minoeke">Wim Callaert</a></li>
+<li><a href="http://www.airliners.net/profile/tommypilot">Tommy Desmet</a></li>
+<li><a href="http://www.airliners.net/profile/snorre">Thomas Posch</a></li>
+<li><a href="http://www.airliners.net/profile/lemonkitty">James Richard Covington</a></li>
+<li><a href="http://www.airliners.net/profile/stegi">Gerry Stegmeier</a></li>
+<li><a href="http://www.airliners.net/profile/aal151heavy">Ben Wang</a></li>
+<li><a href="http://www.airliners.net/profile/dazbo5">Darren Wilson</a></li>
+<li><a href="http://www.airliners.net/profile/fly-k">Konstantin von Wedelstaedt</a></li>
+</ul>
+<p>Please note that the images are made available <strong>exclusively for
+non-commercial research purposes</strong>. The original authors retain the
+copyright on the respective pictures and should be contacted for any
+other usage of them.</p>
+<h1><a id=release></a> Release notes</h1>
+<ul>
+<li><em>FGVC-Aircraft 2013b</em> - The same as 2013a, but with test annotations included.</li>
+<li><em>FGVC-Aircraft 2013a</em> - First public release of the data.</li>
+</ul>
+</body>
+</html>

README.md CHANGED Viewed

@@ -1,3 +1,261 @@
----
-license: mit
----

+# FGVC-Aircraft Benchmark
+**Fine-Grained Visual Classification of Aircraft (FGVC-Aircraft)** is
+a benchmark dataset for the fine grained visual categorization of
+aircraft.
+* [Data, annotations, and evaluation code](archives/fgvc-aircraft-2013b.tar.gz) [2.75 GB | [MD5 Sum](archives/fgvc-aircraft-2013b.html)].
+* [Annotations and evaluation code only](archives/fgvc-aircraft-2013b-annotations.tar.gz) [375 KB | [MD5 Sum](archives/fgvc-aircraft-2013b-annotations.html)].
+* Project [home page](http://www.robots.ox.ac.uk/~vgg/data/fgvc-aircraft/).
+* This data was used as part of the fine-grained recognition challenge
+  [FGComp 2013](https://sites.google.com/site/fgcomp2013/) which ran
+  jointly with the ImageNet Challenge 2013
+  ([results](https://sites.google.com/site/fgcomp2013/results)). Please
+  note that *the evaluation code provided here may differ* from the
+  one used in the challenge.
+Please use the following citation when referring to this dataset:
+*Fine-Grained Visual Classification of Aircraft*, S. Maji, J. Kannala,
+E. Rahtu, M. Blaschko, A. Vedaldi, [arXiv.org](http://arxiv.org/abs/1306.5151), 2013
+    @techreport{maji13fine-grained,
+       title         = {Fine-Grained Visual Classification of Aircraft},
+       author        = {S. Maji and J. Kannala and E. Rahtu
+                        and M. Blaschko and A. Vedaldi},
+       year          = {2013},
+       archivePrefix = {arXiv},
+       eprint        = {1306.5151},
+       primaryClass  = "cs-cv",
+    }
+For further information see:
+* [Quick start](#quick)
+  * [About aircraft](#aircraft)
+* [Data and annotation format](#format)
+* [Evaluation](#evaluation)
+  * [Evaluation metric](#metric)
+  * [Evaluation code](#code)
+* [Ackwonledgments](#ack)
+* [Release notes](#release)
+**Note.** This data has been used as part of the *ImageNet FGVC
+challenge in conjuction with the International Conference on Computer
+Vision (ICCV) 2013*. Test labels were not made available until the
+challenge due to the ImageNet challenge policy. They have now been
+released as part of the download above. If you arelady downloaded the
+iamge archive and want to have access to the test labels, simply
+download the annotations archive again.
+**Note.** Images in the benchmark are generously made available **for
+non-commercial research purposes only** by a number of *airplane
+spotters*. Please note that the original authors retain the copyright
+of the respective photographs and should be contacted for any other
+use. For further details see the [copyright note](#ack) below.
+# <a id=quick></a> Quick start
+The dataset contains 10,200 images of aircraft, with 100 images for
+each of 102 different aircraft model variants, most of which are
+airplanes. The (main) aircraft in each image is annotated with a tight
+bounding box and a hierarchical airplane model label.
+Aircraft models are organized in a four-levels hierarchy. The four
+levels, from finer to coarser, are:
+* **Model**, e.g. *Boeing 737-76J*. Since certain models are nearly visually
+  indistinguishable, this level is not used in the evaluation.
+* **Variant**, e.g. *Boeing 737-700*. A variant collapses all the
+  models that are visually indistinguishable into one class. The
+  dataset comprises 102 different variants.
+* **Family**, e.g. *Boeing 737*. The dataset comprises 70 different
+  families.
+* **Manufacturer**, e.g. *Boeing*. The dataset comprises 41
+  different manufacturers.
+The data is divided into three equally-sized *training*, *validation*
+and *test* subsets. The first two sets can be used for development,
+and the latter should be used for final evaluation only. The format of
+the data is described [next](#format).
+The performance of a fine-grained classification algorithm is
+evaluated in term of average class-prediction accuracy. This is
+defined as the average of the diagonal of the row-normalized confusion
+matrix, as used for example in Caltech-101. Three classification
+challenges are considered: variant, family, and manufacturer. An
+[evaluation script](#software) in MATLAB is provided.
+## <a href=aircraft></a> About aircraft
+Aircraft, and in particular airplanes, are alternative to objects
+typically considered for fine-grained categorization such as birds and
+pets. There are several aspects that make aircraft model recognition
+particularly interesting. Firstly, aircraft designs span a hundred
+years, including many thousand different models and hundreds of
+different makes and airlines. Secondly, aircraft designs vary
+significantly depending on the size (from home-built to large
+carriers), destination (private, civil, military), purpose
+(transporter, carrier, training, sport, fighter, etc.), propulsion
+(glider, propeller, jet), and many other factors including
+technology. One particular axis of variation, which is is not shared
+with categories such as animals, is the fact that the *structure* of
+the aircraft changes with their design (number of wings,
+undercarriages, wheel per undercarriage, engines, etc.). Thirdly, any
+given aircraft model can be re-purposed or used by different
+companies, which causes further variations in appearance
+(livery). These, depending on the identification task, may be consider
+as noise or as useful information to be extracted. Finally, aircraft
+are largely rigid objects, which simplifies certain aspects of their
+modeling (compared to highly-deformable animals such as cats),
+allowing one to focus on the core aspects of the fine-grained
+recognition problem.
+# <a id=format></a> Data format
+The directory `data` contains the images as well as a number of text
+files with the data annotations.
+Images are contained in the `data/images` sub-directory. They are in
+JPEG format and have a name composed of seven digits and the `.jpg`
+suffix (e.g. `data/images/1187707.jpg`). The image resolution is about
+1-2MP. Each image has at the bottom a banner 20 pixels high containing
+[copyright](#ack) information. Please make sure to remove this banner
+when using the images to train and evaluate algorithms.
+The annotations come in a number of text files. Each line of these
+files contains an image name optionally followed by an image
+annotation, either a textual label or a sequence of numbers.
+`data/images_train.txt` contains the list of training images:
+<pre>
+0787226
+1481091
+1548899
+0674300
+...
+</pre>
+Similar files `data/images_val.txt` and `data/images_test.txt` contain the list
+of validation and test images.
+`data/images_variant_train.txt`, `data/images_family_train.txt`, and
+`data/images_manufacturer_train.txt` contain the list of training
+images annotated with the model variant, family, and manufacturer
+names respectively:
+<pre>
+0787226 Abingdon Spherical Free Balloon
+1481091 AEG Wagner Eule
+1548899 Aeris Naviter AN-2 Enara
+0674300 Aeritalia F-104S Starfighter
+...
+</pre>
+Similar files are provided for the validation and test subsets.
+Finally, `data/images_box.txt` contains the aircraft bounding
+boxes, one per image. The bounding box is specified by four numbers:
+*xmin*, *ymin*, *xmax* and *ymax*. The top-left pixel of an image has
+coordinate (1,1).
+# <a id=evaluation></a> Evaluation
+The performance of a classifier is measured in term of its average
+classification accuracy, as detailed next.
+## <a id=metric></a> Evaluation metric
+The output of a classification algorithm must be a list of triplets of
+the type (*image*,*label*,*score*), where
+* *image* is an image label, i.e. a seven-digit number,
+* *label* is an image label, i.e.. an aircraft model variant, family, or manufacturer, and
+* *score* is a real number expressing the belief in the judgment.
+When computing the classification accuracy, an image is assigned the
+label contained in its highest-scoring triplet. An image that has no
+triplets is considered unclassified and always count as a
+classification error (therefore it is better to guess at least one
+label for each image rather than leaving it unclassified).
+The quality of the predictions is measured in term of *average
+accuracy*, obtained as follows:
+* The confusion matrix is square, with one row per class.
+* Each element of the confusion matrix is the number of time aircraft
+  of a given class (specified by the row) are classified as a second
+  class (column). Ideally, the confusion matrix should be diagonal.
+* The confusion matrix is row-normalized by the number of images of
+  the corresponding aircraft class (each row therefore sums to one if
+  there are no unclassified images).
+* The average accuracy is computed as the average of the diagonal of
+  the confusion matrix.
+There are three challenges: classifying the aircraft variant, family, and manufacturer.
+## <a id=code></a> Evaluation code
+The evaluation protocol has been implemented in the MATLAB m-file
+`evaluation.m`. This function takes the path to the `data` folder, a
+composite name indicating the evaluation subset and challenge
+(e.g. `'manufacturer_test'` or `'family_val'`), and the list of
+triplets, and returns the confusion matrix. For example
+<pre>
+images = {'2074164'} ;
+labels = {'McDonnell Douglas MD-90-30'} ;
+scores = 1 ;
+confusion = evaluate('/path/fgcv-aircraft/data', 'test', images, labels, scores) ;
+accuracy = mean(diag(confusion)) ;
+</pre>
+evaluates a classifier output containing exactly one triplet (image,
+label, score), where the image is `'2074164'`, its predicted class is
+`'McDonnell Douglas MD-90-30'`, and the score of the prediction is
+`1`. In practice, a complete set of predictions (one for each
+image-class pair) is usually evaluated.
+See the builtin help of the `evaluation` MATLAB functions for further
+practical details. See also `example_evaluation.m` for examples on how
+to use this function.
+# <a id=ack></a> Acknowledgments
+The creation of this dataset started during the *Johns Hopkins CLSP
+Summer Workshop 2012*
+[Towards a Detailed Understanding of Objects and Scenes in Natural Images](http://www.clsp.jhu.edu/workshops/archive/ws-12/groups/tduosn/)
+with, in alphabetical order, Matthew B. Blaschko, Ross B. Girshick,
+Juho Kannala, Iasonas Kokkinos, Siddharth Mahendran, Subhransu Maji,
+Sammy Mohamed, Esa Rahtu, Naomi Saphra, Karen Simonyan, Ben Taskar,
+Andrea Vedaldi, and David Weiss.
+The CLSP workshop was supported by the National Science Foundation via
+Grant No 1005411, the Office of the Director of National Intelligence
+via the JHU Human Language Technology Center of Excellence; and Google
+Inc.
+A special thanks goes to Pekka Rantalankila for helping with the
+creation of the airplane hieararchy.
+Many thanks to the photographers that kindly made available their
+images for research purposes. Each photographer is listed below, along
+with a link to his/her [airlners.net](http://airliners.net) page:
+* [Mick Bajcar](http://www.airliners.net/profile/dendrobatid)
+* [Aldo Bidini](http://www.airliners.net/profile/aldobid)
+* [Wim Callaert](http://www.airliners.net/profile/minoeke)
+* [Tommy Desmet](http://www.airliners.net/profile/tommypilot)
+* [Thomas Posch](http://www.airliners.net/profile/snorre)
+* [James Richard Covington](http://www.airliners.net/profile/lemonkitty)
+* [Gerry Stegmeier](http://www.airliners.net/profile/stegi)
+* [Ben Wang](http://www.airliners.net/profile/aal151heavy)
+* [Darren Wilson](http://www.airliners.net/profile/dazbo5)
+* [Konstantin von Wedelstaedt](http://www.airliners.net/profile/fly-k)
+Please note that the images are made available **exclusively for
+non-commercial research purposes**. The original authors retain the
+copyright on the respective pictures and should be contacted for any
+other usage of them.
+# <a id=release></a> Release notes
+* *FGVC-Aircraft 2013b* - The same as 2013a, but with test annotations included.
+* *FGVC-Aircraft 2013a* - First public release of the data.

evaluation.m ADDED Viewed

	@@ -0,0 +1,118 @@

+function [confusion, results] = evaluation(datasetPath, split, images, labels, scores)
+% EVALUATION Evaluate classification results
+%   CONFUSION = EVALUATION(DATASETPATH, SPLIT, IMAGES, LABELS, SCORES)
+%   evaluate the classification results IMAGES,LABELS,SCORES on the
+%   data split SPLIT.
+%
+%   IMAGES, LABELS and SCORES are one-dimensional arrays of the same length,
+%   specifying a number of (image,lable,score) triplets. IMAGES and
+%   LABELS can be either cell arrays of strings, with the name of
+%   images and airplane models respectively, or indexes in the list of
+%   images (images.txt) and evaluated airplane models
+%   (models_evaluated.txt) -- the latter option is generally more
+%   efficient. SCORES is a numeric array containing the score of the
+%   corresponding predictions.
+%
+%   CONFUSION is confusion matrix, with one row
+%   per ground truth class and one column per estimated class. The
+%   average accuracy is simply the average of the diagonal of the confusion.
+%
+%   [~,RESULTS] = EVALUATION() returns an additional struct array with
+%   one entry for each evaluated class. It has the following
+%   fields:
+%
+%   RESULTS.RC - Recall
+%   RESULTS.PR - Precision
+%   RESULTS.TP - True positive rate
+%   RESULTS.TN - True negative rate
+%   RESULTS.AP - Average precision
+%   RESULTS.ROCEER - ROC Equal Error Rate
+% Author: Andrea Vedaldi
+% Copyright (C) 2013 Andrea Vedaldi
+% This code is released in the public domain.
+% Get the ground truth image list and labels for the set.
+[images0, labels0] = textread(fullfile(datasetPath, ['images_' split '.txt']), '%7s%*1s%s', 'delimiter', '\n', 'whitespace', '') ;
+[classes0, ~, y0] = unique(labels0) ;
+% Convert character labels to indexes. Images and ground truth classes
+% are assigned a number in the same order as the training data.
+ok = true(size(labels)) ;
+if isnumeric(labels)
+  y = labels ;
+else
+  [~,y] = ismember(labels, classes0) ;
+  if any(y == 0)
+    for i = find(y == 0)
+      warning('Class %s not found in set of ground truth classes\n', labels{i}) ;
+      ok(i) = false ;
+    end
+  end
+end
+if isnumeric(images)
+  x = images ;
+else
+  [~, x] = ismember(images, images0) ;
+  if any(y == 0)
+    for i = find(y == 0)
+      warning('Image %s was not found in set of ground truth images\n', images{i}) ;
+      ok(i) = false ;
+    end
+  end
+end
+y0 = y0' ;
+y = y(ok)' ;
+x = x(ok)' ;
+numImages = numel(images0) ;
+numClasses = numel(classes0) ;
+fprintf('%s: %s split, %d classes, %d images\n', mfilename, split, numClasses, numImages) ;
+% Iterate over predicted classes. For each, initialize all prediction
+% scores for all images to -infinity. Then, replace the score for
+% those image-label pairs that appear in the input.
+scorem = -inf(numClasses, numImages) ;
+for y1 = 1:numClasses
+  scorem(y1, x(y == y1)) = scores(y == y1) ;
+  [rc,pr,info] = vl_pr(2 * (y0 == y1) - 1, scorem(y1, :), 'IncludeInf', false) ;
+  results(y1).rc = rc ;
+  results(y1).pr = pr ;
+  results(y1).ap = info.ap ;
+  [tp,tn,info] = vl_roc(2 * (y0 == y1) - 1, scorem(y1, :), 'IncludeInf', false) ;
+  results(y1).tp = tp ;
+  results(y1).tn = tn ;
+  results(y1).roceer = info.eer ;
+  results(y1).name = classes0{y1} ;
+  results(y1).numGtSamples = sum(y0 == y1) ;
+  results(y1).numCandidates = sum(y == y1) ;
+  fprintf('%s: %25s [%5d gt,%5d cands] AP %5.2f%%, ROC-EER %5.2f%%\n', ...
+    mfilename, ...
+    results(y1).name, ...
+    results(y1).numGtSamples, ...
+    results(y1).numCandidates, ...
+    results(y1).ap * 100, ...
+    results(y1).roceer * 100) ;
+end
+confusion = zeros(numClasses) ;
+[~, preds] = max([-inf(1, numImages) ; scorem]) ;
+preds = preds - 1 ;
+for y1 = 1:numClasses
+  z = accumarray(preds(preds > 0 & y0 == y1)', 1, [numClasses 1])' ;
+  z = z/results(y1).numGtSamples ;
+  confusion(y1,:) = z ;
+end
+fprintf('%s: mean accuracy: %.2f %%\n', mfilename, mean(diag(confusion))*100) ;

example_evaluation.m ADDED Viewed

	@@ -0,0 +1,43 @@

+% Demonstrates the use of the EVALUATION() functions.
+% choose a task-set combination
+split = 'variant_test' ;
+%split = 'variant_trainval' ;
+%split = 'family_test' ;
+%split = 'manufacturer_test' ;
+switch 1
+  case 1
+    % Example 1: the evaluation set contains exactly one image-label pair
+    images = {'0900914'} ;
+    labels = {'747-400'} ;
+    scores = 1 ;
+  case 2
+    % Example 2: the evaluation set contains exactly all the ground truth image-label pairs (perfect
+    % performance).
+    [images, labels] = textread(fullfile('data', ['images_' split '.txt']), '%7s%*1s%s', 'delimiter', '\n', 'whitespace', '') ;
+    scores = ones(size(labels)) ;
+  case 3
+    % Example 3: the evaluation set contains all the possible
+    % image-label pair and random scores. Numeric inputs are used
+    % for efficiency.
+    [images0, labels0] = textread(fullfile('data', ['images_' split '.txt']), '%7s%*1s%s', 'delimiter', '\n', 'whitespace', '') ;
+    n = numel(images0) ;
+    clear images labels scores ;
+    for ci = 1:100
+      images{ci} = 1:n ;
+      labels{ci} = repmat(ci,1,n) ;
+      scores{ci} = randn(1,n) ;
+    end
+    images = [images{:}] ;
+    labels = [labels{:}] ;
+    scores = [scores{:}] ;
+end
+[confusion, results] = evaluation('data', split, images, labels, scores) ;
+figure(1) ; clf ;
+imagesc(confusion) ; axis tight equal ;
+xlabel('predicted') ;
+ylabel('ground truth') ;
+title(sprintf('mean accuracy: %.2f %%\n', mean(diag(confusion))*100)) ;

vl_argparse.m ADDED Viewed

	@@ -0,0 +1,72 @@

+function [conf, args] = vl_argparse(conf, args, varargin)
+% VL_ARGPARSE  Parse list of parameter-value pairs
+%   CONF = VL_ARGPARSE(CONF, ARGS) updates the structure CONF based on
+%   the specified parameter-value pairs ARGS={PAR1, VAL1, ... PARN,
+%   VALN}. The function produces an error if an unknown parameter name
+%   is passed in.
+%
+%   [CONF, ARGS] = VL_ARGPARSE(CONF, ARGS) copies any parameter in
+%   ARGS that does not match CONF back to ARGS instead of producing an
+%   error.
+%
+%   Example::
+%     The function can be used to parse a list of arguments
+%     passed to a MATLAB functions:
+%
+%       function myFunction(x,y,z,varargin)
+%       conf.parameterName = defaultValue ;
+%       conf = vl_argparse(conf, varargin)
+%
+%     If only a subset of the options should be parsed, for example
+%     because the other options are interpreted by a subroutine, then
+%     use the form
+%
+%      [conf, varargin] = vl_argparse(conf, varargin)
+%
+%     that copies back to VARARGIN any unknown parameter.
+%
+%   See also: VL_OVERRIDE(), VL_HELP().
+% Authors: Andrea Vedaldi
+% Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+% All rights reserved.
+%
+% This file is part of the VLFeat library and is made available under
+% the terms of the BSD license (see the COPYING file).
+if ~isstruct(conf), error('CONF must be a structure') ; end
+if length(varargin) > 0, args = {args, varargin{:}} ; end
+remainingArgs = {} ;
+names = fieldnames(conf) ;
+if mod(length(args),2) == 1
+  error('Parameter-value pair expected (missing value?).') ;
+end
+for ai = 1:2:length(args)
+  paramName = args{ai} ;
+  if ~ischar(paramName)
+    error('The name of the parameter number %d is not a string.', (ai-1)/2+1) ;
+  end
+  value = args{ai+1} ;
+  if isfield(conf,paramName)
+    conf.(paramName) = value ;
+  else
+    % try case-insensitive
+    i = find(strcmpi(paramName, names)) ;
+    if isempty(i)
+      if nargout < 2
+        error('Unknown parameter ''%s''.', paramName) ;
+      else
+        remainingArgs(end+1:end+2) = args(ai:ai+1) ;
+      end
+    else
+      conf.(names{i}) = value ;
+    end
+  end
+end
+args = remainingArgs ;

vl_pr.m ADDED Viewed

	@@ -0,0 +1,234 @@

+function [recall, precision, info] = vl_pr(labels, scores, varargin)
+%VL_PR   Precision-recall curve.
+%   [RECALL, PRECISION] = VL_PR(LABELS, SCORES) computes the
+%   precision-recall (PR) curve. LABELS are the ground truth labels,
+%   greather than zero for a positive sample and smaller than zero for
+%   a negative one. SCORES are the scores of the samples obtained from
+%   a classifier, where lager scores should correspond to positive
+%   samples.
+%
+%   Samples are ranked by decreasing scores, starting from rank 1.
+%   PRECISION(K) and RECALL(K) are the precison and recall when
+%   samples of rank smaller or equal to K-1 are predicted to be
+%   positive and the remaining to be negative. So for example
+%   PRECISION(3) is the percentage of positive samples among the two
+%   samples with largest score. PRECISION(1) is the precision when no
+%   samples are predicted to be positive and is conventionally set to
+%   the value 1.
+%
+%   Set to zero the lables of samples that should be ignored in the
+%   evaluation. Set to -INF the scores of samples which are not
+%   retrieved. If there are samples with -INF score, then the PR curve
+%   may have maximum recall smaller than 1, unless the INCLUDEINF
+%   option is used (see below). The options NUMNEGATIVES and
+%   NUMPOSITIVES can be used to add additional surrogate samples with
+%   -INF score (see below).
+%
+%   [RECALL, PRECISION, INFO] = VL_PR(...) returns an additional
+%   structure INFO with the following fields:
+%
+%   info.auc::
+%     The area under the precision-recall curve. If the INTERPOLATE
+%     option is set to FALSE, then trapezoidal interpolation is used
+%     to integrate the PR curve. If the INTERPOLATE option is set to
+%     TRUE, then the curve is piecewise constant and no other
+%     approximation is introduced in the calculation of the area. In
+%     the latter case, INFO.AUC is the same as INFO.AP.
+%
+%   info.ap::
+%     Average precision as defined by TREC. This is the average of the
+%     precision observed each time a new positive sample is
+%     recalled. In this calculation, any sample with -INF score
+%     (unless INCLUDEINF is used) and any additional positive induced
+%     by NUMPOSITIVES has precision equal to zero. If the INTERPOLATE
+%     option is set to true, the AP is computed from the interpolated
+%     precision and the result is the same as INFO.AUC. Note that AP
+%     as defined by TREC normally does not use interpolation [1].
+%
+%   info.ap_interp_11::
+%     11-points interpolated average precision as defined by TREC.
+%     This is the average of the maximum precision for recall levels
+%     greather than 0.0, 0.1, 0.2, ..., 1.0. This measure was used in
+%     the PASCAL VOC challenge up to the 2008 edition.
+%
+%   info.auc_pa08::
+%     Deprecated. It is the same of INFO.AP_INTERP_11.
+%
+%   VL_PR(...) with no output arguments plots the PR curve in the
+%   current axis.
+%
+%   VL_PR() accepts the following options:
+%
+%   Interpolate:: false
+%     If set to true, use interpolated precision. The interpolated
+%     precision is defined as the maximum precision for a given recall
+%     level and onwards. Here it is implemented as the culumative
+%     maximum from low to high scores of the precision.
+%
+%   NumPositives:: []
+%   NumNegatives:: []
+%     If set to a number, pretend that LABELS contains this may
+%     positive/negative labels. NUMPOSITIVES/NUMNEGATIVES cannot be
+%     smaller than the actual number of positive/negative entrires in
+%     LABELS. The additional positive/negative labels are appended to
+%     the end of the sequence, as if they had -INF scores (not
+%     retrieved). This is useful to evaluate large retrieval systems
+%     for which one stores ony a handful of top results for efficiency
+%     reasons.
+%
+%   IncludeInf:: false
+%     If set to true, data with -INF score SCORES is included in the
+%     evaluation and the maximum recall is 1 even if -INF scores are
+%     present. This option does not include any additional positive or
+%     negative data introduced by specifying NUMPOSITIVES and
+%     NUMNEGATIVES.
+%
+%   Stable:: false
+%     If set to true, RECALL and PRECISION are returned the same order
+%     of LABELS and SCORES rather than being sorted by decreasing
+%     score (increasing recall). Samples with -INF scores are assigned
+%     RECALL and PRECISION equal to NaN.
+%
+%   NormalizePrior:: []
+%     If set to a scalar, reweights positive and negative labels so
+%     that the fraction of positive ones is equal to the specified
+%     value. This computes the normalised PR curves of [2]
+%
+%   About the PR curve::
+%     This section uses the same symbols used in the documentation of
+%     the VL_ROC() function. In addition to those quantities, define:
+%
+%       PRECISION(S) = TP(S) / (TP(S) + FP(S))
+%       RECALL(S) = TPR(S) = TP(S) / P
+%
+%     The precision is the fraction of positivie predictions which are
+%     correct, and the recall is the fraction of positive labels that
+%     have been correctly classified (recalled). Notice that the recall
+%     is also equal to the true positive rate for the ROC curve (see
+%     VL_ROC()).
+%
+%   REFERENCES:
+%   [1] C. D. Manning, P. Raghavan, and H. Schutze. An Introduction to
+%   Information Retrieval. Cambridge University Press, 2008.
+%   [2] D. Hoiem, Y. Chodpathumwan, and Q. Dai. Diagnosing error in
+%   object detectors. In Proc. ECCV, 2012.
+%
+%   See also VL_ROC(), VL_HELP().
+% Author: Andrea Vedaldi
+% Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+% All rights reserved.
+%
+% This file is part of the VLFeat library and is made available under
+% the terms of the BSD license (see the COPYING file).
+% TP and FP are the vectors of true positie and false positve label
+% counts for decreasing scores, P and N are the total number of
+% positive and negative labels. Note that if certain options are used
+% some labels may actually not be stored explicitly by LABELS, so P+N
+% can be larger than the number of element of LABELS.
+[tp, fp, p, n, perm, varargin] = vl_tpfp(labels, scores, varargin{:}) ;
+opts.stable = false ;
+opts.interpolate = false ;
+opts.normalizePrior = [] ;
+opts = vl_argparse(opts,varargin) ;
+% compute precision and recall
+small = 1e-10 ;
+recall = tp / max(p, small) ;
+if isempty(opts.normalizePrior)
+  precision = max(tp, small) ./ max(tp + fp, small) ;
+else
+  a = opts.normalizePrior ;
+  precision = max(tp * a/max(p,small), small) ./ ...
+      max(tp * a/max(p,small) + fp * (1-a)/max(n,small), small) ;
+end
+% interpolate precision if needed
+if opts.interpolate
+  precision = fliplr(vl_cummax(fliplr(precision))) ;
+end
+% --------------------------------------------------------------------
+%                                                      Additional info
+% --------------------------------------------------------------------
+if nargout > 2 || nargout == 0
+  % area under the curve using trapezoid interpolation
+  if ~opts.interpolate
+    if numel(precision) > 1
+      info.auc = 0.5 * sum((precision(1:end-1) + precision(2:end)) .* diff(recall)) ;
+    else
+      info.auc = 0 ;
+    end
+  end
+  % average precision (for each recalled positive sample)
+  sel = find(diff(recall)) + 1 ;
+  info.ap = sum(precision(sel)) / p ;
+  if opts.interpolate
+    info.auc = info.ap ;
+  end
+  % TREC 11 points average interpolated precision
+  info.ap_interp_11 = 0.0 ;
+  for rc = linspace(0,1,11)
+    pr = max([0, precision(recall >= rc)]) ;
+    info.ap_interp_11 = info.ap_interp_11 + pr / 11 ;
+  end
+  % legacy definition
+  info.auc_pa08 = info.ap_interp_11 ;
+end
+% --------------------------------------------------------------------
+%                                                                 Plot
+% --------------------------------------------------------------------
+if nargout == 0
+  cla ; hold on ;
+  plot(recall,precision,'linewidth',2) ;
+  if isempty(opts.normalizePrior)
+    randomPrecision = p / (p + n) ;
+  else
+    randomPrecision = opts.normalizePrior ;
+  end
+  spline([0 1], [1 1] * randomPrecision, 'r--', 'linewidth', 2) ;
+  axis square ; grid on ;
+  xlim([0 1]) ; xlabel('recall') ;
+  ylim([0 1]) ; ylabel('precision') ;
+  title(sprintf('PR (AUC: %.2f%%, AP: %.2f%%, AP11: %.2f%%)', ...
+                info.auc * 100, ...
+                info.ap * 100, ...
+                info.ap_interp_11 * 100)) ;
+  if opts.interpolate
+    legend('PR interp.', 'PR rand.', 'Location', 'SouthEast') ;
+  else
+    legend('PR', 'PR rand.', 'Location', 'SouthEast') ;
+  end
+  clear recall precision info ;
+end
+% --------------------------------------------------------------------
+%                                                        Stable output
+% --------------------------------------------------------------------
+if opts.stable
+  precision(1) = [] ;
+  recall(1) = [] ;
+  precision_ = precision ;
+  recall_ = recall ;
+  precision = NaN(size(precision)) ;
+  recall = NaN(size(recall)) ;
+  precision(perm) = precision_ ;
+  recall(perm) = recall_ ;
+end
+% --------------------------------------------------------------------
+function h = spline(x,y,spec,varargin)
+% --------------------------------------------------------------------
+prop = vl_linespec2prop(spec) ;
+h = line(x,y,prop{:},varargin{:}) ;

vl_roc.m ADDED Viewed

	@@ -0,0 +1,234 @@

+function [tpr,tnr,info] = vl_roc(labels, scores, varargin)
+%VL_ROC   ROC curve.
+%   [TPR,TNR] = VL_ROC(LABELS, SCORES) computes the Receiver Operating
+%   Characteristic (ROC) curve. LABELS are the ground truth labels,
+%   greather than zero for a positive sample and smaller than zero for
+%   a negative one. SCORES are the scores of the samples obtained from
+%   a classifier, where lager scores should correspond to positive
+%   labels.
+%
+%   Samples are ranked by decreasing scores, starting from rank 1.
+%   TPR(K) and TNR(K) are the true positive and true negative rates
+%   when samples of rank smaller or equal to K-1 are predicted to be
+%   positive. So for example TPR(3) is the true positive rate when the
+%   two samples with largest score are predicted to be
+%   positive. Similarly, TPR(1) is the true positive rate when no
+%   samples are predicted to be positive, i.e. the constant 0.
+%
+%   Set the zero the lables of samples that should be ignored in the
+%   evaluation. Set to -INF the scores of samples which are not
+%   retrieved. If there are samples with -INF score, then the ROC curve
+%   may have maximum TPR and TNR smaller than 1.
+%
+%   [TPR,TNR,INFO] = VL_ROC(...) returns an additional structure INFO
+%   with the following fields:
+%
+%   info.auc:: Area under the ROC curve (AUC).
+%     The ROC curve has a `staircase shape' because for each sample
+%     only TP or TN changes, but not both at the same time. Therefore
+%     there is no approximation involved in the computation of the
+%     area.
+%
+%   info.eer:: Equal error rate (EER).
+%     The equal error rate is the value of FPR (or FNR) when the ROC
+%     curves intersects the line connecting (0,0) to (1,1).
+%
+%   VL_ROC(...) with no output arguments plots the ROC curve in the
+%   current axis.
+%
+%   VL_ROC() acccepts the following options:
+%
+%   Plot:: []
+%     Setting this option turns on plotting unconditionally. The
+%     following plot variants are supported:
+%
+%     tntp:: Plot TPR against TNR (standard ROC plot).
+%     tptn:: Plot TNR against TPR (recall on the horizontal axis).
+%     fptp:: Plot TPR against FPR.
+%     fpfn:: Plot FNR against FPR (similar to DET curve).
+%
+%   NumPositives:: []
+%   NumNegatives:: []
+%     If set to a number, pretend that LABELS contains this may
+%     positive/negative labels. NUMPOSITIVES/NUMNEGATIVES cannot be
+%     smaller than the actual number of positive/negative entrires in
+%     LABELS. The additional positive/negative labels are appended to
+%     the end of the sequence, as if they had -INF scores (not
+%     retrieved). This is useful to evaluate large retrieval systems in
+%     which one stores ony a handful of top results for efficiency
+%     reasons.
+%
+%   About the ROC curve::
+%     Consider a classifier that predicts as positive all samples whose
+%     score is not smaller than a threshold S. The ROC curve represents
+%     the performance of such classifier as the threshold S is
+%     changed. Formally, define
+%
+%       P = overall num. of positive samples,
+%       N = overall num. of negative samples,
+%
+%     and for each threshold S
+%
+%       TP(S) = num. of samples that are correctly classified as positive,
+%       TN(S) = num. of samples that are correctly classified as negative,
+%       FP(S) = num. of samples that are incorrectly classified as positive,
+%       FN(S) = num. of samples that are incorrectly classified as negative.
+%
+%     Consider also the rates:
+%
+%       TPR = TP(S) / P,      FNR = FN(S) / P,
+%       TNR = TN(S) / N,      FPR = FP(S) / N,
+%
+%     and notice that by definition
+%
+%       P = TP(S) + FN(S) ,    N = TN(S) + FP(S),
+%       1 = TPR(S) + FNR(S),   1 = TNR(S) + FPR(S).
+%
+%     The ROC curve is the parametric curve (TPR(S), TNR(S)) obtained
+%     as the classifier threshold S is varied in the reals. The TPR is
+%     also known as recall (see VL_PR()).
+%
+%     The ROC curve is contained in the square with vertices (0,0) The
+%     (average) ROC curve of a random classifier is a line which
+%     connects (1,0) and (0,1).
+%
+%     The ROC curve is independent of the prior probability of the
+%     labels (i.e. of P/(P+N) and N/(P+N)).
+%
+%   REFERENCES:
+%   [1] http://en.wikipedia.org/wiki/Receiver_operating_characteristic
+%
+%   See also: VL_PR(), VL_DET(), VL_HELP().
+% Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+% All rights reserved.
+%
+% This file is part of the VLFeat library and is made available under
+% the terms of the BSD license (see the COPYING file).
+[tp, fp, p, n, perm, varargin] = vl_tpfp(labels, scores, varargin{:}) ;
+opts.plot = [] ;
+opts.stable = false ;
+opts = vl_argparse(opts,varargin) ;
+% compute the rates
+small = 1e-10 ;
+tpr = tp / max(p, small) ;
+fpr = fp / max(n, small) ;
+fnr = 1 - tpr ;
+tnr = 1 - fpr ;
+% --------------------------------------------------------------------
+%                                                      Additional info
+% --------------------------------------------------------------------
+if nargout > 2 || nargout == 0
+  % Area under the curve. Since the curve is a staircase (in the
+  % sense that for each sample either tn is decremented by one
+  % or tp is incremented by one but the other remains fixed),
+  % the integral is particularly simple and exact.
+  info.auc = sum(tnr .* diff([0 tpr])) ;
+  % Equal error rate. One must find the index S for which there is a
+  % crossing between TNR(S) and TPR(s). If such a crossing exists,
+  % there are two cases:
+  %
+  %                  o             tnr o
+  %                 /                   \
+  % 1-eer =  tnr o-x-o     1-eer = tpr o-x-o
+  %               /                       \
+  %          tpr o                         o
+  %
+  % Moreover, if the maximum TPR is smaller than 1, then it is
+  % possible that neither of the two cases realizes (then EER=NaN).
+  s = max(find(tnr > tpr)) ;
+  if s == length(tpr)
+    info.eer = NaN ;
+  else
+    if tpr(s) == tpr(s+1)
+      info.eer = 1 - tpr(s) ;
+    else
+      info.eer = 1 - tnr(s) ;
+    end
+  end
+end
+% --------------------------------------------------------------------
+%                                                                 Plot
+% --------------------------------------------------------------------
+if ~isempty(opts.plot) || nargout == 0
+  if isempty(opts.plot), opts.plot = 'fptp' ; end
+  cla ; hold on ;
+  switch lower(opts.plot)
+    case {'truenegatives', 'tn', 'tntp'}
+      hroc = plot(tnr, tpr, 'b', 'linewidth', 2) ;
+      hrand = spline([0 1], [1 0], 'r--', 'linewidth', 2) ;
+      spline([0 1], [0 1], 'k--', 'linewidth', 1) ;
+      plot(1-info.eer, 1-info.eer, 'k*', 'linewidth', 1) ;
+      xlabel('true negative rate') ;
+      ylabel('true positive rate (recall)') ;
+      loc = 'sw' ;
+    case {'falsepositives', 'fp', 'fptp'}
+      hroc = plot(fpr, tpr, 'b', 'linewidth', 2) ;
+      hrand = spline([0 1], [0 1], 'r--', 'linewidth', 2) ;
+      spline([1 0], [0 1], 'k--', 'linewidth', 1) ;
+      plot(info.eer, 1-info.eer, 'k*', 'linewidth', 1) ;
+      xlabel('false positive rate') ;
+      ylabel('true positive rate (recall)') ;
+      loc = 'se' ;
+    case {'tptn'}
+      hroc = plot(tpr, tnr, 'b', 'linewidth', 2) ;
+      hrand = spline([0 1], [1 0], 'r--', 'linewidth', 2) ;
+      spline([0 1], [0 1], 'k--', 'linewidth', 1) ;
+      plot(1-info.eer, 1-info.eer, 'k*', 'linewidth', 1) ;
+      xlabel('true positive rate (recall)') ;
+      ylabel('false positive rate') ;
+      loc = 'sw' ;
+    case {'fpfn'}
+      hroc = plot(fpr, fnr, 'b', 'linewidth', 2) ;
+      hrand = spline([0 1], [1 0], 'r--', 'linewidth', 2) ;
+      spline([0 1], [0 1], 'k--', 'linewidth', 1) ;
+      plot(info.eer, info.eer, 'k*', 'linewidth', 1) ;
+      xlabel('false positive (false alarm) rate') ;
+      ylabel('false negative (miss) rate') ;
+      loc = 'ne' ;
+    otherwise
+      error('''%s'' is not a valid PLOT type.', opts.plot);
+  end
+  grid on ;
+  xlim([0 1]) ;
+  ylim([0 1]) ;
+  axis square ;
+  title(sprintf('ROC (AUC: %.2f%%, EER: %.2f%%)', info.auc * 100, info.eer * 100), ...
+        'interpreter', 'none') ;
+  legend([hroc hrand], 'ROC', 'ROC rand.', 'location', loc) ;
+end
+% --------------------------------------------------------------------
+%                                                        Stable output
+% --------------------------------------------------------------------
+if opts.stable
+  tpr(1) = [] ;
+  tnr(1) = [] ;
+  tpr_ = tpr ;
+  tnr_ = tnr ;
+  tpr = NaN(size(tpr)) ;
+  tnr = NaN(size(tnr)) ;
+  tpr(perm) = tpr_ ;
+  tnr(perm) = tnr_ ;
+end
+% --------------------------------------------------------------------
+function h = spline(x,y,spec,varargin)
+% --------------------------------------------------------------------
+prop = vl_linespec2prop(spec) ;
+h = line(x,y,prop{:},varargin{:}) ;

vl_tpfp.m ADDED Viewed

	@@ -0,0 +1,62 @@

+function [tp, fp, p, n, perm, varargin] = vl_tpfp(labels, scores, varargin)
+% VL_TPFP  Compute true positives and false positives
+%  This is an helper function used by VL_PR(), VL_ROC(), VL_DET().
+%
+%  See also: VL_PR(), VL_ROC(), VL_DET(), VL_HELP().
+% Author: Andrea Vedaldi
+% Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+% All rights reserved.
+%
+% This file is part of the VLFeat library and is made available under
+% the terms of the BSD license (see the COPYING file).
+% extraNeg and extraPos depend on numNegatives and numPositives:
+%
+%    [           labels            |    -1       +1    ]
+%    [ +inf | finite scores | -inf | extraNeg  extraPos]
+opts.includeInf = false ;
+opts.numNegatives = [] ;
+opts.numPositives = [] ;
+[opts, varargin] = vl_argparse(opts, varargin) ;
+% make row vectors
+labels = labels(:)' ;
+scores = scores(:)' ;
+% count labels
+p = sum(labels > 0) ;
+n = sum(labels < 0) ;
+if ~isempty(opts.numPositives)
+  if opts.numPositives < p
+    warning('NUMPOSITIVES is smaller than the number of positives in LABELS.') ;
+  end
+  p = opts.numPositives ;
+end
+if ~isempty(opts.numNegatives)
+  if opts.numNegatives < n
+    warning('NUMNEGATIVES is smaller than the number of negatives in LABELS.') ;
+  end
+  n = opts.numNegatives ;
+end
+% sort by descending scores
+[scores, perm] = sort(scores, 'descend') ;
+% assume that data with -INF score is never retrieved
+if opts.includeInf
+  stop = length(scores) ;
+else
+  stop = max(find(scores > -inf)) ;
+end
+perm = perm(1:stop) ;
+labels = labels(perm) ;
+% accumulate true positives and false positives by scores
+% in descending order
+tp = [0 cumsum(labels > 0)] ;
+fp = [0 cumsum(labels < 0)] ;