用什么算法確定保險(xiǎn)用戶是欺詐用戶

1、 數(shù)據(jù)類型轉(zhuǎn)換：因”gender”實(shí)際代表男性、女性用戶，故需要將“gender”變量轉(zhuǎn)換成因子變量，且因子水平用“F”替換1，“M”替換2；將“fraudRisk”變量也轉(zhuǎn)換成因子變量。

創(chuàng)新互聯(lián)公司專注為客戶提供全方位的互聯(lián)網(wǎng)綜合服務(wù)，包含不限于成都做網(wǎng)站、成都網(wǎng)站設(shè)計(jì)、重慶網(wǎng)絡(luò)推廣、成都小程序開發(fā)、重慶網(wǎng)絡(luò)營銷、重慶企業(yè)策劃、重慶品牌公關(guān)、搜索引擎seo、人物專訪、企業(yè)宣傳片、企業(yè)代運(yùn)營等，從售前售中售后，我們都將竭誠為您服務(wù)，您的肯定，是我們最大的嘉獎；創(chuàng)新互聯(lián)公司為所有大學(xué)生創(chuàng)業(yè)者提供重慶建站搭建服務(wù)，24小時(shí)服務(wù)熱線：18982081108，官方網(wǎng)址：chinadenli.net

答：首先將數(shù)據(jù)導(dǎo)入到R中，并查看數(shù)據(jù)維度：

# 導(dǎo)入數(shù)據(jù) ccFraud - read.csv("ccFraud.csv") # 查看數(shù)據(jù)維度 str(ccFraud)'data.frame': 10000000 obs. of 9 variables:$ custID : int 1 2 3 4 5 6 7 8 9 10 ...$ gender : int 1 2 2 1 1 2 1 1 2 1 ...$ state : int 35 2 2 15 46 44 3 10 32 23 ...$ cardholder : int 1 1 1 1 1 2 1 1 1 1 ...$ balance : int 3000 0 0 0 0 5546 2000 6016 2428 0 ...$ numTrans : int 4 9 27 12 11 21 41 20 4 18 ...$ numIntlTrans: int 14 0 9 0 16 0 0 3 10 56 ...$ creditLine : int 2 18 16 5 7 13 1 6 22 5 ...$ fraudRisk : int 0 0 0 0 0 0 0 0 0 0 ...

ccFraud數(shù)據(jù)集一共有一千萬行9列，各列均為整型變量。按照題目要求先將“gender”變量轉(zhuǎn)變?yōu)橐蜃有停乙蜃铀接谩癋”替換1，“M”替換2。代碼如下：

ccFraud$gender - factor(ifelse(ccFraud$gender==1,'F','M')) str(ccFraud)'data.frame': 10000000 obs. of 9 variables:$ custID : int 1 2 3 4 5 6 7 8 9 10 ...$ gender : Factor w/ 2 levels "F","M": 1 2 2 1 1 2 1 1 2 1 ...$ state : int 35 2 2 15 46 44 3 10 32 23 ...$ cardholder : int 1 1 1 1 1 2 1 1 1 1 ...$ balance : int 3000 0 0 0 0 5546 2000 6016 2428 0 ...$ numTrans : int 4 9 27 12 11 21 41 20 4 18 ...$ numIntlTrans: int 14 0 9 0 16 0 0 3 10 56 ...$ creditLine : int 2 18 16 5 7 13 1 6 22 5 ...$ fraudRisk : int 0 0 0 0 0 0 0 0 0 0 ...

將“fraudRisk”變量也轉(zhuǎn)換成因子變量，代碼如下：

ccFraud$fraudRisk - as.factor(ccFraud$fraudRisk)str(ccFraud)'data.frame': 10000000 obs. of 9 variables: $ custID : int 1 2 3 4 5 6 7 8 9 10 ... $ gender : Factor w/ 2 levels "F","M": 1 2 2 1 1 2 1 1 2 1... $ state : int 35 2 2 15 46 44 3 10 32 23... $ cardholder : int 1 1 1 1 1 2 1 1 1 1 ... $ balance : int 3000 0 0 0 0 5546 2000 60162428 0 ... $ numTrans : int 4 9 27 12 11 21 41 20 4 18... $ numIntlTrans: int 14 0 9 0 16 0 0 3 10 56 ... $ creditLine : int 2 18 16 5 7 13 1 6 22 5 ... $ fraudRisk : Factor w/ 2 levels"0","1": 1 1 1 1 1 1 1 1 1 1 ...

2、 數(shù)據(jù)探索：查看“fraudRisk”變量中0、1的頻數(shù)及占比情況。

答：此題是送分題，通過table函數(shù)、prop.table函數(shù)即可實(shí)現(xiàn)。代碼如下：

table(ccFraud$fraudRisk) 0 1 9403986 596014 prop.table(table(ccFraud$fraudRisk)) 0 1 0.9403986 0.0596014

3、 數(shù)據(jù)分區(qū)：需要按照變量fraudRisk來進(jìn)行等比例抽樣，其中80%作為訓(xùn)練集train數(shù)據(jù)，20%作為測試集test數(shù)據(jù)。

答：由于要根據(jù)fraudRisk變量進(jìn)行等比例抽樣，我們用caret包的createDataPartition函數(shù)實(shí)現(xiàn)。代碼如下：

library(caret)載入需要的程輯包：lattice載入需要的程輯包：ggplot2 idx - createDataPartition(ccFraud$fraudRisk,p=0.8,list=F) train - ccFraud[idx,] test - ccFraud[-idx,] prop.table(table(train$fraudRisk)) 0 1 0.94039851 0.05960149 prop.table(table(test$fraudRisk)) 0 1 0.94039897 0.05960103

4、 建立模型：利用至少三種常見的分類算法（如KNN近鄰算法、決策樹算法、隨機(jī)森林等）對數(shù)據(jù)建立預(yù)測模型。

答：由于數(shù)據(jù)量較大，學(xué)員反饋運(yùn)行慢，這邊利用MicrosoftML包來跑模型。關(guān)于MRS的快速入門請查閱之前文章：

# 模型一：利用MicrosoftML包的rxFastTrees()函數(shù)構(gòu)建快速決策樹模型 (a - Sys.time()) #模型運(yùn)行前時(shí)間[1] "2017-09-03 23:32:04 CST" treeModel - rxFastTrees(fraudRisk ~ gender + cardholder + balance + numTrans+ + numIntlTrans + creditLine,data = train)Not adding a normalizer.Making per-feature arraysChanging data from row-wise to column-wiseBeginning processing data.Rows Read: 8000001, Read Time: 0, Transform Time: 0Beginning processing data.Processed 8000001 instancesBinning and forming Feature objectsReserved memory for tree learner: 79664 bytesStarting to train ...Not training a calibrator because it is not needed.Elapsed time: 00:01:04.6222538 (b - Sys.time()) #模型運(yùn)行后時(shí)間[1] "2017-09-03 23:33:09 CST" b-a # 模型運(yùn)行時(shí)長Time difference of 1.086313 mins # 模型二：利用MicrosoftML包的rxFastForest()函數(shù)構(gòu)建快速隨機(jī)森林模型 (a - Sys.time()) #模型運(yùn)行前時(shí)間[1] "2017-09-03 23:33:31 CST" forestModel - rxFastForest(fraudRisk ~ gender + cardholder + balance + numTrans+ + numIntlTrans + creditLine,data = train)Not adding a normalizer.Making per-feature arraysChanging data from row-wise to column-wiseBeginning processing data.Rows Read: 8000001, Read Time: 0, Transform Time: 0Beginning processing data.Processed 8000001 instancesBinning and forming Feature objectsReserved memory for tree learner: 79664 bytesStarting to train ...Training calibrator.Beginning processing data.Rows Read: 8000001, Read Time: 0, Transform Time: 0Beginning processing data.Elapsed time: 00:01:25.4585776 (b - Sys.time()) #FastTrees模型運(yùn)行后時(shí)間[1] "2017-09-03 23:34:57 CST" b-a # 模型運(yùn)行時(shí)長Time difference of 1.433823 mins # 模型三：利用MicrosoftML包的rxLogisticRegression()函數(shù)構(gòu)建快速邏輯回歸模型 (a - Sys.time()) #模型運(yùn)行前時(shí)間[1] "2017-09-03 23:34:57 CST" logitModel - rxLogisticRegression(fraudRisk ~ gender + cardholder + balance + numTrans+ + numIntlTrans + creditLine,data = train)Automatically adding a MinMax normalization transform, use 'norm=Warn' or 'norm=No' to turn this behavior off.Beginning processing data.Rows Read: 8000001, Read Time: 0, Transform Time: 0Beginning processing data.Beginning processing data.Rows Read: 8000001, Read Time: 0, Transform Time: 0Beginning processing data.Beginning processing data.Rows Read: 8000001, Read Time: 0, Transform Time: 0Beginning processing data.LBFGS multi-threading will attempt to load dataset into memory. In case of out-of-memory issues, turn off multi-threading by setting trainThreads to 1.Beginning optimizationnum vars: 8improvement criterion: Mean ImprovementL1 regularization selected 8 of 8 weights.Not training a calibrator because it is not needed.Elapsed time: 00:00:19.5887244Elapsed time: 00:00:00.0383181 (b - Sys.time()) #模型運(yùn)行后時(shí)間[1] "2017-09-03 23:35:17 CST" b-a # 模型運(yùn)行時(shí)長Time difference of 20.27396 secs

邏輯回歸模型運(yùn)行時(shí)間最短，消耗20.3秒，其次是決策樹，消耗1.08分鐘，時(shí)間最長的是隨機(jī)森林，時(shí)長為1.4分鐘。

5、 模型評估：利用上面建立的預(yù)測模型（至少第四點(diǎn)建立的三個模型），對訓(xùn)練集和測試集數(shù)據(jù)進(jìn)行預(yù)測，評估模型效果，最終選擇最優(yōu)模型作為以后的業(yè)務(wù)預(yù)測模型。（提示：構(gòu)建混淆矩陣）

答：針對上面的三種模型，我們分別對train、test數(shù)據(jù)集進(jìn)行預(yù)測并評估。

# 利用決策樹模型對數(shù)據(jù)進(jìn)行預(yù)測，并計(jì)算誤差率 treePred_tr - rxPredict(treeModel,data = train)Beginning processing data.Rows Read: 8000001, Read Time: 0, Transform Time: 0Beginning processing data.Elapsed time: 00:00:52.1015119Finished writing 8000001 rows.Writing completed. t - table(train$fraudRisk,treePred_tr$PredictedLabel) t 0 1 0 7446742 76447 1 253008 223804 (paste0(round((sum(t)-sum(diag(t)))/sum(t),3)*100,"%")) #計(jì)算決策樹對train數(shù)據(jù)集的預(yù)測誤差率[1] "4.1%" treePred_te - rxPredict(treeModel,data = test)Beginning processing data.Rows Read: 1999999, Read Time: 0, Transform Time: 0Beginning processing data.Elapsed time: 00:00:13.4980323Finished writing 1999999 rows.Writing completed. t1 - table(test$fraudRisk,treePred_te$PredictedLabel) t1 0 1 0 1861406 19391 1 63176 56026 (paste0(round((sum(t1)-sum(diag(t1)))/sum(t1),3)*100,"%")) #計(jì)算決策樹對test數(shù)據(jù)集的預(yù)測誤差率[1] "4.1%" # 利用隨機(jī)森林模型對數(shù)據(jù)進(jìn)行預(yù)測，并計(jì)算誤差率 forestPred_tr - rxPredict(forestModel,data = train)Beginning processing data.Rows Read: 8000001, Read Time: 0.001, Transform Time: 0Beginning processing data.Elapsed time: 00:00:56.2862657Finished writing 8000001 rows.Writing completed. t - table(train$fraudRisk,forestPred_tr$PredictedLabel) t 0 1 0 7508808 14381 1 373777 103035 (paste0(round((sum(t)-sum(diag(t)))/sum(t),3)*100,"%")) #計(jì)算隨機(jī)森林對train數(shù)據(jù)集的預(yù)測誤差率[1] "4.9%" forestPred_te - rxPredict(forestModel,data = test)Beginning processing data.Rows Read: 1999999, Read Time: 0.001, Transform Time: 0Beginning processing data.Elapsed time: 00:00:14.0430130Finished writing 1999999 rows.Writing completed. t1 - table(test$fraudRisk,forestPred_te$PredictedLabel) t1 0 1 0 1877117 3680 1 93419 25783 (paste0(round((sum(t1)-sum(diag(t1)))/sum(t),3)*100,"%")) #計(jì)算隨機(jī)森林對test數(shù)據(jù)集的預(yù)測誤差率[1] "1.2%" # 利用邏輯回歸模型對數(shù)據(jù)進(jìn)行預(yù)測，并計(jì)算誤差率 logitPred_tr - rxPredict(logitModel,data = train)Beginning processing data.Rows Read: 8000001, Read Time: 0.001, Transform Time: 0Beginning processing data.Elapsed time: 00:00:08.1674394Finished writing 8000001 rows.Writing completed. t - table(train$fraudRisk,logitPred_tr$PredictedLabel) t 0 1 0 7444156 79033 1 250679 226133 (paste0(round((sum(t)-sum(diag(t)))/sum(t),3)*100,"%")) #計(jì)算邏輯回歸對train數(shù)據(jù)集的預(yù)測誤差率[1] "4.1%" logitPred_te - rxPredict(logitModel,data = test)Beginning processing data.Rows Read: 1999999, Read Time: 0, Transform Time: 0Beginning processing data.Elapsed time: 00:00:02.0736547Finished writing 1999999 rows.Writing completed. t1 - table(test$fraudRisk,logitPred_te$PredictedLabel) t1 0 1 0 1860885 19912 1 62428 56774 (paste0(round((sum(t1)-sum(diag(t1)))/sum(t),3)*100,"%")) #計(jì)算邏輯回歸對test數(shù)據(jù)集的預(yù)測誤差率[1] "1%"

從訓(xùn)練集和測試集的預(yù)測誤差率來看，對于此份數(shù)據(jù)，邏輯回歸是最優(yōu)的選擇。

NLP基礎(chǔ)知識: F1-score, 混淆矩陣和語料庫

最近在學(xué)習(xí) NLP 的相關(guān)項(xiàng)目，總覺得不夠深入，決定通過寫作的方式把自己學(xué)到的內(nèi)容記錄下來，分享給大家。并且通過一些通俗易懂的語言讓大家最后能自己能動手實(shí)現(xiàn)一些NLP 的聊天機(jī)器人之類的應(yīng)用。

先了解如何看懂一個模型評估的指標(biāo)，譬如 F1-score , Confusion matrix .

在理解 F1-store 之前，首先定義幾個概念:

TP(True Positive) : 預(yù)測答案正確

FP(False Positive) : 錯將其他類預(yù)測為本類

FN(False Negative) : 本類標(biāo)簽預(yù)測為其他類標(biāo)

F1分?jǐn)?shù)（F1-score）是分類問題的一個衡量指標(biāo), 在 0～1 之間，公式如下:

通過第一步的統(tǒng)計(jì)值計(jì)算每個類別下的 precision 和 recall

精準(zhǔn)度/查準(zhǔn)率(precision)：指被分類器判定正例中的正樣本的比重

召回率/查全率(recall): 指的是被預(yù)測為正例的占總的正例的比重

每個類別下的f1-score，計(jì)算方式如下：

通過對第三步求得的各個類別下的F1-score求均值，得到最后的評測結(jié)果，計(jì)算方式如下：

混淆矩陣的每一列代表了預(yù)測類別，每一列的總數(shù)表示預(yù)測為該類別的數(shù)據(jù)的數(shù)目；每一行代表了數(shù)據(jù)的真實(shí)歸屬類別，每一行的數(shù)據(jù)總數(shù)表示該類別的數(shù)據(jù)實(shí)例的數(shù)目。每一列中的數(shù)值表示真實(shí)數(shù)據(jù)被預(yù)測為該類的數(shù)目。

如有150個樣本數(shù)據(jù)，預(yù)測為1,2,3類各為50個。分類結(jié)束后得到的混淆矩陣為：

每一行之和表示該類別的真實(shí)樣本數(shù)量，每一列之和表示被預(yù)測為該類別的樣本數(shù)量.

巧婦難為無米之炊，語料庫就是 NLP 項(xiàng)目中的 "米"。這里使用的是 awesome-chinese-nlp 中列出的中文wikipedia dump和百度百科語料。其中關(guān)于wikipedia dump的處理可以參考 這篇帖子 。

我們需要一個規(guī)模比較大的中文語料。最好的方法是用對應(yīng)自己需求的語料，比如做金融的chatbot就多去爬取些財(cái)經(jīng)新聞，做醫(yī)療的chatbot就多獲取些醫(yī)療相關(guān)文章。

下面JAVA程序中，怎么樣使用函數(shù)或者類的調(diào)用，讓它簡化？

的執(zhí)行速度慢上約20倍。無論什么都不能阻止Java語言進(jìn)行編譯。寫作本書的時(shí)候，剛剛出現(xiàn)了一些準(zhǔn)實(shí)時(shí)編譯器，它們能顯著加快速度。當(dāng)然，我們完全有理由認(rèn)為會出現(xiàn)適用于更多流行平臺的純固有編譯器，但假若沒有那些編譯器，由于速度的限制，必須有些問題是Java不能解決的。

(2) 和C++一樣，Java也提供了兩種類型的注釋。

(3) 所有東西都必須置入一個類。不存在全局函數(shù)或者全局?jǐn)?shù)據(jù)。如果想獲得與全局函數(shù)等價(jià)的功能，可考慮將static方法和static數(shù)據(jù)置入一個類里。注意沒有象結(jié)構(gòu)、枚舉或者聯(lián)合這一類的東西，一切只有“類”（Class）！

(4) 所有方法都是在類的主體定義的。所以用C++的眼光看，似乎所有函數(shù)都已嵌入，但實(shí)情并非如何（嵌入的問題在后面講述）。

(5) 在Java中，類定義采取幾乎和C++一樣的形式。但沒有標(biāo)志結(jié)束的分號。沒有class foo這種形式的類聲明，只有類定義。

class aType()

void aMethod()

}

(6) Java中沒有作用域范圍運(yùn)算符“::”。Java利用點(diǎn)號做所有的事情，但可以不用考慮它，因?yàn)橹荒茉谝粋€類里定義元素。即使那些方法定義，也必須在一個類的內(nèi)部，所以根本沒有必要指定作用域的范圍。我們注意到的一項(xiàng)差異是對static方法的調(diào)用：使用ClassName.methodName()。除此以外，package（包）的名字是用點(diǎn)號建立的，并能用import關(guān)鍵字實(shí)現(xiàn)C++的“

import java.awt.*;

（

(7) 與C++類似，Java含有一系列“主類型”（Primitive type），以實(shí)現(xiàn)更有效率的訪問。在Java中，這些類型包括boolean，char，byte，short，int，long，float以及double。所有主類型的大小都是固有的，且與具體的機(jī)器無關(guān)（考慮到移植的問題）。這肯定會對性能造成一定的影響，具體取決于不同的機(jī)器。對類型的檢查和要求在Java里變得更苛刻。例如：

■條件表達(dá)式只能是boolean（布爾）類型，不可使用整數(shù)。

■必須使用象X+Y這樣的一個表達(dá)式的結(jié)果；不能僅僅用“X+Y”來實(shí)現(xiàn)“副作用”。

(8) char（字符）類型使用國際通用的16位Unicode字符集，所以能自動表達(dá)大多數(shù)國家的字符。

(9) 靜態(tài)引用的字串會自動轉(zhuǎn)換成String對象。和C及C++不同，沒有獨(dú)立的靜態(tài)字符數(shù)組字串可供使用。

(10) Java增添了三個右移位運(yùn)算符“”，具有與“邏輯”右移位運(yùn)算符類似的功用，可在最末尾插入零值。“”則會在移位的同時(shí)插入符號位（即“算術(shù)”移位）。

(11) 盡管表面上類似，但與C++相比，Java數(shù)組采用的是一個頗為不同的結(jié)構(gòu)，并具有獨(dú)特的行為。有一個只讀的length成員，通過它可知道數(shù)組有多大。而且一旦超過數(shù)組邊界，運(yùn)行期檢查會自動丟棄一個異常。所有數(shù)組都是在內(nèi)存“堆”里創(chuàng)建的，我們可將一個數(shù)組分配給另一個（只是簡單地復(fù)制數(shù)組句柄）。數(shù)組標(biāo)識符屬于第一級對象，它的所有方法通常都適用于其他所有對象。

(12) 對于所有不屬于主類型的對象，都只能通過new命令創(chuàng)建。和C++不同，Java沒有相應(yīng)的命令可以“在堆棧上”創(chuàng)建不屬于主類型的對象。所有主類型都只能在堆棧上創(chuàng)建，同時(shí)不使用new命令。所有主要的類都有自己的“封裝（器）”類，所以能夠通過new創(chuàng)建等價(jià)的、以內(nèi)存“堆”為基礎(chǔ)的對象（主類型數(shù)組是一個例外：它們可象C++那樣通過集合初始化進(jìn)行分配，或者使用new）。

(13) Java中不必進(jìn)行提前聲明。若想在定義前使用一個類或方法，只需直接使用它即可——編譯器會保證使用恰當(dāng)?shù)亩x。所以和在C++中不同，我們不會碰到任何涉及提前引用的問題。

(14) Java沒有預(yù)處理機(jī)。若想使用另一個庫里的類，只需使用import命令，并指定庫名即可。不存在類似于預(yù)處理機(jī)的宏。

(15) Java用包代替了命名空間。由于將所有東西都置入一個類，而且由于采用了一種名為“封裝”的機(jī)制，它能針對類名進(jìn)行類似于命名空間分解的操作，所以命名的問題不再進(jìn)入我們的考慮之列。數(shù)據(jù)包也會在單獨(dú)一個庫名下收集庫的組件。我們只需簡單地“import”（導(dǎo)入）一個包，剩下的工作會由編譯器自動完成。

(16) 被定義成類成員的對象句柄會自動初始化成null。對基本類數(shù)據(jù)成員的初始化在Java里得到了可靠的保障。若不明確地進(jìn)行初始化，它們就會得到一個默認(rèn)值（零或等價(jià)的值）。可對它們進(jìn)行明確的初始化（顯式初始化）：要么在類內(nèi)定義它們，要么在構(gòu)建器中定義。采用的語法比C++的語法更容易理解，而且對于static和非static成員來說都是固定不變的。我們不必從外部定義static成員的存儲方式，這和C++是不同的。

(17) 在Java里，沒有象C和C++那樣的指針。用new創(chuàng)建一個對象的時(shí)候，會獲得一個引用（本書一直將其稱作“句柄”）。例如：

String s = new String("howdy");

然而，C++引用在創(chuàng)建時(shí)必須進(jìn)行初始化，而且不可重定義到一個不同的位置。但Java引用并不一定局限于創(chuàng)建時(shí)的位置。它們可根據(jù)情況任意定義，這便消除了對指針的部分需求。在C和C++里大量采用指針的另一個原因是為了能指向任意一個內(nèi)存位置（這同時(shí)會使它們變得不安全，也是Java不提供這一支持的原因）。指針通常被看作在基本變量數(shù)組中四處移動的一種有效手段。Java允許我們以更安全的形式達(dá)到相同的目標(biāo)。解決指針問題的終極方法是“固有方法”（已在附錄A討論）。將指針傳遞給方法時(shí)，通常不會帶來太大的問題，因?yàn)榇藭r(shí)沒有全局函數(shù)，只有類。而且我們可傳遞對對象的引用。Java語言最開始聲稱自己“完全不采用指針！”但隨著許多程序員都質(zhì)問沒有指針如何工作？于是后來又聲明“采用受到限制的指針”。大家可自行判斷它是否“真”的是一個指針。但不管在何種情況下，都不存在指針“算術(shù)”。

(18) Java提供了與C++類似的“構(gòu)建器”（Constructor）。如果不自己定義一個，就會獲得一個默認(rèn)構(gòu)建器。而如果定義了一個非默認(rèn)的構(gòu)建器，就不會為我們自動定義默認(rèn)構(gòu)建器。這和C++是一樣的。注意沒有復(fù)制構(gòu)建器，因?yàn)樗凶宰兞慷际前匆脗鬟f的。

(19) Java中沒有“破壞器”（Destructor）。變量不存在“作用域”的問題。一個對象的“存在時(shí)間”是由對象的存在時(shí)間決定的，并非由垃圾收集器決定。有個finalize()方法是每一個類的成員，它在某種程度上類似于C++的“破壞器”。但finalize()是由垃圾收集器調(diào)用的，而且只負(fù)責(zé)釋放“資源”（如打開的文件、套接字、端口、URL等等）。如需在一個特定的地點(diǎn)做某樣事情，必須創(chuàng)建一個特殊的方法，并調(diào)用它，不能依賴finalize()。而在另一方面，C++中的所有對象都會（或者說“應(yīng)該”）破壞，但并非Java中的所有對象都會被當(dāng)作“垃圾”收集掉。由于Java不支持破壞器的概念，所以在必要的時(shí)候，必須謹(jǐn)慎地創(chuàng)建一個清除方法。而且針對類內(nèi)的基礎(chǔ)類以及成員對象，需要明確調(diào)用所有清除方法。

(20) Java具有方法“過載”機(jī)制，它的工作原理與C++函數(shù)的過載幾乎是完全相同的。

(21) Java不支持默認(rèn)自變量。

(22) Java中沒有g(shù)oto。它采取的無條件跳轉(zhuǎn)機(jī)制是“break 標(biāo)簽”或者“continue 標(biāo)準(zhǔn)”，用于跳出當(dāng)前的多重嵌套循環(huán)。

(23) Java采用了一種單根式的分級結(jié)構(gòu)，因此所有對象都是從根類Object統(tǒng)一繼承的。而在C++中，我們可在任何地方啟動一個新的繼承樹，所以最后往往看到包含了大量樹的“一片森林”。在Java中，我們無論如何都只有一個分級結(jié)構(gòu)。盡管這表面上看似乎造成了限制，但由于我們知道每個對象肯定至少有一個Object接口，所以往往能獲得更強(qiáng)大的能力。C++目前似乎是唯一沒有強(qiáng)制單根結(jié)構(gòu)的唯一一種OO語言。

(24) Java沒有模板或者參數(shù)化類型的其他形式。它提供了一系列集合：Vector（向量），Stack（堆棧）以及Hashtable（散列表），用于容納Object引用。利用這些集合，我們的一系列要求可得到滿足。但這些集合并非是為實(shí)現(xiàn)象C++“標(biāo)準(zhǔn)模板庫”（STL）那樣的快速調(diào)用而設(shè)計(jì)的。Java 1.2中的新集合顯得更加完整，但仍不具備正宗模板那樣的高效率使用手段。

(25) “垃圾收集”意味著在Java中出現(xiàn)內(nèi)存漏洞的情況會少得多，但也并非完全不可能（若調(diào)用一個用于分配存儲空間的固有方法，垃圾收集器就不能對其進(jìn)行跟蹤監(jiān)視）。然而，內(nèi)存漏洞和資源漏洞多是由于編寫不當(dāng)?shù)膄inalize()造成的，或是由于在已分配的一個塊尾釋放一種資源造成的（“破壞器”在此時(shí)顯得特別方便）。垃圾收集器是在C++基礎(chǔ)上的一種極大進(jìn)步，使許多編程問題消彌于無形之中。但對少數(shù)幾個垃圾收集器力有不逮的問題，它卻是不大適合的。但垃圾收集器的大量優(yōu)點(diǎn)也使這一處缺點(diǎn)顯得微不足道。

(26) Java內(nèi)建了對多線程的支持。利用一個特殊的Thread類，我們可通過繼承創(chuàng)建一個新線程（放棄了run()方法）。若將synchronized（同步）關(guān)鍵字作為方法的一個類型限制符使用，相互排斥現(xiàn)象會在對象這一級發(fā)生。在任何給定的時(shí)間，只有一個線程能使用一個對象的synchronized方法。在另一方面，一個synchronized方法進(jìn)入以后，它首先會“鎖定”對象，防止其他任何synchronized方法再使用那個對象。只有退出了這個方法，才會將對象“解鎖”。在線程之間，我們?nèi)匀灰?fù)責(zé)實(shí)現(xiàn)更復(fù)雜的同步機(jī)制，方法是創(chuàng)建自己的“監(jiān)視器”類。遞歸的synchronized方法可以正常運(yùn)作。若線程的優(yōu)先等級相同，則時(shí)間的“分片”不能得到保證。

(27) 我們不是象C++那樣控制聲明代碼塊，而是將訪問限定符（public，private和protected）置入每個類成員的定義里。若未規(guī)定一個“顯式”（明確的）限定符，就會默認(rèn)為“友好的”（friendly）。這意味著同一個包里的其他元素也可以訪問它（相當(dāng)于它們都成為C++的“friends”——朋友），但不可由包外的任何元素訪問。類——以及類內(nèi)的每個方法——都有一個訪問限定符，決定它是否能在文件的外部“可見”。private關(guān)鍵字通常很少在Java中使用，因?yàn)榕c排斥同一個包內(nèi)其他類的訪問相比，“友好的”訪問通常更加有用。然而，在多線程的環(huán)境中，對private的恰當(dāng)運(yùn)用是非常重要的。Java的protected關(guān)鍵字意味著“可由繼承者訪問，亦可由包內(nèi)其他元素訪問”。注意Java沒有與C++的protected關(guān)鍵字等價(jià)的元素，后者意味著“只能由繼承者訪問”（以前可用“private protected”實(shí)現(xiàn)這個目的，但這一對關(guān)鍵字的組合已被取消了）。

(28) 嵌套的類。在C++中，對類進(jìn)行嵌套有助于隱藏名稱，并便于代碼的組織（但C++的“命名空間”已使名稱的隱藏顯得多余）。Java的“封裝”或“打包”概念等價(jià)于C++的命名空間，所以不再是一個問題。Java 1.1引入了“內(nèi)部類”的概念，它秘密保持指向外部類的一個句柄——創(chuàng)建內(nèi)部類對象的時(shí)候需要用到。這意味著內(nèi)部類對象也許能訪問外部類對象的成員，毋需任何條件——就好象那些成員直接隸屬于內(nèi)部類對象一樣。這樣便為回調(diào)問題提供了一個更優(yōu)秀的方案——C++是用指向成員的指針解決的。

(29) 由于存在前面介紹的那種內(nèi)部類，所以Java里沒有指向成員的指針。

(30) Java不存在“嵌入”（inline）方法。Java編譯器也許會自行決定嵌入一個方法，但我們對此沒有更多的控制權(quán)力。在Java中，可為一個方法使用final關(guān)鍵字，從而“建議”進(jìn)行嵌入操作。然而，嵌入函數(shù)對于C++的編譯器來說也只是一種建議。

(31) Java中的繼承具有與C++相同的效果，但采用的語法不同。Java用extends關(guān)鍵字標(biāo)志從一個基礎(chǔ)類的繼承，并用super關(guān)鍵字指出準(zhǔn)備在基礎(chǔ)類中調(diào)用的方法，它與我們當(dāng)前所在的方法具有相同的名字（然而，Java中的super關(guān)鍵字只允許我們訪問父類的方法——亦即分級結(jié)構(gòu)的上一級）。通過在C++中設(shè)定基礎(chǔ)類的作用域，我們可訪問位于分級結(jié)構(gòu)較深處的方法。亦可用super關(guān)鍵字調(diào)用基礎(chǔ)類構(gòu)建器。正如早先指出的那樣，所有類最終都會從Object里自動繼承。和C++不同，不存在明確的構(gòu)建器初始化列表。但編譯器會強(qiáng)迫我們在構(gòu)建器主體的開頭進(jìn)行全部的基礎(chǔ)類初始化，而且不允許我們在主體的后面部分進(jìn)行這一工作。通過組合運(yùn)用自動初始化以及來自未初始化對象句柄的異常，成員的初始化可得到有效的保證。

1045頁程序

(32) Java中的繼承不會改變基礎(chǔ)類成員的保護(hù)級別。我們不能在Java中指定public，private或者protected繼承，這一點(diǎn)與C++是相同的。此外，在衍生類中的優(yōu)先方法不能減少對基礎(chǔ)類方法的訪問。例如，假設(shè)一個成員在基礎(chǔ)類中屬于public，而我們用另一個方法代替了它，那么用于替換的方法也必須屬于public（編譯器會自動檢查）。

(33) Java提供了一個interface關(guān)鍵字，它的作用是創(chuàng)建抽象基礎(chǔ)類的一個等價(jià)物。在其中填充抽象方法，且沒有數(shù)據(jù)成員。這樣一來，對于僅僅設(shè)計(jì)成一個接口的東西，以及對于用extends關(guān)鍵字在現(xiàn)有功能基礎(chǔ)上的擴(kuò)展，兩者之間便產(chǎn)生了一個明顯的差異。不值得用abstract關(guān)鍵字產(chǎn)生一種類似的效果，因?yàn)槲覀儾荒軇?chuàng)建屬于那個類的一個對象。一個abstract（抽象）類可包含抽象方法（盡管并不要求在它里面包含什么東西），但它也能包含用于具體實(shí)現(xiàn)的代碼。因此，它被限制成一個單一的繼承。通過與接口聯(lián)合使用，這一方案避免了對類似于C++虛擬基礎(chǔ)類那樣的一些機(jī)制的需要。

為創(chuàng)建可進(jìn)行“例示”（即創(chuàng)建一個實(shí)例）的一個interface（接口）的版本，需使用implements關(guān)鍵字。它的語法類似于繼承的語法，如下所示：

1046頁程序

(34) Java中沒有virtual關(guān)鍵字，因?yàn)樗蟹莝tatic方法都肯定會用到動態(tài)綁定。在Java中，程序員不必自行決定是否使用動態(tài)綁定。C++之所以采用了virtual，是由于我們對性能進(jìn)行調(diào)整的時(shí)候，可通過將其省略，從而獲得執(zhí)行效率的少量提升（或者換句話說：“如果不用，就沒必要為它付出代價(jià)”）。virtual經(jīng)常會造成一定程度的混淆，而且獲得令人不快的結(jié)果。final關(guān)鍵字為性能的調(diào)整規(guī)定了一些范圍——它向編譯器指出這種方法不能被取代，所以它的范圍可能被靜態(tài)約束（而且成為嵌入狀態(tài)，所以使用C++非virtual調(diào)用的等價(jià)方式）。這些優(yōu)化工作是由編譯器完成的。

(35) Java不提供多重繼承機(jī)制（MI），至少不象C++那樣做。與protected類似，MI表面上是一個很不錯的主意，但只有真正面對一個特定的設(shè)計(jì)問題時(shí)，才知道自己需要它。由于Java使用的是“單根”分級結(jié)構(gòu)，所以只有在極少的場合才需要用到MI。interface關(guān)鍵字會幫助我們自動完成多個接口的合并工作。

(36) 運(yùn)行期的類型標(biāo)識功能與C++極為相似。例如，為獲得與句柄X有關(guān)的信息，可使用下述代碼：

X.getClass().getName();

為進(jìn)行一個“類型安全”的緊縮造型，可使用：

derived d = (derived)base;

這與舊式風(fēng)格的C造型是一樣的。編譯器會自動調(diào)用動態(tài)造型機(jī)制，不要求使用額外的語法。盡管它并不象C++的“new casts”那樣具有易于定位造型的優(yōu)點(diǎn)，但Java會檢查使用情況，并丟棄那些“異常”，所以它不會象C++那樣允許壞造型的存在。

(37) Java采取了不同的異常控制機(jī)制，因?yàn)榇藭r(shí)已經(jīng)不存在構(gòu)建器。可添加一個finally從句，強(qiáng)制執(zhí)行特定的語句，以便進(jìn)行必要的清除工作。Java中的所有異常都是從基礎(chǔ)類Throwable里繼承而來的，所以可確保我們得到的是一個通用接口。

1047頁程序

(38) Java的異常規(guī)范比C++的出色得多。丟棄一個錯誤的異常后，不是象C++那樣在運(yùn)行期間調(diào)用一個函數(shù)，Java異常規(guī)范是在編譯期間檢查并執(zhí)行的。除此以外，被取代的方法必須遵守那一方法的基礎(chǔ)類版本的異常規(guī)范：它們可丟棄指定的異常或者從那些異常衍生出來的其他異常。這樣一來，我們最終得到的是更為“健壯”的異常控制代碼。

(39) Java具有方法過載的能力，但不允許運(yùn)算符過載。String類不能用+和+=運(yùn)算符連接不同的字串，而且String表達(dá)式使用自動的類型轉(zhuǎn)換，但那是一種特殊的內(nèi)建情況。

(40) 通過事先的約定，C++中經(jīng)常出現(xiàn)的const問題在Java里已得到了控制。我們只能傳遞指向?qū)ο蟮木浔镜馗北居肋h(yuǎn)不會為我們自動生成。若希望使用類似C++按值傳遞那樣的技術(shù)，可調(diào)用clone()，生成自變量的一個本地副本（盡管clone()的設(shè)計(jì)依然尚顯粗糙——參見第12章）。根本不存在被自動調(diào)用的副本構(gòu)建器。為創(chuàng)建一個編譯期的常數(shù)值，可象下面這樣編碼：

static final int SIZE = 255

static final int BSIZE = 8 * SIZE

(41) 由于安全方面的原因，“應(yīng)用程序”的編程與“程序片”的編程之間存在著顯著的差異。一個最明顯的問題是程序片不允許我們進(jìn)行磁盤的寫操作，因?yàn)檫@樣做會造成從遠(yuǎn)程站點(diǎn)下載的、不明來歷的程序可能胡亂改寫我們的磁盤。隨著Java 1.1對數(shù)字簽名技術(shù)的引用，這一情況已有所改觀。根據(jù)數(shù)字簽名，我們可確切知道一個程序片的全部作者，并驗(yàn)證他們是否已獲得授權(quán)。Java 1.2會進(jìn)一步增強(qiáng)程序片的能力。

(42) 由于Java在某些場合可能顯得限制太多，所以有時(shí)不愿用它執(zhí)行象直接訪問硬件這樣的重要任務(wù)。Java解決這個問題的方案是“固有方法”，允許我們調(diào)用由其他語言寫成的函數(shù)（目前只支持C和C++）。這樣一來，我們就肯定能夠解決與平臺有關(guān)的問題（采用一種不可移植的形式，但那些代碼隨后會被隔離起來）。程序片不能調(diào)用固有方法，只有應(yīng)用程序才可以。

(43) Java提供對注釋文檔的內(nèi)建支持，所以源碼文件也可以包含它們自己的文檔。通過一個單獨(dú)的程序，這些文檔信息可以提取出來，并重新格式化成HTML。這無疑是文檔管理及應(yīng)用的極大進(jìn)步。

(44) Java包含了一些標(biāo)準(zhǔn)庫，用于完成特定的任務(wù)。C++則依靠一些非標(biāo)準(zhǔn)的、由其他廠商提供的庫。這些任務(wù)包括（或不久就要包括）：

■連網(wǎng)

■數(shù)據(jù)庫連接（通過JDBC）

■多線程

■分布式對象（通過RMI和CORBA）

■壓縮

■商貿(mào)

由于這些庫簡單易用，而且非常標(biāo)準(zhǔn)，所以能極大加快應(yīng)用程序的開發(fā)速度。

(45) Java 1.1包含了Java Beans標(biāo)準(zhǔn)，后者可創(chuàng)建在可視編程環(huán)境中使用的組件。由于遵守同樣的標(biāo)準(zhǔn)，所以可視組件能夠在所有廠商的開發(fā)環(huán)境中使用。由于我們并不依賴一家廠商的方案進(jìn)行可視組件的設(shè)計(jì)，所以組件的選擇余地會加大，并可提高組件的效能。除此之外，Java Beans的設(shè)計(jì)非常簡單，便于程序員理解；而那些由不同的廠商開發(fā)的專用組件框架則要求進(jìn)行更深入的學(xué)習(xí)。

(46) 若訪問Java句柄失敗，就會丟棄一次異常。這種丟棄測試并不一定要正好在使用一個句柄之前進(jìn)行。根據(jù)Java的設(shè)計(jì)規(guī)范，只是說異常必須以某種形式丟棄。許多C++運(yùn)行期系統(tǒng)也能丟棄那些由于指針錯誤造成的異常。

(47) Java通常顯得更為健壯，為此采取的手段如下：

■對象句柄初始化成null（一個關(guān)鍵字）

■句柄肯定會得到檢查，并在出錯時(shí)丟棄異常

■所有數(shù)組訪問都會得到檢查，及時(shí)發(fā)現(xiàn)邊界違例情況

■自動垃圾收集，防止出現(xiàn)內(nèi)存漏洞

■明確、“傻瓜式”的異常控制機(jī)制

■為多線程提供了簡單的語言支持

■對網(wǎng)絡(luò)程序片進(jìn)行字節(jié)碼校驗(yàn)

另外,團(tuán)IDC網(wǎng)上有許多產(chǎn)品團(tuán)購,便宜有口碑

誰做過 EM算法 java實(shí)現(xiàn)

參考：

package?nlp;

/**

*?@author?Orisun

*?date?2011-10-22

*/

import?java.util.ArrayList;

public?class?BaumWelch?{

int?M;?//?隱藏狀態(tài)的種數(shù)

int?N;?//?輸出活動的種數(shù)

double[]?PI;?//?初始狀態(tài)概率矩陣

double[][]?A;?//?狀態(tài)轉(zhuǎn)移矩陣

double[][]?B;?//?混淆矩陣

ArrayListInteger?observation?=?new?ArrayListInteger();?//?觀察到的集合

ArrayListInteger?state?=?new?ArrayListInteger();?//?中間狀態(tài)集合

int[]?out_seq?=?{?2,?1,?1,?1,?2,?2,?2,?2,?2,?1,?1,?1,?1,?2,?2,?2,?2,?1,?1,

1,?1,?1,?2,?2,?2,?1,?1,?1,?1,?1,?2,?1?};?//?測試用的觀察序列

int[]?hidden_seq?=?{?1,?1,?1,?1,?2,?2,?2,?2,?2,?2,?2,?2,?2,?2,?2,?2,?2,?1,

1,?1,?1,?1,?2,?2,?2,?1,?1,?1,?1,?1,?1,?1?};?//?測試用的隱藏狀態(tài)序列

int?T?=?32;?//?序列長度為32

double[][]?alpha?=?new?double[T][];?//?向前變量

double?PO;

double[][]?beta?=?new?double[T][];?//?向后變量

double[][]?gamma?=?new?double[T][];

double[][][]?xi?=?new?double[T?-?1][][];

//?初始化參數(shù)。Baum-Welch得到的是局部最優(yōu)解，所以初始參數(shù)直接影響解的好壞

public?void?initParameters()?{

M?=?2;

N?=?2;

PI?=?new?double[M];

PI[0]?=?0.5;

PI[1]?=?0.5;

A?=?new?double[M][];

B?=?new?double[M][];

for?(int?i?=?0;?i??M;?i++)?{

A[i]?=?new?double[M];

B[i]?=?new?double[N];

}

A[0][0]?=?0.8125;

A[0][1]?=?0.1875;

A[1][0]?=?0.2;

A[1][1]?=?0.8;

B[0][0]?=?0.875;

B[0][1]?=?0.125;

B[1][0]?=?0.25;

B[1][1]?=?0.75;

observation.add(1);

observation.add(2);

state.add(1);

state.add(2);

for?(int?t?=?0;?t??T;?t++)?{

alpha[t]?=?new?double[M];

beta[t]?=?new?double[M];

gamma[t]?=?new?double[M];

}

for?(int?t?=?0;?t??T?-?1;?t++)?{

xi[t]?=?new?double[M][];

for?(int?i?=?0;?i??M;?i++)

xi[t][i]?=?new?double[M];

}

}

//?更新向前變量

public?void?updateAlpha()?{

for?(int?i?=?0;?i??M;?i++)?{

alpha[0][i]?=?PI[i]?*?B[i][observation.indexOf(out_seq[0])];

}

for?(int?t?=?1;?t??T;?t++)?{

for?(int?i?=?0;?i??M;?i++)?{

alpha[t][i]?=?0;

for?(int?j?=?0;?j??M;?j++)?{

alpha[t][i]?+=?alpha[t?-?1][j]?*?A[j][i];

}

alpha[t][i]?*=?B[i][observation.indexOf(out_seq[t])];

}

}

}

//?更新觀察序列出現(xiàn)的概率，它在一些公式中當(dāng)分母

public?void?updatePO()?{

for?(int?i?=?0;?i??M;?i++)

PO?+=?alpha[T?-?1][i];

}

//?更新向后變量

public?void?updateBeta()?{

for?(int?i?=?0;?i??M;?i++)?{

beta[T?-?1][i]?=?1;

}

for?(int?t?=?T?-?2;?t?=?0;?t--)?{

for?(int?i?=?0;?i??M;?i++)?{

for?(int?j?=?0;?j??M;?j++)?{

beta[t][i]?+=?A[i][j]

*?B[j][observation.indexOf(out_seq[t?+?1])]

*?beta[t?+?1][j];

}

}

}

}

//?更新xi

public?void?updateXi()?{

for?(int?t?=?0;?t??T?-?1;?t++)?{

double?frac?=?0.0;

for?(int?i?=?0;?i??M;?i++)?{

for?(int?j?=?0;?j??M;?j++)?{

frac?+=?alpha[t][i]?*?A[i][j]

*?B[j][observation.indexOf(out_seq[t?+?1])]

*?beta[t?+?1][j];

}

}

for?(int?i?=?0;?i??M;?i++)?{

for?(int?j?=?0;?j??M;?j++)?{

xi[t][i][j]?=?alpha[t][i]?*?A[i][j]

*?B[j][observation.indexOf(out_seq[t?+?1])]

*?beta[t?+?1][j]?/?frac;

}

}

}

}

//?更新gamma

public?void?updateGamma()?{

for?(int?t?=?0;?t??T?-?1;?t++)?{

double?frac?=?0.0;

for?(int?i?=?0;?i??M;?i++)?{

frac?+=?alpha[t][i]?*?beta[t][i];

}

//?double?frac?=?PO;

for?(int?i?=?0;?i??M;?i++)?{

gamma[t][i]?=?alpha[t][i]?*?beta[t][i]?/?frac;

}

//?for(int?i=0;iM;i++){

//?gamma[t][i]=0;

//?for(int?j=0;jM;j++)

//?gamma[t][i]+=xi[t][i][j];

//?}

}

}

//?更新狀態(tài)概率矩陣

public?void?updatePI()?{

for?(int?i?=?0;?i??M;?i++)

PI[i]?=?gamma[0][i];

}

//?更新狀態(tài)轉(zhuǎn)移矩陣

public?void?updateA()?{

for?(int?i?=?0;?i??M;?i++)?{

double?frac?=?0.0;

for?(int?t?=?0;?t??T?-?1;?t++)?{

frac?+=?gamma[t][i];

}

for?(int?j?=?0;?j??M;?j++)?{

double?dem?=?0.0;

//?for?(int?t?=?0;?t??T?-?1;?t++)?{

//?dem?+=?xi[t][i][j];

//?for?(int?k?=?0;?k??M;?k++)

//?frac?+=?xi[t][i][k];

//?}

for?(int?t?=?0;?t??T?-?1;?t++)?{

dem?+=?xi[t][i][j];

}

A[i][j]?=?dem?/?frac;

}

}

}

//?更新混淆矩陣

public?void?updateB()?{

for?(int?i?=?0;?i??M;?i++)?{

double?frac?=?0.0;

for?(int?t?=?0;?t??T;?t++)

frac?+=?gamma[t][i];

for?(int?j?=?0;?j??N;?j++)?{

double?dem?=?0.0;

for?(int?t?=?0;?t??T;?t++)?{

if?(out_seq[t]?==?observation.get(j))

dem?+=?gamma[t][i];

}

B[i][j]?=?dem?/?frac;

}

}

}

//?運(yùn)行Baum-Welch算法

public?void?run()?{

initParameters();

int?iter?=?22;?//?迭代次數(shù)

while?(iter--??0)?{

//?E-Step

updateAlpha();

//?updatePO();

updateBeta();

updateGamma();

updatePI();

updateXi();

//?M-Step

updateA();

updateB();

}

}

public?static?void?main(String[]?args)?{

BaumWelch?bw?=?new?BaumWelch();

bw.run();

System.out.println("訓(xùn)練后的初始狀態(tài)概率矩陣：");

for?(int?i?=?0;?i??bw.M;?i++)

System.out.print(bw.PI[i]?+?"\t");

System.out.println();

System.out.println("訓(xùn)練后的狀態(tài)轉(zhuǎn)移矩陣：");

for?(int?i?=?0;?i??bw.M;?i++)?{

for?(int?j?=?0;?j??bw.M;?j++)?{

System.out.print(bw.A[i][j]?+?"\t");

}

System.out.println();

}

System.out.println("訓(xùn)練后的混淆矩陣：");

for?(int?i?=?0;?i??bw.M;?i++)?{

for?(int?j?=?0;?j??bw.N;?j++)?{

System.out.print(bw.B[i][j]?+?"\t");

}

System.out.println();

}

}

}

「數(shù)據(jù)分類」15支持向量機(jī)(SVM)及混淆矩陣

1.支持向量機(jī)（SVM）概述

（1）支持向量機(jī)(Support Vector Machines，SVM)是一種二元分類模型，它是一類模型的統(tǒng)稱，其中包括：

①線性可分支持向量機(jī)；

②線性支持向量機(jī)；

③非線性支持向量機(jī)。

（2）核心思想：

訓(xùn)練階段在特征空間中尋找一個超平面，它能（或盡量能）將訓(xùn)練樣本中的正例和負(fù)例分離在它的兩側(cè)，預(yù)測時(shí)以該超平面作為決策邊界判斷輸入實(shí)例的類別。尋找超平面的原則是，在可分離的情況下使超平面與數(shù)據(jù)集間隔最大化。

（3）支持向量機(jī)的分類示意圖為：

簡單來說，SVM的原理就是在平面內(nèi)找到一條直線，使得這兩類不同的樣本點(diǎn)分開，并且保證能夠盡可能遠(yuǎn)的遠(yuǎn)離這條直線。用向量表示兩類樣本點(diǎn)之間的分類間隔(Margin)為：

支持向量機(jī)的目的是使r最大，等價(jià)于使||w||/2最小。而幾何向量使分類間隔最大問題可以轉(zhuǎn)化為運(yùn)籌學(xué)上的約束優(yōu)化問題。因?yàn)樯婕疤鄰?fù)雜公式，此處省略。

只要理解了SVM的原理，并且學(xué)會利用sklearn庫調(diào)用SVM模塊，就達(dá)到了數(shù)據(jù)分析的目的。

2.SVM算法實(shí)現(xiàn)

（1）重要參數(shù)說明：

①kernel?：核函數(shù)，默認(rèn)是rbf，可以是‘linear’, ‘poly’, ‘rbf’, ‘sigmoid’, ‘precomputed’?。

·kernel='linear'時(shí)為線性核，C越大分類效果越好，但有可能會過擬合（defaul C=1）；

·kernel='poly'時(shí)為多項(xiàng)式核函數(shù)；

·kernel='rbf'時(shí)（default）為高斯核，gamma值越小，分類界面越連續(xù)；gamma值越大，分類界面越“散”，分類效果越好，但有可能會過擬合。

②decision_function_shape：

·decision_function_shape='ovr'時(shí)，為one v rest，即一個類別與其他類別進(jìn)行劃分；

·decision_function_shape='ovo'時(shí)，為one v one，即將類別兩兩之間進(jìn)行劃分，用二分類的方法模擬多分類的結(jié)果。

（2）程序?qū)崿F(xiàn)過程：

【注】

在分類型模型評判的指標(biāo)中，常見的方法有如下三種：

①混淆矩陣（也稱誤差矩陣，Confusion Matrix）

混淆矩陣是評判模型結(jié)果的指標(biāo)，屬于模型評估的一部分。此外，混淆矩陣多用于判斷分類器（Classifier）的優(yōu)劣，適用于分類型的數(shù)據(jù)模型，如分類樹（Classification Tree）、邏輯回歸（Logistic Regression）、線性判別分析（Linear Discriminant Analysis）等方法。

混淆矩陣的一級指標(biāo)：

通過混淆矩陣可以計(jì)算出評估模型的幾個指標(biāo)（二級指標(biāo)）：

三級指標(biāo)：F1-score

其中，P代表Precision，R代表Recall。

F1-Score指標(biāo)綜合了Precision與Recall的產(chǎn)出的結(jié)果。F1-Score的取值范圍從0到1的，1代表模型的輸出最好，0代表模型的輸出結(jié)果最差。

Ps：當(dāng)分類結(jié)果多于兩種時(shí)，需要將結(jié)果轉(zhuǎn)化為上面的類型。

詳細(xì)內(nèi)容參考博文

②ROC曲線

③AUC面積

python是否有繪制混淆矩陣的函數(shù)，怎么來實(shí)現(xiàn)

#?-*-?coding:?UTF-8?-*-

"""繪制混淆矩陣圖"""

import?matplotlib.pyplot?as?plt

from?sklearn.metrics?import?confusion_matrix

def?confusion_matrix_plot_matplotlib(y_truth,?y_predict,?cmap=plt.cm.Blues):

"""Matplotlib繪制混淆矩陣圖

parameters

----------

y_truth:?真實(shí)的y的值,?1d?array

y_predict:?預(yù)測的y的值,?1d?array

cmap:?畫混淆矩陣圖的配色風(fēng)格,?使用cm.Blues，更多風(fēng)格請參考官網(wǎng)

"""

cm?=?confusion_matrix(y_truth,?y_predict)

plt.matshow(cm,?cmap=cmap)??#?混淆矩陣圖

plt.colorbar()??#?顏色標(biāo)簽

for?x?in?range(len(cm)):??#?數(shù)據(jù)標(biāo)簽

for?y?in?range(len(cm)):

plt.annotate(cm[x,?y],?xy=(x,?y),?horizontalalignment='center',?verticalalignment='center')

plt.ylabel('True?label')??#?坐標(biāo)軸標(biāo)簽

plt.xlabel('Predicted?label')??#?坐標(biāo)軸標(biāo)簽

plt.show()??#?顯示作圖結(jié)果

if?__name__?==?'__main__':

y_truth?=?[1,?0,?1,?1,?1,?1,?1,?1,?1,?1,?0,?0,?0,?0,?0]

y_predict?=?[1,?0,?0,?1,?0,?1,?1,?1,?1,?1,?0,?1,?0,?1,?0]

confusion_matrix_plot_matplotlib(y_truth,?y_predict)

當(dāng)前名稱：混淆矩陣代碼實(shí)現(xiàn)Java,一個混淆矩陣怎么劃分
當(dāng)前路徑：http://chinadenli.net/article5/dsessoi.html

成都網(wǎng)站建設(shè)公司_創(chuàng)新互聯(lián)，為您提供企業(yè)網(wǎng)站制作、微信小程序、品牌網(wǎng)站建設(shè)、全網(wǎng)營銷推廣、網(wǎng)站策劃、網(wǎng)站設(shè)計(jì)公司

廣告

聲明：本網(wǎng)站發(fā)布的內(nèi)容（圖片、視頻和文字）以用戶投稿、用戶轉(zhuǎn)載內(nèi)容為主，如果涉及侵權(quán)請盡快告知，我們將會在第一時(shí)間刪除。文章觀點(diǎn)不代表本網(wǎng)站立場，如需處理請聯(lián)系客服。電話：028-86922220；郵箱：631063699@qq.com。內(nèi)容未經(jīng)允許不得轉(zhuǎn)載，或轉(zhuǎn)載時(shí)需注明來源： 創(chuàng)新互聯(lián)