java贝叶斯分类器 开源_贝叶斯分类器

app.js

//贝叶斯分类器

//特征字典：一些词语数组(改成了特征函数)，定义生产特征

//类别的训练集：找出特征在类别中的概率

//->产出概率矩阵

//特征组合全展开,找出特征相同，概率最大的列表

//生产特征组合字典，做判断

const fs=require('fs');

function getText(filepath){

return fs.readFileSync(filepath).toString();

}

const makeFeatures=require('./makeFeatures')

const {tagNames,getTagIndex,getAllP}=require('./config')

const html=getText('./src/tag2/2.txt')

const nfeature=makeFeatures({html});

// console.log(getAllP(nfeature));

const index=getTagIndex(nfeature);

console.log(tagNames[index],index,tagNames);

特征函数 makeFeatures.js

//贝叶斯分类器//特征字典：一些词语数组//类别的训练集：找出特征在类别中的概率//->产出概率矩阵//特征组合全展开,找出特征相同，概率最大的列表//生产特征组合字典，做判断

const locals={};

const funcArr=[function({html,locals}) {if(html.indexOf('垃圾')>-1){return '1'}return '0'},function({html,locals}) {if(html.indexOf('食品')>-1){return '1'}return '0'},function({html,locals}) {if(html.indexOf('商品')>-1){return '1'}return '0'}

];

const crypto= require('crypto');

const cryptoPassFunc= function(password) {

const md5= crypto.createHash('md5');return md5.update(password).digest('hex');

};

locals.md5Cache={}//生产特征

functionmakeFeatures({html}) {

const md5=cryptoPassFunc(html)if(!locals.md5Cache[md5]){

const req={

locals:locals,

html:html,

};

let s='';for(let i=0;i

s=s+funcArr[i](req);

}

locals.md5Cache[md5]=s;

}returnlocals.md5Cache[md5];

}

module.exports=makeFeatures;

配置文件，定义了分类名称、训练集位置 config.js

//贝叶斯分类器//特征字典：一些词语数组//类别的训练集：找出特征在类别中的概率//->产出概率矩阵//特征组合全展开,找出特征相同，概率最大的列表//生产特征组合字典，做判断

const glob=require('glob');

const Bayes=require('./utils/Bayes');functiongetMaxIndex(arr) {

let index=0;for(let i=1;i

index=i;

}

}returnindex;

}

const tagNames=glob.sync('./src/*/').map(function(path) {return path.replace(/\.\/src\/(.+)?\//,'$1')

})

const tagArr=[glob.sync("./src/tag1/*"),glob.sync("./src/tag2/*"),glob.sync("./src/tag3/*")]//发生事件map表

const rect=Bayes.getFeaPosRect(tagArr)//console.log(rect);

const featureMap={}functiongetAllP(feature) {if(!featureMap[feature]){

featureMap[feature]=Bayes.getAllP(feature,rect)

}returnfeatureMap[feature];

}functiongetTagIndex(feature) {returngetMaxIndex(getAllP(feature));

}

module.exports={

getAllP,

getTagIndex,

tagNames,

};

入口工具，存在了bayes公式相关运算 utils/Bayes.js

//贝叶斯分类器

//特征字典：一些词语数组

//类别的训练集：找出特征在类别中的概率

//->产出概率矩阵

//特征组合全展开,找出特征相同，概率最大的列表

//生产特征组合字典，做判断

const getFeaPosRect=require('./getFeaPosRect');

const execMathExpress=require('./execMathExpress');

//特征n存在，属于类别m的概率

function getPSW(n,m,rect) {

const PWS=rect[m][n];

const PWSArr=rect.map(function (arr) {

return arr[n];

})

const str=`${PWS}/(${PWSArr.join('+')})`;

return execMathExpress(str)

}

//联合SW1*SWn

function getPE(feature,m,rect){

const arr=[]

for(let i =0;i

if(feature[i]=='1'){

const PSW=getPSW(i,m,rect)

arr.push(PSW)

}

}

return execMathExpress(arr.join('*'))

}

//获取全概率 p1*pn

function getPEN(feature,rect){

const arr=[]

for(let i=0;i

arr.push(getPE(feature,i,rect))

}

const str=`${arr.join('+')}`;

return execMathExpress(str)

}

//特征feature属于类别m的概率

function getP(feature,m,rect){

const arr=[]

for(let i=0;i

arr.push(getPE(feature,i,rect))

}

const pE=getPE(feature,m,rect);

const pEN=getPEN(feature,rect);

return execMathExpress(`(${pE})/(${pEN})`)

}

//特征feature属于所有类别的概率

function getAllP(feature,rect) {

const arr=[];

for(let i=0;i

arr.push(getP(feature,i,rect))

}

return arr;

}

module.exports={

getFeaPosRect:getFeaPosRect,

getAllP:getAllP,

}

每个文件都有特征，将特征组合成矩阵

//贝叶斯分类器//特征字典：一些词语数组//类别的训练集：找出特征在类别中的概率//->产出概率矩阵//特征组合全展开,找出特征相同，概率最大的列表//生产特征组合字典，做判断

const fs=require('fs');functiongetText(filepath){returnfs.readFileSync(filepath).toString();

}

const makeFeatures=require('../makeFeatures');functionmakeFeatureRect(fileArr) {

const rect=[]for(let i=0;i

const html=getText(fileArr[i])

const feature=makeFeatures({html})

rect.push(feature)

}returnrect;

}

module.exports=makeFeatureRect;

单个特征存在的情况，属于类别的概率，getFeaPosInTag.js

//贝叶斯分类器//特征字典：一些词语数组//类别的训练集：找出特征在类别中的概率//->产出概率矩阵//特征组合全展开,找出特征相同，概率最大的列表//生产特征组合字典，做判断

const makeFeatureRect=require('./makeFeatureRect')//找出特征在类别中的概率

functiongetFeaPosInTag(fileArr) {

const featureRect=makeFeatureRect(fileArr);

const arr=[];for(let i=0;i

let num=0;

const den=featureRect.length;for(let j=0;j

num++;

}

}

arr.push(num+'/'+den);

}returnarr;

}

module.exports=getFeaPosInTag;

找出每个特征存在时，每个类别的概率，getFeaPosRect.js

//贝叶斯分类器//特征字典：一些词语数组//类别的训练集：找出特征在类别中的概率//->产出概率矩阵//特征组合全展开,找出特征相同，概率最大的列表//生产特征组合字典，做判断

const getFeaPosInTag=require('./getFeaPosInTag')//找出特征在类别中的概率，多个类别

functiongetFeaPosRect(tagArr) {

const rect=[]for(let i=0;i

rect.push(getFeaPosInTag(tagArr[i]))

}returnrect;

}

module.exports=getFeaPosRect;