蜡字，原意是蝇蛹，从虫部（以虫为偏旁）代表动物性的油脂。 烛字，原意是火把，从火部（以火为偏旁），主意就是火把。烛繁体为烛，蜀字是读音，zhushu。后来简写为虫。 所以烛字的虫与蜡烛这个词没有什么关联性，它只是读音。而蜡字那半个虫字，油脂的代表才是这个词的关键。 二者联系起来可以这样理解带油脂的火把。
1、首先要注意一定要选无烟大豆蜡的，不要问为什么，只有这个不呛，当然有些蜡烛用了棉线烛心的，灭的时候肯定有黑烟，但只是一瞬间，矫情的话可以弄个灭炷罩。
2、第一次燃烧的时候尽量烧够40分钟以上，风不要太大，这样会有一个很圆的圆心，最后可以充分利用。
3、有牌子的几个固然好 但是就是贵 个人觉得没那个必要，除非你是个无品牌不欢的人，什么都要用大牌。
4、价格一般选50左右的就行了，真的不用太贵的，但拼夕夕上有很多特别便宜的注意，并不是全都是大豆腊的，大多数成分石蜡夹杂大豆腊。慎买。
5、大豆腊熔点比较低 超过40度就出汗，超过50度肯定就化了。所以夏天买注意，别觉得这是产品不好，好才化，你搞个石蜡的试试。邦邦硬。所以不要傻。
6、网上有好几家都还不错的，有想要的我可以推荐。
在家庭购房的过程中，选择一个适宜的房屋平面图是至关重要的。俩室俩厅的平面图备受许多家庭青睐，因为它为居住者提供了足够的私密性、灵活性和舒适性。在这篇博客中，我们将探讨俩室俩厅平面图的优点以及如何打破常规布局创造一种时尚而现代的居住环境。
俩室俩厅的平面图设计非常实用，适合各种家庭类型。以下是该房屋平面图的一些重要优点：
总之，俩室俩厅平面图提供了具有私密性、灵活性和舒适性的居住空间。
为了使俩室俩厅的平面图更加时尚和现代，我们可以采用一些创意的设计方法。以下是一些建议：
将厨房与客厅合而为一，打破传统的隔断模式，创造出一个开放、通透的空间。这种设计将增加空间的流动感，方便家庭成员在烹饪和社交活动之间无缝切换。
为俩室俩厅平面图增加一个阳台，并将阳台与客厅直接相连。这样设计不仅增加了自然采光和通风，还提供了一个舒适的户外休闲区域，让居住者能够更好地享受室内外的美好风景。
在有限的空间中，合理规划并兼顾多种功能将变得至关重要。例如，客厅中可以设计一个嵌入式的书柜，既增加了储物空间，又为家庭成员提供了一个阅读和放松的场所。卧室也可以设计成带书桌的工作区，使其既能用于休息，又能用于工作学习。
在选择适合的俩室俩厅平面图时，需要考虑以下几个方面：
最重要的是，选择一个符合个人喜好和家庭需求的俩室俩厅平面图。
俩室俩厅平面图是一种受欢迎的房屋设计布局，它提供了私密性、灵活性和舒适性。通过打破常规布局，创造一种时尚而现代的居住环境，俩室俩厅平面图可以成为一个理想的选择。选择适合自己的平面图，为自己和家人创造一个温馨的家。
在现代社会，动漫已经成为了一种娱乐方式和文化符号。影响力广泛而深远的动漫作品吸引着无数的观众和粉丝。其中，俩男俩女的故事情节成为了很多人钟爱的题材之一。我们不妨来一起探索一下俩男俩女的动漫图片图库，感受这个独特的世界吧！
俩男俩女的恋爱故事向我们展示了不同性别之间的爱情和情感。这样的故事通常会呈现出截然不同的个性和世界观之间的碰撞与融合。让我们一同欣赏这些特别的图画，感受其中的浪漫和甜蜜。
俩男俩女的动漫图片图库中的情节往往能够触动观众的内心深处，让人们对爱情和情感产生共鸣。通过精心绘制的画面和人物形象，这些故事能够在观众心中营造出一种真实而深刻的情感体验。
无论是幸福的时光还是遭遇挫折的瞬间，俩男俩女之间的情感纠葛和成长历程都能够让观众感同身受。这样的情感共鸣让人们更加珍惜和理解爱情的真谛。
俩男俩女的故事不仅仅限于爱情，还常常展现出深厚的友谊和亲情。伴随着故事的发展，人物之间的情感关系也逐渐变得复杂而丰富。
朋友之间的默契、亲人之间的牵挂，都体现了一个真实而温暖的社会关系网络。这样的故事情节不仅让观众产生共鸣，也提醒了我们珍惜身边的关爱和陪伴。
俩男俩女的动漫图片图库中也经常涉及到人物的成长和自我探索。通过追溯他们的过去，观察他们的成长轨迹，我们可以从中得到很多启示和思考。
成长的道路并不平坦，每个人都会经历起起伏伏，经历各种困难和挑战。俩男俩女的故事向我们展示了他们如何通过勇敢、坚持和不屈不挠的精神逐渐成长为更好的自己。
俩男俩女的动漫图片图库既展示了情感故事，也涉及到了文化和多样性的问题。在这个多元化的社会中，人们对于不同性取向和关系模式的接受程度也在逐渐提高。
通过俩男俩女动漫作品，我们能够更加理解和尊重不同性别的爱情和生活方式。这样的作品鼓励人们欣赏和包容多样性，为社会的进步和文明发展做出了贡献。
俩男俩女的动漫图片图库也是美术创作与表现的一大突破点。通过精湛的画面和细腻的线条，艺术家们将人物形象和情感表达得淋漓尽致。
他们的创作灵感来自于真实社会和虚构世界，融合了现实与想象，呈现出一种独特的美学风格。这些作品既展示了艺术家们的才华，又为我们带来了视觉上的享受。
俩男俩女的动漫图片图库为我们呈现了一种独特的视角和表达方式。通过这些作品，我们能够更好地理解和感受爱情、友情、亲情以及成长和探索的重要性。
同时，这样的作品也推动了社会对于多样性和包容性的认知和接受。希望未来会有更多优秀的俩男俩女动漫作品涌现出来，为我们带来更多感动和启示。
歌曲名:俩俩相望 歌手:辛晓琪 专辑:杨佩佩精装大戏主题曲II 俩俩相望 原唱：辛晓琪 拈朵微笑的花 想一番人世变换 到头来输赢又何妨 日与月共消长 富与贵难久长 今早的容颜老于昨晚 眉间放一字宽 看一段人世风光 谁不是把悲喜在尝 海连天走不完 恩怨难计算 昨日非今日该忘 浪 滔滔 人渺渺 青春鸟 飞去了 纵然是千古风流浪里摇 风 潇潇 人渺渺 快意刀 山中草 爱恨的百般滋味随风飘 歌曲鉴赏： 这首歌婉转动听，唱出了人世间的恩怨情仇。人们能在歌曲里找到自己的故事，印证自己的爱情。
在现代生活中，蜡烛灯蜡烛灯蜡烛灯虽然已经不再是主流的照明设备，但是它在某些特定的场合下仍然具有很大的用处。本文将介绍蜡烛灯蜡烛灯蜡烛灯的应用和优点。
在烛光晚会上使用蜡烛灯蜡烛灯蜡烛灯，可以营造出浪漫、温馨的氛围。在这样的场合下，蜡烛灯蜡烛灯蜡烛灯可以作为主要的照明设备，为整个活动提供温暖的光线。
在停电等突发事件发生时，蜡烛灯蜡烛灯蜡烛灯可以作为临时的照明设备。由于它不需要电力，因此在这样的场合下非常实用。
蜡烛灯蜡烛灯蜡烛灯在装饰方面也非常实用。在一些重要的场合下，比如婚礼、生日等，使用蜡烛灯蜡烛灯蜡烛灯可以让整个场面更加庄重、隆重。
蜡烛灯蜡烛灯蜡烛灯不需要电力，因此不会产生二氧化碳等有害气体，对环境不会造成污染。同时，使用蜡烛灯蜡烛灯蜡烛灯也可以节约能源，为环保事业做出一份贡献。
蜡烛灯蜡烛灯蜡烛灯的光线柔和、温暖，可以改善室内的氛围，让人感到更加舒适、放松。在一些需要营造浪漫、温馨氛围的场合下，蜡烛灯蜡烛灯蜡烛灯可以发挥出很大的作用。
蜡烛灯蜡烛灯蜡烛灯具有独特的外观和质感，可以为室内装饰增加一份别样的美感。在一些需要追求个性、独特性的场合下，蜡烛灯蜡烛灯蜡烛灯也是非常实用的。
总之，虽然蜡烛灯蜡烛灯蜡烛灯已经不再是主流的照明设备，但是它在某些特定的场合下仍然具有很大的用处。同时，蜡烛灯蜡烛灯蜡烛灯还具有节能环保、改善氛围、独特性等优点，值得我们一试。
大家好，欢迎来到我的博客。今天我将为大家介绍有关蜡烛蜡烛灯的内容。
蜡烛，是一种以蜡质为主体、内置蜡芯（灯芯）并点燃蜡芯进行燃烧而发光的装置。它是人们生活中常见的光源之一，同时也具备辅助照明、装饰和氛围营造的功能。蜡烛通常由蜡资料、芯线和芯座三个主要部分组成。
蜡烛在古代被广泛运用于照明，而在现代，虽然电灯等技术的发展已经取代了蜡烛作为主要光源的地位，但是它仍然受到许多人喜爱。
蜡烛的历史可以追溯到公元前3000年的古埃及时代。当时，通过将蜂蜡或动物脂肪制成的蜡烛点燃来产生光亮。此后，蜡烛在不同文明和时期的生活中扮演了重要的角色。
在古代，蜡烛不仅被用作照明工具，还被视为一种神圣的象征。在宗教仪式和庆典中，蜡烛经常被点燃，象征着照亮心灵的力量和纯洁。
现如今，蜡烛的种类繁多，根据不同的用途和特点，我们可以将其分为以下几类：
除此之外，还有许多其他类型和款式的蜡烛，如芳香蜡烛、装饰蜡烛等。
蜡烛灯是一种以蜡烛为光源的照明装置。与传统的蜡烛相比，蜡烛灯通过增加适合点燃的材料、改变外部结构和加入保护措施等，使蜡烛的使用更加方便和安全。
蜡烛灯具有以下几个特点：
在使用蜡烛时，我们需要注意以下几点：
通过正确的使用和注意事项，我们可以更好地享受蜡烛带来的美好体验。
在现代科技高度发达的社会中，蜡烛和蜡烛灯作为源远流长的照明工具依然被广泛使用和喜爱。它们不仅给人们带来光明和温暖，也通过独特的烛光营造出浪漫的氛围。在我们忙碌的生活中，点燃一支蜡烛灯，让自己感受到内心的宁静和美好。
谢谢大家阅读我的博客，在评论区与我分享你们对蜡烛蜡烛灯的看法和使用心得吧！
曼彻斯特俩蛾是世界蛾类界的传奇对决，它们的生态和行为一直引发着人们的兴趣和惊叹。这两种蛾子，分别是曼彻斯特蓝和曼彻斯特红蛾，拥有强大而独特的特征，使它们成为了学界和自然爱好者们的研究对象。
曼彻斯特蓝蛾，科学上称为Lepidoptera manchesterensis，是一种出现在曼彻斯特地区的稀有物种。它以其迷人的蓝色翅膀而闻名，这种蓝色是如此明亮和鲜艳，宛如正在跳舞的宝石。曼彻斯特蓝蛾的发现地点并不多，一般只在雨林或森林的阴暗角落才能见到它们的身影。
与之相对的是曼彻斯特红蛾，科学上称为Lepidoptera manchesterensis rubrum，也是一种令人着迷的存在。虽然曼彻斯特红蛾和蓝蛾在生态上有着许多相似之处，但它们最大的区别在于颜色。曼彻斯特红蛾的翅膀呈现出绯红色，散发着一种神秘而妖艳的光芒，使人无法抗拒其吸引力。
曼彻斯特俩蛾在生态上有着相似的特征和行为模式。它们是夜行性动物，主要在黄昏过后才开始活动。这些蛾子依靠散发出的化学信息素来吸引异性，并进行繁殖。这是它们生命周期中最为关键的时刻，因为只有在繁殖时期，这些蛾子才能传承下去。
它们的幼虫阶段也是十分有趣的。曼彻斯特俩蛾的幼虫是食草动物，它们以特定的植物为食。根据研究发现，曼彻斯特蓝蛾的幼虫主要以蓝色花朵为食，而曼彻斯特红蛾的幼虫则以红色花朵为食。这种对于特定颜色花朵的偏好是独特而有趣的。
由于曼彻斯特俩蛾的独特之处，它们一直受到着科学研究人员的关注。许多专家和学者致力于探索这两种蛾子的生态、进化和遗传学等方面。
在进化学上，曼彻斯特俩蛾的研究帮助我们了解了它们作为物种如何适应并生存下来的。它们的独特外貌和行为模式是由于环境中特定的选择压力而形成的。通过对曼彻斯特俩蛾的基因组进行分析，科学家们揭示了它们在适应环境变化方面的基因调控机制。
另外，曼彻斯特俩蛾的研究也有助于我们理解生物多样性的保护和管理。由于曼彻斯特俩蛾的稀有和珍贵，它们面临着栖息地破坏和非法捕捞的威胁。科学家们通过研究它们的生态需求和繁殖习性，为其保护提供了科学依据，并提出了相应的保护建议。
随着科学技术的不断发展，我们对曼彻斯特俩蛾的了解将不断深入。未来，我们可能会通过基因编辑技术来培育更多外观独特的蛾子，以观察它们的行为和生态特征。同时，科学家们也将加强对曼彻斯特俩蛾的保护工作，确保这两种珍稀蛾子能够在自然界中继续繁衍生息。
曼彻斯特俩蛾的对决是自然界中一幕精彩的戏剧。无论是蓝蛾的清新与红蛾的妖艳，都在向我们展示着大自然的魅力和多样性。希望我们能够一直保持对曼彻斯特俩蛾的关注和研究，用科学的眼光去探索它们的奥秘。
俩纳米芯片的新时代
俩纳米芯片的新时代
俩纳米芯片是当今科技领域最激动人心的突破之一。纳米技术作为21世纪最具前沿的研究领域之一，为人类带来了众多的惊喜和突破。现在，科学家们已经成功开发出俩纳米芯片，这一突破将会彻底改变我们的生活。
什么是纳米芯片？
首先，我们需要理解什么是纳米芯片。纳米芯片是由纳米技术制造的集成电路芯片，其特点是尺寸非常小，仅为纳米级别。纳米级芯片通常由几十亿个二极管、晶体管和其他电子元件组成，这些元件都是微小到几乎不可见的尺寸。
纳米芯片的制造需要先进的光刻和电子束准直技术，以及纳米级别的材料工程。由于其尺寸小巧，纳米芯片具有更高的集成度和更快的运算速度，同时功耗也更低。正是这些特点使得纳米芯片在计算机、通信和物联网等领域有着广泛的应用。
俩纳米芯片的突破
俩纳米芯片的突破在于其材料和制造工艺的改进。通过使用最先进的纳米技术，科学家们成功地制造出了尺寸更小、性能更高的纳米芯片。
首先，俩纳米芯片采用了全新的材料。这种材料在纳米级别上具有出色的电子特性，能够实现更高的导电性能和更低的电阻。同时，新材料还具有更好的热传导性能，可以更好地处理芯片散热问题。
其次，俩纳米芯片的制造工艺得到了突破性的提升。科学家们使用了更精密的光刻技术和更高效的电子束准直装置，使得芯片的制造精度大大提升。这一突破使得俩纳米芯片具备更高的性能和更稳定的工作状态。
俩纳米芯片的应用前景
俩纳米芯片的应用前景不可限量。由于其尺寸小巧且性能出色，纳米芯片将推动电子设备和信息技术的发展。
首先，俩纳米芯片的应用将推动智能手机和电脑等设备的性能升级。纳米芯片的高集成度和快速运算能力将为用户带来更流畅的使用体验，并支持更复杂的应用程序和功能。
其次，俩纳米芯片将加速物联网的发展。纳米芯片可以嵌入到各种终端设备中，实现对物联网设备的智能化控制和监测。例如，通过嵌入纳米芯片，可以实现智能家居的自动化控制，提升生活的便捷性和舒适度。
最后，俩纳米芯片的应用还将推动人工智能和机器学习的发展。纳米芯片具有更高的计算能力和更低的功耗，可以为人工智能算法提供更强大的计算支持。这将加速人工智能技术的进步，推动其在各个领域的应用。
结论
俩纳米芯片的突破将会引领科技发展的新时代。纳米技术是当今科技领域最具潜力的研究领域之一，而俩纳米芯片的问世将为人类带来更先进的电子设备和信息技术。
随着纳米芯片的应用不断扩大，我们将迎来更加智能、便捷和高效的生活。同时，纳米芯片的应用也将推动物联网、人工智能等领域的发展。俩纳米芯片的突破标志着纳米技术正迈向一个新的里程碑，我们期待着未来科技的精彩呈现！
之前看了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());
}
}
显示全部
收起
