int main(){ int N = 10; int D = 5; int K = 4; int rand_seed = 2; double* X = gen_matrix(N,D); // Build ball tree on data set VpTree<DataPoint, euclidean_distance>* tree = new VpTree<DataPoint, euclidean_distance>(); vector<DataPoint> obj_X(N, DataPoint(D, -1, X)); std::srand((unsigned int) rand_seed); for(int n = 0; n < N; n++) obj_X[n] = DataPoint(D, n, X + n * D); std::random_shuffle(obj_X.begin(), obj_X.end()); pd(obj_X); cout << "size:" << obj_X.size() << endl; // cout << "1:" << obj_X[1] << endl; tree->create(obj_X); vector<DataPoint> indices; vector<double> distances; for(int n = 0; n < N; n++) { // Find nearest neighbors indices.clear(); distances.clear(); tree->search(obj_X[n], K + 1, &indices, &distances); std::cout << n << std::endl; pv(indices); pv(distances); } free(X); delete tree; }
void TSNE<NDims>::computeGaussianPerplexity(double* X, unsigned int N, int D, int K) { if(perplexity > K) Rprintf("Perplexity should be lower than K!\n"); // Allocate the memory we need setupApproximateMemory(N, K); // Build ball tree on data set VpTree<DataPoint, T>* tree = new VpTree<DataPoint, T>(); vector<DataPoint> obj_X(N, DataPoint(D, -1, X)); for(unsigned int n = 0; n < N; n++) obj_X[n] = DataPoint(D, n, X + n * D); tree->create(obj_X); // Loop over all points to find nearest neighbors if (verbose) Rprintf("Building tree...\n"); int steps_completed = 0; #pragma omp parallel for schedule(guided) num_threads(num_threads) for(unsigned int n = 0; n < N; n++) { vector<DataPoint> indices; vector<double> distances; indices.reserve(K+1); distances.reserve(K+1); // Find nearest neighbors tree->search(obj_X[n], K + 1, &indices, &distances); double * cur_P = val_P.data() + row_P[n]; computeProbabilities(perplexity, K, distances.data()+1, cur_P); // +1 to avoid self. unsigned int * cur_col_P = col_P.data() + row_P[n]; for (int m=0; m<K; ++m) { cur_col_P[m] = indices[m+1].index(); // +1 to avoid self. } #pragma omp atomic ++steps_completed; if (verbose) { if(steps_completed % 10000 == 0) Rprintf(" - point %d of %d\n", steps_completed, N); } } // Clean up memory obj_X.clear(); delete tree; }
void testVpTree2() { VpTree<Point<int>, int, EuclideanDistance<Point<int> >::DistanceIncremental> tree; int N = 1500000; for(int i = 0; i < N; ++i) { tree.insert(Point<int>(GlobalRNG.next(), GlobalRNG.next()), i); } int M = 15000; for(int i = 0; i < M; ++i) { assert(tree.nearestNeighbor(Point<int>(GlobalRNG.next(), GlobalRNG.next()))); int k = 100; assert(tree.kNN(Point<int>(GlobalRNG.next(), GlobalRNG.next()), k).getSize() == k); } }
void testVpTree() { VpTree<Point<int>,int, EuclideanDistance<Point<int> >::DistanceIncremental> tree; int N = 5; for(int i = 0; i < N; ++i) { tree.insert(Point<int>(i, i), i); } for(int i = 0; i < N; ++i) { int* result = tree.find(Point<int>(i, i)); if(result) DEBUG(*result); assert(result && *result == i); } Vector<VpTree<Point<int>,int, EuclideanDistance<Point<int> >::DistanceIncremental>::NodeType*> result2 = tree.distanceQuery(Point<int>(0, 4), sqrt(10)); for(int i = 0; i < result2.getSize(); ++i) { DEBUG(result2[i]->key[0]); DEBUG(result2[i]->key[1]); } }
KNNGraph_FixedK_MST::KNNGraph_FixedK_MST(std::shared_ptr<gsl::Matrix> data, PropertyList property_list) : data_(data), property_list_(property_list) { if (property_list_[KNNGRAPH_FIXED_K_NUMBER] == 0.0) property_list_[KNNGRAPH_FIXED_K_NUMBER] = 30.0; if (property_list_[KNNGRAPH_FIXED_K_WITH_MST_EDGE_POOL_DEPTH] == 0.0) property_list_[KNNGRAPH_FIXED_K_WITH_MST_EDGE_POOL_DEPTH] = property_list_[KNNGRAPH_FIXED_K_NUMBER] + 100; if (property_list_[KNNGRAPH_GRAPH_BACKEND] == KNNGRAPH_GRAPH_BACKEND_ADJACENCYLIST) { knngraph_ = std::make_shared<GraphUtils::AdjacencyList>(data_->rows()); } else if (property_list_[KNNGRAPH_GRAPH_BACKEND] == KNNGRAPH_GRAPH_BACKEND_BOOST) { knngraph_ = std::make_shared<GraphUtils::BoostAdjacencyList>(data_->rows()); } else { throw std::invalid_argument("Invalid KNNGRAPH_GRAPH_BACKEND value."); } kIndex FIXED_K = static_cast<Index>(property_list_[KNNGRAPH_FIXED_K_NUMBER]); kIndex MST_EDGE_POOL_DEPTH = static_cast<Index>(property_list_[KNNGRAPH_FIXED_K_WITH_MST_EDGE_POOL_DEPTH]); LOGI("Constructing kNN graph with FixedK_MST.") VpTree<PixelView, SquaredDistance> vptree; LOGI("Create PixelView array."); auto pixel_views = CreatePixelViewsFromMatrix(*data_); LOGI("Creating VpTree for the current data matrix.") vptree.create(pixel_views); LOGI("VpTree created. Now creating kNN graph.") UnionFind uf(data_->rows()); std::vector<UndirectedEdge> unused_edges; for (Index n = 0; n < data_->rows(); ++n) { PixelView current_pixel = pixel_views[n]; std::vector<PixelView> results; std::vector<Scalar> distance_squares; vptree.search(current_pixel, MST_EDGE_POOL_DEPTH, &results, &distance_squares); for (Index j = 0; j < MST_EDGE_POOL_DEPTH; ++j) { if (j < FIXED_K) { knngraph_->Connect(current_pixel.index, results[j].index, std::sqrt(distance_squares[j])); uf.Connect(current_pixel.index, results[j].index); } else { unused_edges.push_back(UndirectedEdge(current_pixel.index, results[j].index, std::sqrt(distance_squares[j]))); } } } LOGI("kNN graph without MST has " << uf.count() << " connected parts.") if (uf.count() != 1) { LOGI("Start augmenting MST.") std::sort(std::begin(unused_edges), std::end(unused_edges), [](UndirectedEdge a, UndirectedEdge b) { return a.weight < b.weight; }); Index augment_count = 0; for (auto edge : unused_edges) { Index old_count = uf.count(); uf.Connect(edge.index_a, edge.index_b); if (uf.count() < old_count) { knngraph_->Connect(edge.index_a, edge.index_b, edge.weight); augment_count++; } if (uf.count() == 1) break; } LOGI(augment_count << " edges augmented.") if (uf.count() != 1) { throw std::invalid_argument( "MST Augmentation failed -- need to increase KNNGRAPH_FIXED_K_WITH_MST_EDGE_POOL_DEPTH"); } }
// Compute input similarities with a fixed perplexity using ball trees (this function allocates memory another function should free) void TSNE::computeGaussianPerplexity(double* X, int N, int D, int** _row_P, int** _col_P, double** _val_P, double perplexity, int K) { if(perplexity > K) printf("Perplexity should be lower than K!\n"); // Allocate the memory we need *_row_P = (int*) malloc((N + 1) * sizeof(int)); *_col_P = (int*) calloc(N * K, sizeof(int)); *_val_P = (double*) calloc(N * K, sizeof(double)); if(*_row_P == NULL || *_col_P == NULL || *_val_P == NULL) { cout<<"Memory allocation failed!\n"; } int* row_P = *_row_P; int* col_P = *_col_P; double* val_P = *_val_P; double* cur_P = (double*) malloc((N - 1) * sizeof(double)); if(cur_P == NULL) { cout<<"Memory allocation failed!\n"; } row_P[0] = 0; for(int n = 0; n < N; n++) row_P[n + 1] = row_P[n] + K; // Build ball tree on data set VpTree<DataPoint, euclidean_distance>* tree = new VpTree<DataPoint, euclidean_distance>(); vector<DataPoint> obj_X(N, DataPoint(D, -1, X)); for(int n = 0; n < N; n++) obj_X[n] = DataPoint(D, n, X + n * D); tree->create(obj_X); // Loop over all points to find nearest neighbors printf("Building tree...\n"); vector<DataPoint> indices; vector<double> distances; for(int n = 0; n < N; n++) { if(n % 10000 == 0) printf(" - point %d of %d\n", n, N); // Find nearest neighbors indices.clear(); distances.clear(); tree->search(obj_X[n], K + 1, &indices, &distances); // Initialize some variables for binary search bool found = false; double beta = 1.0; double min_beta = -DBL_MAX; double max_beta = DBL_MAX; double tol = 1e-5; // Iterate until we found a good perplexity int iter = 0; double sum_P; while(!found && iter < 200) { // Compute Gaussian kernel row for(int m = 0; m < K; m++) cur_P[m] = exp(-beta * distances[m + 1]); // Compute entropy of current row sum_P = DBL_MIN; for(int m = 0; m < K; m++) sum_P += cur_P[m]; double H = .0; for(int m = 0; m < K; m++) H += beta * (distances[m + 1] * cur_P[m]); H = (H / sum_P) + log(sum_P); // Evaluate whether the entropy is within the tolerance level double Hdiff = H - log(perplexity); if(Hdiff < tol && -Hdiff < tol) { found = true; } else { if(Hdiff > 0) { min_beta = beta; if(max_beta == DBL_MAX || max_beta == -DBL_MAX) beta *= 2.0; else beta = (beta + max_beta) / 2.0; } else { max_beta = beta; if(min_beta == -DBL_MAX || min_beta == DBL_MAX) beta /= 2.0; else beta = (beta + min_beta) / 2.0; } } // Update iteration counter iter++; } // Row-normalize current row of P and store in matrix for(int m = 0; m < K; m++) cur_P[m] /= sum_P; for(int m = 0; m < K; m++) { col_P[row_P[n] + m] = indices[m + 1].index(); val_P[row_P[n] + m] = cur_P[m]; } } // Clean up memory obj_X.clear(); free(cur_P); delete tree; }
int _tmain(int argc, _TCHAR* argv[]) { #else int main(int argc, char **argv) { #endif if(argc != 2 && argc != 3) { fprintf(stderr, "Usage: sc <img1>\n"); return 1; } int spSize = 5; if(argc == 3) { sscanf(argv[2], "%d", &spSize); } ImageFile imgFile (argv[1]); if(!imgFile.Load()) { fprintf(stderr, "Error loading file: %s\n", argv[1]); return 1; } FasTC::Image<> *img = imgFile.GetImage(); const int kWidth = img->GetWidth(); const int kHeight = img->GetHeight(); const int nPixels = kWidth * kHeight; const uint32 pixelBufSz = nPixels * sizeof(FasTC::Pixel); FasTC::Pixel *pixels = new FasTC::Pixel[pixelBufSz]; memcpy(pixels, img->GetPixels(), pixelBufSz); uint32 *rawPixels = new uint32[kWidth * kHeight]; for(int i = 0; i < nPixels; i++) { // Pixels are stored as little endian ARGB, so we want ABGR pixels[i].Shuffle(0x6C); // 01 10 11 00 rawPixels[i] = pixels[i].Pack(); } int *labels = new int[nPixels]; int numLabels; SLIC slic; slic.PerformSLICO_ForGivenStepSize( rawPixels, kWidth, kHeight, labels, numLabels, spSize, 1.0); std::unordered_map<uint32, Region> regions; CollectPixels(kWidth, kHeight, pixels, labels, regions); std::cout << "Num regions: " << regions.size() << std::endl; for(auto &r : regions) { r.second.Compress(); r.second.Reconstruct(); } for(int i = 0; i < nPixels; i++) { pixels[i] = regions[labels[i]].GetNextPixel(); pixels[i].Shuffle(0x6C); } std::vector<Partition<4, 4> > partitions; EnumerateBPTC(partitions); std::cout << partitions.size() << " 4x4 BPTC partitions" << std::endl; VpTree<Partition<4, 4>, Partition<4, 4>::Distance> vptree; vptree.create(partitions); // Just to test, find the partition close to half 0 half 1.. Partition<4, 4> test; for(uint32 i = 0; i < 16; i++) { if(i < 8) { test[i] = 0; } else { test[i] = 1; } } vector<Partition<4, 4> > closest; vptree.search(test, 1, &closest, NULL); std::cout << closest[0].GetIndex() << std::endl; BPTCC::CompressionSettings settings; settings.m_NumSimulatedAnnealingSteps = 0; settings.m_ShapeSelectionFn = ChosePresegmentedShape<4, 4>; SelectionInfo info(vptree, labels, kWidth, kHeight); settings.m_ShapeSelectionUserData = &info; uint8 *outBuf = new uint8[kWidth * kHeight]; FasTC::CompressionJob cj( FasTC::eCompressionFormat_BPTC, reinterpret_cast<const uint8 *>(pixels), outBuf, static_cast<uint32>(kWidth), static_cast<uint32>(kHeight)); StopWatch sw; sw.Start(); BPTCC::Compress(cj, settings); sw.Stop(); std::cout << "Compression time: " << sw.TimeInMilliseconds() << "ms" << std::endl; CompressedImage ci(kWidth, kHeight, FasTC::eCompressionFormat_BPTC, outBuf); FasTC::Image<> outImg(kWidth, kHeight, pixels); std::cout << "PSNR: " << outImg.ComputePSNR(&ci) << "db" << std::endl; ImageFile outImgFile("out.png", eFileFormat_PNG, outImg); outImgFile.Write(); delete [] labels; delete [] rawPixels; delete [] pixels; return 0; }
// Compute input similarities with a fixed perplexity using ball trees (this function allocates memory another function should free) void TSNE::computeGaussianPerplexity(double* X, int N, int D, unsigned int** _row_P, unsigned int** _col_P, double** _val_P, double perplexity, int K, float gpu_mem, int verbose) { float start; float end; if (perplexity > K) printf("Perplexity should be lower than K!\n"); // Allocate the memory we need *_row_P = (unsigned int*)malloc((N + 1) * sizeof(unsigned int)); *_col_P = (unsigned int*)calloc(N * K, sizeof(unsigned int)); *_val_P = (double*)calloc(N * K, sizeof(double)); if (*_row_P == NULL || *_col_P == NULL || *_val_P == NULL) { printf("Memory allocation failed!\n"); exit(1); } unsigned int* row_P = *_row_P; unsigned int* col_P = *_col_P; double* val_P = *_val_P; double* cur_P = (double*)malloc((N - 1) * sizeof(double)); if (cur_P == NULL) { printf("Memory allocation failed!\n"); exit(1); } row_P[0] = 0; for (int n = 0; n < N; n++) row_P[n + 1] = row_P[n] + (unsigned int)K; // Build ball tree on data set VpTree<DataPoint, euclidean_distance>* tree = new VpTree<DataPoint, euclidean_distance>(); vector<DataPoint> obj_X(N, DataPoint(D, -1, X)); for (int n = 0; n < N; n++) obj_X[n] = DataPoint(D, n, X + n * D); tree->create(obj_X); //If using gpu then calculate and save all euclidean distances and use those to search the tree EuclideanDistances* all_distances = new EuclideanDistances(); if (gpu_mem > 0){ if (gpu_mem > 1){ printf("Requested GPU memory needs to be between 0 and 1 (of total available memory). Setting it to 0.8."); gpu_mem = 0.8; } start = clock(); computeSquaredEuclideanDistanceOnGpu(X, X, all_distances, N, D, gpu_mem, verbose); tree->set_all_euclidean_distances(*all_distances); end = clock(); if(verbose > 1) printf("Time spend in calculating all distances in GPU: %f\n", float(end - start) / CLOCKS_PER_SEC); } else{ if (verbose > 0) printf("Using CPU to calculate distances during tree search\n"); } // Loop over all points to find nearest neighbors if (verbose > 0) printf("Building tree...\n"); vector<DataPoint> indices; vector<double> distances; start = clock(); for (int n = 0; n < N; n++) { if (n % 10000 == 0 && verbose > 1) printf(" - Building tree and finding perplexities, point %d of %d\n", n, N); // Find nearest neighbors indices.clear(); distances.clear(); tree->search(obj_X[n], K + 1, &indices, &distances); // Initialize some variables for binary search bool found = false; double beta = 1.0; double min_beta = -DBL_MAX; double max_beta = DBL_MAX; double tol = 1e-5; // Iterate until we found a good perplexity int iter = 0; double sum_P; while (!found && iter < 200) { // Compute Gaussian kernel row for (int m = 0; m < K; m++) cur_P[m] = exp(-beta * distances[m + 1]); // Compute entropy of current row sum_P = DBL_MIN; for (int m = 0; m < K; m++) sum_P += cur_P[m]; double H = .0; for (int m = 0; m < K; m++) H += beta * (distances[m + 1] * cur_P[m]); H = (H / sum_P) + log(sum_P); // Evaluate whether the entropy is within the tolerance level double Hdiff = H - log(perplexity); if (Hdiff < tol && -Hdiff < tol) { found = true; } else { if (Hdiff > 0) { min_beta = beta; if (max_beta == DBL_MAX || max_beta == -DBL_MAX) beta *= 2.0; else beta = (beta + max_beta) / 2.0; } else { max_beta = beta; if (min_beta == -DBL_MAX || min_beta == DBL_MAX) beta /= 2.0; else beta = (beta + min_beta) / 2.0; } } // Update iteration counter iter++; } // Row-normalize current row of P and store in matrix for (unsigned int m = 0; m < K; m++) cur_P[m] /= sum_P; for (unsigned int m = 0; m < K; m++) { col_P[row_P[n] + m] = (unsigned int)indices[m + 1].index(); val_P[row_P[n] + m] = cur_P[m]; } distances.clear(); indices.clear(); } end = clock(); if (verbose > 1) printf("Time spend in building tree and finding perplexities: %f\n", float(end - start) / CLOCKS_PER_SEC); // Clean up memory obj_X.clear(); free(cur_P); delete tree; delete all_distances; }