ナイーブベイズを実現しました

1つのナイーブベイズプログラミングセルフ

インポートのNPとしてnumpyの
 輸入パンダとしてPD

％設定ZMQInteractiveShell.ast_node_interactivity = 「すべて」

クラスNaiveBayes（）：
     DEF  __init__ （セルフ、lambda_）：
        self.lambda_ = lambda_   ＃0をとるベイズ因子は、それが最尤推定の場合 
        self.y_types_count =なし   ＃Y（タイプ：数） 
        自己。 =なしy_types_proba   ＃Y（タイプ：確率） 
        self.x_types_proba = dictの（）  ＃（XI番号、XI値、Y型）：確率
    
    DEF フィット（セルフ、X_train、y_train）：
        self.y_types = NP .unique（y_train）   ＃1 np.unique（）配列を除去することを繰り返し、デジタル出力をソートされ、Y得られるタイプのすべての値 
        X-pd.DataFrame =（X_train）  ＃変換パンダのデータフレームのフォーマット、以下同じ 
        Y = pd.DataFrame（ y_train）
        ＃Y（タイプ：Number）統計1：-1 9 :. 6。 
        self.y_types_count = Y [0] .value_counts（）
        ＃Y（タイプ：確率）を算出する 
        self.y_types_proba =（self.y_types_count + self.lambda_） /（y.shape [0] + LEN（self.y_types）* self.lambda_） 
        
        ＃（XI番号、タイプYのXIを、値）：確率計算
        のための IDX で X.columns：     ＃1 トラバーサルXI 
            のために J で self.y_types：    ＃各Y型選択
                ＃は統計：（数タイプ）全ての真値データ点特徴のY ==のj個のIDX、これらの値を選択 
                p_x_y = X [（Y == J）.values] [IDX] .value_counts（）
                ＃計算（XI番号、XI値、Y型）：確率
                のためにI でp_x_y.index：
                    self.x_types_proba [（IDX、I、J）] =（p_x_y [I] + self.lambda_）/（self.y_types_count [J] + p_x_y.shape [0] * self.lambda_）
                    
    DEF 予測（セルフ、X_new）：
        RES = []
         のための Y で self.y_types：   ＃1 Yのトラバース可能な値 
            p_y = self.y_types_proba [Y]   ＃1 のY P（Y = CK）を算出する先験的確率 
            。p_xy = 1 用 IDX、X に列挙（X_new）：
                p_xy * = self.x_types_proba [（IDX、X、Y）]   ＃はP（X =（X1、X2計算 、... XD）/ Yは、CK =）を
            
            res.append（p_y * p_xy）
         用 I で：範囲（LEN（self.y_types））
             プリント（" [{}]対応する確率：2％} {：" .format（self.y_types [I]、RES [I]））
        ＃は対応する最大事後確率値yを返す
        リターン self.y_typesを[np.argmax（RES）]

DEF メイン（）：
    X_train = np.array（[ 
                      [ 1、" S " ]、
                      [ 1、" M " ]、
                      [ 1、" M " ]、
                      [ 1、" S " ]、
                      [ 1、" S " ]、
                      [ 2、" S " ]、
                      [ 2、" M "]、
                      [ 2、" M " ]、
                      [ 2、" L " ]、
                      [ 2、" L " ]、
                      [ 3、" L " ]、
                      [ 3、" M " ]、
                      [ 3、" M " ]、
                      [ 3、" L " ]、
                      [ 3、"ザ・" ] 
                      ]）
    y_train = np.array（[ - 1、-1,1,1、-1、-1、-1,1,1,1,1,1,1,1、-1 ]）
    CLF = NaiveBayes（lambda_ = 0.2 ）
    clf.fit（X_train、y_train）
    X_new = np.array（[2、' S ' ]）
    y_predict = clf.predict（X_new）
     プリント（" {}被分类为：{} " .format （X_new、y_predict））
    
であれば __name__ == ' __main__ ' ：
    main（）の

 

2ナイーブベイズsklearnを達成します

インポートNPとしてnumpyの
 から sklearn.naive_bayesはインポートGaussianNB、BernoulliNB、MultinomialNBを
 から sklearnのインポート前処理   ＃预处理

DEF メイン（）：
    X_train = np.array（[ 
                      [ 1、" S " ]、
                      [ 1、" M " ]、
                      [ 1、" M " ]、
                      [ 1、" S " ]、
                      [ 1、" S " ]、
                      [ 2、" S " ]、
                      [ 2、" M "]、
                      [ 2、" M " ]、
                      [ 2、" L " ]、
                      [ 2、" L " ]、
                      [ 3、" L " ]、
                      [ 3、" M " ]、
                      [ 3、" M " ]、
                      [ 3、" L " ]、
                      [ 3、"ザ・" ] 
                      ]）
    y_train = np.array（[ - 1、-1,1,1、-1、-1、-1,1,1,1,1,1,1,1、-1 ]）
    ENC = preprocessing.OneHotEncoder（カテゴリ= ' 自動' ）
    enc.fit（X_train）
    X_train = enc.transform（X_train）.toarray（）
     プリント（X_train）
    CLF = MultinomialNB（アルファ= 0.0000001 ）
    clf.fit（X_train、y_train）
    X_new = np.array（[[2 ' S ' ]]）
    X_new = enc.transform（X_new）.toarray（）
    y_predict = clf.predict（X_new）
    印刷（" ------------------------------------ " ）
     プリント（「{}被分类为。 {} " .format（X_new、y_predict））
     プリント（clf.predict_proba（X_new））
    
なら __name__ == ' __main__ ' ：
    メイン（）

参考：

統計的学習方法トレーニングキャンプ放課後の練習の[1]眼の深さ

[2]「統計的学習法」リーハング