mirror of
https://gitcode.com/gh_mirrors/ope/OpenFace.git
synced 2026-05-22 23:27:57 +00:00
307 lines
9.6 KiB
C++
307 lines
9.6 KiB
C++
// Copyright (C) 2014 Davis E. King (davis@dlib.net)
|
|
// License: Boost Software License See LICENSE.txt for the full license.
|
|
|
|
|
|
#include <sstream>
|
|
#include "tester.h"
|
|
#include <dlib/svm_threaded.h>
|
|
#include <dlib/rand.h>
|
|
|
|
|
|
|
|
namespace
|
|
{
|
|
using namespace test;
|
|
using namespace dlib;
|
|
using namespace std;
|
|
|
|
logger dlog("test.learning_to_track");
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
struct detection_dense
|
|
{
|
|
typedef struct track_dense track_type;
|
|
matrix<double,0,1> measurements;
|
|
};
|
|
|
|
|
|
struct track_dense
|
|
{
|
|
typedef matrix<double,0,1> feature_vector_type;
|
|
|
|
track_dense()
|
|
{
|
|
time_since_last_association = 0;
|
|
}
|
|
|
|
void get_similarity_features(const detection_dense det, feature_vector_type& feats) const
|
|
{
|
|
feats = abs(last_measurements - det.measurements);
|
|
}
|
|
|
|
void update_track(const detection_dense det)
|
|
{
|
|
last_measurements = det.measurements;
|
|
time_since_last_association = 0;
|
|
}
|
|
|
|
void propagate_track()
|
|
{
|
|
++time_since_last_association;
|
|
}
|
|
|
|
matrix<double,0,1> last_measurements;
|
|
unsigned long time_since_last_association;
|
|
};
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
struct detection_sparse
|
|
{
|
|
typedef struct track_sparse track_type;
|
|
matrix<double,0,1> measurements;
|
|
};
|
|
|
|
|
|
struct track_sparse
|
|
{
|
|
typedef std::vector<std::pair<unsigned long,double> > feature_vector_type;
|
|
|
|
track_sparse()
|
|
{
|
|
time_since_last_association = 0;
|
|
}
|
|
|
|
void get_similarity_features(const detection_sparse det, feature_vector_type& feats) const
|
|
{
|
|
matrix<double,0,1> temp = abs(last_measurements - det.measurements);
|
|
feats.clear();
|
|
for (long i = 0; i < temp.size(); ++i)
|
|
feats.push_back(make_pair(i, temp(i)));
|
|
}
|
|
|
|
void update_track(const detection_sparse det)
|
|
{
|
|
last_measurements = det.measurements;
|
|
time_since_last_association = 0;
|
|
}
|
|
|
|
void propagate_track()
|
|
{
|
|
++time_since_last_association;
|
|
}
|
|
|
|
matrix<double,0,1> last_measurements;
|
|
unsigned long time_since_last_association;
|
|
};
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
// ----------------------------------------------------------------------------------------
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
dlib::rand rnd;
|
|
const long num_objects = 4;
|
|
const long num_properties = 6;
|
|
std::vector<matrix<double,0,1> > object_properties(num_objects);
|
|
|
|
void initialize_object_properties()
|
|
{
|
|
rnd.set_seed("23ja2oirfjaf");
|
|
for (unsigned long i = 0; i < object_properties.size(); ++i)
|
|
object_properties[i] = randm(num_properties,1,rnd);
|
|
}
|
|
|
|
template <typename detection>
|
|
detection sample_detection_from_sensor(long object_id)
|
|
{
|
|
DLIB_CASSERT(object_id < num_objects,
|
|
"You can't ask to sample a detection from an object that doesn't exist.");
|
|
detection temp;
|
|
// Set the measurements equal to the object's true property values plus a little bit of
|
|
// noise.
|
|
temp.measurements = object_properties[object_id] + randm(num_properties,1,rnd)*0.1;
|
|
return temp;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
|
|
template <typename detection>
|
|
std::vector<std::vector<labeled_detection<detection> > > make_random_tracking_data_for_training()
|
|
{
|
|
typedef std::vector<labeled_detection<detection> > detections_at_single_time_step;
|
|
typedef std::vector<detections_at_single_time_step> track_history;
|
|
|
|
track_history data;
|
|
|
|
// At each time step we get a set of detections from the objects in the world.
|
|
// Simulate 100 time steps worth of data where there are 3 objects present.
|
|
const int num_time_steps = 100;
|
|
for (int i = 0; i < num_time_steps; ++i)
|
|
{
|
|
detections_at_single_time_step dets(3);
|
|
// sample a detection from object 0
|
|
dets[0].det = sample_detection_from_sensor<detection>(0);
|
|
dets[0].label = 0;
|
|
|
|
// sample a detection from object 1
|
|
dets[1].det = sample_detection_from_sensor<detection>(1);
|
|
dets[1].label = 1;
|
|
|
|
// sample a detection from object 2
|
|
dets[2].det = sample_detection_from_sensor<detection>(2);
|
|
dets[2].label = 2;
|
|
|
|
randomize_samples(dets, rnd);
|
|
data.push_back(dets);
|
|
}
|
|
|
|
// Now let's imagine object 1 and 2 are gone but a new object, object 3 has arrived.
|
|
for (int i = 0; i < num_time_steps; ++i)
|
|
{
|
|
detections_at_single_time_step dets(2);
|
|
// sample a detection from object 0
|
|
dets[0].det = sample_detection_from_sensor<detection>(0);
|
|
dets[0].label = 0;
|
|
|
|
// sample a detection from object 3
|
|
dets[1].det = sample_detection_from_sensor<detection>(3);
|
|
dets[1].label = 3;
|
|
|
|
randomize_samples(dets, rnd);
|
|
data.push_back(dets);
|
|
}
|
|
|
|
return data;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
template <typename detection>
|
|
std::vector<detection> make_random_detections(long num_dets)
|
|
{
|
|
DLIB_CASSERT(num_dets <= num_objects,
|
|
"You can't ask for more detections than there are objects in our little simulation.");
|
|
|
|
std::vector<detection> dets(num_dets);
|
|
for (unsigned long i = 0; i < dets.size(); ++i)
|
|
{
|
|
dets[i] = sample_detection_from_sensor<detection>(i);
|
|
}
|
|
randomize_samples(dets, rnd);
|
|
return dets;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
template <typename detection>
|
|
void test_tracking_stuff()
|
|
{
|
|
print_spinner();
|
|
|
|
|
|
typedef std::vector<labeled_detection<detection> > detections_at_single_time_step;
|
|
typedef std::vector<detections_at_single_time_step> track_history;
|
|
std::vector<track_history> data;
|
|
data.push_back(make_random_tracking_data_for_training<detection>());
|
|
data.push_back(make_random_tracking_data_for_training<detection>());
|
|
data.push_back(make_random_tracking_data_for_training<detection>());
|
|
data.push_back(make_random_tracking_data_for_training<detection>());
|
|
data.push_back(make_random_tracking_data_for_training<detection>());
|
|
|
|
|
|
structural_track_association_trainer trainer;
|
|
trainer.set_c(1000);
|
|
track_association_function<detection> assoc = trainer.train(data);
|
|
|
|
double test_val = test_track_association_function(assoc, data);
|
|
DLIB_TEST_MSG( test_val == 1, test_val);
|
|
test_val = cross_validate_track_association_trainer(trainer, data, 5);
|
|
DLIB_TEST_MSG ( test_val == 1, test_val);
|
|
|
|
|
|
|
|
typedef typename detection::track_type track;
|
|
std::vector<track> tracks;
|
|
|
|
std::vector<detection> dets = make_random_detections<detection>(3);
|
|
assoc(tracks, dets);
|
|
DLIB_TEST(tracks.size() == 3);
|
|
|
|
dets = make_random_detections<detection>(3);
|
|
assoc(tracks, dets);
|
|
DLIB_TEST(tracks.size() == 3);
|
|
|
|
dets = make_random_detections<detection>(3);
|
|
assoc(tracks, dets);
|
|
DLIB_TEST(tracks.size() == 3);
|
|
|
|
dets = make_random_detections<detection>(4);
|
|
assoc(tracks, dets);
|
|
DLIB_TEST(tracks.size() == 4);
|
|
|
|
dets = make_random_detections<detection>(3);
|
|
assoc(tracks, dets);
|
|
DLIB_TEST(tracks.size() == 4);
|
|
unsigned long total_miss = 0;
|
|
for (unsigned long i = 0; i < tracks.size(); ++i)
|
|
total_miss += tracks[i].time_since_last_association;
|
|
DLIB_TEST(total_miss == 1);
|
|
|
|
dets = make_random_detections<detection>(3);
|
|
assoc(tracks, dets);
|
|
DLIB_TEST(tracks.size() == 4);
|
|
total_miss = 0;
|
|
unsigned long num_zero = 0;
|
|
for (unsigned long i = 0; i < tracks.size(); ++i)
|
|
{
|
|
total_miss += tracks[i].time_since_last_association;
|
|
if (tracks[i].time_since_last_association == 0)
|
|
++num_zero;
|
|
}
|
|
DLIB_TEST(total_miss == 2);
|
|
DLIB_TEST(num_zero == 3);
|
|
|
|
|
|
|
|
ostringstream sout;
|
|
serialize(assoc, sout);
|
|
|
|
istringstream sin(sout.str());
|
|
deserialize(assoc, sin);
|
|
DLIB_TEST( test_track_association_function(assoc, data) == 1);
|
|
}
|
|
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
class test_learning_to_track : public tester
|
|
{
|
|
public:
|
|
test_learning_to_track (
|
|
) :
|
|
tester ("test_learning_to_track",
|
|
"Runs tests on the assignment learning code.")
|
|
{}
|
|
|
|
void perform_test (
|
|
)
|
|
{
|
|
initialize_object_properties();
|
|
for (int i = 0; i < 3; ++i)
|
|
{
|
|
dlog << LINFO << "run test_tracking_stuff<detection_dense>()";
|
|
test_tracking_stuff<detection_dense>();
|
|
dlog << LINFO << "run test_tracking_stuff<detection_sparse>()";
|
|
test_tracking_stuff<detection_sparse>();
|
|
}
|
|
}
|
|
} a;
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
}
|
|
|
|
|