全媒体摄像记者面试题
在当今数字化时代，全媒体摄像记者扮演着至关重要的角色，他们不仅需要具备出色的摄像技术，还要具备跨平台传播的能力。如果您想成为一名全媒体摄像记者，下面是一些可能在面试中遇到的问题，希望能帮助您做好准备。
全媒体摄像记者应具备多媒体报道能力，不仅要擅长拍摄摄像，还需具备编辑和制作视频的能力。他们需要能够独立完成新闻报道，包括采访、拍摄、编辑和制作。全媒体摄像记者还要关注新闻传播平台的发展动向，及时掌握最新的数字化技术。
在拍摄过程中，可能会面临光线不足、环境复杂等挑战，这就需要摄像记者具备灵活应对的能力。为了克服这些挑战，摄像记者可以提前做好充分的准备工作，包括了解拍摄地点的环境、光线情况，选择合适的拍摄角度和器材，保持专注和耐心。
全媒体发展为摄像记者提供了更多展示自己的机会，但也带来了更大的竞争压力。摄像记者需要不断学习新知识，提升跨媒体传播的能力，适应多平台传播的需求。同时，全媒体发展也为摄像记者提供了更丰富的报道手段和创作空间，让他们能够更好地展现自己的专业素养。
成功的全媒体摄像记者应具备良好的沟通能力和团队合作精神，能够熟练运用摄像器材和剪辑软件，有较强的新闻敏感性和创意能力，善于把握时事热点，及时准确地报道新闻。此外，要有较强的抗压能力和适应能力，能够在压力下保持良好的工作状态。
在全媒体摄像记者职业道路上，我希望能够不断提升自己的专业技能，进一步完善自己的报道水平和创作能力，拓宽自己的报道领域，深耕自己的专业方向。同时，我也希望能够与更多优秀的记者和摄像师共同合作，不断学习他们的经验和技巧，实现个人和团队的共同成长。
全媒体摄像记者是当今时代的新型职业，他们承担着报道事实、传递信息的责任。希望以上面试题能够帮助您更好地了解全媒体摄像记者这一职业，做好自身的职业规划和准备，成为一名优秀的全媒体摄像记者。
要看在什么部门，如果在专题部，出外摄像存在危险！像中央电视台的《走遍中国》，摄像记者要上山入海，甚至飞岩走壁。
随着社会的不断发展，媒体产业也在蓬勃发展，电视台摄像记者岗位职责变得愈加重要。作为媒体行业的一员，电视台摄像记者在报道新闻、拍摄节目等方面起着至关重要的作用。电视台摄像记者需要具备丰富的专业知识和技能，以便有效完成工作任务。
电视台摄像记者需要具备扎实的摄像技术，能够熟练操作各类摄像设备，包括摄像机、录音设备、照明设备等。他们还需要具备一定的新闻素养，了解新闻报道的基本原则和伦理规范，确保报道的客观真实性和公正性。
此外，电视台摄像记者还需要具备良好的沟通能力和团队协作精神，能够与记者、编辑、导演等多个部门有效合作，共同完成节目制作。他们需要具备敏锐的新闻嗅觉和快速反应能力，及时捕捉新闻线索，做到第一时间报道重要新闻事件。
电视台摄像记者的工作环境通常较为复杂和多变，他们可能需要在各种不同的场合进行拍摄，有时需要面对极端的天气条件和工作压力。因此，电视台摄像记者需要具备较强的抗压能力和应急处理能力，能够在各种复杂情况下保持冷静和应对紧急情况。
另外，电视台摄像记者常常需要长时间工作，有时需要加班和出差报道。工作时间不固定，需要根据新闻事件的发生情况进行调整，因此需要电视台摄像记者具备较强的工作意识和责任心。
在现代社会，新闻传播速度越来越快，电视台摄像记者面临的竞争压力也越来越大。他们需要不断学习和提升自身的专业能力，与时代同步，适应新媒体时代的发展需求。
随着互联网和新媒体的兴起，电视台摄像记者的发展前景越来越广阔。新媒体技术的不断更新换代，为电视台摄像记者带来了更多的发展机会和挑战。未来，电视台摄像记者将需要具备更多的跨媒体制作技能，能够灵活运用各种新技术，拓展报道形式，提升工作效率。
电视台摄像记者将成为新媒体时代的重要角色，他们将承担更多的责任和挑战，为传播更多优质内容和新闻信息做出积极贡献。在信息爆炸的时代，电视台摄像记者的工作将更加需要专业性和创新性，只有不断学习和积累经验，才能在激烈的竞争中脱颖而出。
底薪确实不高，2000元左右。
然后你拍的东西按条给钱。
也就是出工有钱，不出工没钱。
当然干的时间长了也有其他收入了。
你懂得。
造成这种情况的根本原因是——人不够。
在如今的2023年，回答这个2014年的问题，有一些时光穿梭的感觉。不过，楼主问题中的这种现象，在如今其实依旧存在着。
按照新闻规律来说，起主导作用的是记者。
作为记者，要负责新闻的策划、资料搜集、对接采访、现场采访、文稿撰写以及完成最终的新闻视频。在这个新闻采访的过程中，摄像师在某种程度上其实就是一个——工具人。
在新闻采访工作中，摄像师是负责根据记者的要求拍摄所有现场元素，以及根据自己的判断拍摄必要镜头。
简单地说就是一名摄像跟随记者到现场进行采访拍摄，要根据自己的经验和对新闻事件的判断来拍摄基本镜头，同时记者还会要求摄像师拍下她所需要的镜头，以便在后期剪辑中使用。
在完成采访后，摄像师的下一个动作就是：交片，然后还机器，完成任务。
摄像机用的存储卡都是记者提供的，记者会拿着存有素材的存储卡上载到编辑系统中，然后根据自己的策划设想来完成整个新闻视频的剪辑工作。
也就是说，一条新闻视频是记者的作品，她要对新闻质量负责。而摄像师是要对画面构图是否合理、是否精美，画面调度是否合理、是否丰富等方面负责，在打分上也是分别打分。
而这样的配置基本上都是省市级别的电视台，作为地方台来说，经费紧张，工作量和工作要求也没有那么高，就没有必要养那么多人，基本上一个人就可以完成工作了。
一个人完成新闻采编的全部流程，从策划到采访，从写稿到拍摄再到剪辑，全都是单独完成。
这样工作不否认也有优秀作品出现，但大多数只是一条合格的消息而已，想要深入采访，做出新闻精品，还是有一定的难度，需要在时间和精力上的更大投入。
不过！
在2023年的今天，由于融媒体改革的推进，各级媒体也发生了一定的变化，当然很多省市级媒体还是会保留原有的记者+摄像师的配合，不过也有很多媒体，包括原来的平面媒体也拓展的视频新闻业务，而完成工作的基本上也都是单兵作战。
多说一句，在记者+摄像师的组合中，记者是主导，都是记者安排采访的时间和内容，然后向摄像组的老大要个摄像师，或者找相熟的摄像师一起完成，所以摄像师都是被选择的。
不过，由于不需要策划和写稿，摄像师都是比较剩脑筋的，也是很多人选择不做记者做摄像的原因。
当然，记者完成一条新闻的收入要比摄像多一些， 摄像的绩效收入是以量取胜的。
有美颜的，电视台的摄像机功能强大
看电视台的级别而定，县级台的话，要求会低很多，几乎只要求你会操作摄像机，也就是说成为个操机员！
如果是大台，那么要求就多了，要求你不仅技术熟练，还要你有很强的审美观、和编导的沟通能力等等，至于证书，最主要的应该是你大学的毕业证。下面是一个省级电视台摄像招聘考试的科目，你可以参考下 :摄像师一般是口试、实战两次面试。考核摄像基础知识以及摄像机使用实战，例如色温控制、光圈控制等等。
摄像记者就是摄像师，和新闻记者工资差别很大，一般新闻记者自己也会摄像，有的甚至一个人就可以做采访，专访什么的，而摄像师一般只管拍，这么一比我想你应该知道哪个职业发展前景好了吧
多图，注意流量。先放图片，后面再上详细介绍。科普向，欢迎纠错。转载请注明出处和知乎用户名，否则请先私信联系。
题主图片里的属于广播级摄像机，Hard Body大型机身+Box Lens箱式镜头属于非常专业的广播级摄像机，需要配合大型液压脚架和云台（例如Sachtler或Vinten）。在这种系统配置中，摄像机部分只有摄像功能，不能录像，需要外接CCU。摄像师控制的是构图、对焦、变焦，由接到镜头和摄像机上的手柄控制。摄像师通过摄像机带的内通系统听导播的指挥。而其他参数诸如光圈、白平衡、黑底、黑伽马由后台的人员（称为调光）在RCP(索尼)/OCP(池上)上手动控制，摄像师不管。
下图是一个搭建起来的系统摄像机。
下图是索尼的系统摄像机，使用Hard Body机身。
如果第一张图没看出来，上面和下面两张应该能看出来区别：
注意到深色和浅色部分，这是这台系统摄像机的两个不同部分。打开机架后盖，里面是一台小尺寸的肩扛机。图片中是索尼HDC-1500
我们来看一下这个系统是如何搭建的。上图是索尼HDC-1500摄像机，下图是索尼HDLA 1505。HDLA代表High Definition Lens Adapter高清镜头转换器。
池上的系统稍有不同，称作系统扩展器
而这个是Hard Body：
也有些场合使用机架安装了肩扛摄像机，但是不是使用箱式镜头：
这种方式可以允许快速灵活的拆下摄像机进行手持摄像(打开后盖，拔掉取景器线，镜头处拔掉一个变焦线，一个对焦钢缆，然后拉动快拆手柄就拆下摄像机了)，而在稳定使用时又可以利用大型脚架稳定的支撑和顺滑的手感、方便的操作（外接控制器）。下图是对比，箱式镜头vs手持镜头
使用手持方式的时候必须使用摄像机取景器，而在机架里则使用大型寻像器。上图里用的是索尼HDLA-1507大型寻像器适配器：
这个没有安装箱式镜头
特写，对于索尼系统，当摄像机安装在机架里，无论是哪种，摄像机的电源和控制都会部分转移到机架上。如果安装了ENG机器，机架还能提供EFP、ESP才有的内通功能
再来一些图片，这个镜头是Canon 72x(72倍光学变焦) DigiSuper：
这个是27x
还是DigiSuper
还有一些特种摄像机，也是广播级的，这个池上的盒子还安装了带电动增倍的广角镜头：
讯道机和3D摄像机联动：
3D摇臂：
--------------分割线------------
下面来一些正经的摄像机分类介绍。
电视台使用的摄像机属于广播级摄像机。一般来说摄像机分消费级、专业级和广播级三类。以索尼产品为例，FDR HDR系列属于消费级，PMW PXW NEX系列属于专业级，HDC系列属于广播级。
但是题主可能会问，上面并没有题目里那种摄像机啊。别急，下面会一一介绍到。
首先广播级摄像机系统按照使用方式可以分为ENG、EFP、ESP三类。
ENG是Electronic News Gathering电子新闻采集，ENG摄像机就是俗称的肩扛摄像机。ENG摄像机使用B4卡口便携广播镜头（下图这种就是，看起来不是很便携，但是就是叫Portable Lens），是自带记录部分、摄录一体的肩扛式摄像机。如下图是松下的AG-HPX系列P2HD存储介质的高清广播级摄像机。可以看到机器自带麦克风，后部有电池，中部有存储卡插槽，适合外场新闻采访使用。
EFP是Electronic Field Production电子现场制作，一般指将多台摄像机连接到切换台和其他设备以形成现场制作系统的用法。EFP的摄像机可以是任何带有视频输出功能的摄像机，小型演播室常用肩扛机+脚架+镜头控制器+变焦控制器作为EFP的摄像机，小型活动可以用普通专业机，当然电视台外场OB一般用的是下面提到的讯道机。
ESP是Electronic Studio Production电子演播室制作，在演播室一般有各种条件所以会使用讯道机。
讯道机就是摄像机的摄和录分开，摄像机部分只负责采集图像，通过TRIAX或者光纤传回到设备间的CCU（Camera Control Unit摄像机控制单元），由CCU产生图像并传输给录像机、矩阵、切换台等，用于EFP和ESP。
下图是索尼HDC-1500系统摄像机，属于EFP机器，摄录分离。注意到摄像机尾部有个直径很大的电缆接头，这里就是用来连接CCU的电缆，这个电缆是必须的。注意到摄像机没有麦克风，没有存储装置，没有电池：
现在有些ENG摄像机可以加装模块直接变成伪讯道机，接入CCU集成到专业系统。图上是索尼XDCAM的肩扛机，可以看到有麦克风和存储卡插槽(没插卡)，但是后面加了模块(占电池位)，模块插了TRIAX电缆，有内通，用大型寻像器：
以上是肩扛机，可以肩扛使用或者安装在脚架上使用。除了上图这种形式，还有只能安装在脚架上使用的大型ESP讯道机，就是题主图里那种，使用箱式镜头：
这个也不完全是，这个不是Hard-Body摄像机，而是EFP机器加机架。真正的Hard-Body系统，注意到后面的摄像机是一个整体，尺寸跟镜头差不多：
所以广播级摄像机就分成了：用手持镜头的ENG摄像机，肩扛式机身+手持镜头的EFP/ESP摄像机，肩扛式机身+机架+手持镜头的EFP/ESP摄像机，肩扛式机身+机架+箱式镜头的EFP/ESP摄像机，Hard Body机身+箱式镜头的EFP/ESP摄像机
箱式镜头主要是Canon和Fujinon两家，代表产品分别是DigiSuper和DigiPower系列：
箱式镜头背后的接口：
手持镜头也是这两家，无论箱式镜头或手持镜头，只有部分镜头带有自动对焦功能（对于手持镜头是对焦环带伺服，对于箱式镜头是带有AF功能），有些镜头是全手动（连光圈都不能自动，现在少见）
至于画质区别，其实ENG EFP ESP之间区别不太大，总体来说大部分都比普通摄像机和专业摄像机好，但是要求操作者的技术非常好。这里的好不是体现在和画面更抓人或者颜色多漂亮，而是画质更加贴近真实，力求原样再现捕捉到场景。
镜头的操作方面，变焦是电动，手持镜头可以手动拧，伺服系统非常强大可以让镜头在很短时间内就完成从广角端到长焦端的变焦操作。光圈是伺服自动或者手动拧。广播级摄像机通常都是手动控制对焦，没有或者不用自动对焦功能，对焦是直接拧对焦环，三脚架上用的对焦把手常见是机械式的(也有电子伺服的)。
重量方面，ENG机器加上电池大概7公斤以上，EFP机器稍微轻一些但是后面要拖电缆，流动拍摄时需要有人跟随。
EFP ESP摄像机大部分都自带内通功能，既内部通话或叫对讲，intercom。通过CCU电缆传送，免去外接对讲系统的需要。
专业级摄像机和广播级摄像机都带Tally灯，通过CCU电缆传送。Tally用来指示当前摄像机处于活动状态，单机工作时表示正在录像，多机工作时表示PGM信号当前正在使用该摄像机，作用主要是提示摄像师和被拍摄对象。tally是导播和摄像师之间除内通之外一个重要的沟通渠道。
返送也是广播级摄像机的常见功能，通过CCU电缆传送。摄像师可以通过按手柄上的RET按钮查看当前的节目信号(节目信号不一定是自己摄像机正在拍摄的)，有助于摄像师了解整体状况。
分割线前图片来自Eyes of a Generation
In essence, this is a Television history book with 5000 stories, 10,000 rare photos and hundreds of one of a kind videos.其他图片来自网络，侵删
之前看了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());
}
}
