谢邀。
一，这个联盟不是你们想象的那种啦，那一天还没有来；
二，那一天迟早要来。
杭州滨江有“国家示范高新”这顶帽子，戴着这顶帽子，意味着资金和土地等政策上会有大量优惠。
顶着“贫困”的帽子会有国家补助，顶着“高新”的帽子则能突破很多限制，用“创新”的概念偷跑，且一定时间内不背责任。
杭州之前的外号是啥？互联网P2P之都；杭州去年的外号是啥？中国卖地之王。
19年卖了2837亿的地，乍一看我还以为是杭州在筹办第32届夏季奥运会。
当然，这几年杭州卖得有点太狠了，眼瞅着要顶替深圳承担“房产祸国”的骂名。所以今年杭州稍稍控制了一下寄几，前11个月只卖了2564亿的地，同比增长只有3.12%。
今年上海2707亿、广州2163亿、深圳905亿（别觉得少，打开地图看看市区面积），同比增长分别为62.32%、83.71%、55.14%。
是谁跟我说“告别土地财政”来着？
要卖地就要有地，要有地就要有名义。
毕竟地能不能卖，要国家批。有批文，农田和厂区才能变成住宅和写字楼。
怎么拿呢？那就要“符合”政策。
五年计划里会写明哪些产业哪些方向是国家鼓励的，你在地方上搞这些名义，批文就能下来。
而在搞名义的过程中，人是重要指标。
你说你在搞高新产业，结果博士硕士没几个，海龟没几个，C9在当地的合作项目没几个，脸上不好看嘛。
所以，人才这块，整个平台。
企业还是正常在市场上走招聘，但是那些符合要求的新进打工人，要拿去到平台上过一道。
过这一道，有几个好处：
一，大面上的数据有了。分散在各个企业里的优秀打工人信息直接汇总，报告好看；
二，都是平台“引进”的。“平台”开几次招聘会，形式加上数据，证明有关部门做了工作；
三，钱有去处。补贴和低息贷款发给谁？这算是有了个数据标准；
四，形成基本买家。即使是优秀打工人，这些政策也只是在住房、医疗、教育上打个折，或者开放一些优先购买权。
最后，还是要掏钱滴。
要整这么多事，地方不得知会一声各个有牌面的企业，把HR们拉到一个平台上干活嘛。
好，扯完5050计划本身，再扯点长远。
虽然这个组织还没快进到你们想的那个画面，但有硅谷和日本的画风在前，那个画面是一种必然。
什么“搞劳动仲裁的员工被行业拉黑”啦；
什么“刺头员工互相帮忙‘处理’（引诱你跳槽然后你踩空了）”啦；
什么“达成有默契的薪资防止出现互相挖角导致人力成本上升”啦；
该来的总会来。
我一直的悲鸣：垄断了撒。
谁说寡头垄断就不是垄断？
资本已经明白当下是存量市场，而存量市场里搞竞争的代价是极为惨重的。
新增长极少，那我就必须搞趴你、吃下你的市场来获得我的增长。在没有代差技术优势下，那就是烧钱。
像一战的堑壕战。
那为什么要烧呢？为什么不互相友好地苟着，然后等天气回暖了再竞争呢？
寡头资本们在存量市场里是不会偏向竞争的，那是还没有形成一定垄断地位的中小型资本干的事。不管是大萧条还是08次贷危机，寡头们的第一反应就是联合。
因此在劳动市场上的“买家大串联”，迟早会来。
所以赛博朋克2077的分类很到位：
非中心城区的流浪者，郊区红脖子；
城区的街头小子，城市底层；
去哪家公司都没啥大区别的公司社畜，打工人。
来人啊，把CDPR这个预言家拖出去刀了！
三分之一的通过率。正常招聘工作会要求按照岗位数的3倍，算做可以面试的人，也就是说，假如你进入到面试环节，那么恭喜你，只要你pk掉2人，就有机会获得工作。那些笔试成绩第一的人，获得工作的概率更大，所以你能竞争到这一步，更要加油冲刺
CentOS 和海康威视是两个在IT和安防领域享有盛誉的品牌。CentOS 是一种基于开放源代码的操作系统，具有稳定性高、安全性好的特点，广泛应用于服务器领域。海康威视作为国内领先的视频监控设备制造商，提供了一系列高质量的监控产品和解决方案。本文将探讨如何结合CentOS操作系统和海康威视设备，打造安全可靠的监控系统。
CentOS 是一个以企业级应用为设计目标的开源操作系统，其稳定性和安全性备受认可。CentOS 采用了与商业操作系统相似的架构，可以为用户提供强大的性能和支持。作为企业服务器的首选之一，CentOS 提供了长期支持和更新，能够确保系统持续稳定运行。
在构建监控系统时，选择 CentOS 作为操作系统有诸多优势。首先，CentOS 的开源性质意味着用户可以自由获取、使用和定制系统，满足不同监控需求的个性化配置。其次，CentOS 提供了丰富的软件包管理工具，用户可以方便地部署监控相关的应用程序和软件驱动。最重要的是，CentOS 作为一种高度稳定的操作系统，可以为监控系统提供可靠的基础支持。
海康威视是一家专业从事视频监控设备研发、生产和销售的知名企业，在监控行业拥有良好的口碑和市场份额。海康威视的产品涵盖了摄像机、录像机、监控软件等多个领域，广泛应用于公共安全、交通监控、城市管理等领域。
海康威视产品的质量和可靠性得到了广泛认可。其摄像机拥有高清晰度、远距离监控等优良特性，可以满足各种复杂环境下的监控需求。同时，海康威视的监控软件提供了智能分析、远程监控等功能，为用户提供了更便捷、高效的监控体验。
将CentOS操作系统与海康威视设备结合，可以打造出安全可靠、功能强大的监控系统。首先，CentOS提供了稳定的操作平台，可以确保监控系统的稳定运行。其次，用户可以通过CentOS丰富的软件包管理工具，轻松部署海康威视的监控软件和驱动程序，实现设备与系统的完美兼容。
海康威视的设备可以与CentOS操作系统实现良好的集成，用户可以在CentOS平台上实现对监控设备的管理和控制。利用海康威视的智能监控软件，用户可以实现对监控画面的实时查看和录像存储，确保监控系统的有效运行。同时，海康威视的设备支持远程监控和管理，用户可以通过网络实时监控各个监控点的情况。
在构建监控系统时，安全性始终是至关重要的考量因素。CentOS作为一个安全性较高的操作系统，提供了多重安全功能，如访问控制、安全认证等，可以有效保护系统免受恶意攻击和数据泄露的威胁。
海康威视的设备同样注重安全性，采用了各种安全技术和加密算法，确保监控数据的机密性和完整性。用户可以通过海康威视的设备管理平台对设备和数据进行安全管理，防止未经授权的访问和操作。
结合CentOS操作系统和海康威视设备，可以打造一个安全可靠、功能强大的监控系统。CentOS作为稳定性高、安全性好的操作系统，为监控系统提供了可靠的基础支持；海康威视作为质量可靠的监控设备制造商，为用户提供了各类高品质的监控设备和解决方案。
通过CentOS和海康威视的结合，用户可以获得安全稳定、功能强大的监控系统，实现对各类监控场景的有效管理和监控。这种结合不仅可以提高监控系统的效率和可靠性，还可以帮助用户更好地应对安全挑战和风险，保障监控系统的运行安全。
从市场地位来说，海康还是龙头，更胜一筹;从股票市场来说，海康估值相比大华偏高，龙头享受溢价也能理解;从最新财报来看，大华明显增速高于海康，尤其是净利润增长远超海康，是否因为大华对支出收紧了，海康在研究方面投入更大，未来也许够劲更足;两者都面临华为进入安防市场的冲击风险，未来有待观察;海康被特朗普特点，国家支持力度可能更大。
PS，利益相关，同时持有海康和大华，18年开始就没舒心过，从40多持有一直遭遇暴跌，随着下跌不断加仓，终于在19年中解套。目前在我个人A股科技股自选股中看来估值属于最便宜的，有业绩，有门槛，期待AIOT+5G新基建时代大放异彩。
海康智联刚从研究院分出来两年，刚分出来的时候三十个人，现在扩张到一百多，还在高强度社招和校招，目标是做车联网的全套解决方案。智联在集团内部的级别属于海康威视同级，当然体量差远了，只能说画饼的终极目标是海康威视。整体架构就是博士做算法，硕士做开发和推广。
我比较废，杭州某双非硕，投的技术支持岗，谈的是18打包一年，五险一金，开发岗据说是20打包，待遇和大厂比肯定是差远了，不过承诺985工作制我觉得还是相对安稳一些。车联网行业属于前景比较好的行业，大概看了一下四大产品，和华为的产品现在好像有竞争关系，面试的时候忘记问市场范围了，看公告大的单子少，都是几万的项目，毕竟刚起步。公司承诺有年终利润分红，这个姑且算作潜在收入吧，虽然不稳定就像浮动绩效一样，但算是一块起码能吃到的饼。
话说回来，海康威视今年身边同学软开普遍是15*15，不知道算什么水平，毕竟双非中我们也是弱的那一类，横向比还是不错了。
可以在不同信息平台发布招聘信息，也可以到人才市场去设摊招聘，还可以直接到大专院校去招聘。而且招聘行为不以招聘主持人的身份而有特别的内容。
HR人员在实施招聘HR岗位人员时与招聘其他人才是一样的，只须明确被招岗位的具体条件，面试时按流程和条件要求实施，择优录用就可以了。
人力资源管理是现代企业中不可或缺的一部分。随着企业对人才管理的重视和需求不断增加，人力资源专业人士的需求也在不断增长。如果你对管理人力资源、发展员工以及推动组织发展的工作感兴趣，那么进入人力资源领域可能是一个理想的职业选择。
人力资源职业涉及到招聘、培训、员工关系、绩效管理、薪资福利等方面的工作。人力资源专业人士需要具备沟通、协调、分析和解决问题的能力，以帮助企业实现其战略目标。
在现代企业中，人力资源部门的作用越来越被重视。他们不仅负责招聘和员工关系管理，还要关注员工发展、绩效评估以及提升整个组织的工作效率。通过制定和执行人力资源策略，人力资源专业人士在公司的决策中起着至关重要的作用。
进入人力资源领域的职业路径多种多样。以下是一些常见的职业发展路径：
这些只是职业发展路径的一部分，人力资源领域还有很多不同的职位和专业。你可以根据自己的兴趣和能力选择适合自己的发展方向。
要在人力资源领域取得成功，除了学习理论知识外，实践经验也非常重要。以下是一些获取人力资源专业知识的途径：
这些途径可以帮助你建立起全面的人力资源知识体系，并获得在职业生涯中成功的机会。
随着科技的不断发展和企业环境的变化，人力资源领域也在不断演变。以下是人力资源职业的一些未来趋势：
这些趋势为人力资源专业人士创造了更多的机会和挑战。要取得成功，你需要不断学习和适应变化的环境。
人力资源职业是一个充满机遇和挑战的领域。通过学习专业知识，获得实践经验，并密切关注行业的发展趋势，你可以在人力资源职业中取得成功。
无论你是希望从事招聘、培训、员工关系还是绩效管理等工作，人力资源领域提供了丰富的职业机会。
开始你的职业规划，投身于人力资源领域，为企业的发展和员工的成长贡献自己的力量吧！
车企HR经常题的汽车销售顾问题目有三个：
1、 请你自我介绍一下
2、 把你最熟悉的一样东西推销给我
3、 你为什么选择我们公司
回答思路：
1、 请你自我介绍一下
这个题目几乎是所有的面试都会出现的第一个问题，但是汽车4S店HR对于不同的岗位即便是同一个人他们都不希望得到相同的答案。对于汽车销售顾问面试，除了简单的自我基本信息之外应该突出四点重点。分别是在自我介绍中表露出自己对汽车销售方面的热爱和兴趣；让面试官知道你拥有专业的汽车知识；在介绍过程中让HR感受到你自信开朗的性格；简单例举过往事例证明你有销售方面的才能。
2、 把你最熟悉的一样东西推销给我
这个问题是销售行业面试官最喜欢问的问题，即便你在前面的自我介绍中介绍得再好，汽车4S店HR也只相信亲自看到你处理实例的情况。这时汽车销售顾问面试求职者一定要拿一样自己最熟悉的东西，抓住对方特点激发他的需求向他推销。
汽车销售顾问面试题目中例如你最熟悉的一件产品是一台自行车，可以抓住3个点激发他的需求。<1>像您这样的都市白领平时都缺乏锻炼，平时多骑自行车是一种锻炼的好项目；<2>现在到处都在提倡环保，如果上班不是很遥远可以骑自行车上班，环保、交通成本也降下来了；<3>大都市的交通堵塞已经是很严重一个问题，自行车可以避免交通阻塞。这些都是激发“假客户”HR对你所卖产品的需求，这样的回答可以让HR知道你懂得去激发客户的需求从而进行销售。
3、 你为什么选择我们公司
这道题目是汽车4S店考察汽车销售顾问面试求职者的动机，发展愿望以及对在汽车4S店汽车销售顾问这项工作的态度。这时求职者一定要谨慎回答，切不可盲目随便说些好话把这个问题敷衍过去，可以从面试的行业、企业、求职的岗位三个方面去回答。
汽车销售顾问面试题目三个方面的例举，行业方面：“我十分看好汽车销售这个行业，因为从网络上了解到目前中国汽车保有量已经超过8000万辆。并且还在以每年13%的速度递增，汽车销售这个行业前景非常广阔。”企业方面：“贵公司的培训制度非常完善，并且非常重视人才。晋升制度也非常透明，我相信在贵公司能找到我发展的道路。”岗位方面：“我非常喜欢汽车销售顾问这个岗位，因为我觉得这个岗位除了能服务于人更重要可以学到很多东西提升自己。”
汽车销售顾问面试
是求职者向汽车
4S
店
HR推销自己的一个过程，只有能把自己推销给HR才能证明你真的有能力立足汽车销售行业。汽车销售顾问面试题目很大众化，但却恰好是汽车4S店考察求职者能否在大众化的情况下把自己特殊地推销出去。汽车销售顾问面试求职者在面试过程中应该时时注意HR看似普通的问题，把自己准确地推销出去给汽车4S店HR。先做个小总结。
1.客服质量低下，不懂产品，连最基础的存储卡问题都无法帮助解决。
2.拒绝质保。购买时告知一年质保，出了问题后告知已超出质保，仅质保三个月，且在商品详情页面，商品说明书售后卡等任何地方都没有标明。
3.霸王售后，在产品设计缺陷的情况下，坏了产品不进行任何维修，直接让用户花钱买个新的。
以下为正文
天猫旗舰店买了两个C3A的套装，收到货后，插上TF卡发现不识别，告知客服后……
后来我通过重新登陆账号的方式解决。（插上卡后重启摄像头，摄像头也还是不认卡，要重新登陆账号才行）这我都纳闷是硬件问题还是软件问题了……反正是产品设计有问题。
我购买的摄像头是带电池和充电底座的，但后来发现充电底座有严重的设计问题，在经过一次次数的电池插拔使用后，触点就会变形。主要由于电池是滑入式的设计，而很多充电底座是放入式设计。
于是我在5个月的时候将产品发向售后部，结果得到了这样的消息。
最终我上12315投诉，黑猫投诉，萤石都没有给我任何反馈。仿佛在说：我就是硬，不把消费者当人看，你能拿我怎么滴？
再次总结：
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());
}
}
