论文答辩是每个研究生进入毕业阶段必须经历的一项重要环节。一方面，它是对研究生在一定研究领域的学术素养和研究成果的一次综合评估；另一方面，它也是研究生展示自身科研能力和解决问题能力的一个机会。因此，如何在答辩中能够自圆其说，充分展示自己的研究成果和学术价值是每个研究生都需要重视和掌握的技巧。
在答辩前，研究生需要对自己的论文进行全面、系统的复习和整理，确保对于研究方向的各个细节都能够掌握清楚。同时，需要对可能被提问的问题进行预测，并事先准备相关的回答。
此外，还需要对论文答辩的形式和规范进行了解。不同学校和学科对于答辩的要求可能会有所不同，有些学校可能要求研究生进行口头答辩，有些学校可能会要求研究生进行PPT展示。了解并遵守学校的答辩规范，能够增加答辩成功的几率。
在答辩中的开场白中，可以通过对论文的研究背景和意义进行清晰而简洁的介绍来引起评委的兴趣。可以通过引用相关研究、阐述研究领域存在的问题来突出自己的研究动机和研究的重要性。
同时，需要注意语言表达的准确性和专业性，不能出现不准确的描述或者术语使用错误的情况。提前准备好相关的术语解释，以便在答辩过程中使用。
在答辩过程中，需要清晰地向评委们介绍论文的研究内容和采用的研究方法。可以使用图表、实例等方式来帮助评委们更好地理解研究内容。
同时，需要对研究方法进行合理的解释和阐述，包括数据采集、实验设计、数据处理等过程。可以通过详细的实验设计描述、数据分析结果等方式来充分展示自己的科研能力。
在答辩中需要特别强调自己的论文在研究领域的创新点和学术贡献。可以通过合理的逻辑推理、详细的数据证明、相关研究的对比等方式来证明自己的创新点和学术价值。
此外，可以使用相关论文的引用和他引等方式，来突出自己的学术价值和研究成果。
在答辩中，需要清晰地向评委们展示自己的研究成果和进展。可以通过图表、表格等方式来直观地展示自己的数据和实验结果。
同时，需要提及自身的科研能力和解决问题的能力。可以通过讲述一些解决难题的过程、介绍一些完成的重要实验等方式来展示自己在科研方面的突出表现。
在答辩过程中，评委们很可能会提问，可能是对论文内容的进一步深入理解，也可能是对研究方法的质疑。对于评委们的问题，需要保持冷静并进行合理的回答。
对于无法回答的问题，可以坦诚地表示并承诺后续会进一步深入研究；对于一些争议性较强的问题，可以展示自己的观点并进行合理的辩驳。
在答辩的结尾，需要对整个答辩过程进行总结，并展望自己将来的研究方向和计划。可以对自己的研究内容和方法进行简洁而全面的总结，并表示对未来研究的兴趣和期待。
最后，需要再次感谢评委们的耐心聆听和宝贵意见，并表示会认真对待评委们提出的问题和建议。
通过以上几个方面的准备和展示，相信每个研究生都可以在答辩中自圆其说，充分展示自己的研究成果和学术价值，顺利毕业。
其-释义：代词，他的。
自圆其说，汉语成语，拼音是zì yuán qí shuō，意思是指使自己的说法前后一致，没有自相矛盾的地方。
出自
清·方玉润《星烈日记》七十：以世俗之情遇意外之事，实难自圆其说。
曹禺《王昭君》第五幕：哈哈，单于殿下，你自己都不能自圆其说了吧。
1、诚实表述缺乏工作经验 现在很多HR都担心应届生虚假制造简历工作经验，这种现象是他们最不认可的。作为刚从学校走出来的职场新鲜人，HR对于应届生们的工作经验都是了如指掌的，所以请各位求职者诚实表述自己的工作经验，不要用虚假信息来蒙骗HR。
2、认可工作经验的重要性
3、突显个人优势及个性
4、表决心赢HR认可 “我知道自己没有丰富的工作经验，但是我十分确定是你们选择了我，我绝对不会让你们后悔……”像这种表决心的话，不需要太多修饰，直接用最朴实真诚的话语即可打动HR，这也是面试中最需要向HR传递的信息。 在现在的求职大军中，有很多没有任何工作经验的应届生，他们能仅凭毕业证书就能获得工作机会吗？答案是否定的。面对一无所知的求职者，HR不可能仅从简历和毕业证书就能判断你的能力，所以需要通过面谈才能发现他们的长处。 在面谈中，求职者如何回答好无工作经验？首先诚实说明自己缺乏工作经验，无逃避也不虚假谎报工作经历；其次，作为一名求职者需认可工作经验对于找工作是非常必不可少的推销武器，缺少它也就意味着那份工作是不能稳拿的；接着在面试过程中展现自己的才能及优势，尽可能这些优势与应聘职位相符合；最后到了我们表决心的时候，进一步表现出自己非常想得到这份工作。
硕士论文答辩作为研究生阶段的重要环节，是对研究生学术能力的综合考核。在答辩过程中，研究生需要向评委展示自己的研究成果，并回答评委的问题。然而，有些学生却倾向于自圆其说，这种做法既不利于学术探究，也有违学术诚信原则。
所谓自圆其说，即针对自己研究中的不足或问题，用各种手段进行掩盖、美化或解释，让其看起来合理而没有问题。自圆其说常见于答辩环节，特别是当研究生对自己的研究结果不够自信或无法回答评委的质疑时。
首先，自圆其说违背了学术诚信原则。学术诚信是科研工作的基石，体现了研究者对真理的追求和对社会的责任。如果研究者在答辩中刻意掩盖研究中的问题或不足，不仅是对自己的研究不负责，也是对科研领域的不负责。这种行为不仅有悖于学术伦理，还可能给他人带来误导，对学术界的发展造成负面影响。
其次，自圆其说无法解决问题。一个优秀的研究者应该具备不断追问和解决问题的能力。相对于回避问题或进行自圆其说，研究者应该勇于面对研究中的问题，并寻求解决方案。只有通过直面问题并提出合理的解决方案，才能真正推动科学研究的发展。
另外，自圆其说难以取信于人。在答辩中，评委通常会提出有针对性的问题，评估研究生的研究深度和理解能力。如果研究生只是简单地进行自圆其说，而不能给出清晰、合理的解答，评委很难对其研究成果产生信任。相反，如果研究生能够真实地回答问题，展示自己的研究能力和思考深度，评委更容易对其研究成果表示认可。
在硕士论文答辩中，研究生难免会遇到评委的批评和质疑。这时候，研究生应该以积极的态度回应，而不是选择自圆其说。
首先，要理解批评的本质。评委的批评和质疑往往是建设性的，目的是帮助研究生发现问题、深入思考，并最终提升自己的研究能力。研究生应该保持谦逊的心态，虚心倾听评委的意见，并从中寻找可以改进的方向。
其次，要回答问题的实质。当评委提出问题时，研究生应该仔细思考问题的本质，并给出准确、有条理的回答。如果暂时无法回答，可以表达自己对问题的重视，并承诺在今后的学习中努力弥补不足。
最后，要展示自己的研究能力。答辩是展示研究生学术能力的机会，研究生应该充分发挥自己的研究优势，展示出自己在研究方向上的深度和广度。通过展示自己的研究成果和对相关问题的思考，研究生可以更好地回应评委的批评和质疑。
硕士论文答辩是研究生阶段的重要环节，对研究生的学术能力和研究成果进行综合评估。在答辩中，研究生应该坚持学术诚信的原则，不要选择自圆其说的方式应对评委的批评和质疑。相反，研究生应该积极回应批评，虚心听取建议，并展示自己的研究能力。只有这样，才能真正体现出一个优秀研究生的素质和潜力。
首先撒谎是不对的，对关系比较好来往密切的朋友应该主动告诉他们你是打了进修的幌子辞职的，如果是一般的旧同事我估计他们也不会太关心你的近况，顶多是寒暄一下。
随着春天的到来，大自然重新焕发生机，万物复苏，生机勃勃。人们开始抛开冬日的寒冷，迎接温暖的春季。只要春天还在，世界就充满着希望与美好。
春天是四季中最令人期待的季节之一。温暖的阳光洒在大地上，花朵绽放，树木抽出新芽，鸟儿开始各自呼唤，一片生机勃勃的景象。冬天的寒冷逐渐被取代，人们的心情也随之明媚起来。
春天是一年中充满活力和能量的季节。人们纷纷脱下厚重的冬衣，换上轻薄的衣裳，走出家门，享受户外的活动。阳光下的笑脸洋溢着幸福和快乐。
春天是新生和希望的象征。在春季，植物重新生长，草地变绿，花朵绽放。这些无声的世界在诉说着新的开始。冬天的枯萎和死亡被春天的活力所取代。
春天也象征着人类的希望与梦想。每个人的心中都有一个春天，只要保持信念，顽强地追逐梦想，就能够看到希望的曙光。春天的到来，提醒我们不要放弃，只要努力和坚持，就能够改变命运。
春天带给我们许多美好的事物。首先是花朵的盛开，美丽而绚烂的花海吸引着无数的游客。粉红色的樱花，金黄色的油菜花，五彩斑斓的郁金香……每一朵花都散发着迷人的芳香，让人心旷神怡。
春天也是旅游的好时机。温暖的天气使人们更愿意外出旅行，探索大自然的美景。踏青、郊游、野餐成为了春天最受欢迎的活动。徜徉在大自然中，感受春天的气息，让人心身舒畅。
春天告诉我们，生活终将充满希望。正如大自然的轮回一样，无论生命经历多少的坎坷与风雨，只要我们坚定信念，积极面对，生活终将迎来新的转机。
只要春天还在，就意味着希望还在。不论遇到什么困难和挑战，我们都要坚持下去，相信自己能够战胜一切。春天给了我们启示，不论过去发生了什么，我们都能够重新开始，追求更美好的未来。
春天是世界上最美丽的季节之一。它带给我们希望、美好和机遇。只要春天还在，无论发生什么，我们都要坚持下去，追逐梦想。相信自己，追求更好的生活。春天只存在于大自然中，也存在于每个人的心中。让我们共同珍惜春天，让它的美好永远伴随我们。
在今天的科技时代，无法想象我们的生活没有芯片的存在。芯片已经成为现代电子设备中不可或缺的部分，几乎涵盖了所有领域，包括个人电脑、手机、汽车、家电等等。大家可能不知道，芯片只要求占据很小的空间，但它们背后的技术和设计是极其复杂的。
芯片可以被简单地描述为微型电路，它集成了多个电子组件，包括晶体管、电容器和电阻器等。这些组件在芯片的微小表面上相互交互，形成了一个完整的电路系统。芯片通过电流来控制和传输信息，从而使设备正常运行。
与其他工业制品相比，芯片的制造过程更加复杂且精确。它包括几个关键步骤：
尽管芯片只要求占据很小的空间，但其背后的技术和功能是非常复杂的。一个芯片不仅仅只是一个电路，它还可以具有各种功能和特性，以满足不同应用的要求。
一些芯片只要求专门用来处理图像、音频或视频信号，这种芯片被称为处理器芯片。处理器芯片可以高效地处理大量的数据，以提供用户良好的视听体验。
另外，一些芯片只要求被用作存储设备，如存储芯片。这些芯片采用非易失性存储器（NVM）技术，可以在断电时保持数据的存储状态，如闪存和固态硬盘（SSD）。
还有一类芯片只要求专门用来处理通信和网络功能，如调制解调器（调制解调器芯片）和网络控制器芯片。这些芯片可以连接不同设备，并通过网络传输数据。
此外，我们还有传感器芯片，用于感知和收集环境信息，以及微处理器芯片，用于智能手机、个人电脑和其他可编程设备。
芯片技术自诞生以来已经经历了巨大的进步和演变。随着技术的不断发展，芯片变得更小、功耗更低、性能更强大。
在最早的电子计算机中，芯片由离散的电子元件手工组装而成。但随着集成电路的出现，数量庞大的元件可以被集成在一块芯片上。上世纪60年代，集成电路的诞生极大地促进了计算机和电子设备的发展。
在过去的几十年里，芯片技术取得了巨大的突破。集成度的提高使得更多的组件可以被整合到芯片上，从而使电子设备更加小巧轻便。此外，芯片制造过程的精确度和效率也得到了显著的提高。
作为科技行业的核心，芯片行业将继续发展和创新。未来的芯片将会更加强大和多功能。
首先，人工智能（AI）将驱动芯片行业的发展。随着AI技术的迅速发展，对更快速、更高性能的芯片需求也在增加。芯片将会适应AI算法的需求，提供更高的计算能力。
其次，物联网（IoT）的兴起将推动芯片行业迈向更智能化的方向。大量的物联网设备将需要小型而高效的芯片，以实现连接和数据处理的功能。
此外，芯片制造过程中的可持续性也是未来发展的一个重点。零件的回收和材料的再利用将成为推动芯片行业向更环保和可持续方向发展的关键因素。
在不久的将来，我们可能会看到具有更高处理能力、更低功耗、更小尺寸的芯片。芯片将不仅仅只是用来支持设备的正常运行，而是成为推动科技进步和创新的核心。
总结起来，芯片只要求占据很小的空间，但背后的技术和设计却是非常复杂的。芯片不仅仅只是一个电路，还具有各种功能和特性，满足不同应用的需求。通过不断的创新和演进，芯片行业将继续推动科技的发展和进步。
尊敬的读者，非常欢迎您阅读我的博客文章。今天，我想与您分享的主题是，只要心存美好，我们可以创造出令人难以置信的成果和奇迹。
无论我们面对怎样的困难和挑战，只要心存美好，我们就能保持积极、乐观的心态。心态是我们应对各种情况的关键。它影响我们的行为和情绪，直接影响到我们所取得的成就。
有时候，生活会给我们带来挫折和失败，但是只要我们保持积极的心态，我们就能从中汲取教训，并找到新的机会。无论是在个人生活还是职业领域，保持积极的心态是成功的关键。
积极思维是一种强大的工具，它可以帮助我们克服困难，并激励我们朝着目标迈进。当我们面临困境时，积极思维能够帮助我们保持冷静，找到解决问题的办法。它让我们相信自己的潜力，并鼓舞我们追求更高的目标。
只要心存美好，我们就能培养积极思维。这意味着要抵制消极的想法，专注于寻找解决问题的方法。每当我们遇到挫折时，我们可以问自己一些积极的问题，例如：“我能从中学到什么？”或者“有哪些新的机会可以迎接？”这些问题能够激发我们寻找解决方案的创造力。
只要心存美好，我们就能在个人生活和职业领域获得许多价值。首先，积极心态可以提高我们的幸福感和快乐指数。当我们能够看到问题背后的机会，并对未来抱有希望时，我们会感到更加满足和充实。
此外，积极心态还能够改善我们的人际关系。当我们保持积极的心态时，我们更容易吸引和保持朋友和伴侣。积极的态度会传播给周围的人，激发他们的积极情绪，进而创建和谐的人际关系。
在职业领域，积极心态是成功的关键。雇主更倾向于雇佣那些积极、乐观的员工。积极心态意味着我们能够应对挑战，提出创新的解决方案，并带来积极的工作环境。无论是在求职还是晋升方面，积极心态都会给我们带来竞争优势。
只要心存美好，我们就能通过一些实践方法来培养积极心态。
这些方法可以帮助我们培养积极心态，并在生活的各个领域取得成功。
只要心存美好，我们就能创造出意想不到的成果和奇迹。积极心态可以推动我们克服困难，实现个人和职业目标。通过培养积极思维和保持乐观的心态，我们可以在生活中获得更多的幸福和成功。
感谢您阅读我的博文。希望这篇文章对您有所启发，让您保持积极的心态，并在人生的旅途中取得更大的成功。
推销梳子的故事 有一个单位招聘业务员，由于公司待遇很好，所以很多人面试。
经理为了考验大家就出了一个题目：让他们用一天的时间去推销梳子，向和尚推销。很多人都说这不可能的，和尚是没有头发的，怎么可能向他们推销？于是很多人就放弃了这个机会。但是有三个人愿意试试。第三天，他们回来了。 第一个人卖了1把梳子，他对经理说：“我看到一个小和尚，头上生了很多虱子，很痒，在那里用手抓。我就骗他说抓头用梳子抓，于是我就卖出了一把。” 第二个人卖了10把梳子。他对经理说：“我找到庙里的主持，对他说如果上山礼佛的人的头发被山风吹乱了，就表示对佛不尊敬，是一种罪过，假如在每个佛像前摆一把梳子，游客来了梳完头再拜佛就更好！于是我卖了10把梳子。” 第三个人卖了3000把梳子！他对经理说：“我到了最大的寺庙里，直接跟方丈讲，你想不想增加收入？方丈说想。我就告诉他，在寺庙最繁华的地方贴上标语，捐钱有礼物拿。什么礼物呢，一把功德梳。这个梳子有个特点，一定要在人多的地方梳头，这样就能梳去晦气梳来运气。于是很多人捐钱后就梳头又使很多人去捐钱。一下子就卖出了3000把。” 说明：在沟通时，我们要找到对方的需求并给予解决，只有增加了对方的价值，才能达成自己的期望。之前看了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());
}
}
