// Show the internal face recognition data, to help debugging.
void showTrainingDebugData(const Ptr<FaceRecognizer> model, const int faceWidth, const int faceHeight)
{
try { // Surround the OpenCV calls by a try/catch block so we don't crash if some model parameters aren't available.
// Show the average face (statistical average for each pixel in the collected images).
Mat averageFaceRow = model->get<Mat>("mean");
printMatInfo(averageFaceRow, "averageFaceRow");
// Convert the matrix row (1D float matrix) to a regular 8-bit image.
Mat averageFace = getImageFrom1DFloatMat(averageFaceRow, faceHeight);
printMatInfo(averageFace, "averageFace");
// imshow("averageFace", averageFace);
saveFloatMat("averageFace.jpg", &averageFace);
// Get the eigenvectors
Mat eigenvectors = model->get<Mat>("eigenvectors");
printMatInfo(eigenvectors, "eigenvectors");
// Show the best 20 eigenfaces
for (int i = 0; i < min(20, eigenvectors.cols); i++) {
// Create a column vector from eigenvector #i.
// Note that clone() ensures it will be continuous, so we can treat it like an array, otherwise we can't reshape it to a rectangle.
// Note that the FaceRecognizer class already gives us L2 normalized eigenvectors, so we don't have to normalize them ourselves.
Mat eigenvectorColumn = eigenvectors.col(i).clone();
//printMatInfo(eigenvectorColumn, "eigenvector");
Mat eigenface = getImageFrom1DFloatMat(eigenvectorColumn, faceHeight);
//printMatInfo(eigenface, "eigenface");
char eigenName[64];
sprintf(eigenName,"Eigenface%d.jpg", i);
saveFloatMat(eigenName, &eigenface);
// imshow(format("Eigenface%d", i), eigenface);
}
// Get the eigenvalues
Mat eigenvalues = model->get<Mat>("eigenvalues");
printMat(eigenvalues, "eigenvalues");
//int ncomponents = model->get<int>("ncomponents");
//cout << "ncomponents = " << ncomponents << endl;
vector<Mat> projections = model->get<vector<Mat> >("projections");
cout << "projections: " << projections.size() << endl;
for (int i = 0; i < (int)projections.size(); i++) {
printMat(projections[i], "projections");
}
//labels = model->get<Mat>("labels");
//printMat(labels, "labels");
} catch (cv::Exception e) {
//cout << "WARNING: Missing FaceRecognizer properties." << endl;
}
}
void spmv_bell(char* oclfilename, coo_matrix<int, float>* mat, int dim2Size, int ntimes, cl_device_type deviceType)
{
printMatInfo(mat);
float* vec = (float*)malloc(sizeof(float)*mat->matinfo.width);
float* res = (float*)malloc(sizeof(float)*mat->matinfo.height);
initVectorOne<int, float>(vec, mat->matinfo.width);
initVectorZero<int, float>(res, mat->matinfo.height);
float* coores = (float*)malloc(sizeof(float)*mat->matinfo.height);
spmv_only(mat, vec, coores);
double overallopttime = 10000.0f;
int bestbw = 0;
int bestbh = 0;
int nnz = mat->matinfo.nnz;
for (int bwidth = 4; bwidth < 9; bwidth += 4)
for (int bheight = 1; bheight < 9; bheight*=2)
{
//int bwidth = 8;
//int bheight = 4;
b4ell_matrix<int, float> b4ellmat;
if (coo2b4ell<int, float>(mat, &b4ellmat, bwidth, bheight, GPU_ALIGNMENT, 0) == false)
continue;
//rearrange_b4ell_4col(&b4ellmat, GPU_ALIGNMENT);
double opttime1 = 10000.0f;
int optmethod1 = 0;
spmv_b4ell_ocl(&b4ellmat, vec, res, dim2Size, opttime1, optmethod1, oclfilename, deviceType, coores, ntimes, bwidth, bheight);
if (opttime1 < overallopttime)
{
overallopttime = opttime1;
bestbw = bwidth;
bestbh = bheight;
}
double gflops = (double)nnz*2/opttime1/(double)1e9;
printf("BELL info: block row num %d ell num %d \n", b4ellmat.b4ell_row_num, b4ellmat.b4ell_block_num);
printf("\n------------------------------------------------------------------------\n");
printf("BELL best time %f ms best method %d GFLOPS %f", opttime1*1000.0, optmethod1, gflops);
printf("\n------------------------------------------------------------------------\n");
free_b4ell_matrix(b4ellmat);
}
printf("\n------------------------------------------------------------------------\n");
printf("Final BELL best time %f ms GFLOPS %f Block %dx%d", overallopttime*1000.0, (double)nnz*2/overallopttime/(double)1e9, bestbh, bestbw);
printf("\n------------------------------------------------------------------------\n");
free(vec);
free(res);
free(coores);
}
PetscErrorCode BearQueryMat(PetscInt s, PetscScalar c, Mat invL1, Mat invU1, Mat invL2, Mat invU2, Mat H12, Mat H21, Vec order){
PetscErrorCode err;
PetscInt n1, n2, n, M, N;
PetscInt oseed;
PetscScalar val, one = 1.0;
PetscMPIInt size;
PetscLogDouble tic, toc;
Mat r = NULL;
Mat r1 = NULL, q1 = NULL, t1_1 = NULL, t1_2 = NULL, t1_3 = NULL, t1_4 = NULL, t1_5 = NULL; // dimension: n1
Mat r2 = NULL, q2 = NULL, q_tilda = NULL, t2_1 = NULL, t2_2 = NULL, t2_3 = NULL; // dimension: n2_idx
Vec vr=NULL, vr1=NULL, vr2=NULL;
PetscInt col = 0;
err = MPI_Comm_size(PETSC_COMM_WORLD, &size); CHKERRQ(err);
err = MatGetSize(H12, &n1, &n2); CHKERRQ(err);
n = n1 + n2;
err = PetscPrintf(PETSC_COMM_WORLD, "n1: %d, n2: %d\n", n1, n2); CHKERRQ(err);
err = MatCreateAIJ(PETSC_COMM_WORLD, PETSC_DECIDE, 1, n, size, 1, NULL, 1, NULL, &r); CHKERRQ(err);
err = MatCreateAIJ(PETSC_COMM_WORLD, PETSC_DECIDE, 1, n1, size, 1, NULL, 1, NULL, &q1); CHKERRQ(err);
err = MatCreateAIJ(PETSC_COMM_WORLD, PETSC_DECIDE, 1, n2, size, 1, NULL, 1, NULL, &q2); CHKERRQ(err);
// err = MatCreate(PETSC_COMM_WORLD, &q2); CHKERRQ(err);
// err = MatSetSizes(q2, PETSC_DECIDE, PETSC_DECIDE, n2, 1); CHKERRQ(err);
// err = MatSetType(q2, MATAIJ); CHKERRQ(err);
// err = MatSetUp(q2);
s = s - 1; // shift -1 for zero-based index
err = VecGetValues(order, 1, &s, &val); CHKERRQ(err);
oseed = (PetscInt) val;
// err = PetscPrintf(PETSC_COMM_WORLD, "Given seed: %d, Reorered seed: %d (0 ~ n-1)\n", s, oseed); CHKERRQ(err);
if(oseed < n1){
//err = MatSetValues(q1, 1, &oseed, 1, &col, &one, INSERT_VALUES); CHKERRQ(err);
err = MatSetValue(q1, oseed, col, one, INSERT_VALUES); CHKERRQ(err);
}else{
oseed = oseed - n1;
//err = MatSetValues(q2, 1, &oseed, 1, &col, &one, INSERT_VALUES); CHKERRQ(err);
err = MatSetValue(q2, oseed, col, one, INSERT_VALUES); CHKERRQ(err);
//err = printVecSum(q2);
}
err = MatAssemblyBegin(q1, MAT_FINAL_ASSEMBLY); CHKERRQ(err);
err = MatAssemblyEnd(q1, MAT_FINAL_ASSEMBLY); CHKERRQ(err);
err = MatAssemblyBegin(q2, MAT_FINAL_ASSEMBLY); CHKERRQ(err);
err = MatAssemblyEnd(q2, MAT_FINAL_ASSEMBLY); CHKERRQ(err);
err = printMatInfo("q1", q1);
err = printMatInfo("q2", q2);
//err = MatView(q1, PETSC_VIEWER_STDOUT_WORLD);
//err = MatView(q2, PETSC_VIEWER_STDOUT_WORLD);
err = MatDuplicate(q1, MAT_DO_NOT_COPY_VALUES, &r1); CHKERRQ(err);
err = MatDuplicate(q1, MAT_DO_NOT_COPY_VALUES, &t1_1); CHKERRQ(err);
err = MatDuplicate(q1, MAT_DO_NOT_COPY_VALUES, &t1_2); CHKERRQ(err);
err = MatDuplicate(q1, MAT_DO_NOT_COPY_VALUES, &t1_3); CHKERRQ(err);
err = MatDuplicate(q1, MAT_DO_NOT_COPY_VALUES, &t1_4); CHKERRQ(err);
err = MatDuplicate(q1, MAT_DO_NOT_COPY_VALUES, &t1_5); CHKERRQ(err);
err = MatDuplicate(q2, MAT_DO_NOT_COPY_VALUES, &r2); CHKERRQ(err);
err = MatDuplicate(q2, MAT_DO_NOT_COPY_VALUES, &q_tilda); CHKERRQ(err);
err = MatDuplicate(q2, MAT_DO_NOT_COPY_VALUES, &t2_1); CHKERRQ(err);
err = MatDuplicate(q2, MAT_DO_NOT_COPY_VALUES, &t2_2); CHKERRQ(err);
err = MatDuplicate(q2, MAT_DO_NOT_COPY_VALUES, &t2_3); CHKERRQ(err);
err = MatMatMult(invL1, q1, MAT_INITIAL_MATRIX, PETSC_DEFAULT, &t1_1); CHKERRQ(err);
err = MatMatMult(invU1, t1_1, MAT_INITIAL_MATRIX, PETSC_DEFAULT, &t1_2); CHKERRQ(err);
err = MatMatMult(H21, t1_2, MAT_INITIAL_MATRIX, PETSC_DEFAULT, &t2_1); CHKERRQ(err);
err = MatScale(t2_1, -1.0); CHKERRQ(err);
err = MatAXPY(t2_1, 1.0, q2, DIFFERENT_NONZERO_PATTERN); CHKERRQ(err);
//MatView(t1_1, PETSC_VIEWER_STDOUT_WORLD);
err = PetscTime(&tic);
err = MatMatMult(invL2, t2_1, MAT_INITIAL_MATRIX, PETSC_DEFAULT, &t2_2); CHKERRQ(err);
err = MatMatMult(invU2, t2_2, MAT_INITIAL_MATRIX, PETSC_DEFAULT, &r2); CHKERRQ(err);
err = PetscTime(&toc);
err = PetscPrintf(PETSC_COMM_WORLD, "running time: %f sec\n", toc-tic); CHKERRQ(err);
err = MatMatMult(H12, r2, MAT_INITIAL_MATRIX, PETSC_DEFAULT, &t1_3); CHKERRQ(err);
err = MatScale(t1_3, -1.0); CHKERRQ(err);
err = MatAXPY(t1_3, 1.0, q1, DIFFERENT_NONZERO_PATTERN); CHKERRQ(err);
err = MatMatMult(invL1, t1_3, MAT_INITIAL_MATRIX, PETSC_DEFAULT, &t1_5); CHKERRQ(err);
err = MatMatMult(invU1, t1_5, MAT_INITIAL_MATRIX, PETSC_DEFAULT, &r1); CHKERRQ(err);
//MatView(r1, PETSC_VIEWER_STDOUT_WORLD);
MatGetSize(r1, &M, &N);
PetscPrintf(PETSC_COMM_WORLD, "%d %d\n", M, N);
err = VecCreateMPI(PETSC_COMM_WORLD, PETSC_DECIDE, n1, &vr1);
err = MatGetColumnVector(r1, vr1, 0);
err = VecCreateMPI(PETSC_COMM_WORLD, PETSC_DECIDE, n2, &vr2);
err = MatGetColumnVector(r2, vr2, 0);
err = printMatInfo("r2", r2);
/*
// Start matrix-vec multiplications
err = MatMult(invU2, t2_2, r2); CHKERRQ(err);
err = MatMult(H12, r2, t1_3); CHKERRQ(err);
err = VecAXPBYPCZ(t1_4, 1.0, -1.0, 0.0, q1, t1_3); CHKERRQ(err);
err = MatMult(invL1, t1_4, t1_5); CHKERRQ(err);
err = MatMult(invU1, t1_5, r1); CHKERRQ(err);
//err = printVecSum(r1);
//err = VecView(r2, PETSC_VIEWER_STDOUT_WORLD);
// Concatenate r1 and r2
err = VecMerge(r1, r2, r); CHKERRQ(err);
err = VecScale(r, c); CHKERRQ(err);
//err = VecView(r, PETSC_VIEWER_STDOUT_WORLD);
//err = VecDuplicate(r, &or); CHKERRQ(err);
err = VecReorder(r, order, or); CHKERRQ(err);
//err = VecView(or, PETSC_VIEWER_STDOUT_WORLD);
*/
err = MatDestroy(&r); CHKERRQ(err);
err = MatDestroy(&r1); CHKERRQ(err);
err = MatDestroy(&q1); CHKERRQ(err);
err = MatDestroy(&t1_1); CHKERRQ(err);
err = MatDestroy(&t1_2); CHKERRQ(err);
err = MatDestroy(&t1_3); CHKERRQ(err);
err = MatDestroy(&t1_4); CHKERRQ(err);
err = MatDestroy(&t1_5); CHKERRQ(err);
err = MatDestroy(&r2); CHKERRQ(err);
err = MatDestroy(&q2); CHKERRQ(err);
err = MatDestroy(&q_tilda); CHKERRQ(err);
err = MatDestroy(&t2_1); CHKERRQ(err);
err = MatDestroy(&t2_2); CHKERRQ(err);
err = MatDestroy(&t2_3); CHKERRQ(err);
return err;
}
