void bayesian_classifier() {
	Mat img;
	const int featureSize = 28 * 28;
	const int noOfInstances = 60000;
	const int noOfClasses = 10;
	const int noOfTestInstances = 10000;
	Mat X = Mat(noOfInstances, featureSize, CV_8UC1);
	Mat XTest = Mat(noOfTestInstances, featureSize, CV_8UC1);
	int rowX = 0;
	int rowXTest = 0;
	Mat y(noOfInstances, 1, CV_8UC1);
	Mat yTest(noOfTestInstances, 1, CV_8UC1);

	char classes[noOfClasses][10] =
	{ "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" };

	//to hold a-priori probability
	double priors[5];
	int elementsOfClassTrain[5];
	int priorNr;
	//load the train instances
	char fname[256];
	for (int i = 0; i < noOfClasses; i++) {
		priorNr = 0;
		for(;;)
		{
			sprintf(fname, "images_bayes/train/%s/%06d.png", classes[i], priorNr);
			priorNr++;
			 img = imread(fname, CV_8UC1);
			if (0 == img.cols )
			{
				std::cout << "\n All photos " << i << " read from train folder " << priorNr;
				break;
			}
			Mat binary = grayToBinary(img, 128);

			int d = 0;
			for (int r = 0; r < binary.rows; r++) {
				for (int c = 0; c < binary.cols; c++) {
					X.at<uchar>(rowX, d) = binary.at<uchar>(r, c);
					d++;
				}
			}
			y.at<uchar>(rowX) = i;
			rowX++;
		}
		priors[i] = priorNr / (double)noOfInstances;
		elementsOfClassTrain[i] = priorNr;
	}
	char classesT[noOfClasses][10] =
	{ "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" };
	//loatd the test instances
	char fnameTest[256];
	for (int i = 0; i < noOfClasses; i++) {
		priorNr = 0;
		while (1) {
			sprintf(fnameTest, "images_bayes/test/%s/%06d.png", classesT[i], priorNr);
			priorNr++;
			Mat img = imread(fnameTest, CV_8UC1);
			if (img.cols == 0) {
				std::cout << "\n All photos from class " << i << " read from test folder : " << priorNr;
				break;
			}
			Mat binary = grayToBinary(img, 128);

			int d = 0;
			for (int r = 0; r < binary.rows; r++) {
				for (int c = 0; c < binary.cols; c++) {
					XTest.at<uchar>(rowXTest, d) = binary.at<uchar>(r, c);
					d++;
				}
			}
			yTest.at<uchar>(rowXTest) = i;
			rowXTest++;
		}
	}

	//compute likelihood
	//w/ laplace smoothing
	Mat likelihood = Mat::zeros(noOfClasses, featureSize, CV_64FC1);
	for (int k = 0; k < noOfInstances; k++) {
		for (int d = 0; d < featureSize; d++) {
			if (X.at<uchar>(k, d) == 255) {
				likelihood.at<double>((int)y.at<uchar>(k), d) += 1.0;
			}
		}
	}
	//laplace smoothing
	for (int r = 0; r < likelihood.rows; r++) {
		for (int c = 0; c < likelihood.cols; c++) {
			double value = likelihood.at<double>(r, c) + 1.0;
			likelihood.at<double>(r, c) = (value / (double)(noOfClasses + elementsOfClassTrain[r]));
		}
	}

	//classify test images
	Mat C = Mat::zeros(noOfClasses, noOfClasses, CV_32F);
	for (int count = 0; count < noOfTestInstances; count++) {
		Mat randImg = XTest.row(count);
		double classProbs[noOfClasses];
		for (int c = 0; c < noOfClasses; c++) {
			classProbs[c] = log(priors[c]);
			for (int j = 0; j < featureSize; j++) {
				if (randImg.at<uchar>(0, j) == 255) {
					classProbs[c] += log(likelihood.at<double>(c, j));
				}
				else {
					classProbs[c] += log(1.0f - likelihood.at<double>(c, j));
				}
			}
		}
		double max = *std::max_element(classProbs, classProbs + noOfClasses);
		int predictedClass = -1;
		for (int i = 0; i < noOfClasses; i++) {
			if (max == classProbs[i]) {
				predictedClass = i;
			}
		}
		C.at<float>(predictedClass, yTest.at<uchar>(count)) += 1.0;
	}
	double accuracy = getAccuracyFromConfusionMatrix(C);
	std::cout << "\nAccuracy: " << accuracy << std::endl;
	cout << endl;
	for (int i = 0; i < C.rows; i++) {
		for (int j = 0; j < C.cols; j++)
			cout << C.at<float>(i, j) << " ";

		cout << endl;
	}
	waitKey(0);
}