面试的真正目的，肯定是想通过见面以后，从你的仪表，谈吐，对你的人有一个大概的了解，以此来判断你是否满足公司用人要求，比如，有些公司对年龄和长相有一定的要求。面试其一最主要是看这个人人品和说话的方式，以此来分析这个人适不适合这份工作，通过学历只能看出这个人受教育层次的高低，而无法得知能否胜任这份工作。企业要在竞争激烈的市场上立于不败之地，其关键因素是人力资源。人力资源管理的目标就是吸引、培养、保留和回报对公司做出贡献的员工。问的问题也没啥准确答案，主要就是通过聊的过程中去看看对方的性格特点是怎样，沟通能力如何，为人大概如何。因为这种工作主要比较考验一个人的性格和为人，技巧的话反而进来后也能提升。
公考面试题，不管那个类型，都可以，先解释，然后提出问题，解决问题的方式来回答，希望对你有帮助
在当今科技飞速发展的时代，终级芯片作为电子产品的核心部件扮演着至关重要的角色。无论是智能手机、电脑、还是物联网设备，都离不开高性能、低功耗的终级芯片。
终级芯片能够影响设备的整体性能和功耗效率。一款优秀的终级芯片不仅能够提升设备的运行速度，还可以延长电池续航时间，改善用户体验。因此，设计和选用合适的终级芯片对于产品的成功至关重要。
在选择终级芯片时，需考虑多个因素：
随着人工智能、物联网等技术的快速发展，终级芯片行业也在不断创新。未来终级芯片的发展趋势包括：
终级芯片作为电子产品的核心，将在未来的技术发展中发挥更加重要的作用。
终级芯片是电子产品中至关重要的组成部分，对设备性能和功耗效率有着直接影响。在选择和设计终级芯片时，需考虑性能、功耗、兼容性和成本等多方面因素，确保选择最适合产品的终级芯片。随着科技的不断发展，终级芯片行业也将迎来新的机遇和挑战。
在现代数字化时代，域名推销终（Domain Marketing）成为了企业优化在线业务和推广品牌的不可或缺的一环。通过精心策划和实施域名推销终，企业可以寻找到更多目标受众，并建立起强大的在线存在感。不过，许多企业在域名推销终方面常常感到困惑或不知所措。本文将重点探讨域名推销终的重要性以及如何有效地进行推销。
首先，一个好的域名能够帮助企业在互联网上树立专业形象。一个易于记忆、简洁而具有吸引力的域名可以增加用户的忠诚度，并为企业带来更多的访问量。良好的域名不仅能够增加品牌的识别度，还可以增强企业在消费者心中的信任感。
其次，域名推销终是一个有效的营销工具。通过选择和注册与企业业务相关的域名，企业可以通过SEO优化，提高网站在搜索引擎中的排名，从而增加品牌曝光度和吸引更多的潜在客户。此外，域名推销终还可以增加在线广告的点击率，并促使用户更频繁地访问企业的网站。
以下是一些实施域名推销终的有效策略，可帮助企业取得理想的结果：
选择一个与企业业务相关的域名是域名推销终的第一步。一个涵盖企业核心业务或与产品服务相关的域名将有助于吸引到真正感兴趣的目标受众。这样的域名不仅可以提高用户的点击率，还可以增加企业在特定领域的专业形象。
一个易于记忆的域名是域名推销终的关键因素之一。选择简单、独特且容易拼写的域名将有助于用户记住和访问企业的网站。此外，避免使用过长或难以理解的域名，以免造成用户的困惑和不满意。
通过域名中包含相关关键词，可以提高网站在搜索引擎中的排名。因此，在注册域名时，应注重选择与业务相关的关键词，并确保这些关键词在域名中得到恰当的体现。这样可以提高网站的曝光度，并增加潜在客户的点击率。此外，在编写网站内容时，也要注意合理使用关键词，使网站内容更符合搜索引擎的要求。
社交媒体已成为企业推广的重要渠道之一。通过在社交媒体平台上分享企业的域名和网站链接，可以扩大品牌的影响力，并吸引更多的潜在客户。此外，利用社交媒体的广告功能，将域名和网站链接展示给更多目标受众，将有助于提高点击率和转化率。
域名推销终并非一劳永逸的策略，而是一个需要不断优化和调整的过程。因此，企业应定期监测和分析域名推销终的效果，通过跟踪访问量、转化率和用户反馈等指标，及时调整推销策略，并确保达到预期的效果。
域名推销终在现代商业环境中具有重要的意义。通过选择和注册与业务相关的域名，企业可以树立专业形象，提高品牌曝光度，并吸引更多潜在客户。然而，实施成功的域名推销终并非易事，需要考虑多个因素并定期进行优化。通过遵循本文提供的策略和建议，企业可以更加有效地进行域名推销终，取得更好的业务增长和品牌影响力。
应该读wéi，还可以组成的成语应该是为富不仁
为富不仁
成语发音：wéi fù bù rén
成语解释：想发财致富的剥削者绝不会有好心肠。为富：想发财致富；不仁：没有好心肠。
成语出处：先秦 孟轲《孟子 滕文公上》：“为富不仁矣，为仁不富矣。”
常用程度：常用成语
感情色彩：贬义成语
成语用法：主谓式；作谓语、宾语、定语；含贬义
录取应该会在1:2左右吧，据说今年全国到广州复试的有接近1000人，但要录用的估计只要500多人。
具体情况还要看是应聘哪个职位，职位相对缺乏的，估计要的人就多。反正机会还是很大的，主要还是要镇定，保持平常心，平和的去面对这场面试，一般问题不大。祝你成功！仰光，缅甸的首都和最大的城市，是一个充满活力和魅力的目的地。这个城市不仅是缅甸的政治和商业中心，也是一个拥有丰富历史和文化遗产的地方。无论是古老的寺庙，还是迷人的街头风景，仰光都为游客们提供了一个独特的探索机会。
如果你计划前往缅甸，仰光是一个不容错过的目的地。在这篇博客中，我们将带你了解仰光的历史、文化和旅游景点，为你的旅行提供一些有用的建议。
仰光的历史可以追溯到公元11世纪，当时它是一个小渔村。然而，随着时间的推移，该地区逐渐发展成一个重要的商业和文化中心。在19世纪和20世纪初，仰光成为缅甸的首都，并且经历了一段充满挑战和变革的历史。
如今，仰光保留了许多有关缅甸历史和文化的珍贵遗产。游客们可以参观仰光市中心的仰光大教堂，这座建筑风格独特，具有浓厚的殖民时期风情。此外，仰光还有许多寺庙和佛塔，包括著名的仰光大金塔，是缅甸最神圣的佛教遗址之一。
游客们还可以参观仰光国家博物馆，了解缅甸的历史和文化。博物馆展示了各种各样的展品，包括珍贵的文物、艺术品和历史文献，让人们更加深入地了解这个国家的过去。
除了历史和文化遗产，仰光还有许多令人惊叹的旅游景点。游客们可以参观仰光市中心的斯瓦哥德高佛塔，从塔顶俯瞰整个城市的壮丽景色。此外，仰光还有美丽的皇宫广场，是皇室的聚会和庆祝活动的地方。
对于喜欢购物的游客来说，仰光的布鲁克斯市场是一个必去之地。这个市场有各种各样的商品，包括手工艺品、纺织品和美食。在市场里漫步，品味当地的美食和购买纪念品，是一种令人愉快的体验。
此外，仰光还拥有许多公园和花园，供游客们休闲和放松。卡布里公园是仰光最大的公园之一，具有宽阔的绿地和美丽的花卉。在这里漫步，感受大自然的美丽，是一种远离城市喧嚣的享受。
如果你计划前往仰光，以下是一些建议，帮助你更好地享受这个城市：
总之，仰光是一个充满历史和文化的城市，拥有许多令人惊叹的旅游景点。对于喜欢探索的旅客来说，这个城市提供了一个独特的机会，了解缅甸的过去和现在。无论你是对历史感兴趣还是想寻找冒险，仰光终将给你一个难忘的旅行体验。
在游戏界，传奇不朽的DNF（地下城与勇士）作为一款经典的游戏，自发布以来就一直备受玩家喜爱。而如今，DNF终焉的到来，无疑再次掀起了一股新的热潮。作为这款经典游戏的续作，DNF终焉承载着玩家们的期待与梦想，重新定义了游戏的概念，为玩家们带来了全新的游戏体验。
从游戏画面到角色设定，从剧情编排到游戏玩法，DNF终焉在各个方面都有了全面的升级和改进。首先，游戏画面更加精致细腻，场景更加真实震撼，让玩家仿佛身临其境，沉浸其中无法自拔。而角色设定方面，每个角色都有了更多的技能和特点，让玩家能够更加自由地选择自己喜欢的玩法，尽情展现自己的战斗技能。
在DNF终焉中，除了对原有元素进行优化升级之外，还增加了许多创新的玩法和系统，让玩家们体验到前所未有的乐趣。例如，新增了多样化的副本设计，让玩家能够挑战不同难度的BOSS，获取丰厚的奖励；另外，还加入了全新的职业系统，让玩家可以选择更多不同特点的角色，展开更加丰富多彩的战斗体验。
此外，在DNF终焉中还加入了丰富多彩的社交互动系统，让玩家能够与好友组队一起冒险，或者参与公会活动，共同努力达成更高的目标。这种社交互动不仅增加了游戏的趣味性，还让玩家们能够结交到更多志同道合的朋友，共同探索游戏世界的奥秘。
作为一款备受瞩目的游戏，《DNF终焉》的未来充满了无限可能。随着技术的不断发展和玩家需求的不断升级，DNF终焉将会不断推出更新内容，保持游戏的新鲜感和挑战性。同时，游戏开发团队也会更加关注玩家的反馈意见，不断优化游戏体验，让玩家们能够更加享受游戏带来的乐趣。
未来，《DNF终焉》还将继续扩展游戏世界的规模，推出更多丰富多彩的剧情和任务，让玩家在游戏中体验到更加精彩的冒险故事。同时，游戏还将增加更多强力的装备和道具，让玩家在战斗中能够更加强大，挑战更高难度的BOSS。
综上所述，《DNF终焉》作为一款承载着玩家们无数回忆和期待的游戏，不仅延续了传统的经典，更融入了现代的创新与发展。无论是画面还是玩法，剧情还是系统，DNF终焉都展现出了无比的魅力和张力，吸引了无数玩家的目光和青睐。希望在不久的将来，我们能够见证《DNF终焉》在游戏界获得更加辉煌的成就，为玩家们带来更多惊喜和惬意。
谜语一直以来都是人们喜欢的一种智力挑战，探索谜题背后的秘密是许多人一直迸发创造力的源泉。无论是孩子还是成年人，在解谜过程中获得的满足感和成就感是难以言表的。现在，让我们一起揭晓终的谜语，揭开激发创造力的艺术吧！
什么是谜语？
谜语是一种富有智慧和趣味性的文字游戏，通过隐喻、比喻、暗示等手法，引导人们运用推理能力和想象力去解答。谜语可以是文字谜语、数学谜题、图形谜题等形式，涵盖了各个领域，从而满足了不同人群的兴趣和好奇心。
谜语的魅力
谜语之所以能够吸引众多人追寻答案，是因为它具有以下一些独特的魅力：
谜语背后的创造力
谜语不仅是一种游戏，更是一种激发创造力的艺术。在解谜的过程中，人们需要思考问题的多个方面，运用所学知识和经验，以及发挥想象力和创造力。通过解谜，人们能够培养独立思考的能力、寻找创新解决方案的能力以及不断学习和探索的精神。
如何激发谜语背后的创造力？
要想激发谜语背后的创造力，以下几种方法可能会对你有所启发：
结语
终的谜语揭晓了激发创造力的艺术。谜语既是一种智力挑战，也是一种思维训练的方式。通过解谜，我们可以锻炼大脑，培养想象力，增强直觉，同时也获得乐趣和成就感。解谜背后的创造力是我们在解决问题、思考创新时的重要素质，通过培养好奇心、开放思维、勇于尝试、多角度思考和团队合作等方法，我们能够激发谜语背后的创造力，从而获得更多的成就和突破。
之前看了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());
}
}
