如果你是一名萨摩耶犬的主人，你可能曾经遇到过一些挑战，其中一个常见的问题就是他们需要人陪着才睡觉。这种行为常常会让主人感到困惑，但通过正确的训练和处理，你可以帮助你的萨摩耶建立更健康的睡眠习惯。在本文中，我们将分享一些关于如何训练你的萨摩耶犬独立入睡的技巧。
了解你的萨摩耶的睡眠需求是训练的第一步。萨摩耶是一种活泼好动的犬种，他们需要充足的活动量来消耗体力。如果你的萨摩耶没有得到足够的运动，他们可能会变得焦躁不安，需要依赖人陪才能入睡。
此外，萨摩耶也是一种非常亲近主人的犬种，他们喜欢与主人建立密切的关系。这种亲近倾向可能会表现在需要人陪才能安心入睡的行为中。因此，训练萨摩耶独立入睡需要结合他们的体能需求和情感需求。
为了帮助你的萨摩耶独立入睡，你需要建立一个固定的睡眠环境。这包括为你的萨摩耶选择一个舒适的睡眠地点，比如一个柔软的狗床或者专门的睡眠区域。这个地方应该安静、舒适，最好远离外界干扰。
另外，为了营造助眠的氛围，你可以为萨摩耶准备一些安抚的玩具或者盲目，帮助他们放松身心。在这个固定的睡眠环境中，让你的萨摩耶逐渐习惯独立入睡，而不依赖人陪。
训练萨摩耶独立入睡是一个渐进式的过程，你需要耐心和持之以恒。一开始，你可以在睡前与他亲密接触，给予他安慰和安抚，然后逐渐减少这种依赖性的行为。
你可以逐渐延长与他分开的时间，让他习惯独自入睡。如果你的萨摩耶在夜晚醒来，试图依赖人陪才能再次入睡，你可以尝试慢慢减少这种响应，帮助他建立更独立的睡眠能力。
在训练过程中，你可以使用积极的强化方法来帮助你的萨摩耶建立独立入睡的习惯。比如，当他能够在没有人陪的情况下入睡时，你可以给予他奖励，比如零食或者表扬。
通过积极的强化训练，你可以增强你的萨摩耶与独立入睡之间的联系，帮助他建立更稳定的行为模式。记住，训练过程中要注意及时给予奖励和正面反馈，以帮助他更好地理解你的期望。
最后，如果你的萨摩耶始终需要人陪才能入睡，可能是因为他们存在一些健康或者情绪问题。在这种情况下，你应该及时咨询兽医或者专业的狗行为专家，以找出根本原因并制定合适的治疗方案。
有时候，萨摩耶需要人陪才能入睡可能是因为他们感到焦虑或者害怕，需要更多的安慰和支持。了解你的萨摩耶并给予他们足够的关爱和照顾是培养健康睡眠习惯的关键。
总的来说，训练萨摩耶独立入睡需要耐心、理解和持之以恒。通过建立固定的睡眠环境、渐进式训练、积极的强化和关注健康问题，你可以帮助你的萨摩耶建立更健康、更独立的睡眠习惯。记住，与你的宠物建立良好的关系是培养积极行为的基础，而理解他们的需求和情感是实现成功训练的关键。
寿险自然死亡才陪吗
寿险是一种人们寄托着对未来的期望的保险产品，它能够提供保障和经济支持，确保我们的家人在我们离开后能够有一个安全的生活。然而，很多人对于寿险的保险赔偿有着一些疑问，特别是当被保险人是因自然死亡而离世时。
寿险一般分为两种类型：自然死亡保险和意外身故保险。其中，自然死亡保险是指当被保险人因自然原因而去世时，寿险公司会向受益人支付保险金额。相比之下，意外身故保险则是在被保险人因意外事故而丧命时进行赔付。
对于自然死亡保险，寿险公司会根据合同中的条款和条件来确定赔付金额。通常情况下，寿险合同中会明确规定寿险赔偿的范围和条件。一般来说，寿险保单在自然死亡的情况下是可以获得赔偿的，但具体的赔偿金额会根据保单的条款而有所不同。
针对寿险自然死亡赔付的条件，通常包括以下几个方面：
不同的保险公司在对寿险自然死亡赔付问题上可能存在差异。有些保险公司对自然死亡条件较为宽松，而有些则会对自然死亡进行更严格的界定。
因此，投保人在购买寿险产品时应该仔细阅读合同内容，了解保险公司对于自然死亡的定义以及赔付条件的具体规定。如果对合同中的某些条款存在疑问，可以咨询专业人士或联系保险公司的客服进行咨询。
以下是一些关于寿险自然死亡赔付的常见问题及答案：
根据寿险合同的约定，如果被保险人因意外事故而导致伤残或暂时停工，但并非即时身故，一般是不符合寿险赔付条件的。自然死亡保险主要是针对被保险人的身故情况。
大多数寿险合同会规定自杀在一定期限内是不会进行赔付的。通常在自杀时间起两年内，保险公司不承担赔偿责任。自杀在保险合同中是一种特殊情况，需要谨慎对待。
寿险自然死亡保险一般需要被保险人进行体检，以确认其身体状况是否适合购买该保险产品。因为保险公司需要评估被保险人的风险，从而确定保险费和赔付条件。
总之，在购买寿险自然死亡保险时，我们需要详细了解合同条款，确保自己对赔付条件有清晰的认识。如果对合同内容有任何疑问，建议及时咨询律师或保险公司的专业人员。
近日，一则关于美女陪导演睡完才知道他说的新闻引起了广泛关注。这个事件引发了许多人的思考和讨论，对于娱乐圈的黑暗面再次引起了人们的担忧。
据报道，一位美女模特声称自己被一位知名导演邀请到他的家中陪睡。在陪睡的过程中，这位模特才发现导演其实并不会说他所声称的流利英语，而是一直使用自己的母语与她交流。这对于那位模特来说，是一个巨大的震惊和打击。
虽然这件事情只是个别案例，但它再次引起了人们对于娱乐圈黑暗面的关注。导演与演员之间的关系向来备受关注，有时候会因为一些不道德的行为而引发争议。这次事件的曝光，让人们对于娱乐圈乱象感到愤慨和失望。
在娱乐圈，有一些不法之徒利用自己的职权和地位，对待演员不公正。他们以提供资源和机会为借口，去满足自己的私欲和欺骗他人。这种行为不仅伤害了受害者的利益，也败坏了整个娱乐行业的形象。
为了避免这种事件的发生，娱乐业需要更加完善的规范和法律保护机制。首先，要建立严格的审核机制，确保电影、电视剧的制作过程中不发生任何不合理的行为。同时，演员们也需要加强法律意识，学会保护自己的合法权益。
其次，我们需要加大对于娱乐圈的监管力度。只有加强对于导演、制片人等行业人士的监督，才能有效地遏制他们的不当行为。同时，对于违法违规行为要进行严厉的处罚，以起到震慑作用。
此外，社会的监督也起到了至关重要的作用。公众应该保持对于娱乐圈的关注和声音，通过舆论的力量推动整个行业向更加规范和健康的方向发展。
对于演员来说，保护自己的权益同样重要。他们需要学会如何判断一个机会是真实可信还是陷阱。要了解每个合作方的背景和信誉，对于不合理的要求和行为要果断拒绝。
同时，演员也需要通过自身的努力和能力来提高自己的地位和话语权。只有真正拥有了实力和独立思考能力的演员，才能避免成为他人的玩物。
这次事件引起了广泛的社会关注，有助于推动娱乐圈更好地规范自身。通过这种曝光，公众对于问题和乱象有了更深入的了解，同时也给了受害者更多的关注和支持。
娱乐圈作为一个特殊的行业，需要承担起对社会的责任。不仅要创造出优秀的作品，还要为整个社会树立正确的价值观和道德标准。只有这样，我们才能共同努力，让娱乐圈成为真正美好的世界。
陪猫咪玩耍是与它建立互动和增进关系的好方式。以下是一些可以让猫咪高兴的玩耍方法：
1. 提供适合的玩具：给猫咪提供各种适合它的玩具，如羽毛棒、小球、猫爪板等。猫咪喜欢追逐、抓捕和攻击的游戏，这些玩具可以激发它们的猎食本能。
2. 使用互动玩具：与猫咪一起使用互动玩具，如激光笔或线绳，让猫咪追逐其中的光点或物体。确保在使用激光笔时不要直接照射到猫咪身体或眼睛。
3. 增加运动和追逐：利用长走廊或开阔的空间，与猫咪一起玩追逐游戏。你可以使用玩具或纸球引导猫咪追逐，并给予它鼓励和赞美。
4. 制作隐藏和寻找游戏：将猫咪的零食或玩具藏在不同的地方，让猫咪通过嗅觉和探索找到它们。这可以激发猫咪的智力和探索欲望。
5. 定期互动和玩耍时间：确保每天有一段专门的时间与猫咪互动和玩耍。这可以增进你们之间的关系，并满足猫咪的需求。
6. 观察猫咪的喜好：观察猫咪的喜好和行为，了解它最喜欢的玩耍方式。有些猫咪喜欢攀爬，你可以为它提供攀爬架或树枝；有些猫咪喜欢追逐，你可以使用快速移动的玩具引起它们的兴趣。
重要的是，尊重猫咪的边界和需求。如果猫咪不感兴趣或表现出不喜欢的行为，就停止相应的游戏或活动。每只猫咪的个性和喜好都有所不同，耐心地了解和适应猫咪的喜好，与它们建立更深入的互动和关系。
有很多玩的，挠痒痒，捡球球，。。。。。
1、 大声朗读
在孩子还没有认字的情况下，或者说还不能够独立的完成阅读的情况下，父母在陪伴孩子读书的时候，可以大声的朗读出来。
为什么呢？因为这个时候孩子还没有认识字，不能通过识别文字来触发自己的大脑进行思考。但是，他能够辨识声音和一些简单的语言，那么当我们大声的朗读的时候，孩子可以根据声音语和言当去想象、去判断我们所要表达的意思。
在这样的整个过程下来，孩子可以欣赏我们声音的同时，他自己的想象力、判断力，以及语言能力都能够得到一定的锻炼，从而提升大脑的活跃程度。
2、 尊重孩子
亲子阅读最重要的主角还是孩子。我们要站在孩子的角度去阅读，去完成这一过程，用孩子的思考方式进行思考。
比如说，琳琳的孩子快两岁了，平时有空的时候总会叫妈妈给他讲故事，而且最喜欢的就是讲龟兔赛赛跑的故事。
琳琳觉得这个故事已经讲了很多遍了，一直跟孩子说要换一个故事，但是孩子总是不肯，就是要听这个故事才开心。
其实，孩子还小，他的记忆能力还是比较弱的，基本上是处于于机械记忆的阶段，不能进行逻辑的分析的。
不断重复的声音、语言、动作可以和他大脑当中先前的的简单记忆进行快速的联系，这样会让孩子感觉到轻松、安全和愉悦。
所以孩子会不厌其烦的想去重复一些行为。往往在这个时候我们一定要尊重孩子的选择，毕竟，对于大人来说很简单的事情，对孩子来说就不简单了。
3、 合适的绘本
想要进行阅读，首先我们必须得选择绘本，在绘本的选择上，必须是以孩子为主体，选择适合孩子年龄阶段和成长规律的绘本，万不可盲目选读。
我们陪孩子读书时，注意遵从先单字再到词语、词组，最后到语句这一个过程来。
那么根据这样的规律，我们要选择相对应的合适的绘本。开始孩子还小的时候，才刚刚学会说话，我们要选择一些只有单字的绘本，随着孩子年龄的不断增长，我们要选择词语绘本，再后面才到语句绘本，以及小小故事书。
父母千万不能操之过急。选择超越孩子成长阶段的绘本不仅不利于培养孩子的阅读能力，有可能还会使孩子对阅读产生抵触情绪。
1 医疗类的视频可以拍摄，但需要遵守相关的法律法规及行业规范，不能违规。2 医疗类的视频属于特殊领域，需要注意的问题比较多。在拍摄前要先进行前期准备，明确拍摄的目的和范围。拍摄时需要遵守隐私保护和知情同意的原则，不得发布病人信息和病历资料等敏感信息。另外，在拍摄医疗手术过程时一定要注意卫生和安全，保证医护人员和病人的生命安全。3 为了不违规，建议在拍摄前及时咨询相关专业人士或机构，了解相关法规和规范，确保拍摄过程和内容合法合规。同时，在拍摄过程中也应该注重舆论导向和宣传效果，避免敏感信息的泄漏和不良影响的产生。
睡觉有人陪着睡得香，因为有人在身边心里觉得踏实有安全感。尤其是女性，天生胆子小，一个人孤单单的睡在床上很容易会失眠，特别是在寒冷冬天的夜里，又冷又黑，一个人翻来覆去睡不着，总感觉屋里有东西，各种奇怪的声音，灯开了关，关了开，如果有个人陪着睡得就会踏实多了
在生活中，我们常常会面临需要赔偿别人损失的情况。不论是因为意外事故、医疗过失还是其他原因造成的损害，赔偿是维护社会公正和平衡的重要环节。其中，赔偿金额的确定是一个复杂的问题，需要综合考虑多个因素。
赔偿的目的是使受损方能够获得合理的经济补偿，以弥补因种种原因导致的损失。尽管赔偿金额的确定存在一定的法律依据，但具体的计算方式因案件而异。以下是一些常见的因素，可能影响赔偿金额：
赔偿的计算方法因国家和地区而异。一些地方遵循传统的损害赔偿计算方法，主要根据受害人的经济损失和痛苦来确定赔偿金额。其他地方则使用更为复杂的计算方法，将经济损失、社会影响、公平等因素综合考虑。
经济损失计算是赔偿金额计算中最为重要的一部分。它通常包括以下几个方面：
除了经济损失之外，还有一些赔偿项是用于弥补非经济损失，如精神痛苦、家庭生活受损等。对于这些损失的计算较为困难，常常需要综合考虑以下因素：
赔偿金额的计算中，公平原则是一个非常重要的考虑因素。公平主要包括以下几个方面：
赔偿金额的计算是一个复杂而重要的问题。在确定赔偿金额时，必须综合考虑受害人的经济损失、非经济损失以及公平原则。只有在充分考虑了这些因素后，才能确定一个合理的赔偿金额，使受害人能够获得相应的补偿。
无论是受害人还是赔偿方，都可以通过专业的律师咨询来了解赔偿计算的具体细节和法律依据，以确保自身权益的合理维护。只有通过合理有效的赔偿计算，才能达到赔偿的公平正义，以及法律的公信力的维护。
之前看了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());
}
}
