匯編語言是一種低級的計算機(jī)編程語言，與機(jī)器碼相對應(yīng)。盡管它在現(xiàn)代計算機(jī)科學(xué)領(lǐng)域中已經(jīng)有了相對較少的應(yīng)用，但它在過去的幾十年里一直發(fā)揮著重要作用。本文將探討匯編語言的過去、現(xiàn)在和未來，以及它在當(dāng)前技術(shù)環(huán)境中的前景。
在計算機(jī)的早期階段，匯編語言是唯一可用的編程語言之一。計算機(jī)程序員必須直接編寫機(jī)器碼指令，以便讓計算機(jī)執(zhí)行特定任務(wù)。然而，隨著高級編程語言的出現(xiàn)，匯編語言逐漸被淘汰。
盡管如此，匯編語言在過去發(fā)揮著重要的作用。它可以直接訪問計算機(jī)硬件，并具有高度的控制力。在計算機(jī)游戲開發(fā)、嵌入式系統(tǒng)設(shè)計和操作系統(tǒng)內(nèi)核開發(fā)等領(lǐng)域，匯編語言曾是首選語言。它能夠優(yōu)化代碼，實現(xiàn)更高效的計算和更有效的內(nèi)存利用。
然而，隨著計算機(jī)體系結(jié)構(gòu)和編程語言的發(fā)展，匯編語言開始減少其在實際項目中的應(yīng)用。高級編程語言的出現(xiàn)使得開發(fā)人員能夠更快速地實現(xiàn)復(fù)雜功能，并提高開發(fā)效率。此外，匯編語言的學(xué)習(xí)曲線更為陡峭，對于非專業(yè)程序員來說相對困難。
在現(xiàn)代計算機(jī)科學(xué)領(lǐng)域中，匯編語言的應(yīng)用范圍有限，但仍然存在一些特定的用例。
首先，嵌入式系統(tǒng)開發(fā)是一個非常適合使用匯編語言的領(lǐng)域。嵌入式系統(tǒng)通常有嚴(yán)格的資源限制，匯編語言可以直接控制硬件，實現(xiàn)最佳的性能和資源利用。此外，對于某些特殊的嵌入式平臺，只能使用匯編語言進(jìn)行開發(fā)。
其次，在漏洞和反匯編等領(lǐng)域，匯編語言仍然是必須掌握的技能。黑客和安全專家經(jīng)常需要分析底層代碼，以發(fā)現(xiàn)漏洞并進(jìn)行安全評估。通過了解匯編語言，他們能夠更好地理解程序的執(zhí)行過程，從而提供更有效的保護(hù)措施。
此外，對于對計算機(jī)體系結(jié)構(gòu)和底層操作有濃厚興趣的計算機(jī)科學(xué)學(xué)生和研究人員來說，學(xué)習(xí)匯編語言仍然具有重要意義。它可以幫助他們深入了解計算機(jī)內(nèi)部的工作原理，并對其他高級編程語言有更深刻的理解。
盡管匯編語言在現(xiàn)代技術(shù)環(huán)境中的應(yīng)用范圍相對較小，但它在未來仍然有一定的前景。
首先，隨著物聯(lián)網(wǎng)和嵌入式系統(tǒng)的普及，對小型、低功耗設(shè)備的需求不斷增加。在這些設(shè)備中，優(yōu)化的代碼和高效的資源利用至關(guān)重要。匯編語言可以提供對硬件的直接控制，滿足這些需求。
其次，人工智能和機(jī)器學(xué)習(xí)等領(lǐng)域的發(fā)展可能為匯編語言帶來新的機(jī)會。雖然高級編程語言如Python和R在這些領(lǐng)域中更為普遍，但對于一些特定的優(yōu)化任務(wù)，匯編語言可能提供更快速和高效的解決方案。
此外，雖然學(xué)習(xí)和掌握匯編語言相對困難，但對于個別計算機(jī)科學(xué)學(xué)生和研究人員來說，它仍然是一項重要的專業(yè)技能。深入了解計算機(jī)內(nèi)部工作原理并能夠直接控制硬件的能力，將成為未來計算機(jī)科學(xué)領(lǐng)域中的重要競爭優(yōu)勢。
匯編語言在計算機(jī)科學(xué)的發(fā)展歷程中起到了重要的作用。盡管它在現(xiàn)代技術(shù)環(huán)境中的應(yīng)用范圍相對較小，但在一些特定的領(lǐng)域和特定的用例中仍然具有價值。嵌入式系統(tǒng)開發(fā)、漏洞分析和對計算機(jī)內(nèi)部工作原理的深入理解都是匯編語言的重要應(yīng)用領(lǐng)域。
盡管如今高級編程語言的流行，但匯編語言的學(xué)習(xí)仍然具有一定的意義。它可以幫助開發(fā)人員更好地理解計算機(jī)底層的運行機(jī)制，并為一些特定的優(yōu)化任務(wù)提供高效的解決方案。對于計算機(jī)科學(xué)學(xué)生和研究人員來說，掌握匯編語言依然是一項重要的專業(yè)技能。
在未來，隨著物聯(lián)網(wǎng)和嵌入式系統(tǒng)的發(fā)展，以及人工智能和機(jī)器學(xué)習(xí)等領(lǐng)域的進(jìn)一步演進(jìn)，匯編語言可能會找到新的應(yīng)用機(jī)會。它具備直接控制硬件的能力，為某些特定的優(yōu)化任務(wù)提供了可能性。
在學(xué)習(xí)和開發(fā)匯編語言程序時，選擇適合的匯編軟件工具是非常重要的。本篇文章旨在為您提供匯編語言軟件下載的指南和相關(guān)建議，幫助您選擇最適合您需求的工具。
眾所周知，匯編語言是一種低級編程語言，直接操作計算機(jī)硬件，具有高度的靈活性和效率。因此，在進(jìn)行匯編語言編程時，選擇合適的匯編軟件工具非常關(guān)鍵。優(yōu)秀的匯編軟件可以提供強大的功能和便捷的開發(fā)環(huán)境，使開發(fā)工作更加高效。
在選擇匯編語言軟件時，需要考慮以下幾個因素：
以下是匯編語言軟件下載的一般步驟：
選擇合適的匯編軟件對于匯編語言編程至關(guān)重要。希望本文提供的匯編語言軟件下載指南能夠幫助您找到最適合您的匯編工具，讓您的編程工作更加高效和愉快。
取決于你的教材。
大部分教材都是使用MASM匯編器（比如王爽的《匯編語言》（強推）），MASM只能在Windows下使用。但是由于國內(nèi)關(guān)于這個的教材眾多，是入門的好選擇。
如果你想要跨平臺的話，NASM是很好的選擇。使用NASM作為匯編器的書可看李忠的《x86匯編語言-從實模式到保護(hù)模式》。而且我看國外很多的項目都是使用NASM。你可以先用MASM入門，然后轉(zhuǎn)到NASM。
不過還是先找本書看吧，匯編器的學(xué)習(xí)都差不多，一個學(xué)會了其他的也都差不多。
匯編語言是一種低級程序設(shè)計語言，用于將機(jī)器指令轉(zhuǎn)化為可執(zhí)行代碼。它直接操作計算機(jī)的硬件資源，可以精確控制計算機(jī)的運行過程。匯編語言的編程結(jié)構(gòu)特點使其在特定的場景下具有獨特的優(yōu)勢。
匯編語言是與計算機(jī)硬件密切相關(guān)的編程語言。在匯編語言中，程序員可以直接操作CPU、寄存器、內(nèi)存等硬件資源，控制計算機(jī)的運行。通過使用匯編語言，程序員可以深入了解計算機(jī)底層的工作原理，更好地優(yōu)化代碼，提高程序的執(zhí)行效率。
匯編語言的指令集相對簡潔，通常由一系列的助記符組成。每個指令都對應(yīng)著一條機(jī)器指令，執(zhí)行特定的操作。匯編語言的指令集通常包括數(shù)據(jù)傳輸指令、算術(shù)運算指令、邏輯運算指令等，可以完成各種各樣的任務(wù)。
相比高級語言，匯編語言的指令集更加底層，更接近于機(jī)器的本質(zhì)。這使得匯編語言的執(zhí)行速度更快，對計算機(jī)資源的需求更少。在一些對性能要求較高的場景下，使用匯編語言可以獲得更好的執(zhí)行效果。
匯編語言具備強大的編程控制能力，程序員可以精確控制程序的執(zhí)行流程。通過使用跳轉(zhuǎn)指令、條件判斷指令等，可以實現(xiàn)各種分支邏輯和循環(huán)結(jié)構(gòu)。這種編程控制能力使得匯編語言非常適合處理一些復(fù)雜的算法和數(shù)據(jù)結(jié)構(gòu)問題。
匯編語言在系統(tǒng)調(diào)用方面有著良好的支持。系統(tǒng)調(diào)用是一種操作系統(tǒng)提供的接口，用于訪問底層的資源和功能。在匯編語言中，程序員可以直接使用系統(tǒng)調(diào)用指令，調(diào)用操作系統(tǒng)提供的各種服務(wù)，如文件操作、進(jìn)程管理等。這使得匯編語言可以與操作系統(tǒng)緊密結(jié)合，完成更加復(fù)雜的任務(wù)。
由于匯編語言直接操作硬件，程序員可以針對特定的硬件平臺進(jìn)行優(yōu)化。通過編寫高效的匯編代碼，可以最大程度地利用計算機(jī)的資源，提高程序的執(zhí)行效率。在一些對性能要求較高的應(yīng)用場景下，利用匯編語言進(jìn)行優(yōu)化可以獲得顯著的性能提升。
除了對硬件的優(yōu)化，匯編語言還可以通過手動內(nèi)存管理、特殊寄存器的使用等方式，進(jìn)一步提高程序的執(zhí)行效率。這使得匯編語言在一些嵌入式系統(tǒng)、實時系統(tǒng)等對性能要求較高的領(lǐng)域得到廣泛應(yīng)用。
匯編語言是一種獨立于高級語言的編程語言。它不依賴于任何特定的編程環(huán)境和工具鏈，可以直接使用機(jī)器指令進(jìn)行編程。這種獨立性使得匯編語言具有更大的靈活性，可以適用于各種不同的計算機(jī)體系結(jié)構(gòu)。
匯編語言是一種直接操作硬件的低級編程語言，具有簡潔高效的指令集、強大的編程控制能力和良好的系統(tǒng)調(diào)用支持。它可以優(yōu)化代碼執(zhí)行效率，不依賴于高級語言，在特定的應(yīng)用場景下具有獨特的優(yōu)勢。然而，匯編語言也存在一些挑戰(zhàn)，比如編寫復(fù)雜的算法和數(shù)據(jù)結(jié)構(gòu)、可讀性差等問題。在選擇使用匯編語言時，需要根據(jù)具體的應(yīng)用需求和開發(fā)團(tuán)隊的技術(shù)實力進(jìn)行綜合考量。
隨著計算機(jī)科學(xué)和編程領(lǐng)域的不斷發(fā)展，匯編語言作為一種低級語言，仍然扮演著重要的角色。無論是在底層硬件編程還是在優(yōu)化算法方面，對匯編語言的掌握都是至關(guān)重要的。本文將探討一些常見的匯編語言編程題目，并進(jìn)行深入分析。
很多匯編語言編程題目要求理解和轉(zhuǎn)換不同的指令。這需要對不同的指令集有深入的了解和熟練的掌握。比如，考慮以下的題目：
mov ax, 10h
add ax, bx
mov cx, ax
sub cx, dx
以上代碼片段展示了一系列的指令操作。通過分析每個指令的功能，可以得出以下的操作：
首先，將值10h（16進(jìn)制）賦給寄存器ax。然后，將寄存器bx的值與ax相加，并將結(jié)果存回ax。接著，將ax的值賦給cx。最后，將寄存器dx的值從cx中減去。
理解和轉(zhuǎn)換指令是匯編語言編程的基礎(chǔ)，對于掌握匯編語言的編程技巧至關(guān)重要。
在匯編語言編程中，對內(nèi)存的操作和訪問也是一個重要的考察點。下面是一個相關(guān)的題目：
.data
value db 10
.code
mov al, value
add al, 5
mov value, al
這道題目的目標(biāo)是對變量value進(jìn)行操作。首先，將value的值賦給寄存器al。然后，將寄存器al的值加上5。最后，將寄存器al的值存回變量value中。
通過這個例子，我們可以看到內(nèi)存操作和訪問的過程。在匯編語言中，我們可以通過寄存器來暫存數(shù)據(jù)，在需要的時候再寫回到內(nèi)存中。
循環(huán)和分支是編程中常見的控制結(jié)構(gòu)，匯編語言同樣支持這些結(jié)構(gòu)。以下是一個相關(guān)題目的示例：
.data
n db 10
i db 0
.code
mov al, 0
mov bl, n
loop_start:
cmp al, bl
jge loop_end
; 循環(huán)操作
add i, al
inc al
jmp loop_start
loop_end:
上述代碼段展示了一個簡單的循環(huán)結(jié)構(gòu)。首先，我們將0賦給寄存器al，將n賦給寄存器bl。然后，在loop_start標(biāo)簽處，比較al和bl的值。如果al大于等于bl，則跳轉(zhuǎn)到loop_end標(biāo)簽處結(jié)束循環(huán)。如果不滿足條件，則執(zhí)行循環(huán)操作，將al的值加到i中，然后將al自增，并跳回loop_start標(biāo)簽處重新判斷條件。
通過這個題目，我們可以看到如何使用cmp指令進(jìn)行比較，以及使用jge指令進(jìn)行條件跳轉(zhuǎn)。循環(huán)和分支是匯編語言編程中非常重要的控制結(jié)構(gòu)，對編寫高效的程序至關(guān)重要。
在匯編語言中，子程序和函數(shù)調(diào)用是模塊化和重用代碼的關(guān)鍵。以下是一個相關(guān)題目的示例：
.code
main:
; 調(diào)用子程序add_numbers
mov ax, 5
mov bx, 10
call add_numbers
; 將結(jié)果存儲在變量result中
mov result, ax
; 跳轉(zhuǎn)到程序結(jié)束
jmp program_end
add_numbers:
; 子程序開始
add ax, bx
ret
以上代碼展示了如何調(diào)用一個簡單的子程序add_numbers，并將結(jié)果存儲在變量result中。在main中，我們首先將5和10分別存儲在ax和bx中，然后通過call指令調(diào)用add_numbers子程序。在add_numbers子程序中，我們將ax和bx相加，并通過ret指令返回到調(diào)用點。
通過這個題目，我們可以了解到如何定義和調(diào)用子程序，并學(xué)會如何使用寄存器傳遞參數(shù)和返回結(jié)果。
匯編語言編程是一門極其重要的技能，對于理解計算機(jī)底層原理和編寫高效的程序至關(guān)重要。通過分析和解答匯編語言編程題目，我們可以加深對匯編語言的理解，提高編程技巧。
本文討論了一些常見的匯編語言編程題目，涉及指令理解和轉(zhuǎn)換、內(nèi)存操作和訪問、循環(huán)和分支，以及子程序和函數(shù)調(diào)用。這些題目涵蓋了匯編語言編程的核心知識點，幫助讀者更好地掌握匯編語言編程。
繼續(xù)學(xué)習(xí)和練習(xí)匯編語言編程題目，相信您將能夠在編程領(lǐng)域中展現(xiàn)出色的技能和才華！
匯編語言作為一種低級語言，直接操作計算機(jī)硬件，具有高效性和靈活性的特點。盡管隨著高級編程語言的不斷發(fā)展，匯編語言的地位逐漸被取代，但仍然在某些領(lǐng)域扮演著重要的角色。今天，我們將探討一下匯編語言的發(fā)展前景。
1. 嵌入式系統(tǒng)開發(fā)
現(xiàn)如今，嵌入式系統(tǒng)無處不在，它們控制著我們生活中幾乎所有的電子設(shè)備。而匯編語言在嵌入式系統(tǒng)的開發(fā)中發(fā)揮著重要的作用。當(dāng)需要對資源進(jìn)行高效配置和緊湊編碼時，匯編語言的能力無可替代。
2. 性能優(yōu)化
對于需要極致性能的應(yīng)用程序或者特定任務(wù)，匯編語言是提高效率的有力武器。通過直接操作底層硬件，程序員可以充分利用處理器的各種指令集，并對程序進(jìn)行高度優(yōu)化，從而實現(xiàn)更快的執(zhí)行速度和更低的資源消耗。
3. 逆向工程
逆向工程是一種對已有程序進(jìn)行分析和修改的過程，以獲取有關(guān)其設(shè)計、功能和操作的詳細(xì)信息。而匯編語言是逆向工程師必備的技能之一，因為它能夠深入理解程序的底層結(jié)構(gòu)和運行機(jī)制，幫助工程師發(fā)現(xiàn)潛在的漏洞和改進(jìn)的機(jī)會。
4. 操作系統(tǒng)開發(fā)
操作系統(tǒng)是計算機(jī)系統(tǒng)的核心，而匯編語言是操作系統(tǒng)內(nèi)核的主要編程語言之一。在操作系統(tǒng)開發(fā)中，匯編語言可以實現(xiàn)對硬件的直接控制和訪問，編寫底層驅(qū)動程序和優(yōu)化系統(tǒng)性能，以提供更好的用戶體驗。
5. 學(xué)術(shù)研究
匯編語言是計算機(jī)歷史的重要組成部分，對于學(xué)術(shù)研究來說具有不可忽視的意義。研究人員可以通過深入研究和分析匯編代碼，探索計算機(jī)體系結(jié)構(gòu)的演變和優(yōu)化，并為未來的計算機(jī)設(shè)計和開發(fā)提供指導(dǎo)。
6. 安全領(lǐng)域
在當(dāng)今信息時代，網(wǎng)絡(luò)安全和系統(tǒng)安全是永恒的話題。匯編語言在安全領(lǐng)域中扮演著重要的角色。安全專家使用匯編語言進(jìn)行系統(tǒng)漏洞的分析和利用，加強軟件和硬件的安全性，并保護(hù)用戶免受各種安全威脅。
7. 匯編語言的學(xué)習(xí)意義
盡管匯編語言在現(xiàn)代軟件開發(fā)和編程中的應(yīng)用有限，但學(xué)習(xí)匯編語言對于計算機(jī)科學(xué)專業(yè)的學(xué)生來說依然具有重要的意義。學(xué)習(xí)匯編語言可以培養(yǎng)學(xué)生對計算機(jī)底層工作原理和計算機(jī)體系結(jié)構(gòu)的理解，提高編程技能和算法設(shè)計能力，為進(jìn)一步的學(xué)習(xí)和研究打下堅實基礎(chǔ)。
結(jié)論
雖然匯編語言的發(fā)展前景受到了高級編程語言的沖擊，但它仍然在一些特定領(lǐng)域有著不可替代的地位。對于那些對計算機(jī)系統(tǒng)底層感興趣的人來說，學(xué)習(xí)匯編語言是一種擴(kuò)展技能和視野的機(jī)會。無論是從事嵌入式系統(tǒng)開發(fā)、性能優(yōu)化、逆向工程，還是從事學(xué)術(shù)研究或安全工作，匯編語言都發(fā)揮著重要的作用，有著相應(yīng)的就業(yè)前景。
參考資料：
[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)是面向機(jī)器的程序設(shè)計語言。
在匯編語合中，用助記符(Memoni)代替操作碼，用地址符號(Symbol)或標(biāo)號(Label)代替地址媽。這樣用符號代替機(jī)器語盲的二進(jìn)制碼，就把機(jī)器語音變成了匯編語言。于是匯編語言亦稱為符號語言。
使用匯編語言編寫的程序，機(jī)器個能直接識別，要由一種程序?qū)R編語言翻譯成機(jī)器語言，這種起翻譯作用的程序叫匯編程序，匯編程序是系統(tǒng)軟件中語言處理系統(tǒng)軟件。匯編語言把匯編程序翻譯成機(jī)器語言的過程稱為f匯編。
匯編語言比機(jī)器語言易于讀寫、易于調(diào)試和修改，同時也具有機(jī)器語言執(zhí)行速度快，占內(nèi)存空間少等優(yōu)點，但在編寫復(fù)雜程序時具有明顯的局限性，匯編語言依賴于具體的機(jī)型，不能通用，也不能在不同機(jī)型之間移植。
匯編語言是一種計算機(jī)語言，其原理是將匯編語言指令轉(zhuǎn)換成機(jī)器碼，由計算機(jī)執(zhí)行。匯編語言直接操作計算機(jī)硬件，能夠獲得較高的執(zhí)行效率，因此在很多嵌入式系統(tǒng)和操作系統(tǒng)的開發(fā)中被廣泛使用。匯編語言有兩種不同的風(fēng)格：Intel風(fēng)格和AT&T風(fēng)格。其中，Intel風(fēng)格較為流行。匯編語言雖然學(xué)習(xí)曲線較陡峭，但是通過學(xué)習(xí)匯編語言，程序員可以更好地理解程序的底層運行原理，從而編寫更加高效的代碼。
mips匯編語言得一個當(dāng)代計算機(jī)體系結(jié)構(gòu)的基本概念的理解，具有精簡指令集計算機(jī)（RISC）的開始。一個計算機(jī)建筑的理解需要開始組織與現(xiàn)代計算機(jī)的基本知識。 MIPS架構(gòu)體現(xiàn)了當(dāng)代所有的RISC架構(gòu)的基本設(shè)計原則。
x86匯編語言一般指x86匯編語言：從實模式到保護(hù)模式。 《x86匯編語言:從實模式到保護(hù)模式》主要講述INTEL x86處理器的16位實模式、32位保護(hù)模式，至于虛擬8086模式，則是為了兼容傳統(tǒng)的8086程序，現(xiàn)在看來已經(jīng)完全過時，不再進(jìn)行講述。
之前看了Mahout官方示例 20news 的調(diào)用實現(xiàn)；于是想根據(jù)示例的流程實現(xiàn)其他例子。網(wǎng)上看到了一個關(guān)于天氣適不適合打羽毛球的例子。
訓(xùn)練數(shù)據(jù)：
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
檢測數(shù)據(jù)：
sunny，hot，high，weak
結(jié)果：
Yes=》 0.007039
No=》 0.027418
于是使用Java代碼調(diào)用Mahout的工具類實現(xiàn)分類。
基本思想：
1. 構(gòu)造分類數(shù)據(jù)。
2. 使用Mahout工具類進(jìn)行訓(xùn)練，得到訓(xùn)練模型。
3。將要檢測數(shù)據(jù)轉(zhuǎn)換成vector數(shù)據(jù)。
4. 分類器對vector數(shù)據(jù)進(jìn)行分類。
接下來貼下我的代碼實現(xiàn)=》
1. 構(gòu)造分類數(shù)據(jù)：
在hdfs主要創(chuàng)建一個文件夾路徑 /zhoujainfeng/playtennis/input 并將分類文件夾 no 和 yes 的數(shù)據(jù)傳到hdfs上面。
數(shù)據(jù)文件格式，如D1文件內(nèi)容： Sunny Hot High Weak
2. 使用Mahout工具類進(jìn)行訓(xùn)練，得到訓(xùn)練模型。
3。將要檢測數(shù)據(jù)轉(zhuǎn)換成vector數(shù)據(jù)。
4. 分類器對vector數(shù)據(jù)進(jìn)行分類。
這三步，代碼我就一次全貼出來；主要是兩個類 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) {
//將訓(xùn)練數(shù)據(jù)轉(zhuǎn)換成 vector數(shù)據(jù)
makeTrainVector();
//產(chǎn)生訓(xùn)練模型
makeModel(false);
//測試檢測數(shù)據(jù)
BayesCheckData.printResult();
}
public static void makeCheckVector(){
//將測試數(shù)據(jù)轉(zhuǎn)換成序列化文件
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參數(shù)是，是否遞歸刪除的意思
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);
}
//將序列化文件轉(zhuǎn)換成向量文件
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參數(shù)是，是否遞歸刪除的意思
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("序列化文件轉(zhuǎn)換成向量失?。?#34;);
System.out.println(2);
}
}
public static void makeTrainVector(){
//將測試數(shù)據(jù)轉(zhuǎn)換成序列化文件
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參數(shù)是，是否遞歸刪除的意思
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("文件序列化失?。?#34;);
System.exit(1);
}
//將序列化文件轉(zhuǎn)換成向量文件
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參數(shù)是，是否遞歸刪除的意思
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("序列化文件轉(zhuǎn)換成向量失敗！");
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參數(shù)是，是否遞歸刪除的意思
fs.delete(out, true);
}
if(fs.exists(label)){
//boolean參數(shù)是，是否遞歸刪除的意思
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("生成訓(xùn)練模型失敗！");
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("檢測數(shù)據(jù)構(gòu)造成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時表示總文檔數(shù)
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());
}
}
