机器学习——k-NN思想及实现（基于Java）

已于 2022-05-07 17:24:51 修改
阅读量588 收藏
点赞数 1
分类专栏： 机器学习 Java 文章标签： 机器学习 java 人工智能
于 2022-05-05 22:22:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Z__XY_/article/details/124597775
版权

k近邻法（k-nearest neighbors,k-NN）是一种基本分类与回归方法。
输入：实例的特征向量，对应于特征空间的点；
输出：实例的类别。
在分类时，对新的实例，根据其k个最近邻的训练实例的类别，通过多数表决等方式进行预测。
在回归时，对新的实例，根据其k个最近邻的训练实例的平均值决定。
两者的代码大同小异，当前实现的分类问题中的k近邻算法。
数据准备：下载地址
相关成员变量声明：

	/**
	 * Manhattan distance.
	 */
	public static final int MANHATTAN = 0;

	/**
	 * Euclidean distance.
	 */
	public static final int EUCLIDEAN = 1;

	/**
	 * The distance measure.
	 */
	public int distanceMeasure = EUCLIDEAN;

	/**
	 * A random instance.
	 */
	public static final Random random = new Random();

	/**
	 * The number of neighbors.
	 */
	int numNeighbors = 5;

	/**
	 * The whole data set.
	 */
	Instances dataset;

	/**
	 * The training set. Represented by the indices of the data.
	 */
	int[] trainingSet;

	/**
	 * The testing set. Represented by the indices of the data.
	 */
	int[] testingSet;

	/**
	 * The predictions.
	 */
	int[] predictions;

	/**
	 * The distance between an instance and the training set.
	 */
	double[] distances;

类的构造函数及实现数据的读入

public KnnClassification(String paraFilename) {
		try {
			FileReader fileReader = new FileReader(paraFilename);
			dataset = new Instances(fileReader);
			System.out.println("The number of totall instances is " + dataset.numInstances());
			// The last attribute is the decision class.
			dataset.setClassIndex(dataset.numAttributes() - 1);
			System.out.println("The data set is: " + dataset.toString());
			fileReader.close();
		} catch (Exception ee) {
			System.out.println("Error occurred while trying to read \'" + paraFilename
					+ "\' in KnnClassification constructor.\r\n" + ee);
			System.exit(0);
		} // Of try
	}// Of the first constructor

数据打印：

The data set is: @relation iris

@attribute sepallength numeric
@attribute sepalwidth numeric
@attribute petallength numeric
@attribute petalwidth numeric
@attribute class {Iris-setosa,Iris-versicolor,Iris-virginica}

@data
5.1,3.5,1.4,0.2,Iris-setosa
4.9,3,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,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,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,1.4,0.1,Iris-setosa
4.3,3,1.1,0.1,Iris-setosa
5.8,4,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.2,Iris-setosa
5.1,3.3,1.7,0.5,Iris-setosa
4.8,3.4,1.9,0.2,Iris-setosa
5,3,1.6,0.2,Iris-setosa
5,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,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,1.3,0.2,Iris-setosa
5.1,3.4,1.5,0.2,Iris-setosa
5,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,3.5,1.6,0.6,Iris-setosa
5.1,3.8,1.9,0.4,Iris-setosa
4.8,3,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,3.3,1.4,0.2,Iris-setosa
7,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,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,Iris-versicolor
6.6,2.9,4.6,1.3,Iris-versicolor
5.2,2.7,3.9,1.4,Iris-versicolor
5,2,3.5,1,Iris-versicolor
5.9,3,4.2,1.5,Iris-versicolor
6,2.2,4,1,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,4.5,1.5,Iris-versicolor
5.8,2.7,4.1,1,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,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,4.4,1.4,Iris-versicolor
6.8,2.8,4.8,1.4,Iris-versicolor
6.7,3,5,1.7,Iris-versicolor
6,2.9,4.5,1.5,Iris-versicolor
5.7,2.6,3.5,1,Iris-versicolor
5.5,2.4,3.8,1.1,Iris-versicolor
5.5,2.4,3.7,1,Iris-versicolor
5.8,2.7,3.9,1.2,Iris-versicolor
6,2.7,5.1,1.6,Iris-versicolor
5.4,3,4.5,1.5,Iris-versicolor
6,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,4.1,1.3,Iris-versicolor
5.5,2.5,4,1.3,Iris-versicolor
5.5,2.6,4.4,1.2,Iris-versicolor
6.1,3,4.6,1.4,Iris-versicolor
5.8,2.6,4,1.2,Iris-versicolor
5,2.3,3.3,1,Iris-versicolor
5.6,2.7,4.2,1.3,Iris-versicolor
5.7,3,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,1.1,Iris-versicolor
5.7,2.8,4.1,1.3,Iris-versicolor
6.3,3.3,6,2.5,Iris-virginica
5.8,2.7,5.1,1.9,Iris-virginica
7.1,3,5.9,2.1,Iris-virginica
6.3,2.9,5.6,1.8,Iris-virginica
6.5,3,5.8,2.2,Iris-virginica
7.6,3,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,Iris-virginica
6.4,2.7,5.3,1.9,Iris-virginica
6.8,3,5.5,2.1,Iris-virginica
5.7,2.5,5,2,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,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,2.2,5,1.5,Iris-virginica
6.9,3.2,5.7,2.3,Iris-virginica
5.6,2.8,4.9,2,Iris-virginica
7.7,2.8,6.7,2,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,1.8,Iris-virginica
6.2,2.8,4.8,1.8,Iris-virginica
6.1,3,4.9,1.8,Iris-virginica
6.4,2.8,5.6,2.1,Iris-virginica
7.2,3,5.8,1.6,Iris-virginica
7.4,2.8,6.1,1.9,Iris-virginica
7.9,3.8,6.4,2,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,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,3,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,5.2,2.3,Iris-virginica
6.3,2.5,5,1.9,Iris-virginica
6.5,3,5.2,2,Iris-virginica
6.2,3.4,5.4,2.3,Iris-virginica
5.9,3,5.1,1.8,Iris-virginica

由上面的打印结果，我们发现数据是按照类别进行排序的，为了数据有更好的代表性，我们需要打乱数据集。
所以，我们先将数据集的索引打乱：

/**
	 * 
	 *********************
	 * @Title: getRandomIndices
	 * @Description: TODO(Get a random indices for data randomization.)
	 *
	 * @param paraLength The length of the sequence.
	 * @return An array of indices, e.g., {4, 3, 1, 5, 0, 2} with length 6.
	 *********************
	 *
	 */
	public static int[] getRandomIndices(int paraLength) {
		int[] resultIndices = new int[paraLength];

		// Step 1. Initialize.
		for (int i = 0; i < paraLength; i++) {
			resultIndices[i] = i;
		} // Of for i

		// Step 2. Randomly swap.
		int tempFirst, tempSecond, tempValue;
		for (int i = 0; i < paraLength; i++) {
			// Generate two random indices.
			tempFirst = random.nextInt(paraLength);
			tempSecond = random.nextInt(paraLength);

			// Swap.
			tempValue = resultIndices[tempFirst];
			resultIndices[tempFirst] = resultIndices[tempSecond];
			resultIndices[tempSecond] = tempValue;
		} // Of for i
		return resultIndices;
	}// Of getRandomIndices

将打乱后的数据集进行分割：

/**
	 * 
	 *********************
	 * @Title: splitTrainingTesting
	 * @Description: TODO(Split the data into training and testing parts.)
	 *
	 * @param paraTrainingFraction The fraction of the training set.
	 *********************
	 *
	 */
	public void splitTrainingTesting(double paraTrainingFraction) {
		int tempSize = dataset.numInstances();
		int[] tempIndices = getRandomIndices(tempSize);
		int tempTrainingSize = (int) (tempSize * paraTrainingFraction);

		trainingSet = new int[tempTrainingSize];
		testingSet = new int[tempSize - tempTrainingSize];

		for (int i = 0; i < tempTrainingSize; i++) {
			trainingSet[i] = tempIndices[i];
		} // Of for i

		for (int i = 0; i < tempSize - tempTrainingSize; i++) {
			testingSet[i] = tempIndices[i + tempTrainingSize];
		} // Of for i
	}// Of splitTrainingTesting

至此，简单的数据处理就算是完成了，整个数据集被划分成了训练数据集和测试数据集。
由于k-NN算法没有具体的模型训练过程，所以可以跳过模拟，直接进行预测。
预测准备：
需要计算测试实例到训练实例的距离：
代码中举例了两种距离的计算方式——曼哈顿距离、欧式距离（的平方）
曼哈顿距离：
L 1 = ( x i , x j ) = ∑ l = 1 n ∣ x i ( l ) − x j ( l ) ∣ L_1=(x_i,x_j)=\sum\limits_{l=1}^n|x_i^{(l)}-x_j^{(l)}| L1​=(xi​,xj​)=l=1∑n​∣xi(l)​−xj(l)​∣
欧式距离：
L 2 = ( x i , x j ) = ( ∑ l = 1 n ∣ x i ( l ) − x j ( l ) ∣ 2 ) 1 2 L_2=(x_i,x_j)=\begin{pmatrix}\sum\limits_{l=1}^n|x_i^{(l)}-x_j^{(l)}|^2\end{pmatrix}^{\frac{1}{2}} L2​=(xi​,xj​)=(l=1∑n​∣xi(l)​−xj(l)​∣2​)21​
补充:
明可夫斯基距离：
L p = ( x i , x j ) = ( ∑ l = 1 n ∣ x i ( l ) − x j ( l ) ∣ p ) 1 p L_p=(x_i,x_j)=\begin{pmatrix}\sum\limits_{l=1}^n|x_i^{(l)}-x_j^{(l)}|^p\end{pmatrix}^{\frac{1}{p}} Lp​=(xi​,xj​)=(l=1∑n​∣xi(l)​−xj(l)​∣p​)p1​
当 p = ∞ p=\infty p=∞时,称为切比雪夫据距离：
L p = ( x i , x j ) = max ⁡ l ( ∣ x i ( l ) − x j ( l ) ∣ ) L_p=(x_i,x_j)=\max\limits_l(|x_i^{(l)}-x_j^{(l)}|) Lp​=(xi​,xj​)=lmax​(∣xi(l)​−xj(l)​∣)
参数的补充：
超参数：在算法运行前需要决定的参数；
模型参数：算法运行过程中学习的参数。
在k-NN算法中的参数k,就是典型的超参数。
因为不同的 p p p，会影响到最近邻实例的选择，所以 p p p也可做为k-NN算法的超参数。

距离计算的代码：

	/**
	 * 
	 *********************
	 * @Title: distance
	 * @Description: TODO(The distance between two instances.)
	 *
	 * @param paraI The index of the first instance.
	 * @param paraJ The index of the second instance.
	 * @return The distance.
	 *********************
	 *
	 */
	public double distance(int paraI, int paraJ) {
		double resultDistance = 0;
		double tempDifference;
		switch (distanceMeasure) {
		case MANHATTAN:
			for (int i = 0; i < dataset.numAttributes() - 1; i++) {
				tempDifference = dataset.instance(paraI).value(i) - dataset.instance(paraJ).value(i);
				if (tempDifference < 0) {
					resultDistance -= tempDifference;
				} else {
					resultDistance += tempDifference;
				} // Of if
			} // Of for i
			break;

		case EUCLIDEAN:
			for (int i = 0; i < dataset.numAttributes() - 1; i++) {
				tempDifference = dataset.instance(paraI).value(i) - dataset.instance(paraJ).value(i);
				resultDistance += tempDifference * tempDifference;
			} // Of for i
			break;
		default:
			System.out.println("Unsupported distance measure: " + distanceMeasure);
			break;
		}// Of switch
		return resultDistance;
	}// Of distance

补充：
设置距离计算类型：

	/**
	 ********************
	 * Set the distance measure.
	 * 
	 * @param paraType The type.
	 *********************
	 */
	public void setDistanceMeasure(int paraType) {
		switch (paraType) {
		case 0:
			distanceMeasure=MANHATTAN;
			break;
		case 1:
			distanceMeasure=EUCLIDEAN;
			break;
		default:
			System.out.println("Unsupported distance measure: " + paraType);
			break;
		}//Of switch
	}//Of setDistanceMeasure

计算完距离之后，就是选择最近的k个实例了：

	/**
	 * 
	 *********************
	 * @Title: computeNearests
	 * @Description: TODO(Compute the nearest k neighbors.)
	 *
	 * @param paraCurrent current instance.
	 * @return The indices of the nearest instances.
	 *********************
	 *
	 */
	public int[] computeNearests(int paraCurrent) {
		int[] resultNearests;

		// Compute all distances to avoid redundant compute.
		double[] tempDistances = new double[trainingSet.length];
		for (int i = 0; i < trainingSet.length; i++) {
			tempDistances[i] = distance(paraCurrent, trainingSet[i]);
		} // Of for i

		// resultNearests = simpleSelect(tempDistances);
		// System.out.println("The nearest of " + paraCurrent + " are: " +
		// Arrays.toString(resultNearests));

		resultNearests = selectWithHeap(tempDistances);
		System.out.println("The nearest of " + paraCurrent + " are: " + Arrays.toString(resultNearests));

		return resultNearests;
	}// Of computeNearests

简单选择方式：

/**
	 * 
	 *********************
	 * @Title: simpleSelect
	 * @Description: TODO(Select the nearest indices.)
	 *
	 * @param paraDistances The distance.
	 * @return A array of result.
	 *********************
	 *
	 */
	public int[] simpleSelect() {
		int[] resultNearests = new int[numNeighbors];
		boolean[] tempSelected = new boolean[trainingSet.length];
		double tempMinimalDistance;
		int tempMinimalIndex = 0;

		for (int i = 0; i < numNeighbors; i++) {
			tempMinimalDistance = Double.MAX_VALUE;

			for (int j = 0; j < trainingSet.length; j++) {
				if (tempSelected[j])
					continue;

				if (paraDistances[j] < tempMinimalDistance) {
					tempMinimalDistance = paraDistances[j];
					tempMinimalIndex = j;
				} // Of if
			} // Of for j
			resultNearests[i] = trainingSet[tempMinimalIndex];
			tempSelected[tempMinimalIndex] = true;
		} // Of for i

		return resultNearests;
	}// Of simpleSelect

堆选择方式：

	/**
	 * 
	 *********************
	 * @Title: adjustHeap
	 * @Description: TODO(Adjust the heap.)
	 *
	 * @param paraStartIndex The start of the index that need to adjust.
	 * @param paraLength     The length of the adjusted sequence.
	 * @param paraDistances  The array of distance.
	 * @param paraIndexes    The index of distance.
	 *********************
	 *
	 */
	public void adjustHeap(int paraStartIndex, int paraLength, double[] paraDistances, int[] paraIndexes) {
		int tempParentIndex = paraStartIndex;
		double tempDistance = paraDistances[paraStartIndex];
		int tempIndex = paraIndexes[paraStartIndex];

		for (int i = paraStartIndex * 2 + 1; i < paraLength; i = i * 2 + 1) {
			// Select the smaller.
			if (i + 1 < paraLength && paraDistances[i + 1] < paraDistances[i])
				i++;
			if (tempDistance > paraDistances[i]) {
				// Update the index and distance.
				paraIndexes[tempParentIndex] = paraIndexes[i];
				paraDistances[tempParentIndex] = paraDistances[i];
				tempParentIndex = i;
			} else {
				break;
			} // Of if
		} // Of for i

		paraDistances[tempParentIndex] = tempDistance;
		paraIndexes[tempParentIndex] = tempIndex;
	}// Of adjustHeap

	/**
	 * 
	 *********************
	 * @Title: selectWithHeap
	 * @Description: TODO(Select the nearest indices.)
	 *
	 * @param paraDistances The distance.
	 * @return A array of result.
	 *********************
	 *
	 */
	public int[] selectWithHeap() {
		int[] resultNearests = new int[numNeighbors];

		// Initialize the indexes.
		int[] tempIndexes = new int[trainingSet.length];
		for (int i = 0; i < trainingSet.length; i++) {
			tempIndexes[i] = i;
		} // Of for i

		// Build the heap.
		int tempLength = paraDistances.length;
		for (int i = trainingSet.length / 2 - 1; i >= 0; i--) {
			adjustHeap(i, tempLength, paraDistances, tempIndexes);
		}

		for (int i = 0; i < numNeighbors; i++) {
			resultNearests[i] = trainingSet[tempIndexes[0]];
			tempIndexes[0] = tempIndexes[tempLength - i - 1];
			paraDistances[0] = paraDistances[tempLength - i - 1];
			adjustHeap(0, tempLength - i - 1, paraDistances, tempIndexes);
		}
		return resultNearests;
	}// Of selectWithHeap

基于堆排序算法的时间复杂度： O ( n + k log ⁡ n ) O(n+k\log n) O(n+klogn)。
基于选择排序算法的选择时间复杂度： O ( k n ) O(kn) O(kn)；
测试结果图：
在这里插入图片描述
在一般情况下，后者的时间开销都会大于前者。
在选择最近k个实例之后就是投票了，根据选择的index，找到对应的分类，并使该类别的计数器++，最后是票数最多的获胜：

	/**
	 * 
	 *********************
	 * @Title: simpleVoting
	 * @Description: TODO(Voting using the instances.)
	 *
	 * @param paraNeihbors The indices of the neighbors.
	 * @return The predicted label.
	 *********************
	 *
	 */
	public int simpleVoting(int[] paraNeihbors) {
		int[] tempVotes = new int[dataset.numClasses()];
		for (int i = 0; i < paraNeihbors.length; i++) {
			tempVotes[(int) dataset.instance(paraNeihbors[i]).classValue()]++;
		} // Of for i

		int tempMaximalVoting = 0;
		int tempMaximalVotingIndex = 0;
		for (int i = 0; i < dataset.numClasses(); i++) {
			if (tempVotes[i] > tempMaximalVoting) {
				tempMaximalVoting = tempVotes[i];
				tempMaximalVotingIndex = i;
			} // Of if
		} // Of for i

		return tempMaximalVotingIndex;
	}// Of simpleVoting

这就充分体现了“近朱者赤，近墨者黑”。
补充：
根据距离的权重进行投票：

	/**
	 ********************
	 * Voting using the instances with distance.
	 *
	 * @param paraNeihbors The indices of the neighbors.
	 * @return The predicted label.
	 *********************
	 */
	public int weightedVoting(int[] paraNeihbors) {
		double[] tempVotes = new double[dataset.numClasses()];
		double tempDistance;
		for (int i = 0; i < paraNeihbors.length; i++) {
			tempDistance = distances[trainingSet.length - i - 1];
			tempVotes[(int) dataset.instance(paraNeihbors[i]).classValue()] += 1 / (tempDistance + 1);
		} // Of for i

		double tempMaximalVoting = 0;
		int tempMaximalVotingIndex = 0;
		for (int i = 0; i < dataset.numClasses(); i++) {
			if (tempVotes[i] > tempMaximalVoting) {
				tempMaximalVoting = tempVotes[i];
				tempMaximalVotingIndex = i;
			} // Of if
		} // Of for i

		return tempMaximalVotingIndex;
	}// Of weightedVoting

(注意：我把测试实例到训练实例的距离数组写成了一个成员变量。)
最后，就是预测和获取预测准确度了：

	/**
	 * 
	 *********************
	 * @Title: predict
	 * @Description: TODO(Predict for the whole testing set. The results are stored
	 *               in predictions.) #see predictions.
	 *********************
	 *
	 */
	public void predict() {
		predictions = new int[testingSet.length];
		for (int i = 0; i < predictions.length; i++) {
			predictions[i] = predict(testingSet[i]);
		} // Of for i
	}// Of predict
	
	/**
	 * 
	 *********************
	 * @Title: predict
	 * @Description: TODO(Predict for given instance.)
	 *
	 * @return The prediction.
	 *********************
	 *
	 */
	public int predict(int paraIndex) {
		int[] tempNeighbors = computeNearests(paraIndex);
		int resultPrediction = simpleVoting(tempNeighbors);

		return resultPrediction;
	}// Of predict
	
	/**
	 * 
	 *********************
	 * @Title: getAccuracy
	 * @Description: TODO(Get the accuracy of the classifier.)
	 *
	 * @return The accuracy.
	 *********************
	 *
	 */
	public double getAccuracy() {
		// A double divides an int gets another double.
		double tempCorrect = 0;
		for (int i = 0; i < predictions.length; i++) {
			if (predictions[i] == dataset.instance(testingSet[i]).classValue()) {
				tempCorrect++;
			} // Of if
		} // Of for i

		return tempCorrect / testingSet.length;
	}// Of getAccuracy

附上主函数：

/**
	 *********************
	 * The entrance of the program.
	 * 
	 * @param args Not used now.
	 *********************
	 */
	public static void main(String args[]) {
		KnnClassification tempClassifier = new KnnClassification("E:/Weka-3-8-6/data/iris.arff");
		tempClassifier.splitTrainingTesting(0.8);
		tempClassifier.predict();
		System.out.println("The accuracy of the classifier is: " + tempClassifier.getAccuracy());

		// for (int i = 4; i < 9; i++) {
		// tempClassifier.setNumNeighbors(i);
		// System.out.println("------------The test with " + tempClassifier.numNeighbors
		// + " neighors------------");
		// tempClassifier.predict();
		// System.out.println("The accuracy of the classifier is: " +
		// tempClassifier.getAccuracy());
		// } // Of for i

	}// Of main

其中for循环是对k的一个简单测试：
在这里插入图片描述
但数据集太小了，这样做意义不大~ 不过还是要提醒，如果发现随着k增大，准确度仍然在增大，说明当前测试到k的边界值只是有可能是最适合的参数，还需要扩大k的范围继续测。

小结：通过这次训练，发现了自己很多短板，比如不会用Java画图，不了解Instance、Attribute，导致我想尝试尝试归一化处理并将处理后的数据作为新的属性添加到原数据上也没有成功，还需要慢慢摸索下文档~

颜妮儿
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
从零开始的机器学习——k-近邻算法 2018.6.15.zip
04-16
作为人工智能核心研究领域之一的机器学习， 其研究动机是为了使计算机系统具有人的学习能力以实现人工智能。 那么， 什么是机器学习呢？ 机器学习 (Machine Learning) 是对研究问题进行模型假设，利用计算机...
R语言knn算法的两种方法：class包与kknn包
import_torch_as_tf
03-31 1万+
k近邻算法工作原理如下： 1、首先指定“训练”数据集 2、对于一个新的即将被预测分类的观测值，算法试图找到距离这个新的观测值最近的K个观测值，并预测这个新的观测值的类别。 3、新观测值的类别由与其最近的k个观测值类别占比最多的类别决定，作为该新值的类别。 4、不像其它模型，k近邻并没有创建一个模型对象。而是，你需要提供训练数据以及测试数据作为参数。 原文：https://blog.csdn.net...
数据分析 第十篇：分类（kNN）
li123128的博客
01-02 2010
　　K最近邻(kNN，k-NearestNeighbor)算法是一种监督式的分类方法，但是，它并不存在单独的训练过程，在分类方法中属于惰性学习法，也就是说，当给定一个训练数据集时，惰性学习法简单地存储或稍加处理，并一直等待，直到给定一个检验数据集时，才开始构造模型，以便根据已存储的训练数据集的相似性对检验数据集进行分类。惰性学习法在提供训练数据集时，只做少量的计算，而在进行分类或数值预测时做更多的...
R语言：KNN算法的实现——kknn包
海军上将光之翼的博客
02-24 2万+
在前文中，我们已经介绍过了KNN算法的原理以及其python实现，具体请见KNN算法及其python实现。 本文将主要介绍LNN算法的R语言实现，使用的R包是kknn。 数据简介 本文数据选择了红酒质量分类数据集，这是一个很经典的数据集，原数据集中“质量”这一变量取值有{3，4，5，6，7，8}。为了实现二分类问题，我们添加一个变量“等级”，并将“质量”为{3，4，5}的观测划分在等级0中，“质...
R语言KNN资料
todingdong的博客
12-02 313
https://blog.csdn.net/LdyInG_/article/details/103513186 https://www.rdocumentation.org/packages/kknn/versions/1.3.1/topics/kknn https://www.cnblogs.com/ljhdo/p/4531164.html https://recomm.cnblogs.com/blogpost/5539723
R语言KNN分类问题（kknn/class包在iris数据集上的实例）
M10150831的博客
05-12 2458
调用iris数据集，并划分训练集测试集 library(datasets) library(class) n<-dim(iris)[1] #样本数 p<-dim(iris)[2]-1 #特征数 index<-sample(1:n,round(0.8*n)) #取80%的样本为训练集，20%样本为测试集 1.kknn包 library(kknn) train<-iris[index,] test<-iris[-index,] #测试集上的预测 pre_test<-kkn
从零开始的机器学习——k-近邻算法的小应用——颜色学习与识别 2018.6.15.zip
最新发布
04-16
作为人工智能核心研究领域之一的机器学习， 其研究动机是为了使计算机系统具有人的学习能力以实现人工智能。 那么， 什么是机器学习呢？ 机器学习 (Machine Learning) 是对研究问题进行模型假设，利用计算机...
Python机器学习之K-Means聚类实现详解
12-24
本文为大家分享了Python机器学习之K-Means聚类的实现代码，供大家参考，具体内容如下 1.K-Means聚类原理 K-means算法是很典型的基于距离的聚类算法，采用距离作为相似性的评价指标，即认为两个对象的距离越近，其...
数据挖掘模型篇之R语言实践
02-27
理论与实践结合的方式，通过通俗易懂的教学方式培养学生运用R语言完成常用挖掘模型算法建立及评估，学习完课程可以掌握：线性回归模型、聚类分析、关联规则算法、KNN近邻算法和主成分分析等常用的模型算法实现。针对具体的数据挖掘应用需求，能熟练抽象出可合适的数据挖掘模型，并整理出其技术实现路线。
KNN算法以及R语言的实现
ISMedal的博客
03-09 1万+
KNN(K-Nearest-Neighbour) Classifiers, 即K-近邻算法，是一种懒惰机器学习算法(lazy learning)。简而言之，它在拿到训练集数据时并不急着去建模，而是在拿到测试集数据后，再到训练集数据中去寻找该测试样本最近的“邻居”，即距离最近的K个训练样本，依照训练样本数据的所属类别，加权或不加权地得出测试数据的类别。那么应该选择多少个邻居呢，即K取值是多还是少好呢...
MachineLearning 4. 癌症诊断方法之 K-邻近算法（KNN）
weixin_41368414的博客
05-05 2850
机器学习方法中的K-邻近算法，在肿瘤诊断中，尤其是乳腺癌表现强健
R语言-knn算法的实现
Hz_ZDeveloper的博客
04-25 1万+
用R语言实现knn算法，步骤如下： 一、加载R包library(kknn) library(sampling) library(class)kknn是用来提供数据集和加权knn算法函数的，sampling是用来提供抽样算法函数的，class是用来提供knn算法函数的。 如果不能加载上面几个包请先下载。 二、准备数据 我用的数据是kknn包自带的数据集miete，可以通过几个
R语言与机器学习学习笔记（分类算法）（1）K-近邻算法
beta
11-09 3万+
前言      最近在学习数据挖掘，对数据挖掘中的算法比较感兴趣，打算整理分享一下学习情况，顺便利用R来实现一下数据挖掘算法。      数据挖掘里我打算整理的内容有：分类，聚类分析，关联分析，异常检测四大部分。其中分类算法主要介绍：K-近邻算法，决策树算法，朴素贝叶斯算法，支持向量机，神经网络，logistic回归。     这篇文章是我博客数据挖掘系列的第一篇文章，介绍分类算法中最基本的
分类算法——K近邻算法及其R实现
一人一花
08-26 9074
原理：已知样本集中每一个数据与所属分类的对应关系，输入没有标签的新数据后，将新数据与训练集的数据对应特征进行比较，找出“距离”最近的k（通常k）数据，选择这k个数据中出现最多的分类作为新数据的分类。 算法描述：（1）计算已知类别数据及中的点与当前点的距离； （2）按距离递增次序排序 （3）选取与当前点距离最小的k个点 （4）确定前K个点所在类别出现的频率 （5）返回频率最高的类别作为当前类
《R语言与数据挖掘》⑥-④分类与预测建模【KNN算法】
王斯的博客
12-23 1342
KNN 算法即K最近邻(k-Nearest Neighbor)分类算法，是一个理论上比较成熟的方法。 kknn()函数 knn()函数 train()函数 # KNN算法 setwd("F:\\桌面") # 设置工作空间 Data <- read.csv("./test.txt",sep = '\t') # 读入数据 Data[, "MN"] <- as.factor(Data[, "MN"]) # 将目标变量转换成因子型 set.seed(1234) # 设置随机种子 # 数
数据挖掘十大算法之 k-NN
Python 自习室
01-22 786
kkk-NN (kkk-nearest neighbor) 由 Cover 和 Hart 于 1968 年提出，属于机器学习算法中的监督学习算法，可以用来解决分类和回归问题。 kkk-NN 的工作原理 为了对 kkk-NN 算法有个直观的认识，我们看个例子： 有两类物体 A 和 B，它们在坐标轴中的分布如上图所示。现在来了一个未知类别的物体，由图中的正方形表示，我们该把它归为哪一类呢？kkk-NN 算法的工作原理是看离待分类物体最近的 kkk 个物体的类别，这 kkk 个物体的大多数属于那个类别，待分类物
机器学习之深入理解K-means、与KNN算法区别及其代码实现
热门推荐
HuangQinJian
02-14 4万+
K-means方法是一种非监督学习的算法，它解决的是聚类问题。
【机器学习】最近邻算法KNN原理、流程框图、代码实现及优缺点
AMG_GT的博客
07-14 2万+
通过机器学习教学视频，初识K-Means算法，对原理公式推导、Python代码实现部分小程序，有了一些自己的理解。因此在此整理一下，既是对自己学习的阶段性总结，也希望能和更多的朋友们共同交流学习相关算法，如有不完善的地方欢迎批评指正。前后花费3天时间，不断修改，完善后才发出来，转载请注明出处，谢谢！1、K-Means概念及原理2、K-Means算法流程3、K-Means代码实现4、K-Means优...
机器学习 --- k-means
10-20
机器学习是一种通过计算机程序和模型来实现对数据的学习和预测，从而达到自动化解决问题的目的的技术。而k-means是机器学习中非监督学习的一种典型聚类算法，可以将相似的数据划分为一个集合，也就是簇。k-means算法的原理很简单，就是将数据聚类为k个簇，其中每个簇的中心采用该簇中所含值的均值计算而成。在实现k-means算法时，可以基于Python语言搭建出一个k-means模型，并使用sklean库中的KMeans函数对数据进行聚类。在聚类过程中，可以选择不同的初始化聚类中心的方式，包括k-means和random两种方式。 --相关问题--:

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值