K最近邻(k-Nearest Neighbor，KNN)分类算法，是一个理论上比较成熟的方法，也是最简单的机器学习算法之一。该方法的思路是：如果一个样本在特征空间中的k个最相似(即特征空间中最邻近)的样本中的大多数属于某一个类别，则该样本也属于这个类别。KNN算法中，所选择的邻居都是已经正确分类的对象。该方法在定类决策上只依据最邻近的一个或者几个样本的类别来决定待分样本所属的类别。 KNN方法虽然从原理上也依赖于极限定理，但在类别决策时，只与极少量的相邻样本有关。由于KNN方法主要靠周围有限的邻近的样本，而不是靠判别类域的方法来确定所属类别的，因此对于类域的交叉或重叠较多的待分样本集来说，KNN方法较其他方法更为适合。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
|
#include "stdafx.h"
#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <cmath>
using namespace std;
//样本特征结构体
struct sample
{
string type;
vector<double> features;
};
//读取训练样本train.txt，训练样本格式：类型名+特征向量
void readTrain(vector<sample>& train, const string& file)
{
ifstream fin(file.c_str()); //file是存储希望读写的文件名的string对象，fin是读的流
if(!fin)
{
cerr<<"Unable to open the input file: "<<file<<endl;
exit(1);
}
string line;
double d=0.0;
while(getline(fin,line)) //fin是读入流，getline从输入流fin读入一行到line
{
istringstream stream(line); //bind to stream to the line we read
sample ts;
stream>>ts.type;
while(stream>>d) //read a word from line
{
ts.features.push_back(d); //在trains.features的末尾添加一个值为d的元素
}
train.push_back(ts); //在train的末尾添加一个值为ts的元素
}
fin.close();
}
//读取测试样本test.txt，每行都是一个特征向量
void readTest(vector<sample>& test, const string& file)
{
ifstream fin(file.c_str());
if(!fin)
{
cerr<<"Unable to open the input file: "<<file<<endl;
exit(1);
}
string line;
double d=0.0;
while(getline(fin,line))
{
istringstream stream(line); //bind to stream to the line we read
sample ts;
while(stream>>d)
{
ts.features.push_back(d);
}
test.push_back(ts);
}
fin.close();
}
//输出结果，为每一个向量赋予一个类型，写入result.txt中
void writeResult(const vector<sample>& test, const string& file)
{
ofstream fout(file.c_str());
if(!fout)
{
cerr<<"Unable to write the input file: "<<endl;
exit(1);
}
for(vector<sample>::size_type i=0;i!=test.size();++i)
{
fout << test[i].type << '\t';
for(vector<double>::size_type j=0;j!=test[j].features.size();++j)
{
fout<<test[i].features[j]<<' ';
}
fout<<endl;
}
}
//KNN算法的实现
void knnProcess(vector<sample>& test, const vector<sample>& train, const vector<vector<double> >& dm, unsigned int k)
{
for (vector<sample>::size_type i = 0; i != test.size(); ++i)
{
multimap<double, string> dts; //保存与测试样本i距离最近的k个点
for (vector<double>::size_type j = 0; j != dm[i].size(); ++j)
{
if (dts.size() < k) //把前面k个插入dts中
{
dts.insert(make_pair(dm[i][j], train[j].type)); //插入时会自动排序，按dts中的double排序，最小的排在最后
}
else
{
multimap<double, string>::iterator it = dts.end();
--it;
if (dm[i][j] < it->first) //把当前测试样本i到当前训练样本之间的欧氏距离与dts中最小距离比较，若更小就更新dts
{
dts.erase(it);
dts.insert(make_pair(dm[i][j], train[j].type));
}
}
}
map<string, double> tds;
string type = "";
double weight = 0.0;
//下面for循环主要是求出与测试样本i最邻近的k个样本点中大多数属于的类别，即将其作为测试样本点i的类别
for (multimap<double, string>::const_iterator cit = dts.begin(); cit != dts.end(); ++cit)
{
// 不考虑权重的情况，在 k 个样例中只要出现就加 1
// ++tds[cit->second];
// 这里是考虑距离与权重的关系，距离越大权重越小
tds[cit->second] += 1.0 / cit->first;
if (tds[cit->second] > weight)
{
weight = tds[cit->second];
type = cit->second; //保存一下类别
}
}
test[i].type = type;
}
}
// 计算欧氏距离
double euclideanDistance(const vector<double>& v1, const vector<double>& v2)
{
if(v1.size() != v2.size())
{
cerr<<"Unable to get a distance! "<<endl;
}
else
{
double distance = 0.0;
for (vector<double>::size_type i = 0; i != v1.size(); ++i)
{
distance += (v1[i] - v2[i]) * (v1[i] - v2[i]);
}
return sqrt(distance);
}
}
/*初始化距离矩阵，该矩阵是根据训练样本和测试样本而得，
矩阵的行数为测试样本的数目，列数为训练样本的数目，
每一行为一个测试样本到各个训练样本之间的欧式距离组成的数组*/
void initDistanceMatrix(vector<vector<double> >& dm, const vector<sample>& train, const vector<sample>& test)
{
for (vector<sample>::size_type i = 0; i != test.size(); ++i)
{
vector<double> vd;
for (vector<sample>::size_type j = 0; j != train.size(); ++j)
{
vd.push_back(euclideanDistance(test[i].features, train[j].features));
}
dm.push_back(vd);
}
}
//封装
void xfxKnn(const string& file1, const string& file2, const string& file3, int k)
{
vector<sample> train,test;
readTrain(train, file1.c_str());
readTest(test, file2.c_str());
vector< vector<double> > dm;
initDistanceMatrix(dm, train, test);
knnProcess(test, train, dm, k);
writeResult(test, file3.c_str());
}
// 测试
int main()
{
xfxKnn("train.txt", "test.txt", "result.txt", 5);
return 0;
}
|
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持服务器之家。
原文链接：https://blog.csdn.net/hero_myself/article/details/46242023