Python 기계 학습 의 KNN 근접 알고리즘

1.KNN 개술
쉽게 말 하면 K-근린 알고리즘 은 서로 다른 특징 값 간 의 거 리 를 측정 하 는 방법 으로 분류 한다.
장점:정밀도 가 높 고 이상 치 에 민감 하지 않 으 며 데이터 입력 가정 이 없다.
단점:계산 복잡 도가 높 고 공간 복잡 도가 높다.
적용 데이터 범위:수치 형 과 레이 블 2 형
작업 원리:하나의 샘플 데이터 집합 이 존재 하고 훈련 샘플 집합 이 라 고도 부 르 며 샘플 은 모든 데이터 에 라벨 이 존재 합 니 다.즉,우 리 는 샘플 이 모든 데이터 와 소속 분류의 대응 관계(훈련 집합)를 집중 하 는 것 을 알 고 있 습 니 다.라벨 이 없 는 새로운 데 이 터 를 입력 한 후 새로운 데이터 의 모든 특징 과 샘플 집중 데이터 에 대응 하 는 특징 을 비교 한 다음 에 알고리즘 은 샘플 집중 특징 이 가장 비슷 한 데이터(최근 이웃)의 분류 라벨(테스트 집합)을 추출 합 니 다.일반적으로 우 리 는 견본 데이터 가 집중 되 기 전에 k 개의 가장 비슷 한 데이터 만 선택 합 니 다.이것 이 바로 k-근린 알고리즘 중의 k 의 출처 입 니 다.보통 k 는 20 보다 크 지 않다)
2.Python 으로 데이터 가 져 오기
코드 를 먼저 쓰 겠 습 니 다.

from numpy import *		#   numpy  
import operator		#   operator  
def createDataSet():		#        
	#            
    group = array(
        [[1.0, 1.1], [1.0, 1.0], [0, 0], [0, 0.1]]
    )
    #            
    labels = ['A', 'A', 'B', 'B']
    return group, labels

여기 서 numpy 가방 을 살짝 소개 해 드릴 게 요.
3.numpy.array()
NumPy 의 주요 대상 은 같은 원소 의 다 차원 배열 이다.이것 은 모든 요소 가 하나의 유형 이 고 정수 원 그룹 색인 을 통과 하 는 요소 표 입 니 다(보통 요 소 는 숫자 입 니 다).
NumPy 에서 차원(dimensions)은 축(axes)이 라 고 하고 축의 개 수 는 순위(rank)라 고 합 니 다.그러나 선형 대수 에서 의 순위 와 같 지 않 습 니 다.python 으로 선 대 를 구 하 는 순위 에서 우 리 는 numpy 가방 의 linalg.matrix 를 사용 합 니 다.rank 방법 은 행렬 의 질 서 를 계산한다.
선형 대수 에서 순위 의 정의:행렬 A 에 0 과 같 지 않 은 r 단계 자식 D 가 있 고 모든 r+1 단계 자식(존재 한다 면)은 0 과 같 습 니 다.그러면 D 는 행렬 A 의 최고 단계 비 0 자식 이 라 고 부 르 고 수 r 는 행렬 A 의 순위 라 고 부 르 며 R(A)로 기록 합 니 다.
4.KNN 분류 알고리즘 실시
KNN 알고리즘 에 따라 순서대로 하 겠 습 니 다.
먼저 필요 한 네 개의 데 이 터 를 준비 하 세 요.
inX:분류 에 사용 되 는 입력 벡터 inXdataset:입력 한 훈련 샘플 집 dataset

labels:라벨 벡터 labels(요소 수 와 행렬 dataSet 의 줄 수가 같 음)

k:최근 이웃 의 수 를 선택 하 십시오5.이미 알 고 있 는 분류 데이터 집중 점 과 현재 점 간 의 거 리 를 계산 합 니 다.
유럽식 거리 사용:

6.전체 코드

#        
dataSetSize = dataSet.shape[0]	
#     ，    dataSetSize 
diffMat = tile(inX, (dataSetSize, 1)) - dataSet
sqDiffMat = diffMat ** 2
sqDistances = sqDiffMat.sum(axis=1)
distances = sqDistances**0.5

첫 줄

#        
dataSetSize = dataSet.shape[0]	
#          
answer:4		# 4 

두 번 째 줄

inX = [1. , 0.]
#     ，    dataSetSize 
diffMat = tile(inX, (dataSetSize, 1)) - dataSet

# tile(inX, (dataSetSize, 1))
inX = [
	[1. , 0.],
	[1. , 0.],
	[1. , 0.],
	[1. , 0.]
]
# inX - dataSet      （            ）
dataSet = [
		[1. , 1.1],
        [1. , 1. ],
        [0. , 0. ],
        [0. , 0.1]
]
diffMat = [
	[0. , -1.1],
	[0. , -1.],
	[1. , 0.],
	[1. , -0.1]
]

셋째 줄

#     
sqDiffMat = diffMat * 2

네 번 째 줄

#             
#          1    
sqDistances = sqDiffMat.sum(axis=1)

다섯 째 줄

#    
distances = sqDistances**0.5

거리 증가 순서에 따라 정렬 하 다

#        
sortedDistIndicies = distances.argsort()

현재 점 과 가장 작은 k 개 점 선택

classCount = {}		#       
#    k              
for i in range(k):
	# voteIlabel    labels sortedDistIndicies[i]   
	voteIlabel = labels[sortedDistIndicies[i]]
	classCount[voteIlabel] = classCount.get(voteIlabel, 0) + 1

앞의 k 개 점 이 있 는 분류의 출현 확률 을 확정 합 니 다.

#   
sortedClassCount = sorted(classCount.iteritems(), key=operator.itemgetter(1), reverse=True)

\#\#11\#돌아 가기 전 k 개 점 에서 빈도 가 가장 높 은 분 류 를 현재 점 의 예측 분류 로 합 니 다.

return sortedClassCount[0][0]

방금 C++버 전 을 해 봤 는데...조심 하 세 요.살 려 주세요.

#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <map>
int sum_vector(std::vector<int>& v) {
	int sum = 0;
	for (int i = 0; i < v.size(); ++i) {
		sum = v[i] + sum;
	}
	return sum;
}
int knn(int k) {
	using std::cout;
	using std::endl;
	using std::vector;
	vector<vector<int>> x;	
	vector<int> x_sample = {2, 3, 4};	
	for (int i = 0; i < 4; ++i) {
		x.push_back(x_sample);
	}
	vector<int> y = {1, 1, 1, 1};
	int dataSetSize = x.size();		

	vector<int> x_test = {4, 3, 4};
	vector<vector<int>> x_test_matrix;
	for (int i = 0; i < dataSetSize; ++i) {
		x_test_matrix.push_back(x_test);
	}
	vector<int> v_total;
	for (int i = 0; i < dataSetSize; ++i) {
		for (int j = 0; j < x_test_matrix[i].size(); ++j) {
			x_test_matrix[i][j] = x_test_matrix[i][j] - x[i][j];
			x_test_matrix[i][j] = x_test_matrix[i][j] * 2;
		}
		int sum_vec = sum_vector(x_test_matrix[i]);
		v_total.push_back(sqrt(sum_vec));
	}
	sort(v_total.begin(), v_total.end());
	std::map<int, int> mp;
	for (int i = 0; i < k; ++i) {
		int label = y[v_total[i]];
		mp[label] += 1;
	}
	int max_end_result = 0;
	for (std::map<int, int>::iterator it = mp.begin(); it != mp.end(); it++) {
		if (it->first > max_end_result) {
			max_end_result = it->first;
		}
	}
	return max_end_result;
}
int main() {
	int k = 12;
	int value = knn(k);
	std::cout << "result:
" << std::endl;
	return 0;
}

7.데이터 처리,분석,테스트
엑셀 과 txt 데이터 처리
excel 데 이 터 는 매트릭스 데이터 로 직접 사용 할 수 있 으 며 여기 서 처리 하지 않 습 니 다.
텍스트 txt 데 이 터 는 데이터 처리 가 필요 합 니 다.

def file2matrix(filename):
	fr = open(filename)
	#          
	arrayOLines = fr.readlines()
	#     
	numberOfLines = len(arrayOLines)
	#     shape （numberOfLines, 3）numpy  
	returnMat = zeros((numberOfLines, 3))
	classLabelVector = []
	index = 0
	for line in arrayOLines:
		#         
		line = line.strip()
		#  tab  '\t'          
		listFromLine = line.split('\t')
		#    3   ，           
		returnMat[index, :] = listFromLine[0: 3]
		#             
		classLabelVector.append(int(listFromLine[-1]))
		index += 1
	return returnMat, classLabelVector

데이터 정규 화 와 표준화
수치 에서 일부 데이터 의 크기 가 같 지 않 고 데이터 의 진실성 에 심각 한 영향 을 줄 수 있 기 때문에 데이터 에 대해 획일 화 와 표준 화 를 하 는 것 은 데이터 의 수 치 를 일정한 구간 에 두 고 더욱 좋 은 의합 도 를 가지 게 하 는 것 이다.
예 를 들 어 귀 일 화 는 데이터 의 수치 범 위 를 0 에서 1 또는-1 에서 1 사이 로 처리 하 는 것 이다.

# max：     
# min：     
newValue = (oldValue - min)/(max-min)

함 수 를 쓰다

def autoNorm(dataSet):
	# min(0)             
	minVals = dataSet.min(0)
	# max(0)             
	maxVals = dataSet.max(0)
	#     
	ranges = maxVals - minVals
	#          0  
	normDataSet = zeros(shape(dataSet))
	#     
	m = dataSet.shape[0]
	#          m  1   minVals
	normDataSet = dataSet - tile(minVlas, (m,1))
	#      
	normDataSet = normDataSet/tile(ranges, (m, 1))
	return normDataSet, ranges, minVals

귀 일 화 된 단점:만약 에 이상 치가 최대 치 또는 최소 치 라면 귀 일 화 는 보장 이 없다(안정성 이 비교적 떨 어 지고 전통 적 으로 정확 한 데이터 장면 에 만 적합 하 다)
표준화 검사 가능
8.아이 리 스 데이터 테스트
내 장 된 알고리즘 을 알 고 있 으 니 라 이브 러 리 를 바 꾸 어 쓰 세 요.

from sklearn.datasets import load_iris      #        
from sklearn.model_selection import train_test_split        #          
from sklearn.preprocessing import StandardScaler        #    
from sklearn.neighbors import KNeighborsClassifier      # KNN


def knn_iris():
    #         
    iris = load_iris()
    #      
    # random_state      ，              6
    x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, random_state=6)
    #     ：   
    transfer = StandardScaler()
    #       
    x_train = transfer.fit_transform(x_train)
    #       
    x_test = transfer.transform(x_test)
    #       
    estimator = KNeighborsClassifier(n_neighbors=3)
    #          
    estimator.fit(x_train, y_train)

    #     
    #               
    y_predict = estimator.predict(x_test)
    print("y_predict: 
", y_predict)
    #                    
    print("           ：
", y_test == y_predict)
    #      
    score = estimator.score(x_test, y_test)
    print("    ：
", score)


def main():
    knn_iris()


if __name__ == '__main__':
    main()

9.결과

파 이 썬 머 신 러 닝 의 KNN 근린 알고리즘 에 관 한 이 글 은 여기까지 소개 되 었 습 니 다.파 이 썬 근린 알고리즘 에 관 한 더 많은 내용 은 우리 의 이전 글 을 검색 하거나 아래 의 관련 글 을 계속 찾 아 보 세 요.앞으로 많은 응원 부 탁 드 리 겠 습 니 다!