finished IUM draft

Josh Klontz
1 parent 4b34805a
Showing 3 changed files with 115 additions and 46 deletions
sdk/openbr_plugin.cpp
sdk/openbr_plugin.h
sdk/plugins/quality.cpp
@@ -1270,44 +1270,6 @@ void Transform::backProject(const TemplateList &amp;dst, TemplateList &amp;src) const
 }
  
 /* Distance - public methods */
-void Distance::train(const TemplateList &templates)
-{
-    const TemplateList samples = templates.mid(0, 2000);
-    const QList<float> sampleLabels = samples.labels<float>();
-    QScopedPointer<MatrixOutput> memoryOutput(dynamic_cast<MatrixOutput*>(Output::make(".Matrix", FileList(samples.size()), FileList(samples.size()))));
-    compare(samples, samples, memoryOutput.data());
-
-    double genuineAccumulator, impostorAccumulator;
-    int genuineCount, impostorCount;
-    genuineAccumulator = impostorAccumulator = genuineCount = impostorCount = 0;
-
-    for (int i=0; i<samples.size(); i++) {
-        for (int j=0; j<i; j++) {
-            const float val = memoryOutput.data()->data.at<float>(i, j);
-            if (sampleLabels[i] == sampleLabels[j]) {
-                genuineAccumulator += val;
-                genuineCount++;
-            } else {
-                impostorAccumulator += val;
-                impostorCount++;
-            }
-        }
-    }
-
-    if (genuineCount == 0) { qWarning("No genuine matches."); return; }
-    if (impostorCount == 0) { qWarning("No impostor matches."); return; }
-
-    double genuineMean = genuineAccumulator / genuineCount;
-    double impostorMean = impostorAccumulator / impostorCount;
-
-    if (genuineMean == impostorMean) { qWarning("Genuines and impostors are indistinguishable."); return; }
-
-    a = 1.0/(genuineMean-impostorMean);
-    b = impostorMean;
-
-    qDebug("a = %f, b = %f", a, b);
-}
-
 void Distance::compare(const TemplateList &target, const TemplateList &query, Output *output) const
 {
     const bool stepTarget = target.size() > query.size();
@@ -1336,7 +1298,7 @@ float Distance::compare(const Template &amp;target, const Template &amp;query) const
                 return -std::numeric_limits<float>::max();
         }
  
-    return a * (_compare(target, query) - b);
+    return _compare(target, query);
 }
  
 QList<float> Distance::compare(const TemplateList &targets, const Template &query) const
@@ -1065,15 +1065,9 @@ class BR_EXPORT Distance : public Object
 {
     Q_OBJECT
  
-    // Score normalization
-    Q_PROPERTY(float a READ get_a WRITE set_a RESET reset_a)
-    Q_PROPERTY(float b READ get_b WRITE set_b RESET reset_b)
-    BR_PROPERTY(float, a, 1)
-    BR_PROPERTY(float, b, 0)
-
 public:
     static QSharedPointer<Distance> fromAlgorithm(const QString &algorithm); /*!< \brief Retrieve an algorithm's distance. */
-    virtual void train(const TemplateList &src); /*!< \brief Train the distance. */
+    virtual void train(const TemplateList &src) { (void) src; } /*!< \brief Train the distance. */
     virtual void compare(const TemplateList &target, const TemplateList &query, Output *output) const; /*!< \brief Compare two template lists. */
     float compare(const Template &target, const Template &query) const; /*!< \brief Compute the normalized distance between two templates. */
     QList<float> compare(const TemplateList &targets, const Template &query) const; /*!< \brief Compute the normalized distance between a template and a template list. */
@@ -74,6 +74,119 @@ class IUMTransform : public Transform
  
 BR_REGISTER(Transform, IUMTransform)
  
+/* Kernel Density Estimator */
+struct KDE
+{
+    float min, max;
+    QList<float> bins;
+
+    KDE() : min(0), max(1) {}
+    KDE(const QList<float> &scores)
+    {
+        Common::MinMax(scores, &min, &max);
+        double h = Common::KernelDensityBandwidth(scores);
+        const int size = 255;
+        bins.reserve(size);
+        for (int i=0; i<size; i++)
+            bins.append(Common::KernelDensityEstimation(scores, min + (max-min)*i/(size-1), h));
+    }
+
+    float operator()(float score) const
+    {
+        if (score <= min) return bins.first();
+        if (score >= max) return bins.last();
+        const float x = (score-min)/(max-min)*bins.size();
+        const float y1 = bins[floor(x)];
+        const float y2 = bins[ceil(x)];
+        return y1 + (y2-y1)*(x-floor(x));
+    }
+};
+
+QDataStream &operator<<(QDataStream &stream, const KDE &kde)
+{
+    return stream << kde.min << kde.max << kde.bins;
+}
+
+QDataStream &operator>>(QDataStream &stream, KDE &kde)
+{
+    return stream >> kde.min >> kde.max >> kde.bins;
+}
+
+/* Non-match Probability */
+struct NMP
+{
+    KDE genuine, impostor;
+    NMP() {}
+    NMP(const QList<float> &genuineScores, const QList<float> &impostorScores)
+        : genuine(genuineScores), impostor(impostorScores) {}
+    float operator()(float score) const { float g = genuine(score); return g / (impostor(score) + g); }
+};
+
+QDataStream &operator<<(QDataStream &stream, const NMP &nmp)
+{
+    return stream << nmp.genuine << nmp.impostor;
+}
+
+QDataStream &operator>>(QDataStream &stream, NMP &nmp)
+{
+    return stream >> nmp.genuine >> nmp.impostor;
+}
+
+/*!
+ * \ingroup distances
+ * \brief Impostor Uniqueness Distance \cite klare12
+ * \author Josh Klontz \cite jklontz
+ */
+class IUMDistance : public Distance
+{
+    Q_OBJECT
+    Q_PROPERTY(br::Distance* distance READ get_distance WRITE set_distance RESET reset_distance STORED false)
+    BR_PROPERTY(br::Distance*, distance, Factory<Distance>::make(".Dist(L2)"))
+
+    QList<NMP> nmps;
+
+    void train(const TemplateList &src)
+    {
+        distance->train(src);
+
+        const QList<float> labels = src.labels<float>();
+        QScopedPointer<MatrixOutput> memoryOutput(dynamic_cast<MatrixOutput*>(Output::make(".Matrix", FileList(src.size()), FileList(src.size()))));
+        distance->compare(src, src, memoryOutput.data());
+
+        const int IUM_Bins = 3;
+        QVector< QList<float> > genuineScores(IUM_Bins), impostorScores(IUM_Bins);
+        for (int i=0; i<src.size(); i++)
+            for (int j=0; j<i; j++) {
+                const float score = memoryOutput.data()->data.at<float>(i, j);
+                const int bin = src[i].file.getInt("IUM_Bin");
+                if (labels[i] == labels[j]) genuineScores[bin].append(score);
+                else                        impostorScores[bin].append(score);
+            }
+
+        for (int i=0; i<IUM_Bins; i++)
+            nmps.append(NMP(genuineScores[i], impostorScores[i]));
+    }
+
+    float _compare(const Template &target, const Template &query) const
+    {
+        return nmps[query.file.getInt("IUM_Bin")](distance->compare(target, query));
+    }
+
+    void store(QDataStream &stream) const
+    {
+        distance->store(stream);
+        stream << nmps;
+    }
+
+    void load(QDataStream &stream)
+    {
+        distance->load(stream);
+        stream >> nmps;
+    }
+};
+
+BR_REGISTER(Distance, IUMDistance)
+
 } // namespace br
  
 #include "quality.moc"