P (Y | X) = P (Y) * P (X | Y) / P (X)
샘플 속성은 독립적이다;
문제는 원래의 문제에 해당합니다 :
데이터 처리
P (Y) * P 방지하기 위하여 | 언더 값 (x 및 y), 즉 원래의 질문의 대수 :
주 : 속성 값은 트레이닝 세트에서와 같은 시간에 볼 수없는 경우, 클래스, 직접 P (Y) 또는 P (X | y)는 0이 될 수 있도록 계산 된 P (Y) * P (X | Y)의 0 인 것은 확률 값의 개수는 일반적으로 "평활화"프로세스 라플라스 보정 필요 찾을 비교할 불편하지 않다.
고정 선험적 확률 : D 클래스의 Dy (Y)의 샘플 세트들의 조합 세트를 나타내는 훈련하자, N은 D 가능한 카테고리의 트레이닝 세트의 개수를 나타내며
즉, 각 종류의 샘플들의 수는 1을 첨가 하였다.
클래스 조건부 확률 : 또 하나의 Dy가 XI 직류 샘플 XI는 i 번째 속성에 형성 될 때 설정 한 값이고, NI는 가능한 수의 속성 값 i 번째를 나타낸다
즉, i 번째 속성 카테고리 샘플을 증가한다.
-------------------------------------------------- ------------
데이터 전처리
훈련자
시험 시료
함수 호출
참고
파이썬 순진 베이 즈 분류 MNIST 데이터 세트
구조체 가져 오기
NumPy와 가져 오기 *의에서
NP AS 가져 오기 NumPy와
가져 오기 시간
DEF의 read_image (FILE_NAME) :
# 첫번째 바이너리 모드는 모든 문서에 와서 읽는
file_handle = 개방 (FILE_NAME, "RB ") #의 바이너리 문서 열
file_content = file_handle.read을 () # 버퍼에 판독
오프셋 = 0
, 반환 헤드 struct.unpack_from = ( '> IIII'FILE_CONTENT 오프셋) # 4의 정수 전에 수행하는 튜플
오프셋 + = struct.calcsize ( '> IIII')
imgNum = 헤드 [1] # 화상 번호
= 헤드 [2] # 폭 행
= 헤드 [3] # 높이 COLS
사진 = np.empty ((imgNum, 784 )) 빈 #은, 그것이 상기 어레이 내의 모든 요소에 공통된은 빈 실질적인 의미가없는, 그 배열 생성하는 빠른 방법이다
= 행 * COLS 번호를 크기의 단일 사진 image_size를
FMT = '>'+ STR ( image_size) 'B'# + 단일 이미지 포맷을
난에 (imgNum)의 범위는 :
이미지 [I] = np.array (struct.unpack_from (FMT, FILE_CONTENT) 오프셋)
() (행 COLS) 이미지 # [I] = np.array (struct.unpack_from (FMT, FILE_CONTENT 오프셋)). 모양 변경을
+ = struct.calcsize 오프셋 (FMT)
반환 이미지
#가 태그 판독
DEF의 read_label (FILE_NAME)
file_handle = 개방 (FILE_NAME을 "RB") # 이진의 문서 열기
file_content = file_handle.read ()를 # 1 버퍼로 읽어
헤드 = struct.unpack_from ( '> II'는 , file_content, 0) #은 처음 두 정수를 취 튜플 리턴
오프셋 = struct.calcsize를 ( '> II')
labelNum 헤드 =. 1] 라벨 번호 # 1
# 전단 (labelNum )
bitsString = '>'+ STR (labelNum) 'B'포맷 FMT 번호 + '> 47040000B'어레이 (라벨)
데프 loadDataSet ()
#mnist
라벨 = struct.unpack_from (bitsString,file_content, #은 데이터 데이터를 가져) 오프셋 튜플을 반환
np.array 반환 (라벨)
train_x_filename = "기차 - 이미지 - IDX3-ubyte"
train_y_filename = "기차 라벨 - IDX1-ubyte"
test_x_filename = "t10k - 이미지 - IDX3-ubyte"
test_y_filename = "t10k - 라벨 - IDX1-ubyte "
# #fashion mnist
# train_x_filename ="패션 - 기차 - 이미지 - IDX3-ubyte "
#의 train_y_filename ="패션 기차 라벨 - IDX1-ubyte "
#의 test_x_filename ="패션 t10k - 이미지 - IDX3-ubyte "
# test_y_filename = "패션 t10k - 라벨 - IDX1-ubyte"
train_x = read_image (train_x_filename) # 60000 * 784的矩阵
train_y = read_label (train_y_filename) # 60000 * 1的矩阵
test_x = read_image (test_x_filename) # 10000 * 784
test_y = read_label (test_y_filename) # 10000 * 1
train_x = 정규화 (train_x)
= 노멀 test_x (test_x)
# 번호 빠를 속도 디버그 시간, 데이터의 크기를 줄이는 설정
# train_x = train_x [0 : 1000 :]
# train_y = train_y [0 : 1000]
# test_x test_x = [0 : 500 :]
# test_y test_y = [0 : 500]
복귀 train_x, test_x, train_y, test_y
DEF 평준화 (데이터) : # 치화 화상 픽셀 분포하게 0-1
m = data.shape [0]
, N-NP = .Array (데이터) .shape의 [1.]
I에 대한 거리 (m)에서 :
범위 J 대 (N-)
! IF 데이터 [I, J = 0
. 데이터 [I, J] 1 =
다른 :
데이터 [I , J = 0
복귀 데이터
. (1) # 조건부 확률 사전 확률을 계산
DEF의 train_model (train_x, train_y, classNum) # 10 개의 classNum 카테고리 수단 여기 train_x 이미 치화,
m = train_x.shape [0]
, N-train_x.shape = 1. ]
# = np.zeros prior_probability (N-) #의 선험적 확률
prior_probability = np.zeros (classNum) #의 선험적 확률
conditional_probability = np.zeros ((classNum, N , 2)) # 조건부 확률
#의 사전 계산 된 조건부 확률
범위 I에 대해 (m ) : #의 m은 화상의 수가 60,000 개의이다
IMG = train_x [I] #img 1 * N 개의 행 벡터의 i 번째의 화상이다
레이블 = train_y [I] #label 라벨에 대응하는 i 번째의 화상
prior_probability [ 라벨] + 라벨 번호 (p (Y = CK) = (1 #)의 통계 클래스 라벨, N으로 나눈 첨자 라벨 prior_probability [상표]을 저장하기위한 클래스 사전 확률이고
(N) 범위 J의 경우 : #N은 특성 번호 784의 합계이다
온도 = IMG [J] .astype ( INT) #img [J] 정수만 표시 첨자 오류 들어갈 0.0,
. conditional_probability가 [라벨] [J]를 [TEMP는] + 1 =
의 곱을 계산 # (2) 주어진 X, 조건부 확률 사전 확률
# conditional_probability [상표] [J]를 [IMG은 [J]를] = 1 개 + # 통계 클래스 라벨은 각 열에서의 행의 수는 숫자 1 또는 0이다 , IMG는 [j]가 값 0 또는 1이고, 조건부 확률을 계산
# 확률 [1.10001]로 정규화
범위 (classNum)에 대한 I :
J에 대한 범위 (N-)
# 치화 화상 만 두 값 0
pix_0 = conditional_probability을 [I] [J ] [0 ]
pix_1 conditional_probability = [I] [J]. 1]
# 0에 대응하는 픽셀 계산 된 조건부 확률
probability_0 = (플로트 (pix_0) / 플로트 (pix_0의 pix_1의 +)) * 10000 +. 1
probability_1 = (플로트 (pix_1) / 플로트 (pix_0 + pix_1)) * 10000 +. 1
conditional_probability [I] [J] [0] = probability_0
conditional_probability [I] [J]. 1] = probability_1의
복귀 prior_probability, conditional_probability의
cal_probability DEF (IMG, 레이블 prior_probability, conditional_probability)
확률 = INT (prior_probability [상표]) #의 선험적 확률
N-img.shape = [0]
# 전단 (N-)
범위 (N-)의 I위한 # 특성되어야 번호
확률 * = INT (conditional_probability [상표] [I] [IMG [I] .astype (INT)])
회신 확률
argmax에 대응하여 결정되는 클래스의 #의 X 인스턴스
DEF (test_x, test_y, prior_probability, conditional_probability) 예측 # test_x 후에 전달 또는 train_x 치화
predict_y = []
m = test_x.shape [0]
, N-test_x.shape = 1이다.]
거리 (m)에 대한 I :
IMG = np.array (test_x를 [ I]) # IMG에 이미 열 벡터 치화 후의
라벨 test_y = [I]
max_label = 0
max_probability = cal_probability (IMG, 0, prior_probability, conditional_probability)
범위 J 대 (1,10)에 인덱스 # 1 시작이되기 때문에, 아래 첨자 0은 초기 값
확률 = cal_probability (IMG, J, prior_probability, conditional_probability)
경우 max_probability <확률 :
max_probability = 확률
max_label = j 개의
predict_y.append (max_label) #用来记录每行最大概率的라벨
복귀 np.array (predict_y)
데프 cal_accuracy (test_y, predict_y) :
m = test_y.shape [0]
ERRORCOUNT = 0.0
범위 (m)에서의 I :
만약 test_y [I] = predict_y [I]!
ERRORCOUNT + = 1
정확도 = 1.0 유동 (ERRORCOUNT) / m의
반송 정밀도
경우 __name __ == '__ main__'
classNum = 10
인쇄 ( "데이터 ... 읽기 시작")
시간 1 =로 time.time을 ()
train_x, test_x, train_y, test_y = loadDataSet ()
train_x = (train_x) 정상화
test_x = 정규화 (test_x)
TIME2 =로 time.time ()
인쇄 ( "두 번째", TIME2-TIME1 "데이터 코스트를 읽는")
인쇄 ( "시작 트레이닝 데이터 ... ")
prior_probability, conditional_probability = train_model (train_x, train_y, classNum)
나 대 범위 (classNum)
인쇄 (prior_probability [I]) #输出一下每个标签的总共数量
TIME3로 time.time = ()
인쇄 ( "기차 데이터 비용"시간 3-TIME2는 "두 번째")
인쇄 ( "데이터 ... 예측 시작")
predict_y = 예측을 (test_x, test_y, prior_probability, conditional_probability)
time4 = 시간.시각()
인쇄 ( "데이터 비용을 예측", time4-시간 3 ,"둘째")
인쇄 ( "정확도를 계산 시작 ...")
ACC = cal_accuracy (test_y, predict_y)
time5로 time.time = ()
인쇄 ( "accuarcy"ACC)
인쇄 ( "두 번째", time5-time4 "accuarcy 비용을 계산하는")