简介
随机森林是 Bagging 的一种扩展变体。该算法由于实现简单，抗噪声能力强，不容易发生过拟合现象，因此在很多业务中被广泛应用。
本实训项目的主要内容是基于 python 语言搭建出随机森林模型，并使用 sklearn 实现手写数字识别。

Bagging

import numpy as np
from sklearn.tree import DecisionTreeClassifier


class BaggingClassifier(object):
    def __init__(self, n_model=10):
        '''
        初始化函数
        '''
        # 分类器的数量，默认为10
        self.n_model = n_model
        # 用于保存模型的列表，训练好分类器后将对象append进去即可
        self.models = []

    def fit(self, feature, label):
        '''
        训练模型，请记得将模型保存至self.models
        :param feature: 训练集数据，类型为ndarray
        :param label: 训练集标签，类型为ndarray
        :return: None
        '''
        self.models = [DecisionTreeClassifier(max_depth=3).fit(feature, label) for _ in range(self.n_model)]

    def predict(self, feature):
        '''
        :param feature: 测试集数据，类型为ndarray
        :return: 预测结果，类型为ndarray，如np.array([0, 1, 2, 2, 1, 0])
        '''
        tmp_arr = np.transpose([clf_.predict(feature) for clf_ in self.models])
        predict = []
        for row in tmp_arr:
            dic = {}
            for item in row:
                if item not in dic.keys():
                    dic[item] = 1
                else:
                    dic[item] += 1
            predict.append(list(max(dic.items(), key=lambda d: d[1]))[0])
        return predict

随机森林算法流程

import random

import numpy as np
# 建议代码，也算是Begin-End中的一部分
from sklearn.tree import DecisionTreeClassifier


class RandomForestClassifier():
    def __init__(self, n_model=10):
        '''
        初始化函数
        '''
        # 分类器的数量，默认为10
        self.n_model = n_model
        # 用于保存模型的列表，训练好分类器后将对象append进去即可
        self.models = []
        # 用于保存决策树训练时随机选取的列的索引
        self.col_indexs = []
        self.feature_k = 3

    def fit(self, feature, label):
        """
        训练模型
        :param feature: 训练集数据，类型为ndarray
        :param label: 训练集标签，类型为ndarray
        :return: None
        """

        def random_sampling(X, y):
            """
            自助采样
            :param X:
            :param y:
            :return: 自助采样之后的结果
            """
            m, n = np.shape(X)
            # 有放回抽取
            row_indexes = [random.randint(0, m - 1) for _ in range(m)]
            # 选取随机k个特征
            col_indexes = random.sample(range(n), self.feature_k)

            X_res = [[X[index][col] for col in col_indexes] for index in row_indexes]
            y_res = [y[index] for index in row_indexes]
            return X_res, y_res, col_indexes

        for i in range(self.n_model):
            X, y, cols = random_sampling(feature, label)
            self.col_indexs.append(cols)
            self.models.append(DecisionTreeClassifier(max_depth=4).fit(X, y))

    def predict(self, feature):
        '''
        :param feature:测试集数据，类型为ndarray
        :return:预测结果，类型为ndarray，如np.array([0, 1, 2, 2, 1, 0])
        '''
        # ************* Begin ************#
        tmp_arr = np.transpose(
            [clf.predict(np.array(feature[:, self.col_indexs[i]])) for i, clf in enumerate(self.models)])
        predict = []
        for row in tmp_arr:
            di = {}
            for item in row:
                if item not in di.keys():
                    di[item] = 1
                else:
                    di[item] += 1
            predict.append(list(max(di.items(), key=lambda d: d[1]))[0])
        return predict
        # ************* End **************#

手写数字识别

from sklearn.ensemble import RandomForestClassifier
import numpy as np
import sklearn.datasets as db


def digit_predict(train_image, train_label, test_image):
    """
    实现功能：训练模型并输出预测结果
    :param train_image: 包含多条训练样本的样本集，类型为ndarray,shape为[-1, 8, 8]
    :param train_label: 包含多条训练样本标签的标签集，类型为ndarray
    :param test_image: 包含多条测试样本的测试集，类型为ndarry
    :return: test_image对应的预测标签，类型为ndarray
    """
    X = np.reshape(train_image, newshape=(-1, 64))
    clf = RandomForestClassifier(n_estimators=500, max_depth=10)
    clf.fit(X, y=train_label)
    return clf.predict(test_image)


data = db.load_digits()

感谢大家的支持！！！！！！！！！！