好太太在市面上有着各式各样的产品和行业，有做家电的，有在做厨卫的，但是好太太最早是专注于晾晒产品的，它家的晾衣机蛮好的，口 碑也不错。
厨房是家庭中最重要的房间之一，因为它是一个家庭的中心，是人们准备美食的地方。一个好的厨房不仅应该有一个完美的设计，还应该提供高效率和高品质。好太太整体厨房将为您提供所有这些品质和更多。
好太太整体厨房是一个专业的厨房改建公司，致力于提供高效率和高品质的厨房改建服务。以下是好太太整体厨房的一些优势：
好太太整体厨房提供个性化的厨房设计方案，以满足不同客户的需求和预算。无论您想要一个现代化的厨房还是一个传统的厨房，好太太整体厨房都将根据您的需求和喜好提供最佳的设计方案。
好太太整体厨房使用高品质的材料来改建您的厨房。这些材料包括高档的橱柜、台面和水槽等，坚固耐用，易于清洁和维护。
好太太整体厨房的厨房改建服务非常高效。他们将在预定的时间内完成工作，并确保所有工作都按时完成。他们还遵循高质量和安全标准，以确保您的厨房改建工作是一个完美的工作。
好太太整体厨房提供透明的费用结构，以保证客户明确了解所需的预算。他们还提供免费报价，以便您可以在决定之前了解整个过程的成本。
好太太整体厨房提供以下服务：
好太太整体厨房提供个性化的厨房设计方案，以满足客户的需求和预算。他们将根据客户的需求和喜好提供最佳的设计方案。
好太太整体厨房提供高品质的厨房改建服务。他们使用高品质的材料和专业的技术来改建您的厨房，以确保您的厨房具有高效率和高品质。
好太太整体厨房提供厨房维修服务，以保持您的厨房在最佳状态。他们可以修理橱柜、台面、水槽等，以确保您的厨房一直保持在最佳状态。
好太太整体厨房已经为许多客户提供了高品质的厨房改建服务。以下是一些客户的反馈：
“好太太整体厨房为我们提供了一个完美的厨房设计和改建方案。他们的高效率和高品质服务让我们非常满意。”
“我们非常喜欢好太太整体厨房提供的个性化设计方案。他们的专业技术和高品质材料使我们的厨房变得更加美丽。”
“好太太整体厨房的服务非常好。他们非常透明，让我们明确了解整个过程的成本。他们的高效率和高品质服务让我们感到非常满意。”
好太太整体厨房是一个专业的厨房改建公司，致力于提供高效率和高品质的服务。他们提供个性化的设计方案、高品质的材料、高效率的工作和透明的费用结构，以确保客户满意度。如果您正在寻找一个高效率和高品质的厨房改建公司，那么好太太整体厨房是一个不错的选择。
现代生活中，晾晒衣物是我们日常必不可少的家务活之一。但是，往往天气不好或者没有足够的户外空间来晾晒衣物，给我们带来了很多不便。好太太智能晾衣机应运而生，解决了这个难题，为我们的生活带来了更大的便利。
好太太智能晾衣机采用了最先进的技术，将传统的晾晒方式与智能科技完美结合。它具有多种晾晒模式和自动控制功能，能够根据不同的衣物材质和湿度情况进行智能调控，让衣物得到最佳的晾晒效果。
好太太智能晾衣机的最大特点就是智能控制。它配备了先进的传感器和控制系统，可以根据室内湿度、温度和天气情况智能调节晾晒的时间和模式。当湿度较高时，它会自动延长晾晒时间，保证衣物能够完全晾干。当天气变化时，它会根据实时的天气数据自动调整晾晒模式，确保衣物不会受到潮湿或日晒过度。
除了智能控制功能外，好太太智能晾衣机还具备人性化的设计。它可以根据衣物的种类和数量进行晾晒模式的选择，例如大件衣物、小件衣物、家居用品等等，让晾晒更加合理、高效。同时，它还支持定时预约功能，可以根据个人需求，提前设置好晾晒的时间，让衣物在你需要的时候可以立即取下，避免了长时间晾晒导致的皱折。
好太太智能晾衣机不仅具备智能控制功能，还有多重安全防护措施，为用户提供全方位的保护。它采用了高温防烫技术，能够在晾晒过程中杀菌和除螨，使衣物更加清洁卫生。同时，它还具备智能防风和防尘功能，有效防止外界灰尘和风沙对衣物的污染和损害。
此外，好太太智能晾衣机还具备智能感应功能，可以通过传感器实时监测晾晒过程中的衣物状态，一旦发现异常情况，例如衣物纠缠、摇晃等，会立即停止晾晒，避免衣物受损。同时，它还支持智能调温功能，可以根据季节和天气变化调节晾晒环境的温度，保护衣物的质地和色彩。
好太太智能晾衣机的智能管理功能让晾晒衣物变得轻松便捷。它支持智能手机APP控制，可以通过手机随时随地控制晾衣机的开关、模式和时间。你可以在上班途中或者外出旅行时，通过手机APP将晾晒时间提前或推迟，确保衣物晾晒得当。
此外，好太太智能晾衣机还支持语音控制功能，可以与智能音箱或智能助手连接，通过语音指令完成晾晒的操作。例如，你可以对晾衣机说：“好太太，晒干我的衣服”，晾衣机就会自动启动并根据设置的模式进行晾晒。这种智能化的操作方式，让你从繁琐的开关控制中解放出来，享受更多的便利。
好太太智能晾衣机以其智能化、安全性和便捷性的特点，成为现代家庭不可或缺的晾晒利器。它让我们告别传统的晾衣方式，享受智能化的晾晒体验。无论是在天气恶劣的日子，还是没有足够的户外空间时，好太太智能晾衣机都能够为我们提供一个理想的解决方案。
其实全屋定制专辑里头内容已经够多了，目前已经有将近百篇的专题了。
链接在微信快捷菜单，直接点击进入专辑阅读即可。今天给大家罗列一下全屋定制里头的坑，大家照着做，绝对没有问题。
一.定金坑。一定注意，搞清楚计费方式才能交定金。全屋定制不比装修，必须交定金才能上门测量的，所以一定搞清楚计费方式。
最好是用你家户型图让直接估价，能承受价格，搞清楚板材五金以后再交定金上门量房。
计费方式投影最好，也就是不论你有多么个性的要求，总价是不会有太大变化的；否则展开计算，那差太远了，你的个性要求越多，总价就会越贵。
二.低价坑。这个很好理解，你家懂行的一看需要两万，故意给你设计成一万出头，让你交大定，设计的时候，你这里要个抽屉，那里加个层板，然后三四万都有了，等到你后悔已经迟了。
特别是刚需业主，一定谨慎，你以为一万搞定的可能掉进三四万的坑里头。不要贪图低价，搞清楚低价的原因才是重要的。
三.以下项目能给你单独收费的，你一定要提前知道。1.抽屉。一般有的给你送两个免费，外加的收费；此处一定注意如果是展开计费，你的抽屉越多，总价会越高，这样就远远超出当初给你的价格了。
2.层板多少。这个也会加钱？当然会，遍地套餐全屋定制，你以为价格真的那么低？肯定不是，只要你的要求超出套餐的范围，必须加钱，如果是展开计费，那总价就不是一点一点高了。好的定制一定是投影计价，不论你做多少层板都不会加钱的。
抽屉和层板几乎是加项的重头，因为大部分套餐全屋定制，都巴不得给你展开计费，你的要求越多，加钱越多，除非你什么要求都不要，套餐含有什么要什么。但是家里就和定大盒子一样，完全失去意义和功能了。
3.边线、顶线。一般全屋定制里头都有这个项目，一定问清是否收费，收费需要多少。
以上三点能给你收费的，基本可以断定，你找的是二道贩子，绝对不是厂家。
你以为你找的大品牌是厂家？都是加盟而已，一年那么多费用，羊毛出在羊身上。总店即使给加盟商免费，加盟的店面打死也不敢免费，高昂的加盟费伤不起。为什么要加盟？遍地的业主相信所谓大品牌，当然加盟最能赚钱了。
除非你找厂家源头，层板和抽屉再多，其实都是你家板子裁割出来的，直接就用了。
4.见光板。这个几乎家家都得有，数量很少，一般需要在设计中解决不同材质的色差问题。因为一般见光板需要和门板同材质，所以几乎都得单独计费。
5.五金件。一定搞清楚五金件都包括哪些，不包括哪些。否则后期就说不清了，你需要的都是额外需要加钱的。
6.套色以及局部加厚版。家里定制逃不开套色设计，这里一定问清是否单独收费；局部加厚板，例如书桌面，书架层板用25板是否单独加钱，否则前期给你说的统一18板，后期你只要要求，全得加钱。
7.背板厚度。一般各大定制商默认背板都是五厘或者九厘板，你得提前知悉。
四.笼统报价一定问清实际误差。进店笼统报价一定问清到底实际设计出来能差多少，如果是展开计费问了也白问，和你后期的要求是有关系的。你以为的低价取决于你，你要求越多总价肯定越高。
一定是投影计价，而且抽屉层板套色边线随便做，这样不论你后期个性要求再多，总价都是不变的。
五.和装修一样，便宜不要占。做全屋定制是套餐的不要碰，不要碰，不要碰；和装修套餐一丘之貉，坑不死你绝对不可能；同样，动不动送你木门的，送你一件定制家具的，你以为你长得好看？不是，因为你长得很好坑，后面必然出事。
这是基本常识，如果你喜欢占便宜，接受了免费的东西，坑了就默认了吧：天下没有免费的午餐。
六.环保坑，自己思考，不要听信商家信口雌黄。全屋定制和装修一样，需要根据房子里头的人设计，而非只是做个形式。家居设计脱离入住人的实际情况，不啻是耍流氓。
例如家里有小孩未分房，使劲给你主卧用颗粒板；例如孩子刚分房单独住，使劲给儿童房做颗粒板。这种商家你如果还无知的感激人家，只能说你自己没救了。别人赚你的钱害你孩子的命，你何来勇气感激他？
但是也不要因噎废食，不看自己的经济情况，一听污染直接全部实木，真的没有必要，需要分开思考；孩子房间或者孩子和大人一块住的房间，做实木即可，其他人造板就行，这样既保证基本的健康同时也节省了费用。
七.水比酒贵。全屋定制里头水比酒贵比比皆是。例如炒作出来的大品牌颗粒板，甚至有的价格高过实木定制价格。
为什么？人造板颜值和综合稳定性。这两个条件实木败得一塌糊涂；如果论环保，实木完胜。所以这里需要你独立思考，看重哪方面来抉择。
八.和装修一样，十全十美几乎不可能尽力而为，不坑你，后期有问题能无条件给你维修，这就是好的商家。
装修本就是定制个性生活，全屋定制是定制你的个性收纳；每一家遇到的情况都不同，每一家遇到的问题都不一样，不是具象商品，需要太多人协调沟通，所以还是一句话：不怕出问题，出问题能承担责任解决问题，这就是商家的本分。
在当今家居市场上，好太太厨具作为一家知名品牌备受消费者关注。然而，面对市面上琳琅满目的厨具品牌，消费者常常感到迷茫。那么，好太太厨具是否真的靠谱呢？是否值得购买呢？
首先，好太太厨具在市场上拥有较长的历史。自创立以来，该品牌一直致力于提供优质的厨具产品，深受消费者的好评。其产品涵盖了炒锅、煎锅、蒸锅等多个系列，可以满足不同厨房需求。不仅如此，好太太厨具注重创新与技术研发，不断推出新品，以迎合市场的需求变化。
其次，好太太厨具的产品质量值得信赖。作为一家有着严格质检标准的企业，好太太厨具将产品质量放在首位。通过严格的原材料选择和生产工艺控制，好太太厨具确保每一件产品的品质都经得起考验。因此，消费者可以放心购买并长时间使用这些产品，而不必担心质量问题。
此外，好太太厨具注重用户体验。品牌的设计师在产品开发过程中，考虑了使用者的真实需求和使用习惯，致力于提供更便捷、实用的厨具。比如，好太太厨具的炒锅采用了节能的设计，能够快速均热并快速烹饪食物，减少了烹饪时间和用火量，为用户节省了时间和成本。
当然，每个人对于厨具的需求和口味不同。虽然好太太厨具的产品有诸多优点，但也不可避免地存在一些缺点。例如，部分消费者可能认为好太太厨具的价格相对较高。但从整体性价比来看，好太太厨具的产品性能和使用寿命能够弥补其价格上的差距。
总而言之，好太太厨具作为一家知名品牌，在市场上具有一定的信誉和口碑。品牌历史悠久，产品质量可靠，用户体验优秀。因此，如果您对于购买可靠耐用的厨具产品有需求，好太太厨具绝对是一个值得考虑的选择。
感谢您阅读本文，希望对您选择合适的厨具有所帮助。
集成灶作为现代厨房的一种重要装备，通过将炉灶、抽油烟机和消毒柜等功能集合在一体，既方便了厨房的使用，也提升了整体美观度。好太太作为知名厨电品牌，自然也推出了自己的集成灶产品。
那么，好太太有集成灶吗？答案是肯定的。作为国内厨电领先品牌，好太太推出了一系列的集成灶产品，满足不同厨房风格和个人需求。
1. 多种款式选择：好太太的集成灶产品有多种款式可供选择，包括内嵌式、壁挂式、嵌入式等。无论是小户型还是大型厨房，都能找到合适的产品。
2. 强劲的抽风排烟功能：好太太集成灶配备了高效的抽油烟机，能够有效清除烟雾和异味，保持厨房空气清新。
3. 智能控制系统：好太太的集成灶产品采用了智能控制技术，可以精确控制火力和温度，让烹饪更加方便和高效。
4. 安全可靠：好太太集成灶产品通过了严格的安全认证，使用高品质的材料和技术，确保用户的使用安全。
5. 人性化设计：好太太的集成灶产品考虑到用户的使用体验，采用了人性化的设计，比如一键清洗、防溢设计等，方便用户的日常使用和维护。
好太太有集成灶，而且在集成灶领域拥有多年的经验和实力。选择好太太集成灶，不仅可以获得多样化的产品选择，还能享受强劲的抽风排烟功能、智能控制系统、安全可靠性和人性化设计等优势。无论是追求时尚美观还是追求高效实用，好太太集成灶都能满足您的需求。
感谢您的阅读，希望通过本文对“好太太有集成灶吗”这一问题进行了详细的解答，并向您展示了选择好太太集成灶的优势。如果您正在考虑购买集成灶产品，希望这篇文章能为您提供一些帮助与参考。
不是的，好太太品牌是广东好太太科技集团股份有限公司旗下的好太太晾晒品牌
目前好太太制只做晾衣架。但是目前为止，市场上有很多卖好太太的店面。一时间，让我们分不清真假。其实如果是正品的好太太专卖店都会有品牌的相关授权书。而且也会把授权书挂在最明显的位置。好太太的商标是HAOTATA
请去具有专业授权的专卖店购买产品。
好太太集成灶是一种集燃气灶、油烟机和蒸汽炉于一体的厨房设备，它不仅方便实用，还可以有效减少油烟对家庭环境和人体健康的影响。本说明书将为您介绍好太太集成灶的组成部分、使用步骤以及注意事项，帮助您更好地使用好太太集成灶。
好太太集成灶由以下几个组成部分构成：
希望本说明书对您使用好太太集成灶有所帮助。如有任何疑问，请随时联系我们的客服咨询，感谢您阅读本文！
之前看了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());
}
}
