在当今数字化时代，音视频开发和机器学习已经成为IT行业中备受关注的热门话题。作为技术领域中快速发展的两大方向，音视频开发和机器学习的结合不仅为我们带来了全新的科技体验，更在各个行业中展现出巨大的潜力。
音视频开发是指利用计算机技术进行音频和视频内容的处理、编辑、传输和播放。随着网络带宽的提升和智能手机等移动设备的普及，人们对于音视频内容的需求不断增加，这也推动了音视频开发技术的发展。无论是在线直播、短视频应用还是游戏开发，音视频开发都发挥着至关重要的作用。
机器学习是人工智能的一个重要分支，通过训练模型让计算机从数据中学习并不断优化算法，以实现特定任务的自动化。随着大数据的普及和计算能力的提升，机器学习技术正日益成为各行各业的必备技能。
将音视频开发与机器学习相结合，可以为音视频内容的处理和分析带来全新的可能性。通过机器学习算法，可以实现音视频内容的智能识别、内容推荐和个性化定制，提升用户体验的同时也提高了生产效率。
然而，音视频开发和机器学习的结合也面临着一些挑战，比如数据的标注和清洗、模型的训练和优化等问题。但正是这些挑战，为我们带来了更多的机遇。随着技术的不断进步和应用场景的拓展，音视频开发和机器学习的融合将会引领新一波科技革命。
综合来看，音视频开发和机器学习的融合不仅仅是技术上的创新，更是对未来数字化世界的探索和呈现。随着全球技术的飞速发展，我们有理由相信，音视频开发和机器学习的结合将为我们带来更加智能、便捷和丰富的生活体验。
音视频开发的职责是：
1、负责移动端音视频SDK的产品化、场景化解决方案研发；
2、参与多个应用的多媒体相关架构设计、开发、性能优化等工作；
3、参与音视频基础模块和组件的研发、维护和优化。
程序员开发的职责是：
1、参与Android、IOS平台下的APP应用开发、上线和日常维护工作；
2、根据产品需求完成模块设计、编码、和bug修改等工作；
3、根据开发过程中的体验对产品提出改进意见；
4、改善软件的易用性，提升用户使用体验 。
在今天的竞争激烈的互联网行业中，找到一份满意的开发工作并不容易。对于那些正在寻找机会的开发者来说，面试是一个关键的环节。面试官通常会对你的技术能力、项目经验和问题解决能力进行考察。为了帮助你在互联网开发面试中脱颖而出，我精选了一些常见的面试题，并给出了详细的解析。
关键词：前端路由
前端路由是一个重要的概念，它可以实现单页应用（SPA）的页面切换功能。常见的前端路由库有React Router、Vue Router等。在面试中，可能会被问到如何自己实现一个简单的前端路由。
要实现一个简单的前端路由，可以利用5的History API。使用pushState()方法可以将URL的改变添加到浏览历史记录中，然后可以通过popstate事件监听URL的变化，并根据URL进行页面跳转。以下是一个简单的示例：
window.onpopstate = function(event) {
// 根据event.state进行页面跳转
};
var stateObj = { title: "page", url: "/page" };
history.pushState(stateObj, stateObj.title, stateObj.url);
关键词：跨域
在互联网开发中，跨域请求是一个常见的问题。由于浏览器的同源策略限制，不同域名、不同端口、不同协议之间的请求会被禁止。为了解决跨域问题，我们可以采用以下几种方法：
关键词：RESTful API
RESTful API是一种设计风格，它将Web应用程序的所有功能抽象为一组资源，并通过HTTP方法对资源进行操作。在面试中，面试官可能会问你对RESTful API的理解以及如何设计一个符合RESTful风格的API。
一个符合RESTful风格的API应该具备以下特点：
关键词：前端性能优化
在互联网开发中，前端性能优化是一个永恒的话题。优化前端性能可以提升用户体验，降低服务器压力。以下是一些常见的前端性能优化技巧：
关键词：前端安全
前端安全是保护Web应用程序免受恶意攻击的重要一环。在面试中，可能会收到与前端安全相关的问题。以下是一些常见的前端安全问题和对应的解决方案：
如果你能对上述面试题给出准确的回答，并展示出你在实际项目中的经验和解决问题的能力，相信你能在互联网开发的面试中获得成功。
作为一名网站编辑,我很高兴能够为您撰写这篇关于前端开发经典面试题的专业文章。前端开发是web开发的重要组成部分,涉及到网页的展现和交互。对于前端开发岗位的求职者来说,掌握常见的前端面试题并能够清晰地回答,无疑会大大增加入职的机会。
HTML 和 CSS 是前端开发的基础知识,面试官通常会从这两个方面测试应聘者的功底。以下是一些常见的面试题:
JavaScript 作为前端开发的核心语言,面试官通常会从以下几个方面测试应聘者的熟练程度:
随着前端框架和库的流行,面试官也会针对常见的框架和库进行考察,例如:
以上就是一些前端开发常见的面试题,涉及到 HTML、CSS、JavaScript、框架等领域。作为一名前端开发工程师,掌握这些经典题目并能够深入解析,无疑会大大提升面试的成功率。希望这篇文章对您的面试准备有所帮助,祝您前程似锦!
不要着急，可以向面式官表达尝试回答问题的想法，然后可以说明这个领域你没有接触到，自己下来会认真的去寻求答案，给面式管一个勤学上进的印象。
在面式中，一道面式题不会是不会有太大影响的，有些面式本身就是压力面式，看的就是你的临场反应能力。
Java开发面试题是在应聘Java开发岗位时经常会遇到的问题，它涵盖了Java基础知识、面向对象编程、集合框架、多线程、IO流、异常处理、数据库操作等各个方面。掌握这些面试题不仅有助于顺利通过面试，还能够加深对Java编程语言的理解，提升自身的编程能力。
在Java开发面试中，面试官通常会从基础知识入手，考察应聘者对Java语言的掌握程度。常见的问题包括：Java的特点和优缺点、Java中基本数据类型、面向对象编程的特点、方法的重载和重写、构造器和静态代码块的执行顺序等。掌握这些基础知识对于顺利通过面试至关重要。
面向对象编程是Java开发中的核心概念，面试官会考察应聘者对面向对象编程的理解。常见问题包括：什么是封装、继承和多态，如何实现接口、抽象类的应用场景、Java中的内部类等。对面向对象编程原理的熟悉程度直接影响着应聘者的面试表现。
Java的集合框架是开发中经常使用的核心组件，面试中通常会涉及集合框架的相关问题。应聘者需要了解集合框架的体系结构、常用的集合类及其特点、集合类之间的区别、如何实现自定义的比较器等内容。对集合框架的熟练掌握有助于应聘者在面试中脱颖而出。
多线程是Java编程中的重要部分，面试官会考察应聘者对多线程编程的了解程度。常见问题包括：线程的生命周期、线程的同步和互斥、线程池的原理、如何实现线程间通信等。对多线程编程的熟练掌握对于应聘者的综合能力考察至关重要。
IO流是Java中用于处理输入输出的重要部分，面试中经常会涉及IO流的相关问题。应聘者需要了解字节流和字符流的区别、不同类型的IO流、文件的输入输出操作、序列化与反序列化等内容。对IO流的熟练应用可以展现出应聘者在实际开发中的能力。
异常处理是Java编程中不可或缺的部分，面试官会考察应聘者对异常处理的掌握情况。常见问题包括：异常的分类、如何自定义异常、try-catch-finally块的执行顺序、常见的异常类及其应用等。对异常处理的熟练掌握能够展现出应聘者在程序健壮性方面的实力。
数据库操作是Java开发中的常见任务，面试中常常会考察应聘者对数据库操作的了解程度。应聘者需要了解SQL语句的编写、JDBC编程的基本流程、事务的特性和隔离级别、连接池的原理及其实现等内容。对数据库操作的熟练掌握有助于应聘者在面试中展现出全面的技术能力。
综上所述，掌握Java开发面试题不仅有助于应聘者在面试中取得好成绩，还能够提升自身的编程水平和技术能力。希望通过本文的内容能够帮助到广大Java开发人员，顺利通过面试，实现职业发展的目标。
感谢您阅读本文，希望本文能为您在Java开发面试中提供帮助。
如果对方没有公司，只是个体户的话，是开不了抖音视频，类似的是发票的，如果对方是公司付的话，可以要求在抬头那里写上视频类目，然后就可以开具发票了
作为一名中级前端开发工程师,面试时常面临各种棘手的面试题。这些问题不仅考察了面试者的专业知识储备,也考验了他们的问题分析和解决能力。为了帮助您更好地准备这些面试问题,我们特别为您整理了一份中级前端开发常见面试题及详细解答。通过系统学习这些面试题目,您不仅可以全面检视自己的前端技能,还能针对性地进行深入学习,提升面试时的表现。
HTML和CSS是前端开发的基础,面试官常会就这两项技术考察应聘者的掌握程度。以下是一些典型的面试题:
语义化HTML是指使用恰当的HTML标签来表达页面的内容结构,例如使用<h1>-<h6>标签来表示标题,使用<p>标签来表示段落,使用<ul>或<ol>标签来表示列表等。语义化HTML的好处包括:
CSS选择器主要有以下几种:
div、p等。特点是简单易用,但选择范围较广。.开头,如.container。可复用性强,但需要在HTML中添加类名。#开头,如#header。specificity(特殊性)最高,但ID在页面中应该是唯一的。input[type="text"]。可以精确定位元素,但不够语义化。div p。可以定位页面结构中的特定元素。>分隔父子关系,如ul>li。只会选择直接子元素,更加精确。+选择紧邻的兄弟元素,如h1+p。~选择所有兄弟元素,如h1~p。CSS盒模型描述了网页元素如何计算大小和位置。标准盒模型中,元素的总宽度/高度等于content + padding + border,而IE盒模型中,元素的总宽度/高度等于content。也就是说,IE盒模型会将padding和border计入到content区域中。这种差异会在某些布局场景下产生不同的表现。为了统一处理,可以通过box-sizing属性切换盒模型。
JavaScript是前端开发的核心语言,面试中必然会涉及大量与JavaScript相关的问题。以下是一些重点内容:
闭包是指一个函数能够访问并操作其外部函数作用域中的变量,即使外部函数已经执行结束。闭包的主要作用包括:
Promise是JavaScript中用于异步编程的一种解决方案。它解决了传统回调函数嵌套过深(回调地狱)的问题,使异步代码更加清晰、可读性更强。Promise有三种状态:pending(进行中)、fulfilled(已成功)和rejected(已失败)。通过Promise的then()和catch()方法,可以更好地处理异步操作的成功和失败情况。
事件循环是JavaScript运行的机制,负责监视Call Stack和Task Queue(包括微任务队列和宏任务队列),按照先进先出的原则执行任务。具体工作机制如下:
随着前端技术的快速发展,越来越多的前端框架如React、Vue、Angular等涌现。面试中通常会就这些流行框架考察应聘者的掌握程度。以下是一些常见的面试题:
React组件有以下几个主要生命周期阶段:
constructor()、static getDerivedStateFromProps()、render()和componentDidMount(),组件创建时执行。static getDerivedStateFromProps()、shouldComponentUpdate()、render()、getSnapshotBeforeUpdate()和componentDidUpdate(),组件更新时执行。componentWillUnmount(),组件卸载时执行。static getDerivedStateFromError()和componentDidCatch(),组件出错时执行。Vue实现双向数据绑定的核心是利用了Object.defineProperty()方法。当数据发生变化时,Vue会自动地更新视图;当用户在视图上做出修改时,数据也会自动地更新。具体原理如下:
Vuex是Vue.js应用程序开发的状态管理模式。它的核心概念包括:
以上就是我为您整理的中级前端开发常见面试题及详细解答。通过系统学习这些题目,相信您一定能够提升自己的前端技能,在下次面试中表现出色。祝您好运!
感谢您仔细阅读完这篇文章,希望这些内容对您的前端面试准备有所帮助。如果您还有任何其他问题,欢迎随时与我交流探讨。祝您工作顺利,前程似锦!
Vue.js是一款流行的 JavaScript 前端框架,在前端开发行业广受欢迎。作为一名前端开发人员,掌握 Vue.js 的相关知识点并能够应对面试中常见的问题,对于求职和提高自身技能都非常重要。本文将从基础知识、核心原理、常见问题等方面,为您整理并解答 Vue.js 前端开发面试题,帮助您更好地准备面试。
Vue.js 是一个用于构建用户界面的渐进式 JavaScript 框架。它的核心是一个反应式的数据绑定系统,可以非常简单地开发出复杂的 Web 应用程序。在这一部分,我们将介绍 Vue.js 的基础知识,包括它的特点、组件、指令等。
Vue.js 的核心原理包括响应式系统、虚拟 DOM、生命周期等。下面将分别介绍这些核心概念:
在 Vue.js 面试中,常会涉及以下几类问题:
通过系统地学习 Vue.js 相关知识,并结合实际开发经验,相信您一定能够顺利通过面试,为您的前端开发事业增添新的动力。
感谢您阅读本文,希望这篇文章对您有所帮助。如果您还有任何其他问题,欢迎随时与我交流探讨。祝您前程似锦,事业有成!
之前看了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());
}
}
显示全部
收起
