KNN分类算法（K近邻算法）—— 基于GPU的并行编程模型CUDA程序设计

最新推荐文章于 2025-02-08 01:12:10 发布
最新推荐文章于 2025-02-08 01:12:10 发布
阅读量3k 收藏 31
点赞数 3
分类专栏： 并行程序实践笔记 文章标签： 并行计算 cuda
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38162369/article/details/119829325
版权
本文探讨了如何使用CUDA并行编程模型对K近邻分类算法进行优化，通过Windows10环境下的Visual Studio和CUDA Toolkit实现GPU加速。串行与并行程序对比展示了GPU在大规模数据处理中的优势，提供了详细的代码实现和性能分析结果。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

KNN分类算法（K近邻算法）—— 基于GPU的并行编程模型CUDA程序设计

在这里插入图片描述

目录

1 题目描述

  用CUDA设计一个KNN分类算法（K近邻算法）程序。在特征空间中查找K个最相似或者距离最近的样本，然后根据K个最相似的样本对未知样本进行分类。通过训练集和测试集给出算法的正确率。

2 设计思路

首先写出knn的串行代码，包括以下几部分：
1、定义KNN类
2、用constructor创建对象，传进去文件名，用fin读取文件中的训练数据和label
3、然后读入测试数据
4、循环用get_all_distance计算已知类别数据集中的点与当前测试点之间的距离
5、按距离用sort对map递增次序排序
6、选取与当前点距离最小的k个点
7、用get_max_fre_label统计前k个点所在的类别出现的频率，返回前k个点出现频率最高的类别作为当前点的预测分类
8、用get_error_rate计算错误率，输出testdata的真实label与预测label

实验环境

操作系统：Windows10
开发环境：Visual Studio 2019 + CUDA Toolkit 11.0

3 源码

3.1 串行程序

#include<iostream>  
#include<map>  
#include<vector>  
#include<stdio.h>  
#include<cmath>  
#include<algorithm>  
#include<fstream>  
#include<cstdlib>  
#include<stdlib.h>  
using namespace std;  
  
#define maxRow 200//训练数据行数  
#define maxCol 13//列数（数据的维度）  
#define testRow 30//测试数据个数  
int TDnum = 0;//测试数据的个数统计  
double testData_glo[testRow][maxCol];//存放测试数据集  
string label[testRow];//存放测试数据集标签  
string label1[testRow];//存放测试数据集预测得标签  
  
float gpu_time = 0;  
  
  
typedef pair<int, double> PAIR;//模板类  
ifstream fin;//输入文件流  
  
class KNN//KNN类  
{  
private:  
    double dataSet[maxRow][maxCol];//训练数据数组  
    string   labels[maxRow];//训练数据的标签数组  
    double testData[maxCol];//一个测试数据数组  
    map<int, double> map_index_dis;//map类模板存储训练数据的索引值和到测试数据的距离，key是数据的编号/序号，value是距离  
    map<string, int> map_label;//map类模板存储训练数据的标签和索引  
public:  
    int k = 7;//初始化KNN算法中的k值大小，k值一般取奇数且一般小于20  
    KNN(char* filename);//有参构造函数  
    void get_all_distance();//获得欧式距离函数  
    double get_distance(double* d1, double* d2);  
  
    string get_max_fre_label();//找到前k个距离最接近标签函数  
    void get_error_rate();//误差率  
    struct CmpByValue//map的pair对按距离大小排序的结构体  
    {  
        bool operator() (const PAIR& lhs, const PAIR& rhs)  
        {  
            return lhs.second < rhs.second;  
        }  
  
    };  
  
};  
KNN::KNN(char* filename)  
{  
    if (TDnum == 0) {  
        fin.open(filename);//打开文件  
        if (!fin)//打开失败  
        {  
            cout << "can not open the file" << endl;  
            exit(0);  
        }  
        for (int i = 0; i < maxRow; i++)//读入训练数据及其标签存储在dataSet和labels中  
        {  
            for (int j = 0; j < maxCol; j++)  
            {  
                fin >> dataSet[i][j];  
  
            }fin >> labels[i];  
  
        }  
        fin.close();//关闭读操作  
    }  
}  
double KNN::get_distance(double* d1, double* d2)  
{  
    double sum = 0;  
    for (int i = 0; i < maxRow; i++)  
    {  
        sum += pow((d1[i] - d2[i]), 2);  
    }  
  
    //  cout<<"the sum is = "<<sum<<endl;  
    return sqrt(sum);  
}  
void KNN::get_all_distance()  
{  
    double distance;  
    int i;  
    for (i = 0; i < maxRow; i++)  
    {  
        distance = get_distance(dataSet[i], testData);  
        //<key,value> => <i,distance>  
        map_index_dis[i] = distance;  
    }  
  
    //traverse the map to print the index and distance  
    map<int, double>::const_iterator it = map_index_dis.begin();  
    while (it != map_index_dis.end())  
    {  
        //cout << "index = " << it->first << " distance = " << it->second << endl;  
        it++;  
    }  
}  
  
  
string KNN::get_max_fre_label()  
{  
    vector<pair<int, double> >vec_index_dis(map_index_dis.begin(), map_index_dis.end());  
    sort(vec_index_dis.begin(), vec_index_dis.end(), CmpByValue());//按距离排序  
  
  
    for (int i = 0; i < k; i++)//打印距离最小k个的点的信息  
    {  
#ifdef TEST  
        cout << "index = " << vec_index_dis[i].first << " the distance= " << vec_index_dis[i].second  
            << " the label = " << labels[vec_index_dis[i].first] << endl;  
#endif // TEST  
        map_label[labels[vec_index_dis[i].first]]++;//标签是key，标签数是value  
    }  
  
  
    map<string, int>::iterator itr = map_label.begin();  
    int max_freq = 0;  
    string label;  
    while (itr != map_label.end())//寻找出现次数最多的标签  
    {  
        if (itr->second > max_freq)  
        {  
            max_freq = itr->second;  
            label = itr->first;  
        }  
        itr++;  
    }  
    for (int i = 0; i < k; i++)//恢复初始值0  
    {  
        int xuhao = vec_index_dis[i].first;//距离第i小的点的序号  
        map_label[labels[xuhao]]--;  
    }  
    label1[TDnum] = label;  
    return label;  
}  
void KNN::get_error_rate()  
{  
    int i, count = 0;  
    //get testing data and calculate  
    for (i = 0; i < testRow; i++)  
    {  
        if (label[i] != label1[i])  
        {  
            count++;  
        }  
    }  
    cout << "the error rate is = " << (double)count / (double)testRow << endl;  
    cout << "the correct rate is = " << 1.0 - (double)count / (double)testRow << endl;  
}  
  
int main()  
{  
    char* filename = "heart_train.txt";//训练数据文件名  
    KNN knn(filename);//创建KNN类对象  
    if (TDnum == 0) {//程序开始时导入测试数据集存放至testData_glo数组  
        filename = "heart_test.txt";  
        fin.open(filename);  
        if (!fin)  
        {  
            cout << "can not open the file" << endl;  
            exit(0);  
        }  
        for (int i = 0; i < testRow; i++)  
        {  
            for (int j = 0; j < maxCol; j++)  
            {  
                fin >> testData_glo[i][j];  
  
            }  
            fin >> label[i];  
  
        }  
    }  
  
    clock_t begin = clock();//开始时间  
    for (int e = 0; e < testRow; e++)//循环完成测试数据的标签预测  
    {  
        knn.get_all_distance();//计算与训练数据的所有距离  
        knn.get_max_fre_label();  
        TDnum++;//记录测试数据的个数  
    }  
    clock_t end = clock();//结束时间  
    double time_spent = (double)(end - begin) / CLOCKS_PER_SEC;  
  
    cout << "k= " << knn.k << " result:" << endl;  
    knn.get_error_rate();  
    cout << "real    label:";  
    for (int i = 0; i < testRow; i++)  
    {  
        cout << label[i] << " ";  
    }  
    cout << endl; cout << "predict label:";  
    for (int i = 0; i < testRow; i++)  
    {  
        cout << label1[i] << " ";  
    }  
    cout << endl;  
  
    printf("CPU:Time used:%.3f s\n", time_spent);  
  
    return 0;  
}

1.3.2 并行程序

#include<iostream>  
#include<map>  
#include<vector>  
#include<stdio.h>  
#include<cmath>  
#include<algorithm>  
#include<fstream>  
#include<cstdlib>  
#include<stdlib.h>  
#include "cuda_runtime.h"  
#include "device_launch_parameters.h"  
using namespace std;  
  
#define maxRow 100//训练数据行数  
#define maxCol 13//列数（数据的维度）  
#define testRow 30//测试数据个数  
int TDnum = 0;//测试数据的个数统计  
double testData_glo[testRow][maxCol];//存放测试数据集  
string label[testRow];//存放测试数据集标签  
string label1[testRow];//存放测试数据集预测得标签  
  
float gpu_time=0;  
  
__global__ void GPUKNN(double dataset[maxRow][maxCol], double testdata[maxCol], double maps[maxRow])//核函数（训练数据矩阵，测试数据数组，存储距离数组）  
{  
    int i = blockIdx.x * blockDim.x + threadIdx.x;  
    if (i < maxRow)  
        for (int k = 0; k < maxCol; k++)  
            maps[i] += (dataset[i][k] - testdata[k]) * (dataset[i][k] - testdata[k]);//计算欧式距离的平方      
  
}  
  
  
typedef pair<int, double> PAIR;//模板类  
ifstream fin;//输入文件流  
  
class KNN//KNN类  
{  
private:  
    double dataSet[maxRow][maxCol];//训练数据数组  
    string   labels[maxRow];//训练数据的标签数组  
    double testData[maxCol];//一个测试数据数组  
    map<int, double> map_index_dis;//map类模板存储训练数据的索引值和到测试数据的距离，key是数据的编号/序号，value是距离  
    map<string, int> map_label;//map类模板存储训练数据的标签和索引  
public:  
    int k = 7;//初始化KNN算法中的k值大小，k值一般取奇数且一般小于20  
    KNN(char* filename);//有参构造函数  
    void get_all_distance();//获得欧式距离函数  
    string get_max_fre_label();//找到前k个距离最接近标签函数  
    void get_error_rate();//误差率  
    struct CmpByValue//map的pair对按距离大小排序的结构体  
    {  
        bool operator() (const PAIR& lhs, const PAIR& rhs)  
        {  
            return lhs.second < rhs.second;  
        }  
  
    };  
  
};  
KNN::KNN(char* filename)  
{  
    if (TDnum == 0) {  
        fin.open(filename);//打开文件  
        if (!fin)//打开失败  
        {  
            cout << "can not open the file" << endl;  
            exit(0);  
        }  
        for (int i = 0; i < maxRow; i++)//读入训练数据及其标签存储在dataSet和labels中  
        {  
            for (int j = 0; j < maxCol; j++)  
            {  
                fin >> dataSet[i][j];  
  
            }fin >> labels[i];  
  
        }  
        fin.close();//关闭读操作  
    }  
}  
void KNN::get_all_distance()  
{  
    for (int j = 0; j < maxCol; j++)//循环读取测试数据  
    {  
        testData[j] = testData_glo[TDnum][j];  
  
    }  
    double(*gpudS)[maxCol];//dataSet  
    double* gpuTD, * gpuSum;//testData，distance  
  
//记录GPU运行时间  
    cudaEvent_t gpu_start, gpu_stop;  
  
    cudaEventCreate(&gpu_start);//创建事件对象   
    cudaEventCreate(&gpu_stop);  
    cudaEventRecord(gpu_start, 0);//记录事件   
  
//分配显存  
    cudaMalloc(&gpudS, sizeof(double) * maxCol * maxRow);  
    cudaMalloc(&gpuTD, sizeof(double) * maxCol);  
    cudaMalloc(&gpuSum, sizeof(double) * maxRow);  
//拷贝  
    cudaMemcpy(gpudS, dataSet, sizeof(double) * maxCol * maxRow, cudaMemcpyHostToDevice);  
    cudaMemcpy(gpuTD, testData, sizeof(double) * maxCol, cudaMemcpyHostToDevice);  
    cudaMemcpy(gpuSum, 0, sizeof(double) * maxCol, cudaMemcpyHostToDevice);//赋值为0  
    double sum[maxRow];//存放拷回的欧式距离的平方  
#ifdef TEST  
    cout << "testdata" << TDnum << ":" << testData[0] << " " << testData[1] << " " << testData[2] << " " << testData[3] << endl;//查看测试数据的各维度值  
#endif // TEST  
      
    GPUKNN << <maxRow, 1 >> > (gpudS, gpuTD, gpuSum);//调用核函数  
  
    cudaEventRecord(gpu_stop, 0);  
    cudaEventSynchronize(gpu_stop);  
    /* 
    cudaEventSynchronize(gpu_stop):使得直到GPU执行完cudaEventRecord(gpu_stop, 0)之前的所有语句时， 
    事件gpu_stop才会被记录下来，即起到同步的作用。 
    */  
    float timetemp;  
    cudaEventElapsedTime(&timetemp, gpu_start, gpu_stop);//计算两次事件的时间差   
    gpu_time += timetemp;  
  
    cudaEventDestroy(gpu_start);//销毁事件对象   
    cudaEventDestroy(gpu_stop);  
  
    cudaMemcpy(sum, gpuSum, sizeof(double) * maxRow, cudaMemcpyDeviceToHost);//拷回距离到sum数组  
    for (int i = 0; i < maxRow; i++)  
    {  
        sum[i] = sqrt(sum[i]);//开方即为欧氏距离  
        map_index_dis[i] = sum[i];//赋值给map  
    }  
    cudaFree(gpudS);//释放  
    cudaFree(gpuTD);  
    cudaFree(gpuSum);  
}  
  
  
string KNN::get_max_fre_label()  
{  
    vector<pair<int, double> >vec_index_dis(map_index_dis.begin(), map_index_dis.end());  
    sort(vec_index_dis.begin(), vec_index_dis.end(), CmpByValue());//按距离排序  
  
  
    for (int i = 0; i < k; i++)//打印距离最小k个的点的信息  
    {  
#ifdef TEST  
        cout << "index = " << vec_index_dis[i].first << " the distance= " << vec_index_dis[i].second  
            << " the label = " << labels[vec_index_dis[i].first] << endl;  
#endif // TEST  
        map_label[labels[vec_index_dis[i].first]]++;//标签是key，标签数是value  
    }  
  
  
    map<string, int>::iterator itr = map_label.begin();  
    int max_freq = 0;  
    string label;  
    while (itr != map_label.end())//寻找出现次数最多的标签  
    {  
        if (itr->second > max_freq)  
        {  
            max_freq = itr->second;  
            label = itr->first;  
        }  
        itr++;  
    }  
    for (int i = 0; i < k; i++)//恢复初始值0  
    {  
        int xuhao = vec_index_dis[i].first;//距离第i小的点的序号  
        map_label[labels[xuhao]]--;  
    }  
    label1[TDnum] = label;  
    return label;  
}  
void KNN::get_error_rate()  
{  
    int i, count = 0;  
//get testing data and calculate  
    for (i = 0; i < testRow; i++)  
    {  
        if (label[i] != label1[i])  
        {  
            count++;  
        }  
    }  
    cout << "the error rate is = " << (double)count / (double)testRow << endl;  
    cout << "the correct rate is = " << 1.0 - (double)count / (double)testRow << endl;  
}  
  
int main()  
{  
    char* filename = "heart_train.txt";//训练数据文件名  
    KNN knn(filename);//创建KNN类对象  
    if (TDnum == 0) {//程序开始时导入测试数据集存放至testData_glo数组  
        filename = "heart_test.txt";  
        fin.open(filename);  
        if (!fin)  
        {  
            cout << "can not open the file" << endl;  
            exit(0);  
        }  
        for (int i = 0; i < testRow; i++)  
        {  
            for (int j = 0; j < maxCol; j++)  
            {  
                fin >> testData_glo[i][j];  
  
            }  
            fin >> label[i];  
  
        }  
    }  
    for (int e = 0; e < testRow; e++)//循环完成测试数据的标签预测  
    {  
        knn.get_all_distance();//计算与训练数据的所有距离  
  
        knn.get_max_fre_label();  
        TDnum++;//记录测试数据的个数  
    }  
  
    cout << "k= " << knn.k << " result:" << endl;  
    knn.get_error_rate();  
    cout << "real    label:";  
    for (int i = 0; i < testRow; i++)  
    {  
        cout << label[i]<<" ";  
    }  
    cout << endl; cout << "predict label:";  
    for (int i = 0; i < testRow; i++)  
    {  
        cout << label1[i]<<" ";  
    }  
    cout << endl;  
  
    printf("GPU:Time used:%.3f ms\n", gpu_time);//以毫秒为单位，精度为0.5微秒   
  
    return 0;  
}

3.3 性能对比与分析

在这里插入图片描述

在这里插入图片描述
图1 100
在这里插入图片描述
图2 300
在这里插入图片描述
图3 500
在这里插入图片描述
图4 100
在这里插入图片描述
图5 300
在这里插入图片描述
图6 500

KNN算法的CUDA实现
Time_Runner的专栏
09-07 6572
在参考了《Fast k Nearest Neighbor Search using GPU》后，结合现在在做的课题，写点东西。 1.  算法思路         KNN算法的基础是对给定的query点集，对应查找在参考空间中距离最近的K个紧邻点。KNN的应用方面非常广泛，在ICP配准问题，Spin-image旋转图像配准法，SIFT点提取，数据挖掘，机器学习等多个方面中有广泛应用。
矩阵序列matlab代码-kNN-CUDA:使用GPU快速进行k最近邻搜索
05-19
矩阵序列matlab代码介绍 k最近邻算法（k-NN）是广泛用于分类和回归的机器学习算法。 k-NN算法被用于许多研究和工业领域，例如3维对象渲​​染，基于内容的图像检索，统计（熵和散度的估计），生物学（基因分类）等。kNN搜索的处理时间在许多应用领域，尤其是在高维空间中，仍然是瓶颈。 在这项工作中，我们尝试通过使用GPU执行kNN搜索来解决此处理时间问题。 作者 文森特·加西亚（Vincent Garcia） 埃里克·德布鲁夫（ÉricDebreuve） 米歇尔·巴劳德（Michel Barlaud） 描述 输入k-NN算法的值： 一组参考点。 查询点集。 参数k对应于要搜索的邻居数。 对于每个查询点，k-NN算法在参考点集中找到k个最近的点（k个最近的邻居）。 该算法返回（1）参考点集中k个最近点的索引（位置）和（2）k个相关联的欧几里得距离。 我们为此算法提供3种CUDA实现： knn_cuda_global使用GPU全局内存计算k-NN，以存储参考点和查询点，距离和索引。 knn_cuda_texture使用用于存储参考点的GPU纹理内存和用于存储其他阵列的GPU全局内存来计算
Python KNN k-邻近算法 手动实现及分析 分类、回归、糖尿病预测实战
Rp的博客
08-29 2727
Python KNN k-邻近算法 算法原理 \qquad k-邻近算法的核心思想是未标记样本的类别，由距离其最近的k个邻近投票来决定。 \qquad 假设，我们有一个已经标记的数据集，即已经知道了数据集中每个样本所属的类别。此外，有一个未标记的数据样本，我们的任务是预测出这个数据样本所属的类别。k-邻近算法的原理是，计算待标记的数据样本和数据集中每个样本的距离，取距离最近的k个样本。待标记的数据...
【机器学习】训练数据集和测试数据集的划分及KNN准确率测试
最新发布
若兰幽竹
02-08 1149
本博文围绕机器学习算法性能评估方法展开，重点介绍了训练数据集与测试数据集的分离（train test split）的重要性。内容详细说明了为何不能直接将全部原始数据作为训练集投入生产环境，而是需要通过分割部分数据作为测试集来评估模型性能。讲解了如何进行数据乱序和比例分配，并介绍了使用sklearn库进行train test split的示例。此外，还提到了在进行模型选择时，通过测试数据集的反馈来改进算法的重要性。最后，通过一个简单的knn分类器实例展示了如何应用方法评估机器学习算法的性能。
【并行/人工智能】基于KNN算法的手写数字识别(C与CUDA比较)
giantroit的博客
04-21 1019
文章目录一、KNN算法1、算法简介2、基本思想3、应用领域4、算法流程5、计算距离的方法①欧式距离6、采用并行计算的原因 一、KNN算法 1、算法简介 KNN算法(K-Nearest Neighbor algorithm，K最邻近方法)称为邻近算法，它是一种机器学习类的分类算法。 2、基本思想 该方法的思想非常简单：通俗来说就是“近朱者赤，近墨者黑”，测试样本的特征与哪一类别训练样本的特征最接近，那么该测试样本就属于这一类别。具体来说就是去找离测试样本的最接近的K个邻居(K根据情况取值)，这K个邻居大多数属
【CUDA并行编程之六】KNN算法的并行实现
Marshall的专栏
06-24 1738
之前写了两篇文章一个是KNN算法的C++串行实现，另一个是CUDA计算向量的欧氏距离。那么这篇文章就可以说是前两篇文章的一个简单的整合。在看这篇文章之前可以先阅读前两篇文章。 一、生成数据集 现在需要生成一个N个D维的数据，没在一组数据都有一个类标，这个类标根据第一维的正负来进行标识样本数据的类标：Positive and Negative。 [pyt
基于GPU的分类并行算法的研究与实现
01-29
分析了KNN算法在GPU上实现并行计算的可能性，提出了通过使用CUDA实现KNN算法的方案，在研究了GPU对存储访问的机制后，通过设计合理的数据以及对算法的改进，避免存储体冲突的产生，提高了算法的健壮性。研究结果证明...
一种基于OpenCL的高能效并行KNN算法及其GPU验证
10-16
【性能分析】在实验中，新提出的基于OpenCL的KNN并行算法在GPU上的运行速度比基于CUDA的CUKNN算法快16倍，这表明该方法在减少冗余计算的同时，优化了并行计算效率，进一步提升了KNN算法在大数据环境下的应用性能。...
一种基于OpenCL的高能效并行KNN算法及其GPU验证.pdf
09-25
【CUKNN算法】CUKNN是基于CUDA（Compute Unified Device Architecture）实现的KNN并行算法。CUDA是NVIDIA开发的一种编程模型，用于利用GPU进行高性能计算。CUKNN展示了在GPU上实现并行KNN相比于CPU串行执行的巨大...
基于GPU的分类并行算法的研究与实现.pdf
09-25
作者王坤提出使用CUDA（Compute Unified Device Architecture）这一NVIDIA开发的并行计算平台和编程模型来实现KNN算法的并行化。 在研究GPU的存储访问机制后，作者提出了一种避免存储体冲突的方法，即通过合理设计...
CUDA-KNN:CUDA 上的 KNN 算法
06-02
CUDA-KNN CUDA 上的 KNN 算法
KNN分类算法的MapReduce并行化实现1
08-04
摘要：为了提高k-nearestneighboralgorithm(KNN)算法处理大数据集的能力，本文利用MapReduce并行编程模型，同时结合KNN算法自
gpufsknn:基于GPU的kNN问题的高效数据并行表示-开源
04-26
k最近邻（kNN）搜索问题的基于GPU的高效数据并行表示形式，这是在模式识别，机器学习，生物信息学等多个研究领域中对对象进行分类的流行方法。
bf-knn:在GPU上进行蛮力k最近邻搜索
05-01
在GPU上进行蛮力k最近邻搜索 bf-knn实现了一种蛮力方法，用于在GPU上并行查找许多查询中的k个最近邻居。 它利用了基本GPU计算原语的最新进展。 查询和引用之间的平方欧几里德距离由CUDA内核计算得出，该内核是从库中的矩阵乘法子例程修改而来的。 最近的邻居选择是通过在库中的排序和合并功能之上构建的截断合并排序来完成的。 与最先进的方法相比， bf-knn更快并且可以处理更大的输入。 李胜仁和妮娜·阿曼塔（Nina Amenta）。 。 相似性搜索和应用2015。 下载bf-knn并编译该演示的说明： git clone git@github.com:NVlabs/moderngpu.git git clone git@github.com:geomlab-ucd/bf-knn.git cd bf-knn nvcc -arch=sm_21 -I ../moderngpu/inc
基于CUDA的KNN分类算法实现及性能分析
CUDA是由NVIDIA公司开发的一种并行计算平台和编程模型，可以充分利用NVIDIA的GPU进行通用的计算。而KNN（K-Nearest Neighbors）算法是一种基本分类与回归方法，通过测量不同特征值之间的距离来进行分类。 KNN算法的...
推荐文章：KNN_CUDA——GPU加速的高效近邻搜索库
gitblog_00018的博客
05-27 801
推荐文章：KNN_CUDA——GPU加速的高效近邻搜索库 去发现同类优质开源项目:https://gitcode.com/ 1、项目介绍 KNN_CUDA 是一个基于CUDA实现的Python库，用于在PyTorch环境中进行大规模数据集上的K最近邻（K-Nearest Neighbors，简称KNN）搜索。这个库通过充分利用NVIDIA GPU的并行计算能力，显著提升了KNN搜索的速度，并且兼容...
KNN算法的简单实现
weixin_44373412的博客
10-13 770
KNN算法 一，问题分析 KNN最邻近分类算法的实现原理：为了判断未知样本的类别，以所有已知类别的样本作为参照，计算未知样本与所有已知样本的距离，从中选取与未知样本距离最近的K个已知样本，再以k个样本中占多数的类别作为预测结果。 算法中关键的点是“距离”的计算和占多数类的判断。距离的计算，本次采用欧氏距离，以二维平面为例，这里的“距离”在数学上即为两点的直线距离，公式如下： 三维或更高维在此基础...
cuda编程（6）：实现knn算法
SeventhBlue
07-05 2207
暴力实现的复杂度： 实现分析： 完整的代码： Ubuntu运行命令： nvcc -o knn_cuda_with_indexes.exe knn_cuda_with_indexes.cu -lcuda -D_CRT_SECURE_NO_DEPRECATE #include <cuda.h> #include <cuda_runtime.h> #include <cuda_runtime_api.h> #include <device_laun.
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值