2023 Huashu Cup モデリングのアイデア - ケース: ランダム フォレスト

## 0 コンテストのアイデア

(コンテストの質問が出たらすぐに CSDN で共有します)

https://blog.csdn.net/dc_sinor?type=blog

1 ランダムフォレストとは何ですか?

ランダムフォレストは統合学習におけるBagging（Bootstrap AGgregationの略）手法に属します。それらの関係をグラフで表すと次のようになります。

デシジョン ツリー – デシジョン ツリー

ランダム フォレストについて説明する前に、決定木について言及する必要があります。デシジョン ツリーは非常に単純なアルゴリズムであり、説明性が高く、人間の直感的な思考に準拠しています。これは if-then-else ルールに基づいた教師あり学習アルゴリズムであり、上の図は決定木のロジックを直感的に表現できます。

ランダム フォレスト – ランダム フォレスト | RF

ランダム フォレストは多数のデシジョン ツリーで構成されており、異なるデシジョン ツリー間に相関関係はありません。

分類タスクを実行すると、新しい入力サンプルが入力されると、フォレスト内の各ディシジョン ツリーが個別に判断され、分類されます。各ディシジョン ツリーは独自の分類結果を取得します。ランダム フォレストはこの結果を最終結果として採用します。

2 ランダムディープフォレストの構築プロセス

• 1. サンプルサイズが N のサンプルが置き換えられながら N 回抽出され、毎回 1 つのサンプルが抽出され、最終的に N 個のサンプルが形成されます。選択された N 個のサンプルは、デシジョン ツリーのルート ノードのサンプルとしてデシジョン ツリーをトレーニングするために使用されます。
• 2. 各サンプルに M 個の属性がある場合、決定木の各ノードを分割する必要がある場合、m 個の属性が M 個の属性からランダムに選択され、条件 m << M が満たされます。次に、これらの m 個の属性から特定の戦略 (たとえば、情報の獲得) を使用して、ノードの分割属性として 1 つの属性を選択します。
• 3. 決定木を形成するプロセスでは、各ノードをステップ 2 に従って分割する必要があります (ノードが次回選択する属性が、その親ノードが分割されたばかりのときに使用された属性であれば、ノードは到達したことを理解するのは簡単です)リーフ ノードの場合、分割を続ける必要はありません)。分けられなくなるまで。決定木の形成全体を通じて枝刈りは実行されないことに注意してください。
• 4. 手順 1 ～ 3 に従って多数のデシジョン ツリーを構築し、ランダム フォレストを形成します。

3 ランダムフォレストのメリットとデメリット

3.1 利点

• 次元削減や特徴選択を行わずに、非常に高次元 (多くの特徴) データを生成できます。
• 機能の重要性を判断できる
• 異なる特徴間の相互作用を判断できる
• オーバーフィットしにくい
• 学習速度が比較的速く、並列メソッドを作成しやすい
• 実装は比較的簡単です
• 不均衡なデータセットの場合、誤差のバランスがとれます。
• 特徴の大部分が欠落している場合でも、精度は維持できます。

3.2 欠点

• ランダム フォレストは、ノイズの多い分類問題や回帰問題に対して過剰適合することが示されています。
• 異なる値の属性を持つデータの場合、値の分割が多い属性ほどランダム フォレストに大きな影響を与えるため、そのようなデータに対してランダム フォレストによって生成される属性の重みは信頼できません。

4 ランダムディープフォレストアルゴリズムの実装

データセット: https://archive.ics.uci.edu/ml/machine-learning-databases/undocumented/connectionist-bench/sonar/

import csv
from random import seed
from random import randrange
from math import sqrt


def loadCSV(filename):#加载数据，一行行的存入列表
    dataSet = []
    with open(filename, 'r') as file:
        csvReader = csv.reader(file)
        for line in csvReader:
            dataSet.append(line)
    return dataSet

# 除了标签列，其他列都转换为float类型
def column_to_float(dataSet):
    featLen = len(dataSet[0]) - 1
    for data in dataSet:
        for column in range(featLen):
            data[column] = float(data[column].strip())

# 将数据集随机分成N块，方便交叉验证，其中一块是测试集，其他四块是训练集
def spiltDataSet(dataSet, n_folds):
    fold_size = int(len(dataSet) / n_folds)
    dataSet_copy = list(dataSet)
    dataSet_spilt = []
    for i in range(n_folds):
        fold = []
        while len(fold) < fold_size:  # 这里不能用if，if只是在第一次判断时起作用，while执行循环，直到条件不成立
            index = randrange(len(dataSet_copy))
            fold.append(dataSet_copy.pop(index))  # pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。
        dataSet_spilt.append(fold)
    return dataSet_spilt

# 构造数据子集
def get_subsample(dataSet, ratio):
    subdataSet = []
    lenSubdata = round(len(dataSet) * ratio)#返回浮点数
    while len(subdataSet) < lenSubdata:
        index = randrange(len(dataSet) - 1)
        subdataSet.append(dataSet[index])
    # print len(subdataSet)
    return subdataSet

# 分割数据集
def data_spilt(dataSet, index, value):
    left = []
    right = []
    for row in dataSet:
        if row[index] < value:
            left.append(row)
        else:
            right.append(row)
    return left, right

# 计算分割代价
def spilt_loss(left, right, class_values):
    loss = 0.0
    for class_value in class_values:
        left_size = len(left)
        if left_size != 0:  # 防止除数为零
            prop = [row[-1] for row in left].count(class_value) / float(left_size)
            loss += (prop * (1.0 - prop))
        right_size = len(right)
        if right_size != 0:
            prop = [row[-1] for row in right].count(class_value) / float(right_size)
            loss += (prop * (1.0 - prop))
    return loss

# 选取任意的n个特征，在这n个特征中，选取分割时的最优特征
def get_best_spilt(dataSet, n_features):
    features = []
    class_values = list(set(row[-1] for row in dataSet))
    b_index, b_value, b_loss, b_left, b_right = 999, 999, 999, None, None
    while len(features) < n_features:
        index = randrange(len(dataSet[0]) - 1)
        if index not in features:
            features.append(index)
    # print 'features:',features
    for index in features:#找到列的最适合做节点的索引，（损失最小）
        for row in dataSet:
            left, right = data_spilt(dataSet, index, row[index])#以它为节点的，左右分支
            loss = spilt_loss(left, right, class_values)
            if loss < b_loss:#寻找最小分割代价
                b_index, b_value, b_loss, b_left, b_right = index, row[index], loss, left, right
    # print b_loss
    # print type(b_index)
    return {
    
    'index': b_index, 'value': b_value, 'left': b_left, 'right': b_right}

# 决定输出标签
def decide_label(data):
    output = [row[-1] for row in data]
    return max(set(output), key=output.count)


# 子分割，不断地构建叶节点的过程对对对
def sub_spilt(root, n_features, max_depth, min_size, depth):
    left = root['left']
    # print left
    right = root['right']
    del (root['left'])
    del (root['right'])
    # print depth
    if not left or not right:
        root['left'] = root['right'] = decide_label(left + right)
        # print 'testing'
        return
    if depth > max_depth:
        root['left'] = decide_label(left)
        root['right'] = decide_label(right)
        return
    if len(left) < min_size:
        root['left'] = decide_label(left)
    else:
        root['left'] = get_best_spilt(left, n_features)
        # print 'testing_left'
        sub_spilt(root['left'], n_features, max_depth, min_size, depth + 1)
    if len(right) < min_size:
        root['right'] = decide_label(right)
    else:
        root['right'] = get_best_spilt(right, n_features)
        # print 'testing_right'
        sub_spilt(root['right'], n_features, max_depth, min_size, depth + 1)

        # 构造决策树
def build_tree(dataSet, n_features, max_depth, min_size):
    root = get_best_spilt(dataSet, n_features)
    sub_spilt(root, n_features, max_depth, min_size, 1)
    return root
# 预测测试集结果
def predict(tree, row):
    predictions = []
    if row[tree['index']] < tree['value']:
        if isinstance(tree['left'], dict):
            return predict(tree['left'], row)
        else:
            return tree['left']
    else:
        if isinstance(tree['right'], dict):
            return predict(tree['right'], row)
        else:
            return tree['right']
            # predictions=set(predictions)
def bagging_predict(trees, row):
    predictions = [predict(tree, row) for tree in trees]
    return max(set(predictions), key=predictions.count)
# 创建随机森林
def random_forest(train, test, ratio, n_feature, max_depth, min_size, n_trees):
    trees = []
    for i in range(n_trees):
        train = get_subsample(train, ratio)#从切割的数据集中选取子集
        tree = build_tree(train, n_features, max_depth, min_size)
        # print 'tree %d: '%i,tree
        trees.append(tree)
    # predict_values = [predict(trees,row) for row in test]
    predict_values = [bagging_predict(trees, row) for row in test]
    return predict_values
# 计算准确率
def accuracy(predict_values, actual):
    correct = 0
    for i in range(len(actual)):
        if actual[i] == predict_values[i]:
            correct += 1
    return correct / float(len(actual))


if __name__ == '__main__':
    seed(1) 
    dataSet = loadCSV('sonar-all-data.csv')
    column_to_float(dataSet)#dataSet
    n_folds = 5
    max_depth = 15
    min_size = 1
    ratio = 1.0
    # n_features=sqrt(len(dataSet)-1)
    n_features = 15
    n_trees = 10
    folds = spiltDataSet(dataSet, n_folds)#先是切割数据集
    scores = []
    for fold in folds:
        train_set = folds[
                    :]  # 此处不能简单地用train_set=folds，这样用属于引用,那么当train_set的值改变的时候，folds的值也会改变，所以要用复制的形式。（L[:]）能够复制序列，D.copy() 能够复制字典，list能够生成拷贝 list(L)
        train_set.remove(fold)#选好训练集
        # print len(folds)
        train_set = sum(train_set, [])  # 将多个fold列表组合成一个train_set列表
        # print len(train_set)
        test_set = []
        for row in fold:
            row_copy = list(row)
            row_copy[-1] = None
            test_set.append(row_copy)
            # for row in test_set:
            # print row[-1]
        actual = [row[-1] for row in fold]
        predict_values = random_forest(train_set, test_set, ratio, n_features, max_depth, min_size, n_trees)
        accur = accuracy(predict_values, actual)
        scores.append(accur)
    print ('Trees is %d' % n_trees)
    print ('scores:%s' % scores)
    print ('mean score:%s' % (sum(scores) / float(len(scores))))