void testEigenConstMap() { Vector_t x(4); x << 1, 2, 3, 4; std::cout << x << std::endl; const Vector_t y = x; std::cout << y << std::endl; Matrix_t X = Eigen::Map<const Matrix_t>(y.data(), 2, 2); std::cout << X << std::endl; }
void testEigenMap() { Vector_t theta; theta.setZero(4 * 5); for (int i = 0; i < theta.size(); ++i) theta(i) = i; std::cout << theta << std::endl; Eigen::Map<Matrix_t> Theta(theta.data(), 4, 5); // reshape std::cout << Theta << std::endl; Vector_t theta2(Eigen::Map<Vector_t>(Theta.data(), 5 * 4)); std::cout << theta2 << std::endl; }
void testStlDriver() { const int numPatches = 200000; // 200000 const int patchWidth = 9; const int numFeatures = 50; const double lambda = 0.0005f; const double epsilon = 1e-2; Config config; config.setValue("addBiasTerm", false); config.setValue("meanStddNormalize", false); config.setValue("configurePolicyTesting", false); config.setValue("trainingMeanAndStdd", false); updateMNISTConfig(config); if (false) { MNISTSamplePatchesUnlabeledDataFunction mnistUnlabeled(numPatches, patchWidth); SoftICACostFunction sfc(numFeatures, lambda, epsilon); LIBLBFGSOptimizer lbfgs(200); // 1000 Driver drv1(&config, &mnistUnlabeled, &sfc, &lbfgs); const Vector_t optThetaRica = drv1.drive(); Matrix_t Wrica( Eigen::Map<const Matrix_t>(optThetaRica.data(), numFeatures, pow(patchWidth, 2))); std::ofstream ofs_wrica("../W2.txt"); ofs_wrica << Wrica << std::endl; } Matrix_t Wrica; // debug: read off the values std::ifstream in("/home/sam/School/online/stanford_dl_ex/W2.txt"); if (in.is_open()) { std::string str; int nbRows = 0; while (std::getline(in, str)) { if (str.size() == 0) continue; std::istringstream iss(str); std::vector<double> tokens // { std::istream_iterator<double> { iss }, std::istream_iterator<double> { } }; Wrica.conservativeResize(nbRows + 1, tokens.size()); for (size_t i = 0; i < tokens.size(); ++i) Wrica(nbRows, i) = tokens[i]; ++nbRows; } } else { std::cerr << "file W.txt failed" << std::endl; exit(EXIT_FAILURE); } const int imageDim = 28; Eigen::Vector2i imageConfig; imageConfig << imageDim, imageDim; const int numFilters = numFeatures; const int poolDim = 5; const int filterDim = patchWidth; const int convDim = (imageDim - filterDim + 1); assert(convDim % poolDim == 0); const int outputDim = (convDim / poolDim); StlFilterFunction stlFilterFunction(filterDim, Wrica); SigmoidFunction sigmoidFunction; ConvolutionFunction convolutionFunction(&stlFilterFunction, &sigmoidFunction); MeanPoolFunction meanPoolFunction(numFilters, outputDim); MNISTSamplePatchesLabeledDataFunction mnistLabeled(&convolutionFunction, &meanPoolFunction, imageConfig, numFilters, poolDim, outputDim); SoftmaxCostFunction mnistcf(0.01f); LIBLBFGSOptimizer lbfgs2(300); config.setValue("configurePolicyTesting", false); config.setValue("trainingMeanAndStdd", true); config.setValue("meanStddNormalize", true); config.setValue("addBiasTerm", true); config.setValue("numGrd", true); config.setValue("training_accuracy", true); config.setValue("testing_accuracy", true); //config.setValue("addBiasTerm", false); Driver drv2(&config, &mnistLabeled, &mnistcf, &lbfgs2); drv2.drive(); }
void testConvolutionAndPool() { if (true) { const int filterDim = 8; const int imageDim = 28; const int poolDim = 3; const int numFilters = 100; const int outputDim = (imageDim - filterDim + 1) / poolDim; RandomFilterFunction rff(filterDim, numFilters); rff.configure(); SigmoidFunction sf; ConvolutionFunction cf(&rff, &sf); MeanPoolFunction pf(numFilters, outputDim); //MeanPoolFunction mpf; Eigen::Vector2i configImageDim; configImageDim << imageDim, imageDim; MNISTDataFunction mnistdf; Config config; updateMNISTConfig(config); config.setValue("addBiasTerm", false); config.setValue("meanStddNormalize", false); mnistdf.configure(&config); Convolutions* convolvedFeatures = nullptr; for (int i = 0; i < 13; ++i) convolvedFeatures = cf.conv(mnistdf.getTrainingX().topRows<199>(), configImageDim); assert(convolvedFeatures->unordered_map.size() == 199); for (auto i = convolvedFeatures->unordered_map.begin(); i != convolvedFeatures->unordered_map.end(); ++i) assert((int )i->second.size() == rff.getWeights().cols()); // Validate convoluations Matrix_t ConvImages = mnistdf.getTrainingX().topRows<8>(); for (int i = 0; i < 1000; ++i) { const int filterNum = rand() % rff.getWeights().cols(); const int imageNum = rand() % 8; const int imageRow = rand() % (configImageDim(0) - rff.getConfig()(0) + 1); const int imageCol = rand() % (configImageDim(1) - rff.getConfig()(1) + 1); Vector_t im = ConvImages.row(imageNum); Eigen::Map<Matrix_t> Image(im.data(), configImageDim(0), configImageDim(1)); Matrix_t Patch = Image.block(imageRow, imageCol, rff.getConfig()(0), rff.getConfig()(1)); // Filter Eigen::Map<Matrix_t> W(rff.getWeights().col(filterNum).data(), rff.getConfig()(0), rff.getConfig()(1)); const double b = rff.getBiases()(filterNum); double feature = Patch.cwiseProduct(W).sum() + b; feature = 1.0f / (1.0f + exp(-feature)); if (fabs( feature - convolvedFeatures->unordered_map[imageNum][filterNum]->X(imageRow, imageCol)) > 1e-9) { std::cout << "Convolved feature does not match test feature: " << i << std::endl; std::cout << "Filter Number: " << filterNum << std::endl; std::cout << "Image Number: " << imageNum << std::endl; std::cout << "Image Row: " << imageRow << std::endl; std::cout << "Image Col: " << imageCol << std::endl; std::cout << "Convolved feature: " << convolvedFeatures->unordered_map[imageNum][filterNum]->X(imageRow, imageCol) << std::endl; std::cout << "Test feature: " << feature << std::endl; std::cout << "Convolved feature does not match test feature" << std::endl; exit(EXIT_FAILURE); } } // Pool Poolings* pooling = nullptr; for (int i = 0; i < 13; ++i) pooling = pf.pool(convolvedFeatures, poolDim); assert((int )pooling->unordered_map.size() == 199); for (auto iter = pooling->unordered_map.begin(); iter != pooling->unordered_map.end(); ++iter) { assert(iter->second.size() == (size_t )rff.getWeights().cols()); for (auto iter2 = iter->second.begin(); iter2 != iter->second.end(); ++iter2) { assert(iter2->second->X.rows() == (configImageDim(0) - rff.getConfig()(0) + 1) / 3); assert(iter2->second->X.rows() == 7); assert(iter2->second->X.cols() == (configImageDim(0) - rff.getConfig()(0) + 1) / 3); assert(iter2->second->X.cols() == 7); } } } if (true) { // test pool function Vector_t testVec(64); for (int i = 0; i < testVec.size(); ++i) testVec(i) = i + 1; Eigen::Map<Matrix_t> TestMatrix(testVec.data(), 8, 8); std::cout << "TestMatrix: " << std::endl; std::cout << TestMatrix << std::endl; Matrix_t ExpectedMatrix(2, 2); ExpectedMatrix(0, 0) = TestMatrix.block(0, 0, 4, 4).array().mean(); ExpectedMatrix(0, 1) = TestMatrix.block(0, 4, 4, 4).array().mean(); ExpectedMatrix(1, 0) = TestMatrix.block(4, 0, 4, 4).array().mean(); ExpectedMatrix(1, 1) = TestMatrix.block(4, 4, 4, 4).array().mean(); std::cout << "Expected: " << std::endl; std::cout << ExpectedMatrix << std::endl; Convolutions cfs; Convolution xcf; xcf.X = TestMatrix; cfs.unordered_map[0].insert(std::make_pair(0, (&xcf))); MeanPoolFunction testMpf(1, 2); Poolings* pfs = testMpf.pool(&cfs, 4); assert(pfs->unordered_map.size() == 1); assert(pfs->unordered_map[0].size() == 1); Matrix_t PX = pfs->unordered_map[0][0]->X; std::cout << "Obtain: " << std::endl; std::cout << PX << std::endl; } }