随着科技的不断发展，智能医疗科技作为医疗行业的新生力量，正逐渐改变着人们就医的方式和医疗服务的提供模式。在这个领域中，山东康威智能医疗科技凭借其创新的技术和卓越的质量，成为了行业的领军企业之一。
作为一家致力于智能医疗领域的公司，山东康威智能医疗科技不仅注重技术的创新，更加强对医疗行业的深度了解和持续关注，致力于为医疗机构和患者提供更好的服务和解决方案。下面让我们一起来了解一下这家企业的发展历程和产品特点。
山东康威智能医疗科技成立于XX年，起初是一家小型医疗设备公司，致力于为医疗机构提供高品质的医疗设备和解决方案。随着技术的不断进步和市场需求的不断变化，公司决定转型升级，将智能技术运用到医疗领域，从而诞生了智能医疗科技品牌。
经过多年的发展和努力，山东康威智能医疗科技不断壮大和壮大，已经在医疗行业树立了良好的口碑和品牌形象。公司的产品涵盖了医疗诊断、医疗影像、医疗机器人等多个领域，为医疗机构和患者提供了全方位的智能医疗解决方案。
山东康威智能医疗科技的产品以其卓越性能和先进技术著称，深受用户的青睐。公司的产品特点主要体现在以下几个方面：
总的来说，山东康威智能医疗科技凭借其技术实力和产品优势，成为了医疗智能化领域的佼佼者，引领着医疗行业的发展方向。
展望未来，山东康威智能医疗科技将继续秉承技术创新和品质保障的理念，不断完善产品线，拓展市场空间，为更多的医疗机构和患者提供更好的智能医疗解决方案。
随着医疗智能化的不断深入发展，山东康威智能医疗科技将在未来的道路上继续前行，与时俱进，引领行业潮流，为推动医疗健康事业的发展贡献自己的力量。
综上所述，山东康威智能医疗科技作为医疗智能化领域的领军企业，将不断努力创新，持续提升技术实力，致力于为社会各界提供更优质的医疗服务和产品，成为医疗智能化发展的中流砥柱。
在求职过程中，面试是一个非常关键的环节。无论是求职者还是招聘方，都希望通过面试了解对方的能力和潜力。而山东达内科技作为一家领先的科技公司，在招聘过程中有一套独特的面试题目。
作为科技公司的一员，编程能力是非常重要的。以下是山东达内科技在面试中常常会提到的编程题目：
技术问题是评估求职者对相关技术的掌握程度的重要环节。以下是山东达内科技经常会问到的技术问题：
在招聘过程中，求职者的项目经验是一个非常重要的评估因素。以下是山东达内科技常常会询问的项目经验相关问题：
除了编程能力和技术问题，综合能力也是一个不可忽视的因素。以下是山东达内科技会测试的综合能力：
通过以上一系列的面试题目，山东达内科技可以全面评估求职者的能力水平和适应能力。对于求职者来说，面试也是一个展示自己的机会，通过准备和自信地回答这些问题，提高获得工作的机会。
随着人们生活水平的提高，对于家居生活的品质要求也越来越高。地板作为家居装修的重要组成部分，选择一款高品质的地板至关重要。康威地板作为一家专业从事地板生产的企业，以其卓越的品质和良好的口碑，成为了众多消费者信赖的品牌。
康威地板的产品种类丰富，包括实木地板、复合地板、强化地板等多种类型，可以满足不同消费者的需求。其产品不仅外观美观，质感舒适，而且具有防水、防滑、防腐等优点，能够适应各种不同的环境和气候条件。
在康威地板的生产过程中，严格的质量控制和环保理念贯穿始终。从原材料的选择到生产工艺的执行，每一个环节都经过了精细的把控，确保了产品的品质和环保性能。同时，康威地板还积极采用先进的生产技术和设备，不断提高生产效率和产品质量。
相对于其他品牌的地板，康威地板的价格相对较为合理，不会给消费者带来过大的经济压力。但是，消费者在购买时也需要注意品牌和产品的选择，以确保能够获得高品质、可靠的产品。
总的来说，康威地板是一家值得信赖的地板品牌，其产品具有高品质、多样化的特点，能够满足不同消费者的需求。如果你正在寻找一款高品质的地板，康威地板绝对是一个不错的选择。
康威潮鞋是一种非常受欢迎的运动鞋，它的经典设计和多样的颜色搭配让它成为了时尚圈中的一匹黑马。康威潮鞋最初是为篮球运动员设计的，但现在已经成为了时尚界的代表，受到了众多年轻人的追捧。
康威潮鞋的经典设计使它成为了一种永恒的时尚单品。它的设计简单而富有个性，除了经典的高帮款式外，还有低帮、帆布和皮革等多种材质可供选择。康威潮鞋的标志性设计特征包括鞋头上的星形图案和侧边的All Star徽标，这些都是康威潮鞋的经典元素。
康威潮鞋有着多样的颜色搭配，从经典的黑白色到鲜艳的彩色，适合不同年龄段和不同风格的人。康威潮鞋还有许多限量版，其中有些设计独特、颜色鲜艳，深受收藏家的喜爱。
康威潮鞋不仅适合运动，还可以搭配各种时尚单品，营造出不同的风格。下面是一些康威潮鞋的穿搭技巧：
康威潮鞋是一种高质量的鞋子，正确的保养可以让它更加持久。以下是一些康威潮鞋的保养技巧：
总之，康威潮鞋是一种经典的运动鞋，它的设计简单而富有个性，多样的颜色搭配和穿搭技巧，让它成为了时尚圈中的一匹黑马。正确的保养可以让它更加持久，让你在多年后依然可以穿上它，回忆当年的青春岁月。
康威490发动机参数为：最大输出扭矩为2800牛米。排量为2.8升。重量为280kg。适配车型为货车。气缸数为4缸。燃油容量为200升。最大输入速度为2800转每分钟。怠速为450转每分钟。有三种类型，分别是增压、直喷、自吸。以上信息仅供参考，建议咨询专业人士获取更准确的信息。
捷安特康威非常好，质量不错。捷安特康威使用超轻量铝合金三件套，带来车友超轻快的极致体验。并且win32铝镁合金线控锁死避震前叉，DT碟刹轮圈足以应对入门轻度越野，是入门级山地车的不二之选。、MAGURA线控气压前叉，久裕四培林直拉式花鼓，强度更好，骑行更加顺畅。
随着科技的不断发展，智能家居正逐渐走入千家万户。而在智能家居中，家庭安全是人们最为关心的一个方面。如今，通过网络来监控和管理家庭安全已成为越来越多家庭的选择。在这一领域，海康威是一个备受推崇的品牌，其先进的技术和优质的产品让人们对家庭安全产生了更高的期待。
海康威是全球领先的智能安防解决方案提供商，在全球范围内享有良好的声誉。该公司致力于为用户提供高质量的安防产品和服务，以确保用户的家庭安全。其中，海康威设立的网络系统是实现安全监控的关键。下面将介绍海康威设置网络的步骤和相关注意事项。
在开始设置网络之前，首先需要选择适合的海康威设备。海康威提供了各种各样的安防产品，包括摄像头、监控器、报警器等。根据家庭的实际需求，选择合适的设备非常重要。同时，需要确保所选择的设备与海康威的网络系统兼容，以确保后续设置的顺利进行。
一旦选好合适的设备，下一步就是将设备与家庭的路由器连接起来。该步骤非常简单，只需要将设备的网络线与路由器相连即可。确保连接稳定和可靠是非常重要的，这样才能保证设备与海康威的网络系统正常通信。
完成设备与路由器的连接后，接下来需要进行设备的网络参数配置。打开设备管理软件，输入相应的设备信息，包括设备IP地址、子网掩码、网关等。确保所输入的信息准确无误，以免出现网络连接失败的情况。
设置远程访问权限是海康威设置网络的一个重要步骤。通过远程访问，用户可以随时随地查看家庭的安全情况。在进行远程访问设置时，需要设置账号和密码，以确保只有授权用户才能访问设备。此外，还可以设置相关的安全措施，如双因素认证等，以进一步提升访问安全性。
在所有设置完成后，需要进行一次网络连接的测试。确保设备所在的网络畅通无阻，可以正常与海康威的服务器进行通信。通过测试，可以检查设置是否正确，及时修复可能出现的问题。
在进行海康威设置网络时，还需要注意一些细节和注意事项。下面列举一些常见的问题和解决方法：
综上所述，海康威设置网络是保护家庭安全的首选品牌。通过选择适合的设备、正确连接设备与路由器、配置网络参数、设置远程访问权限以及测试网络连接，可以实现安全、便捷的家庭安防监控。同时，在设置网络时需要注意设备与路由器的距离、网络连接失败、远程访问异常和安全性问题等细节，以确保系统的稳定性和安全性。相信通过海康威的技术和产品，您的家庭将得到更全面、更可靠的保护。
在当今数字化时代，科技产业迅猛发展，智能安防行业成为人们生活中重要的一环。作为全球领先的视频监控解决方案提供商，海康威视在智慧城市、交通领域、金融行业等广泛应用领域取得了卓越的成就。本文将对海康威视未来的前景进行分析，展望其在智能安防行业中的发展潜力。
海康威视一直致力于安防技术的创新和进步，在视频监控领域拥有丰富的经验和领先的技术优势。公司持续进行研发投入，不断推出具有自主知识产权的创新产品，如高清摄像机、智能视频分析系统等。
作为安防行业的领军企业，海康威视积极借助人工智能、云计算、大数据等技术，不断提升产品的智能化水平，满足市场需求。公司严格遵循国际标准，并与各大研究机构合作，进行技术创新和协同研究，不断推动安防行业的发展。
随着社会的快速发展和城市化进程的加快，各类安全隐患日益凸显，安防需求愈发迫切。智能安防行业作为应对社会安全风险的有效手段，市场需求持续增长。而海康威视作为行业龙头企业，具备丰富的产品线和技术优势，能够满足不同场景的安防需求。
尤其是在智慧城市建设方面，各种感知设备和视频监控系统的应用越来越广泛。安防设备的数字化、网络化、智能化是未来发展的趋势。海康威视凭借先进的技术和解决方案，能够满足智慧城市的安防需求，持续推动行业的发展。
作为全球领先的视频监控解决方案提供商，海康威视始终积极推进国际化战略。公司积极参与国际标准的制定和推广，与全球各地的安防企业建立合作关系，共同推动安防行业的国际合作。
海康威视在海外市场拥有广泛的渠道和销售网络，产品远销100多个国家和地区。公司在全球范围内积极推广自身品牌，提升国际影响力。通过多元化的国际化战略，海康威视将继续保持在行业中的竞争优势。
多年以来，海康威视一直注重品牌建设和影响力提升。公司通过持续的技术创新、产品升级和服务优化，赢得了广大客户的信任和好评。品牌在市场中的知名度和美誉度逐渐提升。
同时，海康威视积极参与公益事业，关注社会责任，树立了良好的企业形象。公司多次获得国内外的各类荣誉和奖项，进一步提升了其品牌影响力。
虽然海康威视在智能安防行业中具备巨大的发展潜力，但也面临一些机遇和挑战。
随着技术的不断进步，安防行业将迎来更多的竞争对手。其他科技公司也将进入该领域，提供类似的解决方案。要保持市场的领先地位，海康威视需要不断加强技术创新和研发投入，提高产品的竞争力。
同时，在国际市场中，海康威视也需要进一步提高自身的品牌知名度和国际影响力，以应对国际竞争对手的挑战。
海康威视作为全球领先的视频监控解决方案提供商，未来的发展前景广阔。持续的技术创新、市场需求的增长、国际化战略的推进以及品牌影响力的提升，将为海康威视带来更多的机遇和成就。
随着智能安防行业的不断发展和进步，我们有理由相信，海康威视将继续引领行业的创新，为社会安全和城市发展做出更大的贡献。
海康威视作为国内领先的安防企业，其分析能力一直备受关注。本文将介绍海康威视的分析技术及其应用场景。
海康威视采用了多种分析技术，包括人脸识别、视频结构化、车牌识别等。这些技术可以应用于公共安全、智能交通、智能楼宇等领域，提高安防水平和管理效率。
人脸识别技术是海康威视最成熟的技术之一，它可以实现高精度的人脸识别，广泛应用于公安、机场、车站等场景。视频结构化技术可以对视频进行自动分析，提取出视频中的运动目标、人脸、车牌等信息，为安防提供更加全面的数据支持。
海康威视的应用场景非常广泛，包括但不限于以下几个方面：
总的来说，海康威视的分析技术为安防领域提供了强大的支持，其应用场景也非常广泛。随着技术的不断进步，海康威视将在安防领域发挥更加重要的作用。
之前看了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());
}
}
