溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
機器學習之隨機森林，供大家參考，具體內容如下
1、Bootstraping(自助法)
名字來自成語“pull up by your own bootstraps”，意思是依靠你自己的資源，稱為自助法，它是一種有放回的抽樣方法，它是非參數統計中一種重要的估計統計量方差進而進行區間估計的統計方法。其核心思想和基本步驟如下：
（1） 采用重抽樣技術從原始樣本中抽取一定數量（自己給定）的樣本，此過程允許重復抽樣。
（2） 根據抽出的樣本計算給定的統計量T。
（3） 重復上述N次（一般大于1000），得到N個統計量T。
（4） 計算上述N個統計量T的樣本方差，得到統計量的方差。
應該說Bootstrap是現代統計學較為流行的一種統計方法，在小樣本時效果很好。通過方差的估計可以構造置信區間等，其運用范圍得到進一步延伸。
2、Bagging (套袋法)
Bagging即bootstrap aggregating(自舉匯聚法)的縮寫，其算法過程如下：
A).從原始樣本集中抽取訓練集。每輪從原始樣本集中使用Bootstraping的方法抽取n個訓練樣本，意思是從原始集合中隨機選擇一個樣本，然后隨機選擇一個樣本來代替這個樣本（在訓練集中，有些樣本可能被多次抽取到，而有些樣本可能一次都沒有被抽中）。共進行k輪抽取，得到k個訓練集。（k個訓練集之間是相互獨立的）
B).每次使用一個訓練集得到一個模型，k個訓練集共得到k個模型。（注：這里并沒有具體的分類算法或回歸方法，我們可以根據具體問題采用不同的分類或回歸方法，如決策樹、感知器等）
3、Boosting(提升法):
其主要思想是將弱分類器組裝成一個強分類器。在PAC（概率近似正確）學習框架下，則一定可以將弱分類器組裝成一個強分類器。關于Boosting的兩個核心問題：
1）在每一輪如何改變訓練數據的權值或概率分布？
通過提高那些在前一輪被弱分類器分錯樣例的權值，減小前一輪分對樣例的權值，來使得分類器對誤分的數據有較好的效果。
2）通過什么方式來組合弱分類器？
通過加法模型將弱分類器進行線性組合，比如AdaBoost通過加權多數表決的方式，即增大錯誤率小的分類器的權值，同時減小錯誤率較大的分類器的權值。而提升樹通過擬合殘差的方式逐步減小殘差，將每一步生成的模型疊加得到最終模型。
4、gradient boosting(梯度提升法)：
Boosting是一種思想，Gradient Boosting是一種實現Boosting的方法，它主要的思想是，每一次建立模型是在之前建立模型損失函數的梯度下降方向。損失函數(loss function)描述的是模型的不靠譜程度，損失函數越大，則說明模型越容易出錯。如果我們的模型能夠讓損失函數持續的下降，則說明我們的模型在不停的改進，而最好的方式就是讓損失函數在其梯度（Gradient)的方向上下降。
5、Bagging，Boosting二者之間的區別:
相同點：
bagging算法和boosting算法都屬于集成學習集成學習（Ensemble Learning）。
不同點：
1）樣本選擇上：
Bagging：訓練集是在原始集中有放回選取的，從原始集中選出的各輪訓練集之間是獨立的。
Boosting：每一輪的訓練集不變，只是訓練集中每個樣例在分類器中的權重發生變化。而權值是根據上一輪的分類結果進行調整。
2）樣例權重：
Bagging：使用均勻取樣，每個樣例的權重相等
Boosting：根據錯誤率不斷調整樣例的權值，錯誤率越大則權重越大。
3）預測函數：
Bagging：所有預測函數的權重相等。
Boosting：每個弱分類器都有相應的權重，對于分類誤差小的分類器會有更大的權重。
4）并行計算：
Bagging：各個預測函數可以并行生成
Boosting：各個預測函數只能順序生成，因為后一個模型參數需要前一輪模型的結果。
總結：
1）Bagging + 決策樹 = 隨機森林
2）AdaBoost + 決策樹 = 提升樹
3）Gradient Boosting + 決策樹 = GBDT
6、Rand forest(隨機森林)：
隨機森林是一種重要的基于Bagging的集成學習方法，可以用來做分類、回歸等問題。
隨機森林優點：
1)具有極高的準確率
2)隨機性的引入，使得隨機森林不容易過擬合
3)隨機性的引入，使得隨機森林有很好的抗噪聲能力
4)能處理很高維度的數據，并且不用做特征選擇
5)既能處理離散型數據，也能處理連續型數據，數據集無需規范化
6)訓練速度快，可以得到變量重要性排序
7)容易實現并行化
隨機森林的缺點：
1)當隨機森林中的決策樹個數很多時，訓練時需要的空間和時間會較大
2)隨機森林模型還有許多不好解釋的地方，有點算個黑盒模型
隨機森林的構建過程：
1)從原始訓練集中使用Bootstraping方法隨機有放回采樣選出m個樣本，共進行n_tree次采樣，生成n_tree個訓練集
2)對于n_tree個訓練集，我們分別訓練n_tree個決策樹模型
3)對于單個決策樹模型，假設訓練樣本特征的個數為n，那么每次分裂時根據信息增益/信息增益比/基尼指數選擇最好的特征進行分裂
4)每棵樹都一直這樣分裂下去，直到該節點的所有訓練樣例都屬于同一類。在決策樹的分裂過程中不需要剪枝
5)將生成的多棵決策樹組成隨機森林。對于分類問題，按多棵樹分類器投票決定最終分類結果；對于回歸問題，由多棵樹預測值的均值決定最終預測結果.
7、隨機森林的實現：
隨機森林就是對決策樹的集成，但有兩點不同：
（1）采樣的差異性：從含m個樣本的數據集中有放回的采樣，得到含m個樣本的采樣集，用于訓練。這樣能保證每個決策樹的訓練樣本不完全一樣。
（2）特征選取的差異性：每個決策樹的n個分類特征是在所有特征中隨機選擇的（n是一個需要我們自己調整的參數）。傳統決策樹在選擇劃分特征時在當前節點的特征集合（假定有d個特征）中選擇一個最優特征；而在隨機森林中，對于決策樹的每個節點，先從該節點的特征集合中隨機選擇一個包含n個特征的子集，然后再從這個子集中選擇一個最優特征用于劃分。這里的參數n控制了隨機性的引入程度：若令n=d,則決策樹的構建與傳統決策樹相同；若令n=1，則是隨機選擇一個特征進行劃分。
隨機森林需要調整的參數有：
（1）決策樹的個數
（2）每個決策樹分類特征的個數
（3）遞歸次數（即決策樹的深度）
#coding=utf-8
# Random Forest Algorithm on Sonar Dataset
from random import seed
from random import randrange
from csv import reader
from math import sqrt
from math import log
# 加載數據
def load_csv(filename): #導入csv文件
dataset = list()
with open(filename, 'r') as file:
csv_reader = reader(file)
for row in csv_reader:
if not row:
continue
dataset.append(row)
return dataset
#除了判別列，其他列都轉換為float類型
def str_column_to_float(dataset, column): #將數據集的第column列轉換成float形式
for row in dataset:
row[column] = float(row[column].strip()) #strip()返回移除字符串頭尾指定的字符生成的新字符串。
# 將數據集隨機分成n份，方便交叉驗證
def cross_validation_split(dataset, n_folds): #將數據集dataset分成n_flods份，每份包含len(dataset) / n_folds個值，每個值由dataset數據集的內容隨機產生，每個值被使用一次
dataset_split = list()
dataset_copy = list(dataset) #復制一份dataset,防止dataset的內容改變
fold_size = len(dataset) / n_folds # 每份數據集的大小
for i in range(n_folds):
fold = list() #每次循環fold清零，防止重復導入dataset_split
while len(fold) < fold_size: #這里不能用if，if只是在第一次判斷時起作用，while執行循環，直到條件不成立
index = randrange(len(dataset_copy))
fold.append(dataset_copy.pop(index)) #將對應索引index的內容從dataset_copy中導出，并將該內容從dataset_copy中刪除。pop() 函數用于移除列表中的一個元素（默認最后一個元素），并且返回該元素的值。
dataset_split.append(fold)
return dataset_split #由dataset分割出的n_folds個數據構成的列表，為了用于交叉驗證
#導入實際值和預測值，計算精確度
def accuracy_metric(actual, predicted):
correct = 0
for i in range(len(actual)):
if actual[i] == predicted[i]:
correct += 1
return correct / float(len(actual)) * 100.0
#根據特征和特征值分割數據集
def test_split(index, value, dataset):
left, right = list(), list()
for row in dataset:
if row[index] < value:
left.append(row)
else:
right.append(row)
return left, right
# 計算基尼指數
def gini_index(groups, class_values): #個人理解：計算代價，分類越準確，則gini越小
gini = 0.0
for class_value in class_values: #class_values =[0,1]
for group in groups: #groups=(left,right)
size = len(group)
if size == 0:
continue
proportion = [row[-1] for row in group].count(class_value) / float(size)
gini += (proportion * (1.0 - proportion)) #個人理解：計算代價，分類越準確，則gini越小
return gini
#找出分割數據集的最優特征，得到最優的特征index，特征值row[index]，以及分割完的數據groups（left,right）
def get_split(dataset, n_features):
class_values = list(set(row[-1] for row in dataset)) #class_values =[0,1]
b_index, b_value, b_score, b_groups = 999, 999, 999, None
features = list()
#往features添加n_features個特征（n_feature等于特征數的根號），特征索引從dataset中隨機取
while len(features) < n_features:
index = randrange(len(dataset[0])-1)
if index not in features:
features.append(index)
#在n_features個特征中選出最優的特征索引，并沒有遍歷所有特征，從而保證了每課決策樹的差異性
for index in features:
for row in dataset:
#groups=(left,right)；row[index]遍歷每一行index索引下的特征值作為分類值value，找出最優的分類特征和特征值
groups = test_split(index, row[index], dataset)
gini = gini_index(groups, class_values)
if gini < b_score:
b_index, b_value, b_score, b_groups = index, row[index], gini, groups #最后得到最優的分類特征b_index,分類特征值b_value,分類結果b_groups。b_value為分錯的代價成本。
#print b_score
return {'index':b_index, 'value':b_value, 'groups':b_groups}
#輸出group中出現次數較多的標簽
def to_terminal(group):
outcomes = [row[-1] for row in group] #max()函數中，當key參數不為空時，就以key的函數對象為判斷的標準;
return max(set(outcomes), key=outcomes.count) # 輸出group中出現次數較多的標簽
#創建子分割器，遞歸分類，直到分類結束
def split(node, max_depth, min_size, n_features, depth): #max_depth = 10，min_size = 1，n_features = int(sqrt(len(dataset[0])-1))
left, right = node['groups']
del(node['groups'])
# check for a no split
if not left or not right:
node['left'] = node['right'] = to_terminal(left + right)
return
# check for max depth
if depth >= max_depth: #max_depth=10表示遞歸十次，若分類還未結束，則選取數據中分類標簽較多的作為結果，使分類提前結束，防止過擬合
node['left'], node['right'] = to_terminal(left), to_terminal(right)
return
# process left child
if len(left) <= min_size:
node['left'] = to_terminal(left)
else:
node['left'] = get_split(left, n_features) #node['left']是一個字典，形式為{'index':b_index, 'value':b_value, 'groups':b_groups}，所以node是一個多層字典
split(node['left'], max_depth, min_size, n_features, depth+1) #遞歸，depth+1計算遞歸層數
# process right child
if len(right) <= min_size:
node['right'] = to_terminal(right)
else:
node['right'] = get_split(right, n_features)
split(node['right'], max_depth, min_size, n_features, depth+1)
# 創建決策樹
def build_tree(train, max_depth, min_size, n_features):
#找到最佳切分向量和最佳切分點進行劃分為兩個子集
root = get_split(train, n_features)
split(root, max_depth, min_size, n_features, 1)
return root
#預測模型分類結果
def predict(node, row):
if row[node['index']] < node['value']: # index是分割的特征分量，value是特征分量的最優切分點
if isinstance(node['left'], dict): #isinstance是Python中的一個內建函數。是用來判斷一個對象是否是一個已知的類型。
return predict(node['left'], row)
else:
return node['left']
else:
if isinstance(node['right'], dict):
return predict(node['right'], row)
else:
return node['right']
#使用多個決策樹trees對測試集test的第row行進行預測，再使用簡單投票法判斷出該行所屬分類
def bagging_predict(trees, row):
predictions = [predict(tree, row) for tree in trees]
return max(set(predictions), key=predictions.count)
#創建數據集的隨機子樣本
def subsample(dataset, ratio):
sample = list()
n_sample = round(len(dataset) * ratio) #round() 方法返回浮點數x的四舍五入值。
while len(sample) < n_sample:
index = randrange(len(dataset)) #有放回的隨機采樣，有一些樣本被重復采樣，從而在訓練集中多次出現，有的則從未在訓練集中出現，此則自助采樣法。從而保證每棵決策樹訓練集的差異性
sample.append(dataset[index])
return sample
# 隨機森林算法
def random_forest(train, test, max_depth, min_size, sample_size, n_trees, n_features):
trees = list()
for i in range(n_trees): #n_trees表示決策樹的數量
sample = subsample(train, sample_size) #隨機采樣保證了每棵決策樹訓練集的差異性
tree = build_tree(sample, max_depth, min_size, n_features) #建立一個決策樹
trees.append(tree)
predictions = [bagging_predict(trees, row) for row in test]
return(predictions)
#評估算法性能，返回模型得分
def evaluate_algorithm(dataset, algorithm, n_folds, *args):
folds = cross_validation_split(dataset, n_folds)
scores = list()
#每次循環從folds從取出一個fold作為測試集，其余作為訓練集，遍歷整個folds，實現交叉驗證
for fold in folds:
train_set = list(folds)
train_set.remove(fold)
train_set = sum(train_set, []) #將多個fold列表組合成一個train_set列表
test_set = list()
for row in fold: #fold表示從原始數據集dataset提取出來的測試集
row_copy = list(row)
test_set.append(row_copy)
row_copy[-1] = None
predicted = algorithm(train_set, test_set, *args) # 調用隨機森林算法，預測的分類值列表
actual = [row[-1] for row in fold] # 真實的分類值列表
accuracy = accuracy_metric(actual, predicted)
scores.append(accuracy)
return scores
if __name__ == '__main__':
#每一次執行本文件時都能產生同一個隨機數
seed(1)
filename = 'sonar-all-data.csv'
dataset = load_csv(filename)
for i in range(0, len(dataset[0])-1): # 每一列的字符屬性轉為浮點數
str_column_to_float(dataset, i)
n_folds = 5 #分成5份數據，進行交叉驗證
max_depth = 20 #調參（自己修改）決策樹深度不能太深，不然容易導致過擬合
min_size = 1 #每個分支下最小的節點個數
sample_size = 1.0 # 每棵數所用樣本子集的大小，這里和訓練集相同
n_features =15 #調參（自己修改） #準確性與多樣性之間的權衡
for n_trees in [1,10,20]: #理論上樹的棵數是越多越好
scores = evaluate_algorithm(dataset[0:50], random_forest, n_folds, max_depth, min_size, sample_size, n_trees, n_features)
print('Trees: %d' % n_trees)
print('Scores: %s' % scores)
print('Mean Accuracy: %.3f%%' % (sum(scores)/float(len(scores))))
以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支持億速云。
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
