int
main (void) {
TestStruct* data;
/* save */
printf("Saving...\n");
data = (TestStruct*)malloc(sizeof(TestStruct));
if (data == NULL) {
fprintf(stderr, "malloc(): %s\n", strerror(errno));
return 1;
}
data->id = 500;
data->name = "Elanthis";
data->hp = 70;
data->hp_max = 75;
print_test(data);
save_test(data);
free(data);
/* load */
printf("Loading...\n");
data = load_test();
if (data == NULL) {
fprintf(stderr, "load_data(): %s\n", strerror(errno));
return 1;
}
print_test(data);
free(data);
return 0;
}
int main(int argc, char **argv)
{
char path[PATH_MAX];
if (argc == 1) {
DIR *dir = opendir(TESTDIR);
struct dirent *d;
if (!dir) {
perror("failed to open testdir");
return EXIT_FAILURE;
}
while ((d = readdir(dir))) {
if (strcmp(d->d_name, ".") == 0 ||
strcmp(d->d_name, "..") == 0)
continue;
snprintf(path, PATH_MAX, "%s/%s", TESTDIR, d->d_name);
if (!check_path(path))
continue;
load_test(path, d->d_name);
}
if (closedir(dir) < 0) {
perror("failed to close testdir");
return EXIT_FAILURE;
}
} else {
for (int i = 1; i < argc; i++) {
snprintf(path, PATH_MAX, "%s/%s", TESTDIR, argv[i]);
if (!check_path(path))
continue;
load_test(path, argv[i]);
}
}
printf("All tests complete - %d/%d failures\n", nr_failures, nr_tests);
return 0;
}
int main(int argc, char** argv) {
ctst_ctst* ctst = ctst_alloc();
ctst_data data;
data = ctst_set(ctst,"The answer to your question is",0,30,42);
printf("%*s %d (was %d)\n",30,"The answer to your question is",ctst_get(ctst,"The answer to your question is",0,30),data);
data = ctst_set(ctst,"Hello, world!",0,13,57);
printf("%*s %d (was %d)\n",13,"Hello, world!",ctst_get(ctst,"Hello, world!",0,13),data);
data = ctst_set(ctst,"Hello, world!",0,13,62);
printf("%*s %d (was %d)\n",13,"Hello, world!",ctst_get(ctst,"Hello, world!",0,13),data);
data = ctst_set(ctst,"The answer to your question is",0,30,11);
printf("%*s %d (was %d)\n",30,"The answer to your question is",ctst_get(ctst,"The answer to your question is",0,30),data);
data = ctst_set(ctst,"There is something rotten in the kingdom of Denmark",0,51,1122);
printf("DUMP OF THE TREE\n");
ctst_visit_all(ctst, &printer_visitor, 0);
printf("END DUMP OF THE TREE\n");
printf("DUMP OF THE TREE, only H*\n");
ctst_visit_all_from_key(ctst, &printer_visitor, 0, "**Hello", 2, 1);
printf("END DUMP OF THE TREE\n");
printf("DUMP OF THE TREE, only The*\n");
ctst_visit_all_from_key(ctst, &printer_visitor, 0, "The", 0, 3);
printf("END DUMP OF THE TREE\n");
printf("DUMP OF THE TREE, only There*\n");
ctst_visit_all_from_key(ctst, &printer_visitor, 0, "--There", 2, 5);
printf("END DUMP OF THE TREE\n");
printf("Number of entries: %d\nTotal length of keys: %d\nTotal node count: %d\nMemory usage: %d\nRatio: %f\n",
ctst_get_size(ctst),
ctst_get_total_key_length(ctst),
ctst_get_node_count(ctst),
ctst_get_memory_usage(ctst),
ctst_get_ratio(ctst)
);
printf("Removing a key\n");
data = ctst_remove(ctst,"Hello, world!",0,13);
printf("%*s %d (was %d)\n",13,"Hello, world!",ctst_get(ctst,"Hello, world!",0,13),data);
printf("Number of entries: %d\nTotal length of keys: %d\nTotal node count: %d\nMemory usage: %d\nRatio: %f\n",
ctst_get_size(ctst),
ctst_get_total_key_length(ctst),
ctst_get_node_count(ctst),
ctst_get_memory_usage(ctst),
ctst_get_ratio(ctst)
);
printf("DUMP OF THE TREE\n");
ctst_visit_all(ctst, &printer_visitor, 0);
printf("END DUMP OF THE TREE\n");
printf("LOAD TEST\n");
load_test(ctst);
printf("DUMP OF THE TREE\n");
ctst_visit_all(ctst, &printer_visitor, 0);
printf("END DUMP OF THE TREE\n");
printf("Number of entries: %d\nTotal length of keys: %d\nTotal node count: %d\nMemory usage: %d\nRatio: %f\n",
ctst_get_size(ctst),
ctst_get_total_key_length(ctst),
ctst_get_node_count(ctst),
ctst_get_memory_usage(ctst),
ctst_get_ratio(ctst)
);
ctst_free(ctst);
return 0;
}
int main(int argc, char* argv[])
{
const size_t imageCount = 28;
const size_t test_lfw = 1000;
const size_t test_fddb = 1000;
const size_t test_nonface = 1000;
pm_init(argv[0], 0);
std::cout << "initiating network..." << std::endl;
Json::Value networkValue;
// load neural net setting
if (!load_test(networkValue))
{
return 0;
}
NeuralNet::Network network(networkValue);
std::cout << "loading settings finished" << std::endl;
// train only if the argument is given to this program
bool do_train = false;
if (argc >= 2 && !strncmp(argv[1], "train", 5))
{
do_train = true;
}
// loading images for evaluation
std::vector< std::unique_ptr<NeuralNet::Image> > imageList;
for (size_t i = 1; i <= imageCount; i++)
{
std::ostringstream oss;
oss << "eval-image/" << i << ".bmp";
imageList.push_back(preprocessImage(
NeuralNet::loadBitmapImage(oss.str().c_str())));
}
auto originalImgData = getRawDataFromImages(imageList);
imageList.clear();
std::cout << "loading evaluation images (original) finished" << std::endl;
std::vector< std::unique_ptr<NeuralNet::Image> > fddbTestImages;
if (!load_fddb(fddbTestImages, test_fddb, false))
{
std::cout << "error loading FDDB test images" << std::endl;
return false;
}
auto fddbTestData = getRawDataFromImages(fddbTestImages);
fddbTestImages.clear();
std::cout << "loading evaluation images (FDDB) finished" << std::endl;
// loading LFW images for evaluation
std::vector< std::unique_ptr<NeuralNet::Image> > lfwTestImages;
std::ifstream lfw_name_file("image-lfw/peopleDevTest.txt");
for (size_t i = 1; i <= test_lfw; i++)
{
std::string person_line;
if (!std::getline(lfw_name_file, person_line))
{
std::cout << "end-of-file of LFW names" << std::endl;
return 0;
}
std::istringstream iss(person_line);
std::string person_name;
std::getline(iss, person_name, '\t');
std::string file_name("image-lfw/");
file_name.append(person_name);
file_name.append("/");
file_name.append(person_name);
file_name.append("_0001.ppm");
lfwTestImages.push_back(preprocessImage(
NeuralNet::loadPPMImage(file_name.c_str())));
}
auto lfwTestData = getRawDataFromImages(lfwTestImages);
lfwTestImages.clear();
std::cout << "loading evaluation images (LFW) finished" << std::endl;
std::vector< std::unique_ptr<NeuralNet::Image> > nonFaceImages;
if (!load_nonface_patch(nonFaceImages, test_nonface, 1))
{
std::cout << "error loading evaluation non-face images" << std::endl;
return 0;
}
auto nonFaceTestData = getRawDataFromImages(nonFaceImages);
nonFaceImages.clear();
std::cout << "loading evaluation images (non-face) finished" << std::endl;
// put test sets into the network
std::vector< std::vector<int> > clist1;
clist1.emplace_back(test_lfw, 0);
network.registerTestSet("LFW", std::move(lfwTestData), std::move(clist1));
std::vector< std::vector<int> > clist2;
clist2.emplace_back(test_nonface, 1);
network.registerTestSet("non-face", std::move(nonFaceTestData),
std::move(clist2));
std::vector< std::vector<int> > clist3;
clist3.emplace_back(test_fddb, 0);
network.registerTestSet("FDDB", std::move(fddbTestData), std::move(clist3));
std::vector< std::vector<int> > clist4;
std::vector<int> clist4_temp;
for (size_t i = 0; i < 14; i++)
clist4_temp.push_back(0);
for (size_t i = 0; i < 14; i++)
clist4_temp.push_back(1);
clist4.push_back(clist4_temp);
network.registerTestSet("original", std::move(originalImgData),
std::move(clist4));
std::chrono::time_point<std::chrono::system_clock> time_point_start, time_point_finish;
if (do_train)
{
std::vector<float> data;
std::vector< std::vector<int> > category;
category.push_back(std::vector<int>());
// load face images
if (!load_faces(data, category))
{
return 0;
}
std::cout << "loading face images (for training) finished" << std::endl;
// load non-face images
if (!load_non_faces(data, category))
{
return 0;
}
std::cout << "loading non-face images (for training) finished" << std::endl;
std::cout << "training begin, timer start" << std::endl;
time_point_start = std::chrono::system_clock::now();
// actual training goes here
network.train(data, category);
time_point_finish = std::chrono::system_clock::now();
std::cout << "timer finished" << std::endl;
}
else
{
network.loadFromFiles();
std::cout << "network weight/bias load complete, timer start" << std::endl;
time_point_start = std::chrono::system_clock::now();
network.evaluateTestSets();
time_point_finish = std::chrono::system_clock::now();
std::cout << "timer finished" << std::endl;
}
std::chrono::duration<double> elapsed_seconds = time_point_finish - time_point_start;
std::cout << "elapsed time: " << elapsed_seconds.count() << "s" << std::endl;
}
