python knn分类,python em算法

　　KNN主要包括训练过程和分类过程。在训练过程中，必须保存训练集。在分类过程中，将测试集与训练集中的每幅图像进行比较，选择差异最小的图像。

　　如果数据集很多，就把训练集分成两部分，一小部分作为验证集(虚假测试集)，剩下的部分作为训练集。一般70%-90%，视需要调整的超参数数量而定。如果超参数越多，验证集的比例越大。验证集的优点是调整超级参数。如果数据集很小，使用交叉验证来调整参数。但是，交叉验证的成本相对较高。k越大越好，但成本也越高。

　　决策分类

　　确定k个邻居中所有数据类别的个数，将测试数据划分到个数最多的类别中。也就是说，输入案例的类别由输入案例的最近k个训练案例中的多个类别确定。

　　一般决策规则：

　　多数表决：多数表决和我们日常生活中的投票是一样的，多数是最常用的方法。

　　加权投票法：在某些情况下使用加权投票法。比如投票时，试投票权意义重大，而普通人的权重较小。因此，当数据之间存在权重时，一般采用加权投票法。

　　好处：

　　所有选择的邻居都是正确分类的对象。

　　KNN算法本身比较简单，分类器不需要使用训练集进行训练，训练时间复杂度为0。该算法的复杂度与训练集中的数据数量成正比。

　　KNN算法比其他方法更适用于具有重叠或重叠区域的样本分类。

　　缺点：

　　如果样本分布不均衡，就很难做出正确的分类。

　　因为每次都要计算从测试数据到所有数据的距离，所以计算量非常大。

　　Python代码实现：

　　将numpy作为np导入

　　kNearestNeighbor类：

　　定义(来自):

　　传球

　　deftrain(self，x，y):

　　自我。Xtr=X

　　self.ytr=y

　　defpredict(self，x，k=1):

　　数字测试=X .形状[0]

　　ypred=NP。Zeros(num_test，dtype=self.ytr.dtype))).

　　forIinrange(数量测试) :

　　距离=NP.sum (NP。ABS (self.xtr-x [I，])，axis=1)))))。

　　closest _ y=y _ train[NP . arg sort[distances][:k]]

　　u，indexes=NP . unique(closest _ y，return_inverse=True))))

　　yp red[I]=u[NP . arg max(NP . bin count(indexes)]

　　返回Ypred

　　一个

　　三

　　四

　　五

　　六

　　七

　　八

　　九

　　load_CIFAR_batch(和load_CIFAR10)用于加载CIFAR-10数据集。

　　进口泡菜

　　efload_cifar_batch(文件名) :

　　加载一批cifar

　　withopen(文件名， Rb )为f:

　　datadict=pickle.load(f，encoding=latin1 )

　　x=数据字典[data]

　　y=数据字典[标签]

　　x=x . shape(10000，3，32，32)。转置(0，2，3，1)。astype)“float”

　　y=NP。数组(y))

　　返回x，y

　　一个

　　三

　　四

　　五

　　六

　　七

　　八

　　九

　　导入操作系统

　　efload_CIFAR10(根) :

　　加载所有cifar

　　xs=[]

　　ys=[]

　　forbinrange (1，6):

　　F=OS.path.join (root，" data _ batch _% d%) b)

　　x，y=load_cifar_batch(f))

　　是xs.append(x)

　　ys.append(y))

　　Xtr=NP.concatenate(xs))成为行向量。

　　Ytr=np.concatenate(ys)

　　德尔X，Y

　　Xte，Yte=load _ CIFAR _ batch(OS . path . join(ROOT， test_batch ))

　　返回Xtr，Ytr，Xte，Yte

　　一个

　　三

　　四

　　五

　　六

　　七

　　八

　　九

　　Xtr，Ytr，Xte，Yte=load_CIFAR10(cifar10 )

　　xtr _ rows=xtr . shape(xtr . shape[0]，32 * 32 * 3)

　　xte _ rows=xte . shape(xte . shape[0]，32 * 32 * 3)

　　一个

　　三

　　#因为数据集有点大，在电脑上运行非常慢，所以取5000个训练集，500个测试集。

　　数量_培训=5000

　　数字测试=500

　　x_train=Xtr_rows[:数量培训，]

　　y_train=Ytr[:数量_训练]

　　x_test=Xte_rows[:数量测试，]

　　y_test=Yte[:数字测试]

　　一个

　　三

　　四

　　五

　　六

　　七

　　八

　　九

　　knn=kNearestNeighbor()

　　knn.train(x_train，y_train)

　　y_predict=knn.predict(x_test，k=7)

　　acc=np.mean(y_predict==y_test)

　　打印(精度：%f %(acc))

　　一个

　　三

　　四

　　五

　　精确度：0.302000

　　一个

　　#k值最终效果如何？可以用交叉验证的方法，用50%的交叉验证。

　　数字折叠=5

　　k_choices=[1，3，5，8，10，12，15，20，50，100]

　　x _ train _ folds=NP。数组_拆分(x _ train，num_folds)

　　y _ train _ folds=NP。数组_拆分(y _ train，num_folds)

　　k _ to _ accuracies={ }

　　对于k _选择中的k值：

　　print(k= str(k_val))

　　k _ to _ accuracy[k _ val]=[]

　　对于范围内的我(数量_折叠):

　　x _火车_周期=NP。concatenate([f for j，f in enumerate (x_train_folds) if j！=我])

　　y _ train _ cycle=NP。concatenate([f for j，f in enumerate (y_train_folds) if j！=我])

　　x_val_cycle=x_train_folds[i]

　　y_val_cycle=y_train_folds[i]

　　knn=kNearestNeighbor()

　　knn.train(x_train_cycle，y_train_cycle)

　　y _ val _ pred=KNN预测(x _ val _ cycle，k_val)

　　num _ correct=NP。sum(y _ val _ cycle==y _ val _ pred)

　　k _ to _ accuracy[k _ val].append(float(num _ correct)/float(len(y _ val _ cycle)))

　　一

　　四

　　七

　　k=1

　　k=3

　　k=5

　　k=8

　　k=10

　　k=12

　　k=15

　　k=20

　　k=50

　　k=100

　　一

　　四

　　七

　　对于排序后的k(k _到_精度):

　　对于以k _ to _精度为单位的精度：

　　打印( k=%d，精度=%f % (int(k)，accuracy))

　　一

　　k=1，精确度=0.098000

　　k=1，精确度=0.148000

　　k=1，精确度=0.205000

　　k=1，精确度=0.233000

　　k=1，精确度=0.308000

　　k=3，精确度=0.089000

　　k=3，精确度=0.142000

　　k=3，精确度=0.215000

　　k=3，精确度=0.251000

　　k=3，精确度=0.296000

　　k=5，精确度=0.096000

　　k=5，精确度=0.176000

　　k=5，精确度=0.240000

　　k=5，精确度=0.284000

　　k=5，精确度=0.309000

　　k=8，精确度=0.100000

　　k=8，精确度=0.175000

　　k=8，精确度=0.263000

　　k=8，精确度=0.289000

　　k=8，精确度=0.310000

　　k=10，精确度=0.099000

　　k=10，精确度=0.174000

　　k=10，精确度=0.264000

　　k=10，精确度=0.318000

　　k=10，精确度=0.313000

　　k=12，精确度=0.100000

　　k=12，精确度=0.192000

　　k=12，精确度=0.261000

　　k=12，精确度=0.316000

　　k=12，精确度=0.318000

　　k=15，精确度=0.087000

　　k=15，精确度=0.197000

　　k=15，精确度=0.255000

　　k=15，精确度=0.322000

　　k=15，精确度=0.321000

　　k=20，精确度=0.089000

　　k=20，精确度=0.225000

　　k=20，精确度=0.270000

　　k=20，精确度=0.319000

　　k=20，精确度=0.306000

　　k=50，精确度=0.079000

　　k=50，精确度=0.248000

　　k=50，精确度=0.278000

　　k=50，精确度=0.287000

　　k=50，精确度=0.293000

　　k=100，精确度=0.075000

　　k=100，精确度=0.246000

　　k=100，精确度=0.275000

　　k=100，精确度=0.284000

　　k=100，精确度=0.277000

　　一

　　四

　　七

　　可视化交叉验证的结果

　　将matplotlib.pyplot作为血小板计数导入

　　PLT。RC参数[图。figsize ]=(10.0，8.0)

　　PLT。RC params[图像。插值]=最近

　　PLT。RC params[图像。cmap ]=灰色

　　一

　　四

　　对于k _选择中的k:

　　精度=k _ to _精度[k]

　　plt.scatter([k] * len(精度),精度)

　　accurance _ mean=NP。数组([NP。k，v在排序后的平均值(k _ to _ accurance)。items())])

　　accurance _ STD=NP。数组([NP。k的STD(v ), v in sorted(k _ to _ accurance。items())])

　　plt.errorbar(k_choices，accuracies _ mean，yerr=accuracies _ std)

　　PLT。标题( k上的交叉验证)

　　plt.xlabel(k )

　　plt.ylabel("交叉验证准确性")

　　plt.show()

　　一

　　四

　　七

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。

相关文章阅读