机器学习--KNN算法学习笔记

已于 2025-05-17 12:07:16 修改
阅读量704 收藏 14
点赞数 24
文章标签： 机器学习 算法 人工智能 学习 笔记
于 2025-05-17 12:05:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SOLECA_/article/details/148026366
版权
#新星杯·14天创作挑战营·第11期#

文章目录


这是一篇学习机器学习KNN算法的学习笔记，用时2.5h，讲解较为细致，便于理解，整体按照分析题目时思考的逻辑进行写作，通俗易懂，使用c++实现，便于理解底层原理，附有源码和代码分层讲解，并附有数据点，供大家参考

什么是KNN算法？

K最临近算法（K-Nearest-Neighbors）是一种有监督机器学习算法，适用于简单的分类任务，这里以鸢尾花分类的题目为例进行讲解：

  • 鸢尾花分类问题：给定鸢尾花的 花萼长度，花萼宽度，花瓣长度，花瓣宽度 的四种数据，对鸢尾花进行分类,这里鸢尾花的 数据和类别 就是有监督机器学习的分类问题中要学习和求解的部分。
  • 数据点样例：

5.1,3.5,1.4,0.2,Iris-setosa
4.9,3.0,1.4,0.2,Iris-setosa
7.0,3.2,4.7,1.4,Iris-versicolor
6.4,3.2,4.5,1.5,Iris-versicolor
6.3,3.3,6.0,2.5,Iris-virginica
5.8,2.7,5.1,1.9,Iris-virginica

要解决的问题就是，在给定data.txt时，将鸢尾花数据分为训练集和测试集两部分，使用训练集训练KNN算法的模型，通过训练得到的模型对测试集部分的数据进行预测，观察KNN算法得到的模型的预测结果和实际样本的真实结果之间的差异，得出本模型的准确率

KNN算法的基本思路

我们知道了这样一个机器学习算法就是通过程序实现一种算法时，这个程序称为模型，使用训练数据对模型进行输入，经过算法的运算后，再输入测试数据，就能输出这个测试数据的类型的过程，那么怎么设计这个程序呢？

从我们想要实现的效果入手，假设我们现在已经有了并且处理好了训练集的数据，那么当一个被预测的数据出现时，我们来看KNN算法是怎么实现的：

  1. 读取这个想要预测的数据，并计算这个数据和所有已知训练集数据的 差异 ， 也就是计算当前数据和其他样本点的每一个维度的距离大小（这里的距离就像中学的亮点间的距离公式，因为一个数据就是一个多维的向量，在坐标系里每个数据向量对应一个点，使用点的坐标公式就能得到亮点间的距离）
  2. 找到距离最近的k个向量，这k个数据里面出现次数最多的类型就认为是该样本的预测类型

到这里我们就理解了KNN算法的基本思路，下面来考虑怎么使用c++代码实现我们的想法

KNN算法的实现

写代码的第一步当然就是敲好头文件并且优雅地写下main()函数，哈哈哈，那接下来怎么补充程序的内容？

让我们回顾一下，我们想要通过这个程序实现一个算法，读入鸢尾花的有类别数据之后进行处理，并且在之后新读入一个无类别数据时，能够进行预测的效果

怎么处理这些数据？要用文件读取，要有一定的结构来储存，数据量可能不确定，我们可以考虑使用vector进行存储，每一个vector单元中储存一个样本数据，那么可以把鸢尾花的特征放进结构体中

我们先试着完成读取和存储数据的这部分，然后再考虑对数据的进一步操作

#include<iostream>
#include<cstdio>//c++保留的C语言风格的文件读取操作fopen
#include<vector>
#include<cstring>
using namespace std;
struct Iris{
	double a,b,c,d;
	int type;
	Iris(double a, double b, double c, double d, int type)
        : a(a), b(b), c(c), d(d), type(type) {}
};

void readData(vector<Iris>& sample){
	FILE *f=fopen("data.txt","r");
    double a,b,c,d;char ch[20];
    while(fscanf(f,"%lf,%lf,%lf,%lf,%s",&a,&b,&c,&d,ch)==5){
        if(strcmp(ch,"Iris-setosa")==0){
            sample.emplace_back(a,b,c,d,1);//可以直接传参数，不用构造成实际类型后在传递
        }else if(strcmp(ch,"Iris-versicolor")==0){
            sample.emplace_back(a,b,c,d,2);
        }else if(strcmp(ch,"Iris-virginica")==0){
            sample.emplace_back(a,b,c,d,3);
        }
    }
    fclose(f);
    printf("readed successfully!\n");
}
int main(){
	vector<Iris> sample;
	readData(sample);
}

在读入完成后，我们可以考虑如何对数据进行处理，因为样本数据本身都是完整的，所以这里不需要对数据进行初始化了，那么接下来就是把数据划分成训练集和测试集两部分，并在划分成功之后对数据进行训练

具体的划分方法，我们使用c++内置的用于将容器内部的数据进行随机化的函数shuffle(),这个函数在c++的<algorithm>库中,通过调用一个随机化引擎实现对容器中内容的随机化，这里的default_random_engine()引擎存在于<random>库中

#include<iostream>
```exiting code
#include<algorithm>
#include<random>
using namespace std;
```exiting code

void divideData(vector<Iris> &sample,vector<Iris> &train,vector<Iris> &test,double &trainRate){
	shuffle(sample.begin(),sample.end(),default_random_engine(time(0)));
	double trainNum=sample.size()*trainRate;
	for(int i=0;i<sample.size();i++){
		if(i<trainNum){
			train.emplace_back(sample[i]);
		}else{
			test.emplace_back(sample[i]);
		}
	}
	printf("divided successfully!\n");
}
int main(){
	vector<Iris> sample;
	readData(sample);
	vector<Iris> train;
	vector<Iris> test;
	double trainRate=0.7;
	divideData(sample,train,test,trainRate);
}

现在已经对数据成功进行了划分，接下来就是训练数据并实现预测的过程了

#incldue<iostream>
```exiting code
#include<cmath>
using namespace std;
```exiting code
double distance(Iris &x,Iris &y){
	double d1=x.a-y.a;
    double d2=x.b-y.b;
    double d3=x.c-y.c;
    double d4=x.d-y.d;
    return sqrt(d1*d1+d2*d2+d3*d3+d4*d4);
}
double KNN(vector<Iris> &train,vector<Iris> &test,int k){
	double correct=0;
    int n=0;
	for(auto &t:test){
		vector<pair<double,int>> dis;
		int idx=0;
		for(auto &x:train){
			dis.emplace_back(distance(t,x),idx);
			idx++;
		}
		sort(dis.begin(),dis.end());//sort默认按照pair的第一个元素升序排序
		int cnt[4]={0};
		for(int i=0;i<k;i++){
			cnt[train[dis[i].second].type]++;
		}
        int maxx=-1;
        int predict;
        for(int i=1;i<=3;i++){
            if(cnt[i]>maxx){
                maxx=cnt[i];
                predict=i;
            }
        }
        if(predict==t.type)correct++;
        printf("id.%d predict to be %d\n",++n,predict);
	}
    return correct/test.size();

}
int main(){
    vector<Iris> sample;
	readData(sample);
    vector<Iris> train;
    vector<Iris> test;
    double trainRate=0.7;
	divideData(sample,train,test,trainRate);
    int k=4;//k的取值关系到模型结果的准确率
	double correctRate=KNN(train,test,k);
    printf("the correct rate is %.3lf%%",correctRate*100);
}

到这里就已经完整实现了KNN算法了，可喜可贺 \ qwq /
下面附上完整代码和完整样本数据供大家参考
由上面几个步骤完整组成了最终的求解代码

#include<iostream>
#include<cstdio>//c++保留的C语言风格的文件读取操作fopen
#include<vector>
#include<cstring>
#include<algorithm>
#include<random>
#include<cmath>
using namespace std;
struct Iris{
	double a,b,c,d;
	int type;
    Iris(double a, double b, double c, double d, int type)
        : a(a), b(b), c(c), d(d), type(type) {}
};

void readData(vector<Iris>& sample){
	FILE *f=fopen("data.txt","r");
    if(f==nullptr){
        printf("reading failed...");
        return;
    }
    double a,b,c,d;char ch[20];
    while(fscanf(f,"%lf,%lf,%lf,%lf,%s",&a,&b,&c,&d,ch)==5){
        if(strcmp(ch,"Iris-setosa")==0){
            sample.emplace_back(a,b,c,d,1);//可以直接传参数，不用构造成实际类型后在传递
        }else if(strcmp(ch,"Iris-versicolor")==0){
            sample.emplace_back(a,b,c,d,2);
        }else if(strcmp(ch,"Iris-virginica")==0){
            sample.emplace_back(a,b,c,d,3);
        }
    }
    fclose(f);
    printf("readed successfully!\n");
}

void divideData(vector<Iris> &sample,vector<Iris> &train,vector<Iris> &test,double &trainRate){
	shuffle(sample.begin(),sample.end(),default_random_engine(time(0)));
	double trainNum=sample.size()*trainRate;
	for(int i=0;i<sample.size();i++){
		if(i<trainNum){
			train.emplace_back(sample[i]);
		}else{
			test.emplace_back(sample[i]);
		}
	}
	printf("divided successfully!\n");
}
double distance(Iris &x,Iris &y){
	double d1=x.a-y.a;
    double d2=x.b-y.b;
    double d3=x.c-y.c;
    double d4=x.d-y.d;
    return sqrt(d1*d1+d2*d2+d3*d3+d4*d4);
}
double KNN(vector<Iris> &train,vector<Iris> &test,int k){
	double correct=0;
    int n=0;
	for(auto &t:test){
		vector<pair<double,int>> dis;
		int idx=0;
		for(auto &x:train){
			dis.emplace_back(distance(t,x),idx);
			idx++;
		}
		sort(dis.begin(),dis.end());//sort默认按照pair的第一个元素升序排序
		int cnt[4]={0};
		for(int i=0;i<k;i++){
			cnt[train[dis[i].second].type]++;
		}
        int maxx=-1;
        int predict;
        for(int i=1;i<=3;i++){
            if(cnt[i]>maxx){
                maxx=cnt[i];
                predict=i;
            }
        }
        if(predict==t.type)correct++;
        printf("id.%d predict to be %d\n",++n,predict);
	}
    return correct/test.size();

}
int main(){
    vector<Iris> sample;
	readData(sample);
    vector<Iris> train;
    vector<Iris> test;
    double trainRate=0.7;
	divideData(sample,train,test,trainRate);
    int k=4;//k的取值关系到模型结果的准确率
	double correctRate=KNN(train,test,k);
    printf("the correct rate is %.3lf%%",correctRate*100);
} 

5.1,3.5,1.4,0.2,Iris-setosa
4.9,3.0,1.4,0.2,Iris-setosa
4.7,3.2,1.3,0.2,Iris-setosa
4.6,3.1,1.5,0.2,Iris-setosa
5.0,3.6,1.4,0.2,Iris-setosa
5.4,3.9,1.7,0.4,Iris-setosa
4.6,3.4,1.4,0.3,Iris-setosa
5.0,3.4,1.5,0.2,Iris-setosa
4.4,2.9,1.4,0.2,Iris-setosa
4.9,3.1,1.5,0.1,Iris-setosa
5.4,3.7,1.5,0.2,Iris-setosa
4.8,3.4,1.6,0.2,Iris-setosa
4.8,3.0,1.4,0.1,Iris-setosa
4.3,3.0,1.1,0.1,Iris-setosa
5.8,4.0,1.2,0.2,Iris-setosa
5.7,4.4,1.5,0.4,Iris-setosa
5.4,3.9,1.3,0.4,Iris-setosa
5.1,3.5,1.4,0.3,Iris-setosa
5.7,3.8,1.7,0.3,Iris-setosa
5.1,3.8,1.5,0.3,Iris-setosa
5.4,3.4,1.7,0.2,Iris-setosa
5.1,3.7,1.5,0.4,Iris-setosa
4.6,3.6,1.0,0.2,Iris-setosa
5.1,3.3,1.7,0.5,Iris-setosa
4.8,3.4,1.9,0.2,Iris-setosa
5.0,3.0,1.6,0.2,Iris-setosa
5.0,3.4,1.6,0.4,Iris-setosa
5.2,3.5,1.5,0.2,Iris-setosa
5.2,3.4,1.4,0.2,Iris-setosa
4.7,3.2,1.6,0.2,Iris-setosa
4.8,3.1,1.6,0.2,Iris-setosa
5.4,3.4,1.5,0.4,Iris-setosa
5.2,4.1,1.5,0.1,Iris-setosa
5.5,4.2,1.4,0.2,Iris-setosa
4.9,3.1,1.5,0.1,Iris-setosa
5.0,3.2,1.2,0.2,Iris-setosa
5.5,3.5,1.3,0.2,Iris-setosa
4.9,3.1,1.5,0.1,Iris-setosa
4.4,3.0,1.3,0.2,Iris-setosa
5.1,3.4,1.5,0.2,Iris-setosa
5.0,3.5,1.3,0.3,Iris-setosa
4.5,2.3,1.3,0.3,Iris-setosa
4.4,3.2,1.3,0.2,Iris-setosa
5.0,3.5,1.6,0.6,Iris-setosa
5.1,3.8,1.9,0.4,Iris-setosa
4.8,3.0,1.4,0.3,Iris-setosa
5.1,3.8,1.6,0.2,Iris-setosa
4.6,3.2,1.4,0.2,Iris-setosa
5.3,3.7,1.5,0.2,Iris-setosa
5.0,3.3,1.4,0.2,Iris-setosa
7.0,3.2,4.7,1.4,Iris-versicolor
6.4,3.2,4.5,1.5,Iris-versicolor
6.9,3.1,4.9,1.5,Iris-versicolor
5.5,2.3,4.0,1.3,Iris-versicolor
6.5,2.8,4.6,1.5,Iris-versicolor
5.7,2.8,4.5,1.3,Iris-versicolor
6.3,3.3,4.7,1.6,Iris-versicolor
4.9,2.4,3.3,1.0,Iris-versicolor
6.6,2.9,4.6,1.3,Iris-versicolor
5.2,2.7,3.9,1.4,Iris-versicolor
5.0,2.0,3.5,1.0,Iris-versicolor
5.9,3.0,4.2,1.5,Iris-versicolor
6.0,2.2,4.0,1.0,Iris-versicolor
6.1,2.9,4.7,1.4,Iris-versicolor
5.6,2.9,3.6,1.3,Iris-versicolor
6.7,3.1,4.4,1.4,Iris-versicolor
5.6,3.0,4.5,1.5,Iris-versicolor
5.8,2.7,4.1,1.0,Iris-versicolor
6.2,2.2,4.5,1.5,Iris-versicolor
5.6,2.5,3.9,1.1,Iris-versicolor
5.9,3.2,4.8,1.8,Iris-versicolor
6.1,2.8,4.0,1.3,Iris-versicolor
6.3,2.5,4.9,1.5,Iris-versicolor
6.1,2.8,4.7,1.2,Iris-versicolor
6.4,2.9,4.3,1.3,Iris-versicolor
6.6,3.0,4.4,1.4,Iris-versicolor
6.8,2.8,4.8,1.4,Iris-versicolor
6.7,3.0,5.0,1.7,Iris-versicolor
6.0,2.9,4.5,1.5,Iris-versicolor
5.7,2.6,3.5,1.0,Iris-versicolor
5.5,2.4,3.8,1.1,Iris-versicolor
5.5,2.4,3.7,1.0,Iris-versicolor
5.8,2.7,3.9,1.2,Iris-versicolor
6.0,2.7,5.1,1.6,Iris-versicolor
5.4,3.0,4.5,1.5,Iris-versicolor
6.0,3.4,4.5,1.6,Iris-versicolor
6.7,3.1,4.7,1.5,Iris-versicolor
6.3,2.3,4.4,1.3,Iris-versicolor
5.6,3.0,4.1,1.3,Iris-versicolor
5.5,2.5,4.0,1.3,Iris-versicolor
5.5,2.6,4.4,1.2,Iris-versicolor
6.1,3.0,4.6,1.4,Iris-versicolor
5.8,2.6,4.0,1.2,Iris-versicolor
5.0,2.3,3.3,1.0,Iris-versicolor
5.6,2.7,4.2,1.3,Iris-versicolor
5.7,3.0,4.2,1.2,Iris-versicolor
5.7,2.9,4.2,1.3,Iris-versicolor
6.2,2.9,4.3,1.3,Iris-versicolor
5.1,2.5,3.0,1.1,Iris-versicolor
5.7,2.8,4.1,1.3,Iris-versicolor
6.3,3.3,6.0,2.5,Iris-virginica
5.8,2.7,5.1,1.9,Iris-virginica
7.1,3.0,5.9,2.1,Iris-virginica
6.3,2.9,5.6,1.8,Iris-virginica
6.5,3.0,5.8,2.2,Iris-virginica
7.6,3.0,6.6,2.1,Iris-virginica
4.9,2.5,4.5,1.7,Iris-virginica
7.3,2.9,6.3,1.8,Iris-virginica
6.7,2.5,5.8,1.8,Iris-virginica
7.2,3.6,6.1,2.5,Iris-virginica
6.5,3.2,5.1,2.0,Iris-virginica
6.4,2.7,5.3,1.9,Iris-virginica
6.8,3.0,5.5,2.1,Iris-virginica
5.7,2.5,5.0,2.0,Iris-virginica
5.8,2.8,5.1,2.4,Iris-virginica
6.4,3.2,5.3,2.3,Iris-virginica
6.5,3.0,5.5,1.8,Iris-virginica
7.7,3.8,6.7,2.2,Iris-virginica
7.7,2.6,6.9,2.3,Iris-virginica
6.0,2.2,5.0,1.5,Iris-virginica
6.9,3.2,5.7,2.3,Iris-virginica
5.6,2.8,4.9,2.0,Iris-virginica
7.7,2.8,6.7,2.0,Iris-virginica
6.3,2.7,4.9,1.8,Iris-virginica
6.7,3.3,5.7,2.1,Iris-virginica
7.2,3.2,6.0,1.8,Iris-virginica
6.2,2.8,4.8,1.8,Iris-virginica
6.1,3.0,4.9,1.8,Iris-virginica
6.4,2.8,5.6,2.1,Iris-virginica
7.2,3.0,5.8,1.6,Iris-virginica
7.4,2.8,6.1,1.9,Iris-virginica
7.9,3.8,6.4,2.0,Iris-virginica
6.4,2.8,5.6,2.2,Iris-virginica
6.3,2.8,5.1,1.5,Iris-virginica
6.1,2.6,5.6,1.4,Iris-virginica
7.7,3.0,6.1,2.3,Iris-virginica
6.3,3.4,5.6,2.4,Iris-virginica
6.4,3.1,5.5,1.8,Iris-virginica
6.0,3.0,4.8,1.8,Iris-virginica
6.9,3.1,5.4,2.1,Iris-virginica
6.7,3.1,5.6,2.4,Iris-virginica
6.9,3.1,5.1,2.3,Iris-virginica
5.8,2.7,5.1,1.9,Iris-virginica
6.8,3.2,5.9,2.3,Iris-virginica
6.7,3.3,5.7,2.5,Iris-virginica
6.7,3.0,5.2,2.3,Iris-virginica
6.3,2.5,5.0,1.9,Iris-virginica
6.5,3.0,5.2,2.0,Iris-virginica
6.2,3.4,5.4,2.3,Iris-virginica
5.9,3.0,5.1,1.8,Iris-virginica

写在最后，
博主还在上大学~
希望和大家一起成长，
也希望大家能够关注~
目标是每周最少更新一篇机器学习相关笔记，
正在持续的学习中，
如果喜欢的话可以给我一个免费的赞吗~
这将是对我最大的鼓励，
希望这篇文章可以帮助到你~

SOLECA_
关注
机器学习--KNN算法
qq_36102055的博客
08-13 1568
最近开始正式学机器学习的算法了，按照我的习惯学每个新的算法都喜欢记笔记，刚开始可能会有很多错误的地方如果大家发现了还请多多指正 文章目录KNN简介：算法的思路简单的实和sklearn的中的KNN的简单使用简单的实现sklearn的中的KNN的简单使用导入数据集使用KNN分类精确度分离数据手动分离使用sklearn分离精确度超参数 KNN简介： KNN算法属于分类算法，英文名称为K-NearestNeighbor，直译过来就是K个最的邻居。他可以通过计算并找到要预测的数据和训练数据中前K个最近的数据，然后对他
机器学习-近邻KNN算法学习笔记
m0_62639992的博客
10-09 247
KNN算法是机器学习的入门算法，是我学到的第一个监督学习算法，用于分类和回归问题。它基于实例的学习方法，其中模型不会显式地学习数据的内部结构，而是存储训练数据，然后使用它们来进行预测。
机器学习 -- 简析KNN（k近邻算法）
2401_84433535的博客
05-03 122
面试前要精心做好准备，简历上写的知识点和原理都需要准备好，项目上多想想难点和亮点，这是面试时能和别人不一样的地方。还有就是表现出自己的谦虚好学，以及对于未来持续进阶的规划，企业招人更偏爱稳定的人。万事开头难，但是程序员这一条路坚持几年后发展空间还是非常大的，一切重在坚持。开源分享：【大厂前端面试题解析+核心总结学习笔记+真实项目实战+最新讲解视频】为了帮助大家更好更高效的准备面试，特别整理了《前端工程师面试手册》电子稿文件。前端面试题汇总。
学习笔记-机器学习KNN算法实践
qq_36092642的博客
05-22 407
机器学习，KNN算法，人工智能
机器学习笔记--KNN算法
qq_44175983的博客
08-12 527
在数学中，切比雪夫距离(Chebyshev distance)或是L∞度量，是向量空间中的一种度量，二个点之间的距离定义是其各坐标数值差绝对值的最大值。他的平坦空间(即假设没有重力，曲率为零的空间)的概念以及表示为特殊距离量的几何学是与狭义相对论的要求相一致的。汉明距离是使用在数据传输差错控制编码里面的，汉明距离是一个概念，它表示两个(相同长度)字对应位不同的数量，我们以表示两个字,之间的汉明距离。在机器学习算法中，我们经常需要计算样本之间的相似度，通常的做法是计算样本之间的距离。值的选择和分类决策规则。
【机器学习笔记】KNN算法和k-means算法对比
欢迎关注我的博客
08-14 3646
中的。用于分类或回归问题，通常用作分类算法。在处理一个未知样本时，先找出训练集中距离K个已知样本，然后根据这K个已知样本的类别标签来预测测试集样本的类别。在分类问题中，通常选择出现作为预测结果；在回归问题中，则计算这K个临近值的作为预测结果。
深度学习笔记-------KNN算法
要银河 不要迎合
09-02 427
以上图片资料来着梅科尔工作室，仅供学习，请勿随意转载。由此可见，当K=6时准确率最高。
机器学习算法笔记——KNN
sinat_34326100的博客
03-29 823
KNN，最简单的机器学习算法
机器学习——KNN算法
weixin_45936137的博客
05-11 7792
K-近邻算法KNN学习笔记
01-27
K-近邻算法（K-Nearest Neighbor, KNN）是一种基础的机器学习算法，主要用于分类和回归任务。它的核心思想是基于实例的学习，通过在训练数据集中寻找与新样本最为相似的邻居来做出预测。KNN算法由Cover T和Hart P在...
机器学习笔记2-KNN
01-06
算法三要素 k值的选取 距离度量的方式 分类决策规则 k值的选择 对于k值的选择，没有一个固定的经验，一般根据样本的分布，选择一个较小的值，可以通过交叉验证选择一个合适的k值。 选择较小的k值，就相当于用较小的...
CVPR-2022《Efficient Deep Embedded Subspace Clustering》
Christo的博客
05-15 1114
EDESC 提出了一种高效、准确的深度子空间聚类方法，通过非自表达框架和线性复杂度解决了传统方法的局限性。其目标函数联合优化重建损失、子空间基正则化和聚类损失，优化过程通过迭代更新嵌入表示和子空间基实现。实验结果表明，EDESC 在多个基准数据集上显著优于现有方法，适用于大规模和在线聚类场景。算法实现结合自编码器和子空间基迭代优化，支持小批量训练，具有高度的实用性和扩展性。
机器学习-计量经济学
qq_35269774的博客
05-14 561
不要事前决定变量关系，关键是谁也不知道啊，机器学习学习的模型（那也不是真实的关系啊）这就是自然学科的好处：只要不断的优化这个未知的东西（函数），然后在数据上（场景）表现好就可以了，我也接受这种观念。但是社科不一样了：要事前的决定形式（变量是线性关系，非线性关系，二次关系等等），然后根据数据估计参数，得到因果（说实话，我很质疑的）。在回归分析中，存在系数是线性的假设（只能包括系数的一次项，β1β2, 不能是β2eβ然后是模型的设定（假设变量间是线性关系yβxyβx2。
机器学习-人与机器生数据的区分模型测试 - 模型融合与检验
最新发布
weixin_41870426的博客
05-18 334
模型预测# Lift值计算优化# 可视化增强# ROC曲线# 模型预测 y_prob = train_pipe . predict_proba(X_temp) [ : , 1 ] fpr , tpr , thresholds = roc_curve(y_temp , y_prob) auc = roc_auc_score(y_temp , y_prob # Lift值计算优化 decile = pd . DataFrame({
【机器学习】支持向量回归（SVR）从入门到实战：原理、实现与优化指南
Code哈哈笑的博客
05-14 1200
本文围绕支持向量回归（SVR）展开。SVR 是基于支持向量机的回归模型，通过最优超平面预测连续值，与分类的 SVM 不同，其采用 ε- 不敏感损失函数。数学上，通过最小化特定目标函数及核函数映射处理非线性问题。建模时，先对数据标准化，训练时关注核函数等参数，用均方误差等指标评估。超参数调优采用网格搜索交叉验证，如对 C 和 gamma 参数优化。核函数方面，线性核用于线性可分，RBF 核为默认处理非线性，多项式核需调阶数，以此实现 SVR 模型的构建与优化。
【氮化镓】HfO2钝化优化GaN 器件性能
荷塘阅色
05-15 86
2025年，南洋理工大学的Pradip Dalapati等人在《Applied Surface Science》期刊发表研究，探讨了外延HfO₂钝化层对原位Si₃N₄/AlN/GaN基MIS-HEMTs性能的提升及其在高能X射线辐照下的退化抑制效果。研究通过X射线光电子能谱（XPS）和电学特性测试，发现HfO₂钝化层能有效钝化表面陷阱，显著提高器件的最大漏极电流和峰值跨导，同时降低电流崩溃现象。在X射线辐照后，具有HfO₂钝化层的器件性能退化率明显低于未钝化器件，展现出较好的辐射硬化特性。
【软件工程】机器学习多缺陷定位技术分析
meisongqing的博客
05-15 1128
本文探讨了基于机器学习的多缺陷定位技术，重点分析了其在应对多缺陷干扰和动态环境适应方面的策略。技术路径包括使用生成对抗网络（GAN）增强缺陷多样性、多模态数据融合和多维度动态轨迹分析，以提高模型的识别准确率和定位精度。关键方法涉及半监督学习、跨场景迁移与联邦学习、实时反馈与在线优化，以减少对标注数据的依赖并增强模型在不同环境中的泛化能力。文章还指出了多缺陷干扰区分、动态环境数据异构性和极端环境实时性等挑战，并提出了神经符号系统、多模态标准化协议和抗辐照GAN芯片等解决方案。最后，文章展望了工业检测、软件工程
数据科学和机器学习的“看家兵器”——pandas模块 之一
韩鹏飞的博客
05-14 1166
pandas 的主要数据结构是 Series（一维数组）和 DataFrame（二维表格型数据结构），它们能够处理各种类型的数据，无论是时间序列数据、表格数据还是矩阵数据。pandas 提供了高级数据操作功能，包括数据清洗、合并、重塑、聚合和时间序列分析等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值