多线程版本的Item_KNN的C语言实现

最新推荐文章于 2023-04-05 16:20:33 发布
最新推荐文章于 2023-04-05 16:20:33 发布
阅读量1.4k 收藏
点赞数
分类专栏： 并行计算 机器学习 文章标签： 多线程 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/li8630/article/details/45644223
版权

这里模仿了Word2vec里面构建Hash索引的思想,版本1里面由于IO密集型和CPU密集型工作同时进行，这样导致效率很低，所以在版本2中将所有线程首先做CPU密集型的操作然后再由主线程把结果写道文件中，并且经过测试，6核（23虚拟核）的服务器，开100个线程执行效率最佳。
版本1：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
#include <time.h>
#include <pthread.h>
#define MaxString 50
#define MaxUserSize 1024*1024*10
#define SIMILARITY_ITEM 30
#define MaxLen 100
char filename[20][15]={ "output1.txt","output2.txt","output3.txt","output4.txt",
                        "output5.txt","output6.txt","output7.txt","output8.txt",
                        "output9.txt","output10.txt","output11.txt","output12.txt",
                        "output13.txt","output14.txt","output15.txt","output16.txt",
                        "output17.txt","output18.txt","output19.txt","output20.txt"};

const int item_hash_size = 30000000;

struct itemInfo
{
    char itemId[MaxString];
    int totalUser;
    unsigned long long * userList;
    int max_user;
};

unsigned long long max_item =1000,item_size=0;
struct itemInfo * item;
int * item_hash;
char str1[10000][50];
int num_threads=20;
char str2[100];

int GetWordHash(char *itemId) {
  unsigned long long a, hash = 0;
  for (a = 0; a < strlen(itemId); a++) hash = hash * 257 + itemId[a];
  hash = hash % item_hash_size;
  return hash;
}

int SearchItem(char *itemId) {
  unsigned int hash = GetWordHash(itemId);
  while (1) {
    if (item_hash[hash] == -1) return -1;
    if (!strcmp(itemId, item[item_hash[hash]].itemId)) return item_hash[hash];
    hash = (hash + 1) % item_hash_size;
  }
  return -1;
}


int AddItemIdToItem(char *itemId,unsigned long long userId) {
  unsigned int hash;
  item[item_size].max_user = 100;
  item[item_size].userList = (unsigned long long *)calloc(item[item_size].max_user, sizeof(unsigned long long));
  strcpy(item[item_size].itemId, itemId);
  item[item_size].userList[0]=userId;
  item[item_size].totalUser = 1;
  item_size++;
  // Reallocate memory if needed
  if (item_size + 2 >= max_item) {
    max_item += 1000;
    item = (struct itemInfo *)realloc(item, max_item * sizeof(struct itemInfo));
  }
  hash = GetWordHash(itemId);
  while (item_hash[hash] != -1) hash = (hash + 1) % item_hash_size;
  item_hash[hash] = item_size - 1;
  return item_size - 1;
}


int ReadItemInfo()
{
    int a;
    //打开文件
    FILE * fin = fopen("data_1w.txt","rb");
    if (fin==NULL)
    {
        printf("The input file doesn't exist.\n");
        exit(1);
    }

    item =(struct itemInfo *)malloc(max_item*sizeof(struct itemInfo));
    if (item==NULL)
    {
        printf("item allocate failed.\n");
        exit(1);
    }

    //读取用户的购买记录
    char * str=(char *)malloc(MaxUserSize);
    while(fgets (str ,MaxUserSize,fin) != NULL)
    {
        //将用户购买记录分段
        memset(str1,0,sizeof(str1));
        int cn = 0;
        int b = 0;
        int c = 0;
        while(1){
            str1[cn][b] = str[c];
            b++;
            c++;
            str1[cn][b] = 0;
            if (str[c] == 10) break;
            if (str[c] == ' ') {
             cn++;
             b = 0;
             c++;
            }
        }
        cn++;

        //去除u的userID
        int len = strlen(str1[0]);
        unsigned long long value=0; 
        for (int j=1; j < len; j++)
            value = value*10+(str1[0][j]-'0');

        //将ItemId添加到Item中
        for (int i = 1; i < cn; ++i)
        {
            int index = SearchItem(str1[i]);
            if (index == -1) 
               a = AddItemIdToItem(str1[i],value);
            else {
                item[index].totalUser++;
                if (item[index].totalUser+2>=item[index].max_user)
                {
                    item[index].max_user+=100;
                    item[index].userList = (unsigned long long *)realloc(item[index].userList, item[index].max_user * sizeof(unsigned long long));
                }
                item[index].userList[item[index].totalUser-1]=value;
            }
        }

    }
    return 0;
}
void init(){
    //初始化Hash表
    item_hash = (int *)calloc(item_hash_size, sizeof(int));
    for (int i = 0; i < item_hash_size; ++i) item_hash[i] =  -1;

    //为item分配空间
    item = (struct itemInfo *)malloc(max_item*sizeof(struct itemInfo));

}


int binary_search(unsigned long long array[],int n,unsigned long long value)  {  
    int left=0;  
    int right=n-1;    
    while (left<=right)          //循环条件，适时而变  
    {  
        int middle=left + ((right-left)>>1);  //防止溢出，移位也更高效。同时，每次循环都需要更新。  

        if (array[middle]>value)  
        {  
            right =middle-1;   //right赋值，适时而变  
        }   
        else if(array[middle]<value)  
        {  
            left=middle+1;  
        }  
        else  
            return middle;    

    }  
    return -1;  
}  

void * CalItemSim(void * a){
    FILE * fout = fopen(filename[(int)a],"w");
    float bestSim[SIMILARITY_ITEM];
    char  bestUserID[SIMILARITY_ITEM][50];
    float p,similarity;
    int common,pos;
    int left = item_size/ num_threads * (int)a;
    int right  = item_size / num_threads *((int)a+1)-1;
    if ((int)a==num_threads-1)
        right=item_size-1;
    for (int i = left; i <= right; ++i) //遍历此线程需要处理的item
    {
        for (int w = 0; w < SIMILARITY_ITEM; ++w) //初始化
        {
            bestSim[w]=-1;
            bestUserID[w][0]=0;
        }
        for (int j = 0; j < item_size; ++j)
        {
            if (i!=j)
            {
                common=0;
                for (int t = 0; t < item[i].totalUser; ++t)  //寻找购买的相同物品个数
                {   
                    pos=binary_search(item[j].userList,item[j].totalUser,item[i].userList[t]);
                    if (pos!=-1)
                        common++;
                }
                if(common>5){
                    p=sqrt(item[i].totalUser * item[j].totalUser);
                    similarity = common/p;
                    for (int k = 0; k < SIMILARITY_ITEM; ++k)
                    {
                        if (similarity>bestSim[k])
                        {
                            for (int q = SIMILARITY_ITEM -1; q > k; q--)
                            {
                                bestSim[q] = bestSim[q-1];
                                strcpy(bestUserID[q],bestUserID[q-1]);
                            }
                            bestSim[k] =similarity;
                            strcpy(bestUserID[k],item[j].itemId);
                            break;
                        }
                    }
                }

            }   
        }
        for (int c = 0; (c < SIMILARITY_ITEM)&&bestSim[c]!=-1; ++c)
        {
            fprintf(fout,"%s %s %f\n",item[i].itemId,bestUserID[c],bestSim[c]);
        }
    }
    fclose(fout);
    pthread_exit(NULL);
}


void CreatMulThread(){
    pthread_t *pt = (pthread_t *)malloc(num_threads * sizeof(pthread_t));
    for (long long a = 0; a < num_threads; a++) pthread_create(&pt[a], NULL, CalItemSim, (void *)a);
    for (long long a = 0; a < num_threads; a++) pthread_join(pt[a], NULL);  
}
//将多个输出文件合并成
void FileJoin(){
    FILE * fout = fopen("output.txt","w");
    for (int i = 0; i < 20; ++i)
    {
        FILE * fin = fopen(filename[i],"r");
        while(fgets (str2 ,MaxLen,fin) != NULL){
            fprintf(fout,"%s",str2);
        }
        fclose(fin);

        if( remove(filename[i]) == 0 )
            printf("Removed %s\n", filename[i]);
        else
            perror("remove");
    }
    fclose(fout);
}
int main(){
    //freopen("output.txt","w",stdout);
    init();
    ReadItemInfo();
    CreatMulThread();
    FileJoin();
    /*
    char testpid[50]="p535223";
    int test=SearchItem(testpid);
    printf("test:%d\n",test );
    printf("item_size:%llu\n",item_size );
    printf("itemId:%s\n",item[test].itemId);
        printf("totalUser:%d\n",item[test].totalUser);
    for (int i = 0; i < item[test].totalUser; ++i)
    {
        printf("%llu\n",item[test].userList[i]);
    }
    */
    return 0;
}

版本2：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
#include <time.h>
#include <pthread.h>
#define MaxString 50
#define MaxUserSize 1024*1024*10
#define SIMILARITY_ITEM 30
#define MaxLen 100
#define Num_Thread 100
const int item_hash_size = 30000000;

struct itemInfo
{
    char itemId[MaxString];
    int totalUser;
    unsigned long long * userList;
    int max_user;
};
struct recordInfo{
    char itemId1[MaxString];
    char itemId2[MaxString];
    float similarity;
};
struct recordInfo * record[Num_Thread];
int len[Num_Thread];
int max[Num_Thread];
unsigned long long max_item =1000,item_size=0;
struct itemInfo * item;
int * item_hash;
char str1[10000][50];
char str2[100];

int GetWordHash(char *itemId) {
  unsigned long long a, hash = 0;
  for (a = 0; a < strlen(itemId); a++) hash = hash * 257 + itemId[a];
  hash = hash % item_hash_size;
  return hash;
}

int SearchItem(char *itemId) {
  unsigned int hash = GetWordHash(itemId);
  while (1) {
    if (item_hash[hash] == -1) return -1;
    if (!strcmp(itemId, item[item_hash[hash]].itemId)) return item_hash[hash];
    hash = (hash + 1) % item_hash_size;
  }
  return -1;
}


int AddItemIdToItem(char *itemId,unsigned long long userId) {
  unsigned int hash;
  item[item_size].max_user = 100;
  item[item_size].userList = (unsigned long long *)calloc(item[item_size].max_user, sizeof(unsigned long long));
  strcpy(item[item_size].itemId, itemId);
  item[item_size].userList[0]=userId;
  item[item_size].totalUser = 1;
  item_size++;
  // Reallocate memory if needed
  if (item_size + 2 >= max_item) {
    max_item += 1000;
    item = (struct itemInfo *)realloc(item, max_item * sizeof(struct itemInfo));
  }
  hash = GetWordHash(itemId);
  while (item_hash[hash] != -1) hash = (hash + 1) % item_hash_size;
  item_hash[hash] = item_size - 1;
  return item_size - 1;
}


int ReadItemInfo()
{

    int a;
    //打开文件
    FILE * fin = fopen("record_20w.txt","rb");
    if (fin==NULL)
    {
        printf("The input file doesn't exist.\n");
        exit(1);
    }

    item =(struct itemInfo *)malloc(max_item*sizeof(struct itemInfo));
    if (item==NULL)
    {
        printf("item allocate failed.\n");
        exit(1);
    }

    //读取用户的购买记录
    char * str=(char *)malloc(MaxUserSize);
    while(fgets (str ,MaxUserSize,fin) != NULL)
    {
        //将用户购买记录分段
        memset(str1,0,sizeof(str1));
        int cn = 0;
        int b = 0;
        int c = 0;
        while(1){
            str1[cn][b] = str[c];
            b++;
            c++;
            str1[cn][b] = 0;
            if (str[c] == 10) break;
            if (str[c] == ' ') {
             cn++;
             b = 0;
             c++;
            }
        }
        cn++;

        //去除u的userID
        int len = strlen(str1[0]);
        unsigned long long value=0; 
        int j;
        for ( j=1; j < len; j++)
            value = value*10+(str1[0][j]-'0');

        //将ItemId添加到Item中
        int i;
        for ( i = 1; i < cn; ++i)
        {
            int index = SearchItem(str1[i]);
            if (index == -1) 
               a = AddItemIdToItem(str1[i],value);
            else {
                item[index].totalUser++;
                if (item[index].totalUser+2>=item[index].max_user)
                {
                    item[index].max_user+=100;
                    item[index].userList = (unsigned long long *)realloc(item[index].userList, item[index].max_user * sizeof(unsigned long long));
                }
                item[index].userList[item[index].totalUser-1]=value;
            }
        }

    }

    return 0;
}
void init(){
    //初始化max和len
    int i;
    for(i=0;i<Num_Thread;i++){
        max[i]=1000;
        len[i]=0;
    }
    //初始化Hash表
    item_hash = (int *)calloc(item_hash_size, sizeof(int));
    for ( i = 0; i < item_hash_size; ++i) item_hash[i] =  -1;

    //为item分配空间
    item = (struct itemInfo *)malloc(max_item*sizeof(struct itemInfo));

}


int binary_search(unsigned long long array[],int n,unsigned long long value)  {  
    int left=0;  
    int right=n-1;    
    while (left<=right)          //循环条件，适时而变  
    {  
        int middle=left + ((right-left)>>1);  //防止溢出，移位也更高效。同时，每次循环都需要更新。  

        if (array[middle]>value)  
        {  
            right =middle-1;   //right赋值，适时而变  
        }   
        else if(array[middle]<value)  
        {  
            left=middle+1;  
        }  
        else  
            return middle;    

    }  
    return -1;  
}  

void * CalItemSim(void * a){
    int id  = *(int *)a;
    record[id] = (struct recordInfo *)malloc(max[id]*sizeof(struct recordInfo));
    float bestSim[SIMILARITY_ITEM];
    char  bestUserID[SIMILARITY_ITEM][50];
    float p,similarity;
    int common,pos;
    int left = item_size/ Num_Thread * id;
    int right  = item_size / Num_Thread *(id+1)-1;
    if (id==Num_Thread-1)
        right=item_size-1;
    int i,w,j,t,k,q;
    for ( i = left; i <= right; ++i) //遍历此线程需要处理的item
    {
        for ( w = 0; w < SIMILARITY_ITEM; ++w) //初始化
        {
            bestSim[w]=-1;
            bestUserID[w][0]=0;
        }
        for ( j = 0; j < item_size; ++j)
        {
            if (i!=j)
            {
                common=0;
                for ( t = 0; t < item[i].totalUser; ++t)  //寻找购买的相同物品个数
                {   
                    pos=binary_search(item[j].userList,item[j].totalUser,item[i].userList[t]);
                    if (pos!=-1)
                        common++;
                }
                if(common>5){
                    p=sqrt(item[i].totalUser * item[j].totalUser);
                    similarity = common/p;
                    for (k = 0; k < SIMILARITY_ITEM; ++k)
                    {
                        if (similarity>bestSim[k])
                        {
                            for ( q = SIMILARITY_ITEM -1; q > k; q--)
                            {
                                bestSim[q] = bestSim[q-1];
                                strcpy(bestUserID[q],bestUserID[q-1]);
                            }
                            bestSim[k] =similarity;
                            strcpy(bestUserID[k],item[j].itemId);
                            break;
                        }
                    }
                }

            }   
        }
        int c;
        for ( c = 0; (c < SIMILARITY_ITEM)&&bestSim[c]!=-1; ++c){
            if (len[id]+5>=max[id])
            {
                max[id]+=1000;
                record[id] = (struct recordInfo *)realloc(record[id], max[id] * sizeof(struct recordInfo));  
            }
            strcpy(record[id][len[id]].itemId1,item[i].itemId);
            strcpy(record[id][len[id]].itemId2,bestUserID[c]);
            record[id][len[id]].similarity = bestSim[c];
            len[id]++;
        }


    }
    pthread_exit(NULL);
}


void CreatMulThread(){
    pthread_t *pt = (pthread_t *)malloc(Num_Thread* sizeof(pthread_t));
    long long a;
    int id[Num_Thread];
    for(a=0;a<Num_Thread;a++) id[a]=a;
    for ( a = 0; a < Num_Thread; a++) pthread_create(&pt[id[a]], NULL, CalItemSim, (void *)&id[a]);
    for ( a = 0; a < Num_Thread; a++) pthread_join(pt[a], NULL);    
}
//将结果输出到文件
void Output(){
    FILE * fout = fopen("output_item_knn.txt","w");
    int i,j;
    for (i = 0; i < Num_Thread; ++i)
    {
        for (j = 0; j < len[i]; ++j)
        {
            fprintf(fout, "%s %s %f\n",record[i][j].itemId1,record[i][j].itemId2,record[i][j].similarity);
        }

    }
    fclose(fout);
}

int main(){
    //freopen("output.txt","w",stdout);
    init();
    ReadItemInfo();
    printf("sad");
    CreatMulThread();
    int sum= 0,i;
    for (i = 0; i < Num_Thread; ++i)
    {
        printf("len%d:%d\n",i+1,len[i]);
        sum+=len[i];
    }
    printf("sum:%d\n",sum);
    Output();
    /*
    char testpid[50]="p535223";
    int test=SearchItem(testpid);
    printf("test:%d\n",test );
    printf("item_size:%llu\n",item_size );
    printf("itemId:%s\n",item[test].itemId);
        printf("totalUser:%d\n",item[test].totalUser);
    for (int i = 0; i < item[test].totalUser; ++i)
    {
        printf("%llu\n",item[test].userList[i]);
    }
    */
    return 0;
}
li8630
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
knn.rar_c语言实现knn_knn iris_knn算法c语言_鸢尾花
09-23
使用C语言编写的最近邻算法，可以直接运行，算法是对鸢尾花数据进行了分类。
item函数的用法
期待下集是个可爱梦儿
10-20 5513
1) 这个接口返回的是一个Elem，不是Coll 当name指定的elem有多个时，通过index参数确定返回哪一个 [in] VARIANT of type VT_I4 that specifies the zero-based index of the object to retrieve when a collection is returned. 比如有2个name = "abc"
item在C语言中是什么意思中文,item的意思在线翻译,解释item中文英文含义,短语词组,音标读音,例句,词源,同义词【澳典网ODict.Net】...
weixin_33378570的博客
05-23 3989
i.temitem的音标和读音：DJ音标发音： [ˈaitəm]KK音标发音： [ˈaɪtəm]item的词性：n.(名词)1. A single article or unit in a collection, an enumeration, or a series.项目，细目：文集、细目或一套中的单独条目或项目2. A clause of a document, such as a bill ...
item的介绍与使用-1.0
yuhui_2000的博客
10-11 3536
scrapy深入之定义item 我们可以在其中预先定义好我们需要爬取哪些字段 所以，需要在items.py中这样设置 定义好之后，我们后来在爬虫中使用的时候，就可以直接使用这个类，而不需要在爬虫中定义一个字典。 注意：当我们定义好items.py之后，我们可以不全部使用items.py中定义的字段，但是使用的字段一定要是全部属于items.py中定义的字段 比如说，我们定义了3个字段，title、location_name、money 我们可以只爬取两个字段，例如title、location
item()和items()的用法详解与区别
qq_42358298的博客
04-05 1011
原文链接：https://blog.csdn.net/wangxuecheng666/article/details/120664111。由此可以看出使用item()函数取出的元素值的精度更高，所以在求损失函数等时我们一般用item（）items()的作用是把字典中的每对key和value组成一个元组，并把这些元祖放在列表中返回。item()的作用是取出单元素张量的元素值并返回该值，保持该元素类型不变。2、使用item()取出。
c语言中item的用法,c中listview的用法
weixin_39822993的博客
05-22 2347
下面小编就跟你们详细介绍下c中listview的用法的用法，希望对你们有用。c中listview的用法的用法如下：ListView是个较为复杂的控件网上教程写的很乱，C#中文资料太匮乏了，小白叔叔觉得有必要自己出一份了。http://blog.sina.com.cn/s/blog_43eb83b90100mhrs.html1.定义把它拽进来，系统会自动在Designer.cs里添加一个 this...
knn.zip_KNN 分类 python_knn_knn python实现_python knn
09-24
最简单的机器学习分类方法knn算法的python实现
kNN.rar_knn_knn实现
09-24
自己修改后的kNN，实现简单。大神见笑。
Knn.rar_KNN C++实现
09-14
c++课程中要求的实现KNN的问题。解决了数据的产生问题
kNN.zip_KNN 分类 python_knn_knn python实现_knn分类python_数字数据集
09-23
KNN实现python实现代码，结合数字数据集，实现数字的分类任务。
Recommender-System:利用MovieLens数据，Pearson相似度，分别基于User和Item构建一个简单的kNN推荐系统，并进行RMSE评价
03-11
推荐系统 利用MovieLens数据，Pearson相似度，分别基于User和Item构建一个简单的kNN推荐系统，并进行RMSE评价
c语言item头文件,红黑树头文件C语言
weixin_39810196的博客
05-23 484
红黑树,记得刚买那本书的时候我就发现有这个东西,觉得很神秘,终于接触到了,并且,我已经写出来了.很高兴.插入的例程是书上自带的,我给代码实现了.细节部分,我并不是很清楚.删除例程,是自己写的,全下来写了大概15小时,很辛苦.昨天晚上到家就开始写,今天到家也是立刻就开始写,写完了.我想说的是,关于删除例程, 算法部分的自己构建我很满意,旋转部分的细节实现以及细节,也是自己发现并总结的,而且是对的.很...
item()用法
qq_43719331的博客
05-28 967
item():读取元素张量里的元素 import torch import numpy as np a=np.array([1,2,3,4]) tensor=torch.from_numpy(a) print(tensor[2]) print(tensor[2].item()) yun'xing
item在C语言中是什么意思中文,英语item的中文是什么意思
weixin_32818781的博客
05-23 2659
英语item的中文是什么意思英语item看起来是一个很简单的单词，但很多人对于它的中文意思是有点模糊的。以下是百分网小编为大家整理了关于英语单词item具体的中文意思及相关例句，一起来看看吧!英语单词item的中文意思英 [ˈaɪtəm]　美 [ˈaɪtəm]第三人称复数：items名词 项目; 条，条款; 一则; 一件商品(或物品)副词 又，同上名词1. There was an item in...
item在c语言程序设计,《Objective-C高级编程》Blocks 阅读笔记 item2（Block的实质）...
weixin_31205797的博客
05-18 443
《Objective-C高级编程》Blocks 阅读笔记系列2.3 Blocks的实现2.3.1 Block的实质Clang(LLVM编译器)具有将含有Block语法的源代码转换为我们可读源代码的功能。通过“-rewrite-objc”选项就能将含有Block语法的源代码变换为C++的源代码(本质是使用了struct结构的C语言源代码)。int main(){void (^blk)(void) =...
推荐算法普查（基于深度学习）
Jony0917的专栏
10-10 1639
摘要 深度学习已经成为推荐算法研究者们理想的选择。随着机器学习领域研究兴趣的强力增长，已经很难跟踪谁才是TopN推荐问题的最先进算法。与此同时，最近有几篇文章指出现在机器学习领域实践方面的一些问题，比如结果可复现性，以及baseline的选择问题。 本文报告了对TopN推荐算法的系统性分析结果。我们分析了最近几年在顶级研究会议上发表的18种算法。其中只有7种算法，经过合理的尝试后复现了结果。并且，...
item-CF item-KNN的区别
ty2009137128的专栏
06-13 3153
CF。很直接，找到与item A，item B都评价过的用户 C，推荐item B给买过item A 的 用户D。 KNN 则用到了基于社交的相似度计算法 。计算A与B的相似度，则是找到所有买过A的又买过B的用户，考虑评价偏差，计算完成后我们得到k个最相似的item。
【mahout笔记】初步理解KNN Linear interpolation item–based（基于物品的knn算法）在mahout的实现
猫球球的博客
08-05 1252
参考大神的博客：https：//blog.csdn.net/wolvesqun/article/details/52757772 以下为大佬博客对KNN Linear interpolation的介绍： 这个算法在mahout-0.8版本中，已经被@Deprecated。 算法来自论文： This algorithm is based in the paper of Robert M. Be...
c语言中item用法,CCtrlList::InsertItem()的用法
weixin_40000131的博客
05-22 777
第一个没什么问题.但第二个,编译时出现了如下错误:1>CtrlListDlg.cpp1>正在编译资源...1>正在链接...1>正在嵌入清单...1>mt.exe : general error c101008a: Failed to save the updated manifest to the file ".\Debug\CtrlList.exe.embed.m...
tuned_knn = gd_knn.best_estimator_ print(f'Train : {tuned_knn.score(X_train_std, y_train)}') model_eval(tuned_knn,X_test_std,y_test)代码每行解释
最新发布
06-10
1. `tuned_knn = gd_knn.best_estimator_`: 这行代码是将经过网格搜索调参后的最佳KNN模型赋值给`tuned_knn`变量。 2. `print(f'Train : {tuned_knn.score(X_train_std, y_train)}')`: 这行代码是输出`tuned_knn`...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值