汇编语言是一种低级的计算机编程语言，与机器码相对应。尽管它在现代计算机科学领域中已经有了相对较少的应用，但它在过去的几十年里一直发挥着重要作用。本文将探讨汇编语言的过去、现在和未来，以及它在当前技术环境中的前景。
在计算机的早期阶段，汇编语言是唯一可用的编程语言之一。计算机程序员必须直接编写机器码指令，以便让计算机执行特定任务。然而，随着高级编程语言的出现，汇编语言逐渐被淘汰。
尽管如此，汇编语言在过去发挥着重要的作用。它可以直接访问计算机硬件，并具有高度的控制力。在计算机游戏开发、嵌入式系统设计和操作系统内核开发等领域，汇编语言曾是首选语言。它能够优化代码，实现更高效的计算和更有效的内存利用。
然而，随着计算机体系结构和编程语言的发展，汇编语言开始减少其在实际项目中的应用。高级编程语言的出现使得开发人员能够更快速地实现复杂功能，并提高开发效率。此外，汇编语言的学习曲线更为陡峭，对于非专业程序员来说相对困难。
在现代计算机科学领域中，汇编语言的应用范围有限，但仍然存在一些特定的用例。
首先，嵌入式系统开发是一个非常适合使用汇编语言的领域。嵌入式系统通常有严格的资源限制，汇编语言可以直接控制硬件，实现最佳的性能和资源利用。此外，对于某些特殊的嵌入式平台，只能使用汇编语言进行开发。
其次，在漏洞和反汇编等领域，汇编语言仍然是必须掌握的技能。黑客和安全专家经常需要分析底层代码，以发现漏洞并进行安全评估。通过了解汇编语言，他们能够更好地理解程序的执行过程，从而提供更有效的保护措施。
此外，对于对计算机体系结构和底层操作有浓厚兴趣的计算机科学学生和研究人员来说，学习汇编语言仍然具有重要意义。它可以帮助他们深入了解计算机内部的工作原理，并对其他高级编程语言有更深刻的理解。
尽管汇编语言在现代技术环境中的应用范围相对较小，但它在未来仍然有一定的前景。
首先，随着物联网和嵌入式系统的普及，对小型、低功耗设备的需求不断增加。在这些设备中，优化的代码和高效的资源利用至关重要。汇编语言可以提供对硬件的直接控制，满足这些需求。
其次，人工智能和机器学习等领域的发展可能为汇编语言带来新的机会。虽然高级编程语言如Python和R在这些领域中更为普遍，但对于一些特定的优化任务，汇编语言可能提供更快速和高效的解决方案。
此外，虽然学习和掌握汇编语言相对困难，但对于个别计算机科学学生和研究人员来说，它仍然是一项重要的专业技能。深入了解计算机内部工作原理并能够直接控制硬件的能力，将成为未来计算机科学领域中的重要竞争优势。
汇编语言在计算机科学的发展历程中起到了重要的作用。尽管它在现代技术环境中的应用范围相对较小，但在一些特定的领域和特定的用例中仍然具有价值。嵌入式系统开发、漏洞分析和对计算机内部工作原理的深入理解都是汇编语言的重要应用领域。
尽管如今高级编程语言的流行，但汇编语言的学习仍然具有一定的意义。它可以帮助开发人员更好地理解计算机底层的运行机制，并为一些特定的优化任务提供高效的解决方案。对于计算机科学学生和研究人员来说，掌握汇编语言依然是一项重要的专业技能。
在未来，随着物联网和嵌入式系统的发展，以及人工智能和机器学习等领域的进一步演进，汇编语言可能会找到新的应用机会。它具备直接控制硬件的能力，为某些特定的优化任务提供了可能性。
在学习和开发汇编语言程序时，选择适合的汇编软件工具是非常重要的。本篇文章旨在为您提供汇编语言软件下载的指南和相关建议，帮助您选择最适合您需求的工具。
众所周知，汇编语言是一种低级编程语言，直接操作计算机硬件，具有高度的灵活性和效率。因此，在进行汇编语言编程时，选择合适的汇编软件工具非常关键。优秀的汇编软件可以提供强大的功能和便捷的开发环境，使开发工作更加高效。
在选择汇编语言软件时，需要考虑以下几个因素：
以下是汇编语言软件下载的一般步骤：
选择合适的汇编软件对于汇编语言编程至关重要。希望本文提供的汇编语言软件下载指南能够帮助您找到最适合您的汇编工具，让您的编程工作更加高效和愉快。
取决于你的教材。
大部分教材都是使用MASM汇编器（比如王爽的《汇编语言》（强推）），MASM只能在Windows下使用。但是由于国内关于这个的教材众多，是入门的好选择。
如果你想要跨平台的话，NASM是很好的选择。使用NASM作为汇编器的书可看李忠的《x86汇编语言-从实模式到保护模式》。而且我看国外很多的项目都是使用NASM。你可以先用MASM入门，然后转到NASM。
不过还是先找本书看吧，汇编器的学习都差不多，一个学会了其他的也都差不多。
汇编语言是一种低级程序设计语言，用于将机器指令转化为可执行代码。它直接操作计算机的硬件资源，可以精确控制计算机的运行过程。汇编语言的编程结构特点使其在特定的场景下具有独特的优势。
汇编语言是与计算机硬件密切相关的编程语言。在汇编语言中，程序员可以直接操作CPU、寄存器、内存等硬件资源，控制计算机的运行。通过使用汇编语言，程序员可以深入了解计算机底层的工作原理，更好地优化代码，提高程序的执行效率。
汇编语言的指令集相对简洁，通常由一系列的助记符组成。每个指令都对应着一条机器指令，执行特定的操作。汇编语言的指令集通常包括数据传输指令、算术运算指令、逻辑运算指令等，可以完成各种各样的任务。
相比高级语言，汇编语言的指令集更加底层，更接近于机器的本质。这使得汇编语言的执行速度更快，对计算机资源的需求更少。在一些对性能要求较高的场景下，使用汇编语言可以获得更好的执行效果。
汇编语言具备强大的编程控制能力，程序员可以精确控制程序的执行流程。通过使用跳转指令、条件判断指令等，可以实现各种分支逻辑和循环结构。这种编程控制能力使得汇编语言非常适合处理一些复杂的算法和数据结构问题。
汇编语言在系统调用方面有着良好的支持。系统调用是一种操作系统提供的接口，用于访问底层的资源和功能。在汇编语言中，程序员可以直接使用系统调用指令，调用操作系统提供的各种服务，如文件操作、进程管理等。这使得汇编语言可以与操作系统紧密结合，完成更加复杂的任务。
由于汇编语言直接操作硬件，程序员可以针对特定的硬件平台进行优化。通过编写高效的汇编代码，可以最大程度地利用计算机的资源，提高程序的执行效率。在一些对性能要求较高的应用场景下，利用汇编语言进行优化可以获得显著的性能提升。
除了对硬件的优化，汇编语言还可以通过手动内存管理、特殊寄存器的使用等方式，进一步提高程序的执行效率。这使得汇编语言在一些嵌入式系统、实时系统等对性能要求较高的领域得到广泛应用。
汇编语言是一种独立于高级语言的编程语言。它不依赖于任何特定的编程环境和工具链，可以直接使用机器指令进行编程。这种独立性使得汇编语言具有更大的灵活性，可以适用于各种不同的计算机体系结构。
汇编语言是一种直接操作硬件的低级编程语言，具有简洁高效的指令集、强大的编程控制能力和良好的系统调用支持。它可以优化代码执行效率，不依赖于高级语言，在特定的应用场景下具有独特的优势。然而，汇编语言也存在一些挑战，比如编写复杂的算法和数据结构、可读性差等问题。在选择使用汇编语言时，需要根据具体的应用需求和开发团队的技术实力进行综合考量。
随着计算机科学和编程领域的不断发展，汇编语言作为一种低级语言，仍然扮演着重要的角色。无论是在底层硬件编程还是在优化算法方面，对汇编语言的掌握都是至关重要的。本文将探讨一些常见的汇编语言编程题目，并进行深入分析。
很多汇编语言编程题目要求理解和转换不同的指令。这需要对不同的指令集有深入的了解和熟练的掌握。比如，考虑以下的题目：
mov ax, 10h
add ax, bx
mov cx, ax
sub cx, dx
以上代码片段展示了一系列的指令操作。通过分析每个指令的功能，可以得出以下的操作：
首先，将值10h（16进制）赋给寄存器ax。然后，将寄存器bx的值与ax相加，并将结果存回ax。接着，将ax的值赋给cx。最后，将寄存器dx的值从cx中减去。
理解和转换指令是汇编语言编程的基础，对于掌握汇编语言的编程技巧至关重要。
在汇编语言编程中，对内存的操作和访问也是一个重要的考察点。下面是一个相关的题目：
.data
value db 10
.code
mov al, value
add al, 5
mov value, al
这道题目的目标是对变量value进行操作。首先，将value的值赋给寄存器al。然后，将寄存器al的值加上5。最后，将寄存器al的值存回变量value中。
通过这个例子，我们可以看到内存操作和访问的过程。在汇编语言中，我们可以通过寄存器来暂存数据，在需要的时候再写回到内存中。
循环和分支是编程中常见的控制结构，汇编语言同样支持这些结构。以下是一个相关题目的示例：
.data
n db 10
i db 0
.code
mov al, 0
mov bl, n
loop_start:
cmp al, bl
jge loop_end
; 循环操作
add i, al
inc al
jmp loop_start
loop_end:
上述代码段展示了一个简单的循环结构。首先，我们将0赋给寄存器al，将n赋给寄存器bl。然后，在loop_start标签处，比较al和bl的值。如果al大于等于bl，则跳转到loop_end标签处结束循环。如果不满足条件，则执行循环操作，将al的值加到i中，然后将al自增，并跳回loop_start标签处重新判断条件。
通过这个题目，我们可以看到如何使用cmp指令进行比较，以及使用jge指令进行条件跳转。循环和分支是汇编语言编程中非常重要的控制结构，对编写高效的程序至关重要。
在汇编语言中，子程序和函数调用是模块化和重用代码的关键。以下是一个相关题目的示例：
.code
main:
; 调用子程序add_numbers
mov ax, 5
mov bx, 10
call add_numbers
; 将结果存储在变量result中
mov result, ax
; 跳转到程序结束
jmp program_end
add_numbers:
; 子程序开始
add ax, bx
ret
以上代码展示了如何调用一个简单的子程序add_numbers，并将结果存储在变量result中。在main中，我们首先将5和10分别存储在ax和bx中，然后通过call指令调用add_numbers子程序。在add_numbers子程序中，我们将ax和bx相加，并通过ret指令返回到调用点。
通过这个题目，我们可以了解到如何定义和调用子程序，并学会如何使用寄存器传递参数和返回结果。
汇编语言编程是一门极其重要的技能，对于理解计算机底层原理和编写高效的程序至关重要。通过分析和解答汇编语言编程题目，我们可以加深对汇编语言的理解，提高编程技巧。
本文讨论了一些常见的汇编语言编程题目，涉及指令理解和转换、内存操作和访问、循环和分支，以及子程序和函数调用。这些题目涵盖了汇编语言编程的核心知识点，帮助读者更好地掌握汇编语言编程。
继续学习和练习汇编语言编程题目，相信您将能够在编程领域中展现出色的技能和才华！
汇编语言作为一种低级语言，直接操作计算机硬件，具有高效性和灵活性的特点。尽管随着高级编程语言的不断发展，汇编语言的地位逐渐被取代，但仍然在某些领域扮演着重要的角色。今天，我们将探讨一下汇编语言的发展前景。
1. 嵌入式系统开发
现如今，嵌入式系统无处不在，它们控制着我们生活中几乎所有的电子设备。而汇编语言在嵌入式系统的开发中发挥着重要的作用。当需要对资源进行高效配置和紧凑编码时，汇编语言的能力无可替代。
2. 性能优化
对于需要极致性能的应用程序或者特定任务，汇编语言是提高效率的有力武器。通过直接操作底层硬件，程序员可以充分利用处理器的各种指令集，并对程序进行高度优化，从而实现更快的执行速度和更低的资源消耗。
3. 逆向工程
逆向工程是一种对已有程序进行分析和修改的过程，以获取有关其设计、功能和操作的详细信息。而汇编语言是逆向工程师必备的技能之一，因为它能够深入理解程序的底层结构和运行机制，帮助工程师发现潜在的漏洞和改进的机会。
4. 操作系统开发
操作系统是计算机系统的核心，而汇编语言是操作系统内核的主要编程语言之一。在操作系统开发中，汇编语言可以实现对硬件的直接控制和访问，编写底层驱动程序和优化系统性能，以提供更好的用户体验。
5. 学术研究
汇编语言是计算机历史的重要组成部分，对于学术研究来说具有不可忽视的意义。研究人员可以通过深入研究和分析汇编代码，探索计算机体系结构的演变和优化，并为未来的计算机设计和开发提供指导。
6. 安全领域
在当今信息时代，网络安全和系统安全是永恒的话题。汇编语言在安全领域中扮演着重要的角色。安全专家使用汇编语言进行系统漏洞的分析和利用，加强软件和硬件的安全性，并保护用户免受各种安全威胁。
7. 汇编语言的学习意义
尽管汇编语言在现代软件开发和编程中的应用有限，但学习汇编语言对于计算机科学专业的学生来说依然具有重要的意义。学习汇编语言可以培养学生对计算机底层工作原理和计算机体系结构的理解，提高编程技能和算法设计能力，为进一步的学习和研究打下坚实基础。
结论
虽然汇编语言的发展前景受到了高级编程语言的冲击，但它仍然在一些特定领域有着不可替代的地位。对于那些对计算机系统底层感兴趣的人来说，学习汇编语言是一种扩展技能和视野的机会。无论是从事嵌入式系统开发、性能优化、逆向工程，还是从事学术研究或安全工作，汇编语言都发挥着重要的作用，有着相应的就业前景。
参考资料：
[1] Smith, W. (2019). The Importance of Learning Assembly Language. courses/undergraduate/313/fall01/burt/projects/assembly/proctop.htm
[2] Wang, Q. (2017). Why Learn Assembly Language? ~clwang/teaching/cs66/assembly/info.html
汇编语言(Assembly Language)是面向机器的程序设计语言。
在汇编语合中，用助记符(Memoni)代替操作码，用地址符号(Symbol)或标号(Label)代替地址妈。这样用符号代替机器语盲的二进制码，就把机器语音变成了汇编语言。于是汇编语言亦称为符号语言。
使用汇编语言编写的程序，机器个能直接识别，要由一种程序将汇编语言翻译成机器语言，这种起翻译作用的程序叫汇编程序，汇编程序是系统软件中语言处理系统软件。汇编语言把汇编程序翻译成机器语言的过程称为f汇编。
汇编语言比机器语言易于读写、易于调试和修改，同时也具有机器语言执行速度快，占内存空间少等优点，但在编写复杂程序时具有明显的局限性，汇编语言依赖于具体的机型，不能通用，也不能在不同机型之间移植。
汇编语言是一种计算机语言，其原理是将汇编语言指令转换成机器码，由计算机执行。汇编语言直接操作计算机硬件，能够获得较高的执行效率，因此在很多嵌入式系统和操作系统的开发中被广泛使用。汇编语言有两种不同的风格：Intel风格和AT&T风格。其中，Intel风格较为流行。汇编语言虽然学习曲线较陡峭，但是通过学习汇编语言，程序员可以更好地理解程序的底层运行原理，从而编写更加高效的代码。
mips汇编语言得一个当代计算机体系结构的基本概念的理解，具有精简指令集计算机（RISC）的开始。一个计算机建筑的理解需要开始组织与现代计算机的基本知识。 MIPS架构体现了当代所有的RISC架构的基本设计原则。
x86汇编语言一般指x86汇编语言：从实模式到保护模式。 《x86汇编语言:从实模式到保护模式》主要讲述INTEL x86处理器的16位实模式、32位保护模式，至于虚拟8086模式，则是为了兼容传统的8086程序，现在看来已经完全过时，不再进行讲述。
之前看了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());
}
}
