saundersp/ViolaJones
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

cpp : final unit test display revamp

Browse Source
This commit is contained in:
saundersp 2023-07-25 12:36:31 +02:00
parent d0493890f1
commit b507e1b0fd
1 changed files with 85 additions and 95 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

180
cpp/projet.cpp
View File

@ -191,102 +191,95 @@ void testing_and_evaluating(const np::Array<int32_t>& X_train_feat, const np::Ar
} }
} }
void final_unit_test() { void unit_test(void) {
printf("\n| %-49s | %-10s | %-17s | %-29s |\n", "Unit testing", "Test state", "Time spent (ns)", "Formatted time spent"); printf("\n| %-37s | %-10s | %-18s | %-29s |\n", "Unit testing", "Test state", "Time spent (ns)", "Formatted time spent");
printf("|%s|%s|%s|%s|\n", S(51), S(12), S(19), S(31)); printf("|%s|%s|%s|%s|\n", S(39), S(12), S(20), S(31));
if(fs::exists(OUT_DIR "/X_train_ii_CPU.bin") && fs::exists(OUT_DIR "/X_train_ii_GPU.bin")){
const np::Array<uint32_t> X_train_ii_cpu = load<uint32_t>(OUT_DIR "/X_train_ii_CPU.bin");
const np::Array<uint32_t> X_train_ii_gpu = load<uint32_t>(OUT_DIR "/X_train_ii_GPU.bin");
benchmark_function_void("X_train_ii CPU vs GPU", unit_test_cpu_vs_gpu<uint32_t>, X_train_ii_cpu, X_train_ii_gpu);
}
if(fs::exists(OUT_DIR "/X_test_ii_CPU.bin") && fs::exists(OUT_DIR "/X_test_ii_GPU.bin")){
const np::Array<uint32_t> X_test_ii_cpu = load<uint32_t>(OUT_DIR "/X_test_ii_CPU.bin");
const np::Array<uint32_t> X_test_ii_gpu = load<uint32_t>(OUT_DIR "/X_test_ii_GPU.bin");
benchmark_function_void("X_test_ii CPU vs GPU", unit_test_cpu_vs_gpu<uint32_t>, X_test_ii_cpu, X_test_ii_gpu);
}
if(fs::exists(OUT_DIR "/X_train_feat_CPU.bin")){
const np::Array<int32_t> X_train_feat = load<int32_t>(OUT_DIR "/X_train_feat_CPU.bin");
if(fs::exists(OUT_DIR "/X_train_feat_GPU.bin")){
const np::Array<int32_t> X_train_feat_gpu = load<int32_t>(OUT_DIR "/X_train_feat_CPU.bin");
benchmark_function_void("X_train_feat CPU vs GPU", unit_test_cpu_vs_gpu<int32_t>, X_train_feat, X_train_feat_gpu);
}
np::Array<uint16_t> X_train_feat_argsort_cpu;
uint8_t loaded = 0;
if(fs::exists(OUT_DIR "/X_train_feat_argsort_CPU.bin")){
X_train_feat_argsort_cpu = std::move(load<uint16_t>(OUT_DIR "/X_train_feat_argsort_CPU.bin"));
++loaded;
benchmark_function_void("argsort_2D training set (CPU)", unit_test_argsort_2d<int32_t>, X_train_feat, X_train_feat_argsort_cpu);
}
np::Array<uint16_t> X_train_feat_argsort_gpu;
if(fs::exists(OUT_DIR "/X_train_feat_argsort_GPU.bin")){
X_train_feat_argsort_gpu = std::move(load<uint16_t>(OUT_DIR "/X_train_feat_argsort_GPU.bin"));
++loaded;
benchmark_function_void("argsort_2D training set (GPU)", unit_test_argsort_2d<int32_t>, X_train_feat, X_train_feat_argsort_gpu);
}
if (loaded == 2)
benchmark_function_void("X_train_feat_argsort CPU vs GPU", unit_test_cpu_vs_gpu<uint16_t>, X_train_feat_argsort_cpu, X_train_feat_argsort_gpu);
}
if(fs::exists(OUT_DIR "/X_test_feat_CPU.bin")){
const np::Array<int32_t> X_test_feat = load<int32_t>(OUT_DIR "/X_test_feat_CPU.bin");
if(fs::exists(OUT_DIR "/X_test_feat_GPU.bin")){
const np::Array<int32_t> X_test_feat_gpu = load<int32_t>(OUT_DIR "/X_test_feat_GPU.bin");
benchmark_function_void("X_test_feat CPU vs GPU", unit_test_cpu_vs_gpu<int32_t>, X_test_feat, X_test_feat_gpu);
}
np::Array<uint16_t> X_test_feat_argsort_cpu;
uint8_t loaded = 0;
if(fs::exists(OUT_DIR "/X_test_feat_argsort_CPU.bin")){
X_test_feat_argsort_cpu = std::move(load<uint16_t>(OUT_DIR "/X_test_feat_argsort_CPU.bin"));
++loaded;
benchmark_function_void("argsort_2D testing set (CPU)", unit_test_argsort_2d<int32_t>, X_test_feat, X_test_feat_argsort_cpu);
}
np::Array<uint16_t> X_test_feat_argsort_gpu;
if(fs::exists(OUT_DIR "/X_test_feat_argsort_GPU.bin")){
X_test_feat_argsort_gpu = std::move(load<uint16_t>(OUT_DIR "/X_test_feat_argsort_GPU.bin"));
++loaded;
benchmark_function_void("argsort_2D testing set (GPU)", unit_test_argsort_2d<int32_t>, X_test_feat, X_test_feat_argsort_gpu);
}
if (loaded == 2)
benchmark_function_void("X_test_feat_argsort CPU vs GPU", unit_test_cpu_vs_gpu<uint16_t>, X_test_feat_argsort_cpu, X_test_feat_argsort_gpu);
}
char title[BUFFER_SIZE] = { 0 }; char title[BUFFER_SIZE] = { 0 };
char alphas_title[BUFFER_SIZE] = { 0 }; char tmp_title[BUFFER_SIZE / 2] = { 0 };
char final_classifiers_title[BUFFER_SIZE] = { 0 }; char file_cpu[BUFFER_SIZE] = { 0 };
char file_gpu[BUFFER_SIZE] = { 0 };
const std::chrono::system_clock::time_point fnc_s = perf_counter_ns();
uint64_t n_total = 0, n_success = 0;
for (const size_t T : TS) { auto test_fnc = [&n_total, &n_success](const char* title, const auto& fnc) {
sprintf(alphas_title, MODEL_DIR "/alphas_%lu_CPU.bin", T); ++n_total;
if(!fs::exists(alphas_title)) continue; const std::chrono::system_clock::time_point start = perf_counter_ns();
const np::Array<float64_t> alphas = load<float64_t>(alphas_title); const bool state = fnc();
const long long time_spent = duration_ns(perf_counter_ns() - start);
if(state){
printf("| %-37s | %10s | %18s | %-29s |\n", title, "Passed", thousand_sep(time_spent).c_str(), format_time_ns(time_spent).c_str());
++n_success;
} else
printf("| %-37s | %10s | %18s | %-29s |\n", title, "Failed", thousand_sep(time_spent).c_str(), format_time_ns(time_spent).c_str());
};
sprintf(final_classifiers_title, MODEL_DIR "/final_classifiers_%lu_CPU.bin", T); for (const char* label : { "train", "test" }) {
if(!fs::exists(final_classifiers_title)) continue; sprintf(file_cpu, OUT_DIR "/X_%s_ii_CPU.bin", label);
const np::Array<float64_t> final_classifiers = load<float64_t>(final_classifiers_title); sprintf(file_gpu, OUT_DIR "/X_%s_ii_GPU.bin", label);
if (fs::exists(file_cpu) && fs::exists(file_gpu)) {
sprintf(alphas_title, MODEL_DIR "/alphas_%lu_GPU.bin", T); const np::Array<uint32_t> X_train_ii_cpu = load<uint32_t>(file_cpu);
if(!fs::exists(alphas_title)) continue; const np::Array<uint32_t> X_train_ii_gpu = load<uint32_t>(file_gpu);
const np::Array<float64_t> alphas_gpu = load<float64_t>(alphas_title); sprintf(tmp_title, "X_%s_ii", label);
sprintf(title, "%-22s - CPU vs GPU", tmp_title);
sprintf(final_classifiers_title, MODEL_DIR "/final_classifiers_%lu_GPU.bin", T); test_fnc(title, [&X_train_ii_cpu, &X_train_ii_gpu]{ return unit_test_cpu_vs_gpu<uint32_t>(X_train_ii_cpu, X_train_ii_gpu); });
if(!fs::exists(final_classifiers_title)) continue;
const np::Array<float64_t> final_classifiers_gpu = load<float64_t>(final_classifiers_title);
sprintf(title, "alphas %ld CPU vs GPU", T);
benchmark_function_void(title, unit_test_cpu_vs_gpu<float64_t>, alphas, alphas_gpu);
sprintf(title, "final_classifiers %ld CPU vs GPU", T);
benchmark_function_void(title, unit_test_cpu_vs_gpu<float64_t>, final_classifiers, final_classifiers_gpu);
} }
char file_feat[BUFFER_SIZE] = { 0 };
sprintf(file_feat, OUT_DIR "/X_%s_feat_CPU.bin", label);
if (fs::exists(file_feat)) {
const np::Array<int32_t> X_feat = load<int32_t>(file_feat);
sprintf(file_gpu, OUT_DIR "/X_%s_feat_GPU.bin", label);
if (fs::exists(file_gpu)) {
const np::Array<int32_t> X_feat_gpu = load<int32_t>(file_gpu);
sprintf(tmp_title, "X_%s_feat", label);
sprintf(title, "%-22s - CPU vs GPU", tmp_title);
test_fnc(title, [&X_feat, &X_feat_gpu]{ return unit_test_cpu_vs_gpu<int32_t>(X_feat, X_feat_gpu); });
}
sprintf(file_cpu, OUT_DIR "/X_%s_feat_argsort_CPU.bin", label);
np::Array<uint16_t> X_feat_argsort_cpu;
uint8_t loaded = 0;
if (fs::exists(file_cpu)) {
X_feat_argsort_cpu = std::move(load<uint16_t>(file_cpu));
++loaded;
sprintf(tmp_title, "X_%s_feat_argsort", label);
sprintf(title, "%-22s - CPU argsort", tmp_title);
test_fnc(title, [&X_feat, &X_feat_argsort_cpu]{ return unit_test_argsort_2d<int32_t>(X_feat, X_feat_argsort_cpu); });
}
sprintf(file_gpu, OUT_DIR "/X_%s_feat_argsort_GPU.bin", label);
np::Array<uint16_t> X_feat_argsort_gpu;
if (fs::exists(file_gpu)) {
X_feat_argsort_gpu = std::move(load<uint16_t>(file_gpu));
++loaded;
sprintf(tmp_title, "X_%s_feat_argsort", label);
sprintf(title, "%-22s - GPU argsort", tmp_title);
test_fnc(title, [&X_feat, &X_feat_argsort_gpu]{ return unit_test_argsort_2d<int32_t>(X_feat, X_feat_argsort_gpu); });
}
if (loaded == 2){
sprintf(tmp_title, "X_%s_feat_argsort", label);
sprintf(title, "%-22s - CPU vs GPU", tmp_title);
test_fnc(title, [&X_feat_argsort_cpu, &X_feat_argsort_gpu]{ return unit_test_cpu_vs_gpu<uint16_t>(X_feat_argsort_cpu, X_feat_argsort_gpu); });
}
}
}
for (const size_t T : TS)
for (const char* label : { "alphas", "final_classifiers" }) {
sprintf(file_cpu, MODEL_DIR "/%s_%lu_CPU.bin", label, T);
sprintf(file_gpu, MODEL_DIR "/%s_%lu_GPU.bin", label, T);
if (fs::exists(file_cpu) && fs::exists(file_gpu)){
const np::Array<float64_t> cpu = load<float64_t>(file_cpu);
const np::Array<float64_t> gpu = load<float64_t>(file_gpu);
sprintf(tmp_title, "%s_%ld", label, T);
sprintf(title, "%-22s - CPU vs GPU", tmp_title);
test_fnc(title, [&cpu, &gpu]{ return unit_test_cpu_vs_gpu<float64_t>(cpu, gpu); });
}
}
const long long time_spent = duration_ns(perf_counter_ns() - fnc_s);
sprintf(title, "%ld/%ld", n_success, n_total);
printf("|%s|%s|%s|%s|\n", S(39), S(12), S(20), S(31));
printf("| %-37s | %10s | %18s | %-29s |\n", "Unit testing summary", title, thousand_sep(time_spent).c_str(), format_time_ns(time_spent).c_str());
} }
int main(){ int main(){
@ -308,9 +301,6 @@ int main(){
const auto [ X_train_feat, X_train_feat_argsort, y_train, X_test_feat, y_test ] = preprocessing(); const auto [ X_train_feat, X_train_feat_argsort, y_train, X_test_feat, y_test ] = preprocessing();
train(X_train_feat, X_train_feat_argsort, y_train); train(X_train_feat, X_train_feat_argsort, y_train);
testing_and_evaluating(X_train_feat, y_train, X_test_feat, y_test); testing_and_evaluating(X_train_feat, y_train, X_test_feat, y_test);
final_unit_test(); unit_test();
#if __DEBUG
printf("\nAFTER CLEANUP\n");
#endif
return EXIT_SUCCESS; return EXIT_SUCCESS;
} }