滥用职权的词：以权谋私、徇私舞弊、徇私枉法。
滥用职权，是指不法行使职务上的权限的行为，即就形式上属于国家机关工作人员一般职务权限的事项，以不当目的或者以不法方法，实施违反职务行为宗旨的活动。首先，滥用职权应是滥用国家机关工作人员的一般职务权限，如果行为人实施的行为与其一般的职务权限没有任何关系，则不展于滥用职权。
其次，行为人或者是以不当目的实施职务行为或者是以不法方法实施职务行为；在出于不当目的实施职务行为的情况下，即使从行为的方法上看没有超越职权，也属于滥用职权。最后，滥用职权的行为违反了职务行为的宗旨，或者说与其职务行为的宗旨相悖。
滥用职权罪顾名思义就是指国家机关工作人员利用职务便利，损害国家、集体或第三人利益的犯罪。这是一种特殊主体的犯罪，而我国也制定的有相关的司法解释。下面，我们一起来看看滥用职权罪司法解释都有什么内容。
最高人民检察院关于人民检察院直接受理立案侦查案件立案标准的规定(试行)(1999.9.9 高检发释字[1999]2号)二、渎职犯罪案件(一)滥用职权案(第397条)(二)滥用职权罪是指国家机关工作人员超越职权，违法决定、处理其无权决定、处理的事项，或者违反规定处理公务，致使公共财产、国家和人民利益遭受重大损失的行为。
涉嫌下列情形之一的，应予立案：
1、造成死亡人以上，或者重伤2人以上，或者轻伤5人以上的;
2、造成直接经济损失20万元以上的;
3、造成有关公司、企业等单位停产、严重亏损、破产的;
4、严重损害国家声誉，或者赞成恶劣社会影响的;
5、其他致使公共财产、国家和人民利益遭受重大损失的情形;
6、徇私舞弊，具有上述情形之一的。
一、本罪是指国家机关工作人员滥用职权，致使公共财产、国家和人民利益遭受重大
损失的行为。
二、本罪的犯罪主体只能是国家机关工作人员。本罪的主观方面是故意。本罪的客观方面，表现为滥用职权，致使公共财产、国家和人民利益遭受重大损失的行为。
三、本罪是刑法增设的新罪名。目前尚无司法解释。
四、按最高人民法院关于罪名的司法解释，“徇私舞弊罪”已经取消，分解到后面的各个新罪名中。本条第二款，只作为一个加重量刑的情节考虑。但最高人民检察院1997年12月关于适用刑法分则规定的犯罪的罪名的意见，保留了这一罪名。现在按最高人民法院的罪名 体系，不保留。但最高人民检察院以前对询私舞弊犯罪的司法解释,对理解此情节仍有参考作用，故附录于此，在后面各罪中不再重复引用。
附：最高人民检察院关于办理询私舞弊犯罪案件适用法律若干问回的解释(1996.5 16 高检发研字〔1996〕4号)
为维护社会主义法制，促进严格执法，惩治腐败，依法严惩拘私舞弊犯罪，根据中华人民共和国刑法和其他法律的有关规定，现就办理拘私舞弊犯罪案件适用法律的若干问题解释如下：
一、司法工作人员，即依法具有侦讯、检察、审判和监管人犯职务的人员为贪图钱财、袒护亲友、泄愤报复或者其他私情私利，具有下列行为之一的，应当依照刑法第一百八十八条的规定追究刑事责任：
(一)对明知是无罪的人，即没有实施危害社会行为，或者根据刑法第十条规定，情节显著轻微，危害不大，不认为是犯罪以及其他依照刑法规定不负刑事责任的人，采取伪造、隐匿、毁灭证据或者其他隐瞒事实、违背法律的手段，以追究刑事责任为目的进行侦查(合采取强制性措施)、起诉、审判等追诉活动的;
(二)对明知是有罪的人，即有确凿事实证明其实施犯罪的人，采取伪造、隐匿、毁灭证据或者其他隐瞒事实、违背法律的手段，故意包庇使其不受侦查(合采取强制性措施)、起诉或者审判;故意包庇不使受追诉的犯罪事实，既可以是全部的犯罪事实，也可以是部分犯罪事实或情节;
(三)在审判刑事案件中故意违背事实和法律，枉法进行判决、裁定，使有罪判无罪、无罪判有罪或者重罪轻判、轻罪重判的;
(四)故意违背事实真相，违法变更强制措施，或者虽然采取强制措施，但实际放任不管，致使人犯逃避刑事追诉的;
(五)对依法不该减刑、假释、暂予监外执行的犯人，询私枉法,予以减刑、假释、暂予监外执行的;
(六)在审判民事、经济、行政等案件中，故意歪曲事实，违反法律、询私舞弊，枉法裁判的;
(七)司法机关专业技术人员在办案中故意提供虚假材料和意见，或者故意作虚假鉴定，严重影响刑事追诉活动的。
二、下列行为，依法应当依照或者比照刑法第一百八十八条的规定追究刑事责任：
(一)国家工作人员，无论是否司法工作人员，利用职务包庇、窝藏走私、套汇、投机倒把、重大盗窃、贩毒、受贿等犯罪分子，隐瞒、掩饰其犯罪事实的;
(二)对于走私、套汇、投机倒把、重大盗窃、贩毒、受贿和前项规定的犯罪人员，有追究责任的国家工作人员不依法处理的;
(三)有查禁卖淫、嫖娼活动职责的国家工作人员，为使犯罪分子逃避处罚，向其通风报信，提供便利的;
(四)国家工作人员利用职务，对明知有关于惩治假冒注册商标犯罪的补充规定所列犯罪行为的企业事业单位或者个人，故意包庇，使其不受追诉的;对上述补充规定所列犯罪负有追究责任的国家工作人员，不履行法律所规定的追究职责，应当比照刑法第一百八十八条规定追究刑事责任的;
(五)国家工作人员利用职务，对明知犯有关于惩治生产、销售伪劣商品犯罪的决定所列犯罪行为的企业事业单位或者个人故意包庇使其不受追诉的;负有追究责任的国家工作人员对具有上述决定所列犯罪行为的企业事业单位或者个人，不履行法律规定的追究职责，应当比照刑法第一百八十八条规定追究刑事责任的;
(六)专利局工作人员及有关国家工作人员(如专利管理工作人员)，询私舞弊，情节严重的;
(七)其他法律明确规定应当依照或者比照询私舞弊罪追究刑事责任的。
三、为牟取单位或小集体不当利益而实施第一、二条行为的，依法追究直接负责的主管人员和其他直接责任人员的刑事责任。
四、要严格掌握法律规定各种询私舞弊行为的构成条件和情节。 确定依法追究询私舞弊犯罪者的刑事责任，要综合考虑行为给国家、社会和人民利益造成的损失，给有关当事人的生命、人身、财产等方面的权益造成的损失，以及造成的政治影响等方面的情况。情节显著轻微、危害不大的，不应以拘私舞弊罪追究刑事责任。对于由于认识水平、工作能力而造成错案，不应以询私舞弊罪论处。由于隶属关系，不得不执行上级错误指令，造成错案，如果不具有询私舞弊的共同故意和行为，也不能以佝私舞弊罪追究刑事责任。
五、与司法工作人员或法律明确规定依照或比照刑法第一百八十八条规定追究刑事责任的人员勾结，伙同进行本解释所列犯罪行为，以共犯追究刑事责任。
六、犯拘私舞弊罪并有受贿、刑讯逼供等行为构成犯罪的，应当依法按数罪并罚原则追究刑事责任。
七、本解释发布后办理的拘私舞弊犯罪案件，按本解释办理。本解释发布前已按法律规定处理过的案件，不再变动。
寻衅滋事不是滥用权利。
不管有没有权利，素质低下道德败坏的人，都会犯寻衅滋事的错误，就是故意找别人的茬，惹是生非。
而滥用权利是指犯事之人手中有一定的权利，他才可以滥用，滥用的意思是他没有在权利规定范围之内行使职权，而是超出了权利范围给自己或他人谋取私利，从而触犯了法律。
虽然这两种行为都是违法犯罪行为，给他人造成损害，给社会造成不良影响，但本质上还是有所不同的。
一手遮天yī shǒu zhē tiān [释义] 一只手把天遮住。
形容依仗权势；玩弄手段；蒙蔽群众。[语出] 明·张岱《马士英、阮大铖传》：“弦光好酒喜肉；日导以荒淫；毫不省外事；而士英一手遮天；靡所不为矣。” [正音] 一；必须读作“yì”。[辨形] 手；不能写作“首”。[近义] 欺君罔世 瞒上欺下 横行霸道 [用法] 用作贬义。用于掌权人。一般作宾语、定语。[结构] 主谓式。[例句] 如今人民已当家做主；地主老财～的时代已一去不复返了。[英译] cover the sky with one hand
回答如下：案例一：某省市公安局原局长李某滥用职权案
李某曾任某省市公安局局长，在担任该职务期间，他利用职务之便，收受他人贿赂，违反规定为他人办理公务等。李某的行为已经构成了滥用职权罪。
根据我国刑法规定，滥用职权罪的追诉时效为10年。但是，由于李某在担任公安局局长期间，他的行为一直没有被发现和举报，直到他离职后才被揭发。因此，李某的滥用职权罪追诉时效应从罪行发现之日起计算，而不是从他离职之日起计算。最终，李某因滥用职权罪被判处有期徒刑10年。
案例二：某公司总经理张某滥用职权案
张某担任某公司总经理期间，滥用职权，利用公司的资源收受他人贿赂，违反规定为他人办理公务等。张某的行为已经构成了滥用职权罪。
根据我国刑法规定，滥用职权罪的追诉时效为10年。但是，由于张某的滥用职权行为被发现后，已经超过了10年的追诉时效。因此，张某的案件已经属于过失犯罪，不能再依法追究其刑事责任。
结论：
滥用职权罪的追诉时效一般为10年，但是在具体的案件中，追诉时效的计算方法会因情况而异。在案件发现后，应该及时采取措施，尽可能地保留证据，以便在追究刑事责任时能够有效地证明事实，避免因追诉时效问题导致犯罪嫌疑人逍遥法外。
滥用职权是行政行为违法的表现之一。行政机关的决定，虽然其权限范围以内，但不符合法律授予这种权力的目的。
行政机关不能自由地行使权力，法律授予行政机关权力是为了服务于公共利益的目的，以及某个更为具体、特定的目的，行使权力必须符合法律所规定的目的，否则即构成违法行为的权力滥用。
滥用权力是指行使职权过程中违反法律法规、违背公序良俗、损害人民群众合法权益等行为。滥用权力存在以下问题:
1. 侵害人民群众利益和权益，损害政府公信力;
2. 导致执法不公，破坏司法公正;
3. 阻碍公共资源的公正配置，损害社会公平正义;
4. 给政府形象带来负面影响，造成社会不满和不信任。
针对滥用权力的问题，需要采取以下措施:
1. 提高执法与司法的透明度、公正性和职业性，通过建设审判公开、执法公开和系统公开，促进公众对执法、司法和维权过程的监督和参与。
2. 加强行政监察和司法监督，建立健全以监察、审判、公检法合作为主的惩治滥用职权的机制，加强执法人员和司法人员的职业道德和专业素养培训。
3. 优化权力结构和权责关系，加强权力制约和监督，根据权力性质和范围，各司其职、相互独立，避免权力过度集中，造成滥用职权的机会和空间。
4. 健全权力问责机制，完善责任追究、纪律处分和法律救济等制度，使滥用职权者受到惩罚和警示，保护人民群众的合法权益和社会公共利益。
在许多公司中，领导拥有较高的权力和特权，他们应该充当榜样，保持公平和透明。然而，有些领导却滥用自己的职权，侵犯员工的隐私。其中一种常见的行为就是乱动别人的电脑。这种行为不仅侵犯了员工的个人隐私，还对工作环境和员工之间的信任关系产生了严重的负面影响。
公司领导乱动别人电脑的行为可以包括以下几个方面：
这种滥用行为会给员工和工作环境带来很多问题，包括：
为了解决公司领导滥用权力乱动别人电脑的问题，建议以下几点：
公司领导滥用权力乱动别人电脑的行为严重侵犯了员工的个人隐私和工作权益。为了维护一个健康的工作环境，公司应该加强法律的保护，加强员工教育和培训，建立有效的投诉渠道，并扎根道德和职业道德的基础。只有这样，才能构建一个公平、透明和信任的工作环境。
之前看了Mahout官方示例 20news 的调用实现；于是想根据示例的流程实现其他例子。网上看到了一个关于天气适不适合打羽毛球的例子。
训练数据：
Day Outlook Temperature Humidity Wind PlayTennis
D1 Sunny Hot High Weak No
D2 Sunny Hot High Strong No
D3 Overcast Hot High Weak Yes
D4 Rain Mild High Weak Yes
D5 Rain Cool Normal Weak Yes
D6 Rain Cool Normal Strong No
D7 Overcast Cool Normal Strong Yes
D8 Sunny Mild High Weak No
D9 Sunny Cool Normal Weak Yes
D10 Rain Mild Normal Weak Yes
D11 Sunny Mild Normal Strong Yes
D12 Overcast Mild High Strong Yes
D13 Overcast Hot Normal Weak Yes
D14 Rain Mild High Strong No
检测数据：
sunny，hot，high，weak
结果：
Yes=》 0.007039
No=》 0.027418
于是使用Java代码调用Mahout的工具类实现分类。
基本思想：
1. 构造分类数据。
2. 使用Mahout工具类进行训练，得到训练模型。
3。将要检测数据转换成vector数据。
4. 分类器对vector数据进行分类。
接下来贴下我的代码实现=》
1. 构造分类数据：
在hdfs主要创建一个文件夹路径 /zhoujainfeng/playtennis/input 并将分类文件夹 no 和 yes 的数据传到hdfs上面。
数据文件格式，如D1文件内容： Sunny Hot High Weak
2. 使用Mahout工具类进行训练，得到训练模型。
3。将要检测数据转换成vector数据。
4. 分类器对vector数据进行分类。
这三步，代码我就一次全贴出来；主要是两个类 PlayTennis1 和 BayesCheckData = =》
package myTesting.bayes;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.util.ToolRunner;
import org.apache.mahout.classifier.naivebayes.training.TrainNaiveBayesJob;
import org.apache.mahout.text.SequenceFilesFromDirectory;
import org.apache.mahout.vectorizer.SparseVectorsFromSequenceFiles;
public class PlayTennis1 {
private static final String WORK_DIR = "hdfs://192.168.9.72:9000/zhoujianfeng/playtennis";
/*
* 测试代码
*/
public static void main(String[] args) {
//将训练数据转换成 vector数据
makeTrainVector();
//产生训练模型
makeModel(false);
//测试检测数据
BayesCheckData.printResult();
}
public static void makeCheckVector(){
//将测试数据转换成序列化文件
try {
Configuration conf = new Configuration();
conf.addResource(new Path("/usr/local/hadoop/conf/core-site.xml"));
String input = WORK_DIR+Path.SEPARATOR+"testinput";
String output = WORK_DIR+Path.SEPARATOR+"tennis-test-seq";
Path in = new Path(input);
Path out = new Path(output);
FileSystem fs = FileSystem.get(conf);
if(fs.exists(in)){
if(fs.exists(out)){
//boolean参数是，是否递归删除的意思
fs.delete(out, true);
}
SequenceFilesFromDirectory sffd = new SequenceFilesFromDirectory();
String[] params = new String[]{"-i",input,"-o",output,"-ow"};
ToolRunner.run(sffd, params);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("文件序列化失败！");
System.exit(1);
}
//将序列化文件转换成向量文件
try {
Configuration conf = new Configuration();
conf.addResource(new Path("/usr/local/hadoop/conf/core-site.xml"));
String input = WORK_DIR+Path.SEPARATOR+"tennis-test-seq";
String output = WORK_DIR+Path.SEPARATOR+"tennis-test-vectors";
Path in = new Path(input);
Path out = new Path(output);
FileSystem fs = FileSystem.get(conf);
if(fs.exists(in)){
if(fs.exists(out)){
//boolean参数是，是否递归删除的意思
fs.delete(out, true);
}
SparseVectorsFromSequenceFiles svfsf = new SparseVectorsFromSequenceFiles();
String[] params = new String[]{"-i",input,"-o",output,"-lnorm","-nv","-wt","tfidf"};
ToolRunner.run(svfsf, params);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("序列化文件转换成向量失败！");
System.out.println(2);
}
}
public static void makeTrainVector(){
//将测试数据转换成序列化文件
try {
Configuration conf = new Configuration();
conf.addResource(new Path("/usr/local/hadoop/conf/core-site.xml"));
String input = WORK_DIR+Path.SEPARATOR+"input";
String output = WORK_DIR+Path.SEPARATOR+"tennis-seq";
Path in = new Path(input);
Path out = new Path(output);
FileSystem fs = FileSystem.get(conf);
if(fs.exists(in)){
if(fs.exists(out)){
//boolean参数是，是否递归删除的意思
fs.delete(out, true);
}
SequenceFilesFromDirectory sffd = new SequenceFilesFromDirectory();
String[] params = new String[]{"-i",input,"-o",output,"-ow"};
ToolRunner.run(sffd, params);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("文件序列化失败！");
System.exit(1);
}
//将序列化文件转换成向量文件
try {
Configuration conf = new Configuration();
conf.addResource(new Path("/usr/local/hadoop/conf/core-site.xml"));
String input = WORK_DIR+Path.SEPARATOR+"tennis-seq";
String output = WORK_DIR+Path.SEPARATOR+"tennis-vectors";
Path in = new Path(input);
Path out = new Path(output);
FileSystem fs = FileSystem.get(conf);
if(fs.exists(in)){
if(fs.exists(out)){
//boolean参数是，是否递归删除的意思
fs.delete(out, true);
}
SparseVectorsFromSequenceFiles svfsf = new SparseVectorsFromSequenceFiles();
String[] params = new String[]{"-i",input,"-o",output,"-lnorm","-nv","-wt","tfidf"};
ToolRunner.run(svfsf, params);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("序列化文件转换成向量失败！");
System.out.println(2);
}
}
public static void makeModel(boolean completelyNB){
try {
Configuration conf = new Configuration();
conf.addResource(new Path("/usr/local/hadoop/conf/core-site.xml"));
String input = WORK_DIR+Path.SEPARATOR+"tennis-vectors"+Path.SEPARATOR+"tfidf-vectors";
String model = WORK_DIR+Path.SEPARATOR+"model";
String labelindex = WORK_DIR+Path.SEPARATOR+"labelindex";
Path in = new Path(input);
Path out = new Path(model);
Path label = new Path(labelindex);
FileSystem fs = FileSystem.get(conf);
if(fs.exists(in)){
if(fs.exists(out)){
//boolean参数是，是否递归删除的意思
fs.delete(out, true);
}
if(fs.exists(label)){
//boolean参数是，是否递归删除的意思
fs.delete(label, true);
}
TrainNaiveBayesJob tnbj = new TrainNaiveBayesJob();
String[] params =null;
if(completelyNB){
params = new String[]{"-i",input,"-el","-o",model,"-li",labelindex,"-ow","-c"};
}else{
params = new String[]{"-i",input,"-el","-o",model,"-li",labelindex,"-ow"};
}
ToolRunner.run(tnbj, params);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("生成训练模型失败！");
System.exit(3);
}
}
}
package myTesting.bayes;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import org.apache.commons.lang.StringUtils;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.fs.PathFilter;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.mahout.classifier.naivebayes.BayesUtils;
import org.apache.mahout.classifier.naivebayes.NaiveBayesModel;
import org.apache.mahout.classifier.naivebayes.StandardNaiveBayesClassifier;
import org.apache.mahout.common.Pair;
import org.apache.mahout.common.iterator.sequencefile.PathType;
import org.apache.mahout.common.iterator.sequencefile.SequenceFileDirIterable;
import org.apache.mahout.math.RandomAccessSparseVector;
import org.apache.mahout.math.Vector;
import org.apache.mahout.math.Vector.Element;
import org.apache.mahout.vectorizer.TFIDF;
import com.google.common.collect.ConcurrentHashMultiset;
import com.google.common.collect.Multiset;
public class BayesCheckData {
private static StandardNaiveBayesClassifier classifier;
private static Map<String, Integer> dictionary;
private static Map<Integer, Long> documentFrequency;
private static Map<Integer, String> labelIndex;
public void init(Configuration conf){
try {
String modelPath = "/zhoujianfeng/playtennis/model";
String dictionaryPath = "/zhoujianfeng/playtennis/tennis-vectors/dictionary.file-0";
String documentFrequencyPath = "/zhoujianfeng/playtennis/tennis-vectors/df-count";
String labelIndexPath = "/zhoujianfeng/playtennis/labelindex";
dictionary = readDictionnary(conf, new Path(dictionaryPath));
documentFrequency = readDocumentFrequency(conf, new Path(documentFrequencyPath));
labelIndex = BayesUtils.readLabelIndex(conf, new Path(labelIndexPath));
NaiveBayesModel model = NaiveBayesModel.materialize(new Path(modelPath), conf);
classifier = new StandardNaiveBayesClassifier(model);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("检测数据构造成vectors初始化时报错。。。。");
System.exit(4);
}
}
/**
* 加载字典文件，Key: TermValue； Value：TermID
* @param conf
* @param dictionnaryDir
* @return
*/
private static Map<String, Integer> readDictionnary(Configuration conf, Path dictionnaryDir) {
Map<String, Integer> dictionnary = new HashMap<String, Integer>();
PathFilter filter = new PathFilter() {
@Override
public boolean accept(Path path) {
String name = path.getName();
return name.startsWith("dictionary.file");
}
};
for (Pair<Text, IntWritable> pair : new SequenceFileDirIterable<Text, IntWritable>(dictionnaryDir, PathType.LIST, filter, conf)) {
dictionnary.put(pair.getFirst().toString(), pair.getSecond().get());
}
return dictionnary;
}
/**
* 加载df-count目录下TermDoc频率文件，Key: TermID； Value：DocFreq
* @param conf
* @param dictionnaryDir
* @return
*/
private static Map<Integer, Long> readDocumentFrequency(Configuration conf, Path documentFrequencyDir) {
Map<Integer, Long> documentFrequency = new HashMap<Integer, Long>();
PathFilter filter = new PathFilter() {
@Override
public boolean accept(Path path) {
return path.getName().startsWith("part-r");
}
};
for (Pair<IntWritable, LongWritable> pair : new SequenceFileDirIterable<IntWritable, LongWritable>(documentFrequencyDir, PathType.LIST, filter, conf)) {
documentFrequency.put(pair.getFirst().get(), pair.getSecond().get());
}
return documentFrequency;
}
public static String getCheckResult(){
Configuration conf = new Configuration();
conf.addResource(new Path("/usr/local/hadoop/conf/core-site.xml"));
String classify = "NaN";
BayesCheckData cdv = new BayesCheckData();
cdv.init(conf);
System.out.println("init done...............");
Vector vector = new RandomAccessSparseVector(10000);
TFIDF tfidf = new TFIDF();
//sunny，hot，high，weak
Multiset<String> words = ConcurrentHashMultiset.create();
words.add("sunny",1);
words.add("hot",1);
words.add("high",1);
words.add("weak",1);
int documentCount = documentFrequency.get(-1).intValue(); // key=-1时表示总文档数
for (Multiset.Entry<String> entry : words.entrySet()) {
String word = entry.getElement();
int count = entry.getCount();
Integer wordId = dictionary.get(word); // 需要从dictionary.file-0文件（tf-vector）下得到wordID，
if (StringUtils.isEmpty(wordId.toString())){
continue;
}
if (documentFrequency.get(wordId) == null){
continue;
}
Long freq = documentFrequency.get(wordId);
double tfIdfValue = tfidf.calculate(count, freq.intValue(), 1, documentCount);
vector.setQuick(wordId, tfIdfValue);
}
// 利用贝叶斯算法开始分类,并提取得分最好的分类label
Vector resultVector = classifier.classifyFull(vector);
double bestScore = -Double.MAX_VALUE;
int bestCategoryId = -1;
for(Element element: resultVector.all()) {
int categoryId = element.index();
double score = element.get();
System.out.println("categoryId:"+categoryId+" score:"+score);
if (score > bestScore) {
bestScore = score;
bestCategoryId = categoryId;
}
}
classify = labelIndex.get(bestCategoryId)+"(categoryId="+bestCategoryId+")";
return classify;
}
public static void printResult(){
System.out.println("检测所属类别是："+getCheckResult());
}
}
显示全部
收起
