K 근린 법(KNN)에 관 한 지식 총화 및 python 으로 어떻게 실현 하 는 지

1.기본 개념
K 근린 법(K-nearest neighbors,KNN)은 분류 도 가능 하고 회귀 도 가능 하 다.
KNN 이 회귀 와 분 류 를 하 는 차 이 는 최종 예측 시의 의사 결정 방식 에 있다.
       KNN 은 분류 할 때 보통 다수결 법 을 사용한다 
       KNN 이 컴백 할 때 는 보통 평균 법 을 사용한다.
　　 기본 개념 은 다음 과 같다.테스트 인 스 턴 스 에 대해 훈련 데이터 에서 이 인 스 턴 스 와 가장 가 까 운 K 개의 인 스 턴 스(즉,위 에서 말 한 K 개의 이웃)를 집중 적 으로 찾 으 면 이 K 개의 인 스 턴 스 는 대부분 특정한 유형 에 속 하 므 로 이 입력 인 스 턴 스 를 이 유형 으로 분류 한다.
2.KNN 알고리즘 3 요소
KNN 알고리즘 은 주로 k 값 의 선택,거리 측정 방식,분류 결정 규칙 을 고려한다.
       1)k 값 의 선택.응용 에서 k 값 은 일반적으로 비교적 작은 값 을 선택 하고 보통 교차 검증 을 사용 하여 가장 좋 은 k 값 을 취한 다.
                K 수치 가 비교적 작고 훈련 오차 가 줄 어 들 며 일반화 오차 가 커지 면 모델 이 복잡 하고 의합 하기 쉽다.
                K 수치 가 비교적 크 고 일반화 오차 가 줄 어 들 며 훈련 오차 가 커진다.모델 은 간단하게 예측 에 오류 가 발생 한다(하나의 극단,K 는 견본 수 m 와 같 으 면 분류 가 전혀 없다.이때 테스트 집합 이 무엇 이 든 결 과 는 훈련 집중 이 가장 많은 유형 에 속한다).
2)거리 측정.Lp 거리:오차 절대 치 p 차방 구 와 재 구 p 차 근.유럽식 거리:p=2 의 Lp 거리.맨 해 튼 거리:p=1 의 Lp 거리.p 가 무한대 일 때,Lp 거 리 는 각 차원 에서 거리의 최대 값 이다.
3)분류 결정 규칙.K 개 최근 이웃 에 따라 테스트 대상 의 분 류 를 결정 하 는 방법 이다.k 최근 이웃 의 분류 결정 규칙 은 일반적으로 다수 표결 을 선택한다.
3.KNN 기본 실행 절차
1)측정 대상 과 훈련 이 각 견본 점 에 집 중 된 유럽식 거 리 를 계산한다.
2)위의 모든 거리 값 정렬
3)"유권자"로 k 개의 최소 거리의 견본 을 선정한다
4)'유권자'에 따라 측정 대상 견본 의 분류 또는 가 치 를 예측한다
4.KNN 특징
1)원리 가 간단 하 다
2)모델 을 저장 하려 면 모든 견본 집 을 저장 해 야 한다.
3)훈련 과정 이 빠 르 고 예측 속도 가 느리다
・장점:
정밀도 가 높 고 이상 치 에 민감 하지 않다.
수치 형 데이터 와 이산 형 데이터 에 사용 할 수 있다.
단점:
시간 복잡성 이 높다.공간 복잡성 이 높다.많은 메모리 가 필요 합 니 다.
견본 의 불 균형 문제(즉,일부 유형의 견본 수량 이 많 고 다른 견본 의 수량 이 적다).
보통 수치 가 많 을 때 는 이것 을 쓰 지 않 고 계 산 량 이 너무 많다.그러나 하나의 견본 이 너무 적어 서 는 안 된다.그렇지 않 으 면 오점 이 발생 하기 쉽다.
가장 큰 단점 은 데이터 의 내 적 의 미 를 제시 할 수 없다 는 것 이다.
생각해 야 할 문제:
견본 속성 은 어떻게 선택 합 니까?어떻게 두 대상 간 의 거 리 를 계산 합 니까?견본 의 각 속성의 유형 과 척도 가 같 지 않 으 면 어떻게 처리 합 니까?각 속성 이 다른 중요 도 는 어떻게 처리 합 니까?모델 의 좋 고 나 쁨 은 어떻게 평가 합 니까?
5.코드 구현
K 근린 알고리즘 의 일반적인 절차:준비 데이터-분석 데이터-테스트 알고리즘-사용 알고리즘
5.1 sklearn 패키지 구현
sklearn 에 대한 상세 한 소 개 는 이전 블 로 그 를 보십시오.  //www.jb51.net/article/204984.htm
5.1.1 sklearn 실현 k-근린 알고리즘 안내  공식 문서
5.1.2 KNeighbors Classifier 함수 8 개 인자

　　- n_neighs:k 값,최근 k 개 점 을 선택 하고 기본 값 은 5 입 니 다.k 값 은 분류 결과 에 따라 달라 집 니 다

　　- weights:기본적으로 uniform 입 니 다.매개 변 수 는 uniform(균등 권 중),distance(거리 에 따라 권 중 을 분배)일 수도 있 고 사용자 가 정의 한 함수 일 수도 있 습 니 다.교복 은 균등 한 가중치 이다.모든 인접 점 의 가중치 가 같다 고 말한다

　　- algorithm:빠 른 k 근린 검색 알고리즘,기본 매개 변 수 는 auto 입 니 다.그 밖 에 사용자 도 검색 알고리즘 ball 을 스스로 지정 할 수 있 습 니 다.tree、kd_tree,brute 방법 으로 검색 합 니 다

　　- leaf_size:기본 값 은 30 입 니 다.이것 은 구조의 kd 트 리 와 ball 트 리 의 크기 입 니 다.이 값 의 설정 은 트 리 구축 속도 와 검색 속도 에 영향 을 주 고 트 리 저장 에 필요 한 메모리 크기 에 도 영향 을 줍 니 다.문제 의 성질 에 따라 가장 좋 은 크기 를 선택해 야 한다

　　- metric:거리 측정 에 사용 되 며,기본 측정 은 minkowski,즉 p=2 의 오 씨 거리(유클리드 측정)입 니 다

　　- p:거리 도량형 공식.오 씨 거리 와 맨 해 튼 거리.이 매개 변 수 는 기본적으로 2 이 고 1 로 설정 할 수 있 습 니 다

　　- metric_params:거리의 공식 적 인 다른 관건 적 인 매개 변 수 는 상관 하지 않 고 기본 None 를 사용 하면 됩 니 다

　　- n_jobs:병렬 처리 설정.기본 값 은 1 이 며,근접 점 검색 병행 작업 수 입 니 다.-1 이면 CPU 의 모든 cores 는 병행 작업 에 사 용 됩 니 다. 

     주의:샘플 데이터-특징 데이터 feature 는 반드시 디지털 형식 이 어야 하 며 연산 을 해 야 합 니 다!
5.1.3 실례
(1)영화 분류

import pandas as pd
import numpy as np
from sklearn.neighbors import KNeighborsClassifier
#     
df = pd.read_excel(../../myfile.excel)

#1、      
knn = KNeighborsClassifier(n_neighbors=3)

#2、             :      ，       
feature = df[['Action Lean','Love Lean']]
target = feature['target']

#3、    
knn.fit(feature,target)

#4、    
movie = np.array([13,21])
res = knn.predict(movie) #5、  ：       knn.score(feature,target)

(2)연간 수입 이 50K 달러 이상 인지 예측

#   adult.txt  ，        ，   KNN      ，                   50
# 1.     
data = pd.read_csv('../data/adults.txt')
data.head()

# 2.     、    、  、                          
feature = data[['age','education_num','occupation'
     ,'hours_per_week']]
target = data['salary']
 
# 3. knn             ，                   
  #     ， String       int
  #### map  ，      
  
dic = {}# unique()        
occ_arr = feature['occupation'].unique()
#               
for i in range(occ_arr.size):
 dic[occ_arr[i]] = i 

#          
feature['occupation'] = feature['occupation'].map(dic) 
 
# 4.   ：          
#         (            )
feature.shape
 
#    
x_train = feature[:32500]
y_train = target[:32500]

#    
x_test = feature[32500:]
y_test = target[32500:]  

# 5.     
from sklearn.neighbors import KNeighborsClassifier
#       knn  , 
#   :n_neighbors  ,             .
knn = KNeighborsClassifier(n_neighbors=10)
# fit()     , (    ,       )
knn.fit(x_train,y_train)
 
#            (    ,       )
knn.score(x_test,y_test) 
 
# 6.    
print('       ：',np.array(y_test))
print('       ：',knn.predict(x_test))

 (3)실례:sklearn 기반 핸드폰 디지털 식별 시스템 실현
        pylot 그림 읽 기:imgarr.shape 모양 보기

import pandas as pd
import numpy as np
from sklearn.neighbors import KNeighborsClassifier
# 1、      ：       numpy  ：0,1,2,3,4,5,6,7,8,9
feature =[]
target =[]
for i in range(10):#0-9      
 for j in range(1,501): #1-500    
  imgpath = './data/'+str(i)+'/'+str(i)+'_'+str(j)+'.bmp' #    
  img_arr = pld.imread(imgpath)
  feature.append(img_arr)
  target.append(i) 
# 2、     numpy  ;feature        ；
feature = np.array(feature) #  feature         ，
target = np.array(target)

feature.shape 
(5000,28,28) #   5000 28*28     

#   ：feature     ；                ，                ！
# 3、feature       
feature.shape(5000,784)
#4、                
np.random.seed(10)
np.random.shuffle(feature)
np.random.seed(10)
np.random.shuffle(target)

# 5、         ：         
x_train = feature[:4950] 
y_train = target[:4950]
x_test = feature[4950:]
y_test = target[4950:]

# 6、       ：  :n_neighbors  ,              .
from sklearn.neighbors import KNeighborsClassifier
knn = KNeighborsClassifier(n_neighbors=8)
knn.fit(x_train,y_train) # (    ,       )
 
# 7、           (    ,       )
knn.score(x_test,y_test)
# 8、       
print('     ',y_test)
print('       ',knn.predict(x_test))

#9、        
from sklearn.externals import joblib
joblib.dump(knn,'./knn.m')

#10、        
knn = joblib.load('./knn.m')
#-------------------------------------------------------------------------------------------------
# 11、             
#   ：                                  
#  ！！！                     ！！！ 
img_arr = plt.imgread('./  .jpg')
eight_arr = img_arr[170：260，80:70] #        
plt.imshow(eight_arr) #         

#              ：feature.shape(5000,784)          784      ；       
# 12、 eight_arr        (      )： (65,50,3)  (28,28)
 eight_arr.mean(axis=2 ) # axis=2          ,  (65,50)       ！

# 13、            
import scipy.ndimage as ndimage
data_pre_test = ndimage.zoom(eight_arr,zoom=(28/65,28/50))
eight_arr.shape #(28,28)

# 14、          (28,28)    (1,784)
eight_arr = eight_arr(1,784)

# 15、              
knn.predict(eight_arr)
array([8])

# -*- coding: UTF-8 -*-
import numpy as np
import operator
from os import listdir
from sklearn.neighbors import KNeighborsClassifier as kNN

"""
    : 32x32         1x1024  。

Parameters:
 filename -    
Returns:
 returnVect -          1x1024  

"""
def img2vector(filename):
 #  1x1024   
 returnVect = np.zeros((1, 1024))
 #    
 fr = open(filename)
 #    
 for i in range(32):
  #     
  lineStr = fr.readline()
  #     32        returnVect 
  for j in range(32):
   returnVect[0, 32*i+j] = int(lineStr[j])
 #      1x1024  
 return returnVect

"""
    :        

Parameters:
  
Returns:
  

"""
def handwritingClassTest():
 #    Labels
 hwLabels = []
 #  trainingDigits       
 trainingFileList = listdir('trainingDigits')
 #           
 m = len(trainingFileList)
 #      Mat  ,   
 trainingMat = np.zeros((m, 1024))
 #              
 for i in range(m):
  #       
  fileNameStr = trainingFileList[i]
  #       
  classNumber = int(fileNameStr.split('_')[0])
  #         hwLabels 
  hwLabels.append(classNumber)
  #       1x1024     trainingMat   
  trainingMat[i,:] = img2vector('trainingDigits/%s' % (fileNameStr))
 #  kNN   
 neigh = kNN(n_neighbors = 3, algorithm = 'auto')
 #    , trainingMat     ,hwLabels      
 neigh.fit(trainingMat, hwLabels)
 #  testDigits        
 testFileList = listdir('testDigits')
 #      
 errorCount = 0.0
 #       
 mTest = len(testFileList)
 #                    
 for i in range(mTest):
  #       
  fileNameStr = testFileList[i]
  #       
  classNumber = int(fileNameStr.split('_')[0])
  #      1x1024  ,    
  vectorUnderTest = img2vector('testDigits/%s' % (fileNameStr))
  #      
  # classifierResult = classify0(vectorUnderTest, trainingMat, hwLabels, 3)
  classifierResult = neigh.predict(vectorUnderTest)
  print("       %d\t     %d" % (classifierResult, classNumber))
  if(classifierResult != classNumber):
   errorCount += 1.0
 print("    %d   
    %f%%" % (errorCount, errorCount/mTest * 100))


"""
    :main  

Parameters:
  
Returns:
  

"""
if __name__ == '__main__':
 handwritingClassTest()

이 매개 변수의 설정 을 변경 하여 함수 에 대한 이 해 를 강화 할 수 있 습 니 다.
이상 은 K 근린 법(KNN)에 관 한 지식 총화 와 python 으로 어떻게 실현 하 는 지 에 대한 상세 한 내용 입 니 다.python 이 K 근린 법(KNN)을 실현 하 는 지 에 관 한 자 료 는 저희 의 다른 관련 글 에 주목 하 세 요!