简单实现朴素贝叶斯分类

最新推荐文章于 2022-08-26 12:44:38 发布
最新推荐文章于 2022-08-26 12:44:38 发布
阅读量177 收藏
点赞数 2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41663744/article/details/81532574
版权

package pusu;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.Reader;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Scanner;

import org.apdplat.word.WordSegmenter;
import org.apdplat.word.segmentation.Word;

 public class boss {
    static ArrayList<String> pe_term=new ArrayList<>();//记录从文件中出来的词项
    static ArrayList<String> hs_term=new ArrayList<>();
    static ArrayList<String> term = new ArrayList<String>();//库词项
    static ArrayList<forterm> aimToFile=new ArrayList<forterm>();
    static ArrayList<selecte_term> slt_term=new ArrayList<selecte_term>();
    public static void main(String[] args) throws IOException {
        int a=pe_readfile();
        int b=hs_readfile();
        System.out.println("文档集有： "+(a+b)+" 个");
         all_term(term);
//         System.out.println("all_term");
         removeSameElement(term);
//         System.out.println("removeSameElement");
         removeStopElement(term);
//         System.out.println("removeStopElement");
         statistic();
//         System.out.println("statistic");
         getPe_peprior_probability();
//         System.out.println("getPe_peprior_probability");
         precision(term,aimToFile);
         save();
         System.out.println("save");
         //selecte();
    }

    //******************************将体育所有文档中词项提出来    
    public static int  pe_readfile() throws IOException{
        
        File[] file=new File("tiyu").listFiles();
        for(int i=0;i<file.length;i++)
        {
            String temp=null;
            BufferedReader pe_file=new BufferedReader(new FileReader(file[i].getAbsolutePath())); 
            while((temp = pe_file.readLine()) != null) {
                pe_term.add(temp);
            }
            pe_file.close();
        }
        return (file.length);
    }
//******************************将历史所有文档中词项提出来    
    public static int  hs_readfile() throws IOException{
        File[] file=new File("lishi").listFiles();
        for(int i=0;i<file.length;i++)
        {
            String temp=null;
            BufferedReader hs_file=new BufferedReader(new FileReader(file[i].getAbsolutePath())); 
            while((temp = hs_file.readLine()) != null) {
                hs_term.add(temp);
            }
            hs_file.close();
        }
        return (file.length);
    }
//将所有词项合并在一个词项库中
    public static void all_term(ArrayList<String> term) {
        for(int i = 0; i < pe_term.size(); i++) {
            term.add(pe_term.get(i));
        }
        for(int i = 0; i < hs_term.size(); i++) {
            term.add(hs_term.get(i));
        }
    }
//*************************************将词项中重复的删掉
     public static ArrayList<String> removeSameElement(ArrayList<String> term){
         ArrayList<String> temp = new ArrayList<>();
         Iterator it = term.iterator();
         while(it.hasNext()) {
         Object o = (Object)it.next();
         if(!temp.contains(o))
         temp.add((String)o);
         }
         return temp;
     }
//**************************************去掉停用词
     public static ArrayList<String> removeStopElement(ArrayList<String> term) throws IOException{
         ArrayList<String> SW=new ArrayList<>();
         File file_WD=new File("停用词表.txt");
         Scanner file3=new Scanner(file_WD);
         while(file3.hasNextLine()){
                SW.add(file3.nextLine());
            }
         ArrayList<String> temp = new ArrayList<>();
         for(int i=0;i<term.size();i++) {
             if(term.get(i).compareTo("0")!=0)
             {
                 Object o = (Object)term.get(i);
                 temp.add((String)o);
             }
         }
         return temp;
     }
//********************************计算先验概率
    public static double[] getPe_peprior_probability() throws IOException {
        int pe_file_num=pe_readfile();
        int hs_file_num=hs_readfile();
        double[] peprior_probability= {(double)pe_file_num/(hs_file_num+pe_file_num),(double)hs_file_num/(hs_file_num+pe_file_num)};
        System.out.println("历史的先验概率  ："+peprior_probability[0]);
        System.out.println("体育的先验概率  ："+peprior_probability[1]);
        return peprior_probability;
    }
 
//********************************统计计算
    public static void statistic() {
        int[] pe_count=new int[term.size()];
        int[] hs_count=new int[term.size()];
        double[] pe_frequence=new double[term.size()];
        double[] hs_frequence=new double[term.size()];
        for(int i=0;i<term.size();i++){   //初始化
            pe_count[i]=1;
            hs_count[i]=1;
        }
        //计算词出现的次数
        for(int i=0;i<term.size();i++)
            for(int j=0;j<pe_term.size();j++)
                if(pe_term.get(j).compareTo(term.get(i))==0) 
                    pe_count[i]++;
        for(int i=0;i<term.size();i++)
            for(int j=0;j<hs_term.size();j++)
                if(hs_term.get(j).compareTo(term.get(i))==0) 
                    hs_count[i]++;
        //计算频率
        int sum1=0,sum2=0;
        for(int i=0;i<term.size();i++){
            sum1+=pe_count[i];
            sum2+=hs_count[i];
        }
        for(int i=0;i<term.size();i++){
            pe_frequence[i]=(double)pe_count[i]/sum1;
            hs_frequence[i]=(double)hs_count[i]/sum2;
        }
        for(int i=0;i<term.size();i++){
            forterm o=new forterm();
            o.setE_term(term.get(i));
            o.setPe_num(pe_count[i]);
            o.setHs_num(hs_count[i]);
            o.setPe_frequence(pe_frequence[i]);
            o.setHs_frequence(hs_frequence[i]);
            //all_count++;
            aimToFile.add(o);
        }
    }
//***************************************计算正确率、召回率
    public static void precision(ArrayList<String> term,ArrayList<forterm> aimToFile) throws IOException {
        ArrayList<ArrayList<String>> PE=new ArrayList<ArrayList<String>>();
        ArrayList<ArrayList<String>> HS=new ArrayList<ArrayList<String>>();
        double[] pro=new double[2];
        pro=getPe_peprior_probability();
        
        File[] pe_file=new File("测试体育").listFiles();
        for(int i=0;i<pe_file.length;i++)
        {
            ArrayList<String> pe_term = new ArrayList<String>();
            File txt_file=new File("测试体育" + "/" + pe_file[i].getName());
            if (!txt_file.exists()) {
                System.out.println("wrong");
            }
                Scanner file2=new Scanner(pe_file[i]); 
                while(file2.hasNextLine()) {
                    pe_term.add(file2.nextLine());
                }
                PE.add(pe_term);
                file2.close();
        }
        
        File[] hs_file=new File("测试历史").listFiles();
        for(int i=0;i<hs_file.length;i++)
        {
            ArrayList<String>hs_term = new ArrayList<String>();
            File txt_file=new File("测试历史" + "/" + hs_file[i].getName());
                Scanner file1=new Scanner(hs_file[i]); 
                while(file1.hasNextLine()) {
                    hs_term.add(file1.nextLine());
                    
                }
                HS.add(hs_term);
                file1.close();
        }
        int computer_pe=0;
        int computer_hs=0;
        int real_pe=0;
        int real_hs=0;
        int all_pefile=PE.size();
        int all_hsfile=HS.size();
        for(int i=0;i<PE.size();i++) {
            double pe_frequence=0;
            double hs_frequence=0;
            for(int j=0;j<PE.get(i).size();j++) {
                for(int k=0;k<term.size();k++) {
                    if(PE.get(i).get(j).compareTo(aimToFile.get(k).getE_term())==0){
                        pe_frequence+=Math.log(aimToFile.get(k).getPe_frequence());
                        hs_frequence+=Math.log(aimToFile.get(k).getHs_frequence());
                    }
                }
            }
//            每一个文档即刻判断
//            pe_frequence=pe_frequence*();
//            hs_frequence=hs_frequence*(o.getHs_peprior_probability());
            if(pe_frequence>hs_frequence) {
                computer_pe++;//计算机判断出来体育多少个
                real_pe++;
            }
            if(pe_frequence<hs_frequence) {//计算机判断出来体育多少个
                computer_hs++;
            }
            
        }
        for(int i=0;i<HS.size();i++) {
            double pe_frequence=0;
            double hs_frequence=0;
            for(int j=0;j<HS.get(i).size();j++) {
                for(int k=0;k<term.size();k++) {
                    if(HS.get(i).get(j).compareTo(aimToFile.get(k).getE_term())==0){
                        pe_frequence+=Math.log(aimToFile.get(k).getPe_frequence());
                        hs_frequence+=Math.log(aimToFile.get(k).getHs_frequence());
                    }
                }
            }
            //每一个文档即刻判断
//            pe_frequence=pe_frequence*(o.getPe_peprior_probability());
//            hs_frequence=hs_frequence*(o.getHs_peprior_probability());
            if(pe_frequence>hs_frequence) {
                computer_pe++;//计算机判断出来体育多少个
            }
            if(pe_frequence<hs_frequence) {//计算机判断出来体育多少个
                computer_hs++;
                real_hs++;
            }
        }
        System.out.println("体育正确率   ："+(double)real_pe/computer_pe);
        System.out.println("历史正确率   : "+(double)real_hs/computer_hs);
        System.out.println("体育召回率   ："+(double)real_pe/all_pefile);
        System.out.println("历史召回率  : "+(double)real_hs/all_hsfile);
    }
//**************************************将词项存到文档中去
    public static void save() throws IOException {
            File save=new File("allterm(1).txt");
        PrintWriter file=new PrintWriter(save);
        for(int i=0;i<aimToFile.size();i++){
            file.printf("%s   %d   %d   %.6f   %.6f",aimToFile.get(i).getE_term(),aimToFile.get(i).getPe_num(),aimToFile.get(i).getHs_num(),aimToFile.get(i).getPe_frequence(),aimToFile.get(i).getHs_frequence());
            file.println();
            if(i==aimToFile.size()-1) {
                file.printf("%s   %d   %d   %.6f   %.6f",aimToFile.get(i).getE_term(),aimToFile.get(i).getPe_num(),aimToFile.get(i).getHs_num(),aimToFile.get(i).getPe_frequence(),aimToFile.get(i).getHs_frequence());
            }
        }
        file.close();
    }
    
    public static void start_term(ArrayList<String> term) {
        for(int i=0;i<term.size();i++) {
            selecte_term o=new selecte_term(term.get(i));//存入，并且初始化
            slt_term.add(o);
        }
    }
    public static void selecte() throws IOException {
        start_term(term);//调用此函数
        File[] file1=new File("tiyu").listFiles();
        File[] file2=new File("lishi").listFiles();
        for(int i=0;i<slt_term.size();i++) {//每一个词遍历整个学习文档集
            for(int j=0;j<file1.length;j++)
            {
                String temp=null;
                BufferedReader pe_file=new BufferedReader(new FileReader(file1[j].getAbsolutePath())); 
                ArrayList<String> everyterm=new ArrayList<String>();
                while((temp = pe_file.readLine()) != null) {
                    everyterm.add(temp);
                }
                pe_file.close();
                
                for(int k=0;k<everyterm.size();k++) {
                             //如果这个词在这个01的文档中，并且这个文档属于体育类
                            if(slt_term.get(i).get_name().compareTo(everyterm.get(k))==0) {
                                slt_term.get(i).add_N11();
                            }
                            //这个词不在01这个文档中，但是这个文档属于类别体育
                            else if(slt_term.get(i).get_name().compareTo(everyterm.get(k))!=0){
                                slt_term.get(i).add_N01();
                            }    
                }
                            
            }
            for(int j=0;j<file2.length;j++)
            {
                String temp=null;
                BufferedReader hs_file=new BufferedReader(new FileReader(file2[j].getAbsolutePath())); 
                ArrayList<String> everyterm=new ArrayList<String>();
                while((temp = hs_file.readLine()) != null) {
                    everyterm.add(temp);
                }
                hs_file.close();
                
                for(int k=0;k<everyterm.size();k++) {
                             //如果这个词在这个01的文档中，并且这个文档不属于体育类
                            if(slt_term.get(i).get_name().compareTo(everyterm.get(k))==0) {
                                slt_term.get(i).add_N10();
                            }
                            //这个词不在01这个文档中，但是这个文档不属于类别体育
                            else if(slt_term.get(i).get_name().compareTo(everyterm.get(k))!=0){
                                slt_term.get(i).add_N00();
                            }    
                }
                            
            }
                
                
        }
        //套用公式:
        double[] c=new double[slt_term.size()];//每个词的MI值
        for(int i=0;i<slt_term.size();i++) {
            
            File save=new File("selecte_term.txt");
            PrintWriter file=new PrintWriter(save);
            int N,N1,N0,N00,N01,N10,N11;
            N00=slt_term.get(i).get_N00();
            N01=slt_term.get(i).get_N01();
            N10=slt_term.get(i).get_N10();
            N11=slt_term.get(i).get_N11();
            N=N00+N01+N10+N11;
            N1=N10+N11;
            N0=N00+N01;
            c[i]=(N11/N)*Log2((N*N11)/(N1*N1))+(N01/N)*Log2((N*N01)/(N0*N1))+(N10/N)*Log2((N*N10)/(N1*N0))+(N00/N)*Log2((N*N00)/(N0*N0));
            slt_term.get(i).setC(c[i]);
            if(i!=(slt_term.size()-1)) {
            file.printf("%s   %.6f",slt_term.get(i).get_name(),slt_term.get(i).getC());
            file.println();
        }
        file.printf("%s   %.6f",slt_term.get(i).get_name(),slt_term.get(i).getC());
        }
        
    }
    public static double Log2(double a) {
        return Math.log(a)/Math.log(2.0);
    }

}
 
class forterm{
    private String e_term;//不允许用户修改 只能读取文件之后修改
    private int pe_num;
    private int hs_num;
    private double pe_frequence;
    private double hs_frequence;
    public String getE_term() {
        return e_term;
    }
    public void setE_term(String e_term) {
        this.e_term = e_term;
    }
    public int getPe_num() {
        return pe_num;
    }
    public void setPe_num(int pe_num) {
        this.pe_num = pe_num;
    }
    public int getHs_num() {
        return hs_num;
    }
    public void setHs_num(int hs_num) {
        this.hs_num = hs_num;
    }
    public double getPe_frequence() {
        return pe_frequence;
    }
    public void setPe_frequence(double pe_frequence) {
        this.pe_frequence = pe_frequence;
    }
    public double getHs_frequence() {
        return hs_frequence;
    }
    public void setHs_frequence(double hs_frequence) {
        this.hs_frequence = hs_frequence;
    }
}
class selecte_term implements Comparable<selecte_term>{
    private String name;
    private int N00=1;
    private int N01=1;
    private int N10=1;
    private int N11=1;
    private double c;
    selecte_term(String name){
        this.name=name;
        this.N00=1;
        this.N01=1;
        this.N10=1;
        this.N11=1;
    }
    public void set_name(String name) {
        this.name=name;
    }
    public String get_name() {
        return name;
    }
    public void add_N00() {
        N00++;
    }
    public int get_N00() {
        return N00;
    }
    public void add_N01() {
        N01++;
    }
    public int get_N01() {
        return N01;
    }
    public void add_N10() {
        N10++;
    }
    public int get_N10() {
        return N10;
    }
    public void add_N11() {
        N11++;
    }
    public double getC() {
        return c;
    }
    public void setC(double c) {
        this.c = c;
    }
    public int get_N11() {
        return N11;
    }
    @Override
    public int compareTo(selecte_term o) {
        // TODO Auto-generated method stub
        return 0;
    }
    
}

12345小白
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
C++实现朴素贝叶斯分类器(加强版)
09-14
《C++实现朴素贝叶斯分类器的强化实践》 朴素贝叶斯分类器是一种基于概率理论的机器学习算法，其基本思想是假设各个特征之间相互独立，并利用贝叶斯定理来预测未知数据的类别。在C++环境中实现朴素贝叶斯分类器，...
小白之通俗易懂的贝叶斯定理
cjl的博客
08-10 4411
小白之通俗易懂的贝叶斯定理贝叶斯定理的产生以及意义什么是贝叶斯定理？贝叶斯定理的应用案例贝叶斯定理套路生活中的贝叶斯思维 转载自：https://mp.weixin.qq.com/s/lR3eeSWYHJDAJ9kJUzXc7w 贝叶斯定理的产生以及意义 1、贝叶斯定理的产生来源 英国数学家托马斯·贝叶斯（Thomas Bayes）在1763年发表的一篇论文中，首先提出了这个定理。而这篇论文是在他死后才由他的一位朋友发表出来的。在这篇论文中，他为了解决一个“逆向概率”问题，而提出了贝叶斯定理。 在贝叶斯写
贝叶斯简单介绍
iownlucky的博客
07-26 2155
贝叶斯决策论 贝叶斯决策轮是基于贝叶斯理论的决策方法。先来说一下贝叶斯公式。 如果先验概率给出，并且知道了条件概率，那么就可以通过贝叶斯公式求出后验概率。并根据这个概率得到一个最优决策，谓之贝叶斯决策。 如果先验概率P（0），P(1)已知，条件概率P(x|1）和P(x|0)也已知，可以计算得到无条件概率：P(x)=P(0)P(x|0)+P(1)P(x|1)；后验概率P（0|x)= P(0)P(x|0)/P(x)，P(1|x)=P(1)P(X|1)/P(x)，如果P(0|x)>P(1|x)，判决为0，
机器学习实战--基于概率论的分类方法：朴素贝叶斯
aaaaPIKACHU的博客
02-17 829
朴素贝叶斯分类器原理+实战
朴素贝叶斯分类算法简单实例
热门推荐
signal___的博客
08-18 1万+
贝叶斯分类是一类分类算法的总称，这类算法均以贝叶斯定理为基础，故统称为贝叶斯分类。而朴素朴素贝叶斯分类是贝叶斯分类中最简单，也是常见的一种分类方法。这篇文章我尽可能用直白的话语总结一下我们学习会上讲到的朴素贝叶斯分类算法，希望有利于他人理解。 1 分类问题综述 对于分类问题，其实谁都不会陌生，日常生活中我们每天都进行着分类过程。例如，当你看到一个人，你的脑子下意识判断他是学生还是社会上的人；你可能经常会走在路上对身旁的朋友说“这个人一看就很有钱”之类的话，其实这就是一种分类操作。 ..
简单说说贝叶斯定理
谷雨的博客
10-15 1620
在引出贝叶斯定理之前，先学习几个定义： 条件概率（又称后验概率）就是事件A在另外一个事件B已经发生条件下的发生概率。条件概率表示为P(A|B)，读作“在B条件下A的概率”。 比如，在同一个样本空间Ω中的事件或者子集A与B，如果随机从Ω中选出的一个元素属于B，那么这个随机选择的元素还属于A的概率就定义为在B的前提下A的条件概率，所以：P(A|B) = |A∩B|/|B|，接着分子、分母都除以|Ω|得到 联合概率表示两个事件共同发生的概率。A与B的联合概率表示为或者。 边缘概率（又称先验概率）是某个事件发生的概
python实现朴素贝叶斯分类器
09-20
在Python中，我们可以利用scikit-learn库来实现朴素贝叶斯分类。在这个实例中，我们将探讨如何用Python编写一个朴素贝叶斯分类器，并用scikit-learn的iris数据集进行测试。 首先，我们需要导入必要的库，如numpy和...
MATLAB实现朴素贝叶斯分类对手葡萄酒数据集进行分类
10-19
本篇文章将深入探讨如何使用MATLAB来实现朴素贝叶斯分类，并以手葡萄酒数据集为例，展示具体的步骤。 首先，我们要了解朴素贝叶斯的基本原理。朴素贝叶斯假设各个特征之间相互独立，并且基于贝叶斯定理来计算一个...
Python实现的朴素贝叶斯分类器示例
09-20
在Python中，我们可以使用各种库，如sklearn，来实现朴素贝叶斯分类器，但在这个示例中，我们将讨论如何自定义一个朴素贝叶斯分类器。 首先，这个Python实现的朴素贝叶斯分类器（NBClassify）类包含了初始化方法`__...
朴素贝叶斯分类算法原理与Python实现与使用方法案例
09-20
朴素贝叶斯分类算法是一种基于概率的机器学习方法，它基于贝叶斯定理和特征条件独立假设。...在Python中，可以使用诸如`sklearn`库中的`GaussianNB`、`MultinomialNB`和`BernoulliNB`等模块来实现朴素贝叶斯分类。
朴素贝叶斯matlab简单实现
12-02
用matlab实现的朴素贝叶斯分类器，比较简单，有助于理解朴素贝叶斯。代码直接可用。
Python-一个实现朴素贝叶斯分类器简单的Python库
08-11
一个实现朴素贝叶斯分类器简单的Python 库
简单易懂的贝叶斯公式
hys_20151228的博客
10-11 1596
关于贝叶斯公式相信大家都不陌生，也经常能在网上看到关于它的介绍，但大多都专业性太强了，一些专业名称解释不够通俗易懂，所以想写一篇简单易懂的博文跟大家分享一下，我对贝叶斯的理解，希望大家能指点一下。 我们先看看关于贝叶斯公式：      （1） 其中P(A|B)是在B发生的情况下A发生的可能性。  为完备事件组，即   由于A1,….An是一个完备事件，所以公式的分母的等于P(B)。 举...
通俗简单讲解贝叶斯原理，并python实现贝叶斯分类代码
07-22 2885
1. 前言 贝叶斯原理相信大家都非常熟悉了，但是一般情况下，我们的数学水平不怎么地，学生的数学基础也不怎么地，所以要想给学生简单明了的讲明白，还不是一件容易的事情。 为此，在备课（为河南中医药大学python程序设计）时候，做了充分的准备，争取用通俗易懂的方法尽量的少用公式，给大家讲明白贝叶斯原理的过程，并编程使用贝叶斯算法进行分类。 2. 目标 ...
朴素贝叶斯实现分类_关于朴素贝叶斯分类及其实现的简短教程
weixin_26746401的博客
09-06 573
朴素贝叶斯实现分类Naive Bayes classification is one of the most simple and popular algorithms in data mining or machine learning (Listed in the top 10 popular algorithms by CRC Press Reference [1]). The basic ...
机器学习之朴素贝叶斯方法（Naive Bayes)原理和实现
永远飞翔的鸟
01-14 6192
目录 一、贝叶斯理论 二、实战朴素贝叶斯 实战朴素贝叶斯1 实战朴素贝叶斯3 三、scikit-learn中朴素贝叶斯的分类算法的适用 四、贝叶斯算法的优缺点 一、贝叶斯理论 贝叶斯模型 现在我们来看一下怎么操作。假设我有m个样本数据： 这大大的简化了n维条件概率分布的难度，虽然很粗暴，但是很给力。 二、实战朴素贝叶斯 实战朴素贝叶斯1 ......
朴素贝叶斯简单实现
wwqnmdhmp的博客
08-26 123
朴素贝叶斯
简单示例理解朴素贝叶斯算法，通俗易懂
weixin_42108215的博客
09-10 5818
一个简单的例子 让我们看一下这个例子在实践中如何运作。假设我们正在建立一个分类器，说明文本是否涉及体育运动。我们的训练集有5句话： Text Category A great game（一个伟大的比赛） Sports（体育运动） The election was over（选举结束） ...
python实现朴素贝叶斯分类
最新发布
05-30
下面是一个简单的 Python 实现朴素贝叶斯分类的示例代码： ```python import numpy as np class NaiveBayesClassifier: def __init__(self, alpha=1.0): self.alpha = alpha # 平滑参数，避免零概率问题 self....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值