機器學習中的工作流機制

在項目開發(fā)的時候，經(jīng)常需要我們選擇使用哪一種模型。同樣的數(shù)據(jù)，可能決策樹效果不錯，樸素貝葉斯也不錯，SVM也挺好。有沒有一種方法能夠讓我們用一份數(shù)據(jù)，同時訓練多個模型，并用某種直觀的方式（包括模型得分），觀察到模型在既有數(shù)據(jù)上的效果？有的，管線工作流pipeline就是專門干這個的，再配上決策邊界，所有模型只用一眼，就能確定優(yōu)劣，選擇你的夢中情模。上效果圖。

分為兩行，上面是sklearn自帶數(shù)據(jù)集中的數(shù)據(jù)，分兩類。從第二列開始，每一列是某種模型在當前數(shù)據(jù)集中的擬合效果。如何查看某種模型效果好壞？從兩個方面，左上角的模型得分，和圖中顏色深淺，兩種顏色的分解代表模型的決策邊界。

下面是筆者自己的數(shù)據(jù)，分為4類。同樣不同顏色的分界代表兩種類型的判別邊界。如果只看模型得分，那得分為100%的模型有5個，選再根據(jù)決策邊界進一步確定更優(yōu)秀的模型，為工程所用。這里貼出筆者所用代碼供各位修改，也可以直接取官方代碼修改

def loadTrainData():
    df = pd.read_csv('./your/dataset/path/data.csv')
    trainDataLabel = df.values
    nodeData = trainDataLabel[:, :2], trainDataLabel[:, -1]
    return nodeData

def trainAnalySave():
    from matplotlib.colors import ListedColormap
    import joblib

    from sklearn.datasets import make_circles, make_classification, make_moons
    from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis
    from sklearn.ensemble import AdaBoostClassifier, RandomForestClassifier
    from sklearn.gaussian_process import GaussianProcessClassifier
    from sklearn.gaussian_process.kernels import RBF
    from sklearn.inspection import DecisionBoundaryDisplay
    from sklearn.model_selection import train_test_split
    from sklearn.naive_bayes import GaussianNB
    from sklearn.neighbors import KNeighborsClassifier
    from sklearn.neural_network import MLPClassifier
    from sklearn.pipeline import make_pipeline
    from sklearn.preprocessing import StandardScaler
    from sklearn.svm import SVC
    from sklearn.tree import DecisionTreeClassifier

    names = [
        "Nearest Neighbors",
        "Linear SVM",
        "RBF SVM",
        "Gaussian Process",
        "Decision Tree",
        "Random Forest",
        "Neural Net",
        "AdaBoost",
        "Naive Bayes",
        "QDA",
    ]

    classifiers = [
        KNeighborsClassifier(3),
        SVC(kernel="linear", C=0.025),
        SVC(gamma=2, C=1),
        GaussianProcessClassifier(1.0 * RBF(1.0)),
        DecisionTreeClassifier(max_depth=5),
        RandomForestClassifier(max_depth=5, n_estimators=10, max_features=1),
        MLPClassifier(alpha=1, max_iter=1000),
        AdaBoostClassifier(),
        GaussianNB(),
        QuadraticDiscriminantAnalysis(),
    ]

    # X, y = make_classification(
    #     n_features=2, n_redundant=0, n_informative=2, random_state=1, n_clusters_per_class=1
    # )
    # rng = np.random.RandomState(2)
    # X += 2 * rng.uniform(size=X.shape)
    # linearly_separable = (X, y)

    nodeData = loadTrainData()

    datasets = [
        # make_moons(noise=0.3, random_state=0),
        make_circles(noise=0.2, factor=0.5, random_state=1),
        # linearly_separable,
        nodeData,
    ]

    # figure = plt.figure(figsize=(27, 9))
    figure = plt.figure(figsize=(15, 4))
    i = 1
    # iterate over datasets
    for ds_cnt, ds in enumerate(datasets):
        # preprocess dataset, split into training and test part
        X, y = ds
        X_train, X_test, y_train, y_test = train_test_split(
            X, y, test_size=0.4, random_state=42
        )

        x_min, x_max = X[:, 0].min() - 0.5, X[:, 0].max() + 0.5
        y_min, y_max = X[:, 1].min() - 0.5, X[:, 1].max() + 0.5

        # just plot the dataset first
        cm = plt.cm.RdBu
        cm_bright = ListedColormap(["#FF0000", "#00FF00", "#FFFF00", "#0000FF"])
        ax = plt.subplot(len(datasets), len(classifiers) + 1, i)
        if ds_cnt == 0:
            ax.set_title("Input data")
        # Plot the training points
        ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=cm_bright, edgecolors="k")
        # Plot the testing points
        ax.scatter(
            X_test[:, 0], X_test[:, 1], c=y_test, cmap=cm_bright, alpha=0.6, edgecolors="k"
        )
        ax.set_xlim(x_min, x_max)
        ax.set_ylim(y_min, y_max)
        ax.set_xticks(())
        ax.set_yticks(())
        i += 1

        # iterate over classifiers
        for name, clf in zip(names, classifiers):
            ax = plt.subplot(len(datasets), len(classifiers) + 1, i)

            clf = make_pipeline(StandardScaler(), clf)
            clf.fit(X_train, y_train)
            score = clf.score(X_test, y_test)
            # DecisionBoundaryDisplay.from_estimator(
            #     clf, X, cmap=cm, alpha=0.8, ax=ax, eps=0.5
            # )

            # save satisfied model
            savedPath = r'..\models\sklearn\\'
            savedList = ["Nearest Neighbors", "RBF SVM", "Neural Net"]
            if name in savedList:
                joblib.dump(clf, savedPath + name + '.pkl')

            # Plot the training points
            ax.scatter(
                X_train[:, 0], X_train[:, 1], c=y_train, cmap=cm_bright, edgecolors="k"
            )
            # Plot the testing points
            ax.scatter(
                X_test[:, 0],
                X_test[:, 1],
                c=y_test,
                cmap=cm_bright,
                edgecolors="k",
                alpha=0.6,
            )

            ax.set_xlim(x_min, x_max)
            ax.set_ylim(y_min, y_max)
            ax.set_xticks(())
            ax.set_yticks(())
            if ds_cnt == 0:
                ax.set_title(name)
            ax.text(
                # x_max - 0.3,
                # y_min + 0.3,
                x_min + 0.4,
                y_max - 0.4 - ds_cnt,
                ("%.2f" % score),
                # ("%.2f" % score).lstrip("0"),
                # size=15,
                size=10,
                # horizontalalignment="right",
                horizontalalignment="left",
            )
            i += 1

    plt.tight_layout()
    plt.show()   

    nodeData = loadTrainData()
if __name__ == '__main__':
    trainAnalySave()

注意，這里的DecisionBoundaryDisplay模塊，需要安裝sklearn的較新版本，因而python也需要較高版本。

最后打個廣告，如果有想進修服務器開發(fā)相關的技能，這里是可以讓你秒變大神的時光隧道。 enjoy~~文章來源地址http://www.zghlxwxcb.cn/news/detail-625441.html

到了這里，關于機器學習中的工作流機制的文章就介紹完了。如果您還想了解更多內容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關文章，希望大家以后多多支持TOY模板網(wǎng)！