소박 한 베 이 루스 알고리즘 및 Python 의 간단 한 실현

소박 한 베 이 루스 알고리즘 및 Python 의 간단 한 실현
베 이 루스 알고리즘 은 고전 수학 이론 에서 기원 되 었 고 분류 산법 의 총칭 이다.이 는 베 이 루스 의 정 리 를 바탕 으로 특정한 분류 대상 의 견본 이 특정한 확률 분 포 를 만족 시 키 고 이미 관찰 한 견본 데이터 에 따라 이 견본 에 대해 확률 적 으로 계산 하여 가장 좋 은 분류 결정 을 내 릴 수 있다 고 가정 할 수 있다.이미 관찰 한 견본 데 이 터 를 계산 하여 특정한 분류 견본 의 선험 확률 을 평가 하고 베 이 루스 공식 을 이용 하여 후 험 확률 을 계산한다. 즉, 이 견본 은 특정한 유형의 확률 에 속 하고 가장 큰 후 험 확률 을 가 진 유형 을 이 견본 에 속 하 는 유형 으로 선택한다.
선험 확률 은 이전의 경험 과 분석 에 근거 하여 얻 은 확률 이다.가설 h 의 선험 확률 을 P (h) 로 표시 하고, 관찰 할 훈련 데이터 D 의 선험 확률 을 P (D) 로 표시 하 며, 가설 h 가 성립 된 경우 데이터 D 를 관찰 할 확률 을 P (D | h) 로 표시 하 며, 관심 사 는 훈련 데이터 D 를 지정 할 때 h 가 성립 될 확률 을 선험 확률 이 라 고 한다.
베 이 루스 공식: P (h | D) = P (D | h) P (h) / P (D) 는 공식 적 으로 P (h | D) 가 P (h) 와 P (D | h) 의 증가 에 따라 증가 하고 P (h | D) 가 P (D) 의 증가 에 따라 감소 하 는 것 을 알 수 있다.후보 가설 집합 H 를 고려 하고 그 중에서 주어진 데이터 D 를 찾 을 때 가능성 이 가장 큰 가설 h.이러한 최대 가능성 을 가 진 가설 을 최대 후 험 (MAP) 가설 이 라 고 한다.MAP 가설 을 확정 하 는 방법 은 각 후보 가설 의 후 험 확률 을 베 이 루스 공식 으로 계산 하 는 것 이다. 여러 개의 속성 이 있 을 수 있 고 속성 간 에 복잡 한 의존 관계 가 존재 할 수 있 기 때문에 P (D | h) 의 계산 이 매우 어렵다. 조건 확률 의 구 해 난이 도 를 간소화 하기 위해 조건 독립 가설 을 제시 했다. 즉, 훈련 데이터 D 에서 각 속성 간 에 서로 독립 된다 고 가정 하 는 것 이다.베 이 루스 알고리즘 을 바탕 으로 조건 독립 가설 을 추가 하면 우 리 는 소박 한 베 이 루스 알고리즘 이 라 고 부른다.

# -*- coding:utf-8 -*-
import numpy as np
__author__ = 'yangxin'
"""
     
p(xy)=p(x|y)p(y)=p(y|x)p(x)
p(x|y)=p(y|x)p(x)/p(y)
"""
 
 
class SpeechJudgment(object):
 
    def load_data_set(self):
        #     
        posting_list = [
            ['my', 'dog', 'has', 'flea', 'problems', 'help', 'please'],
            ['maybe', 'not', 'take', 'him', 'to', 'dog', 'park', 'stupid'],
            ['my', 'dalmation', 'is', 'so', 'cute', 'I', 'love', 'him'],
            ['stop', 'posting', 'stupid', 'worthless', 'gar e'],
            ['mr', 'licks', 'ate', 'my', 'steak', 'how', 'to', 'stop', 'him'],
            ['quit', 'buying', 'worthless', 'dog', 'food', 'stupid']]
        #        1 ->       , 0 -> not
        class_vec = [0, 1, 0, 1, 0, 1]
        return posting_list, class_vec
 
    def create_vocab_list(self, data_set):
        vocab_set = set()
        for item in data_set:
            vocab_set = vocab_set | set(item)
        #            
        return list(vocab_set)
 
    def set_of_words2vec(self, vocab_list, input_set):
        result = [0] * len(vocab_list)
        for word in input_set:
            if word in vocab_list:
                #            ，    1，   0
                result[vocab_list.index(word)] = 1
        return result
 
    def train_naive_bayes(self, train_mat, train_category):
        train_doc_num = len(train_mat)
        words_num = len(train_mat[0])
        pos_abusive = np.sum(train_category) / train_doc_num
        #        words_num   1   
        p0num = np.ones(words_num)
        p1num = np.ones(words_num)
        p0num_all = 2.0
        p1num_all = 2.0
        for i in range(train_doc_num):
            if train_category[i] == 1:
                p1num += train_mat[i]
                p1num_all += np.sum(train_mat[i])
            else:
                p0num += train_mat[i]
                p0num_all += np.sum(train_mat[i])
        p1vec = np.log(p1num / p1num_all)
        p0vec = np.log(p0num / p0num_all)
        return p0vec, p1vec, pos_abusive
 
    def classify_naive_bayes(self, vec_to_classify, p0vec, p1vec, p_class1):
        p1 = np.sum(vec_to_classify * p1vec) + np.log(p_class1)
        p0 = np.sum(vec_to_classify * p0vec) + np.log(1 - p_class1)
        if p1 > p0:
            return 1
        else:
            return 0
 
    def bag_words_to_vec(self, vocab_list, input_set):
        result = [0] * len(vocab_list)
        for word in input_set:
            if word in vocab_list:
                result[vocab_list.index(word)] += 1
            else:
                print('the word: {} is not in my vocabulary'.format(word))
        return result
 
 
    def testing_naive_bayes(self):
        list_post, list_classes = self.load_data_set()
        vocab_list = self.create_vocab_list(list_post)
        train_mat = []
        for post_in in list_post:
            train_mat.append(
                self.set_of_words_to_vec(vocab_list, post_in)
            )
        p0v, p1v, p_abusive = self.train_naive_bayes(np.array(train_mat), np.array(list_classes))
        test_one = ['love', 'my', 'dalmation']
        test_one_doc = np.array(self.set_of_words2vec(vocab_list, test_one))
        print('the result is: {}'.format(self.classify_naive_bayes(test_one_doc, p0v, p1v, p_abusive)))
        test_two = ['stupid', 'garbage']
        test_two_doc = np.array(self.set_of_words2vec(vocab_list, test_two))
        print('the result is: {}'.format(self.classify_naive_bayes(test_two_doc, p0v, p1v, p_abusive)))