画出决策边界线--plot_2d_separator.py源代码【来自python机器学习基础教程】

 import numpy as np
 import matplotlib.pyplot as plt
 from .plot_helpers import cm2, cm3, discrete_scatter

 def _call_classifier_chunked(classifier_pred_or_decide, X):
 # The chunk_size is used to chunk the large arrays to work with x86
 # memory models that are restricted to < 2 GB in memory allocation. The
 # chunk_size value used here is based on a measurement with the
 # MLPClassifier using the following parameters:
 # MLPClassifier(solver='lbfgs', random_state=0,
 # hidden_layer_sizes=[1000,1000,1000])
 # by reducing the value it is possible to trade in time for memory.
 # It is possible to chunk the array as the calculations are independent of
 # each other.
 # Note: an intermittent version made a distinction between
 # 32- and 64 bit architectures avoiding the chunking. Testing revealed
 # that even on 64 bit architectures the chunking increases the
 # performance by a factor of 3-5, largely due to the avoidance of memory
 # swapping.
 chunk_size = 10000

 # We use a list to collect all result chunks
 Y_result_chunks = []

 # Call the classifier in chunks.
 for x_chunk in np.array_split(X, np.arange(chunk_size, X.shape[0],
 chunk_size, dtype=np.int32),
 axis=0):
 Y_result_chunks.append(classifier_pred_or_decide(x_chunk))

 return np.concatenate(Y_result_chunks)

 def plot_2d_classification(classifier, X, fill=False, ax=None, eps=None,
 alpha=1, cm=cm3):
 # multiclass
 if eps is None:
 eps = X.std() / 2.

 if ax is None:
 ax = plt.gca()

 x_min, x_max = X[:, 0].min() - eps, X[:, 0].max() + eps
 y_min, y_max = X[:, 1].min() - eps, X[:, 1].max() + eps
 xx = np.linspace(x_min, x_max, 1000)
 yy = np.linspace(y_min, y_max, 1000)

 X1, X2 = np.meshgrid(xx, yy)
 X_grid = np.c_[X1.ravel(), X2.ravel()]
 decision_values = classifier.predict(X_grid)
 ax.imshow(decision_values.reshape(X1.shape), extent=(x_min, x_max,
 y_min, y_max),
 aspect='auto', origin='lower', alpha=alpha, cmap=cm)
 ax.set_xlim(x_min, x_max)
 ax.set_ylim(y_min, y_max)
 ax.set_xticks(())
 ax.set_yticks(())

 def plot_2d_scores(classifier, X, ax=None, eps=None, alpha=1, cm="viridis",
 function=None):
 # binary with fill
 if eps is None:
 eps = X.std() / 2.

 if ax is None:
 ax = plt.gca()

 x_min, x_max = X[:, 0].min() - eps, X[:, 0].max() + eps
 y_min, y_max = X[:, 1].min() - eps, X[:, 1].max() + eps
 xx = np.linspace(x_min, x_max, 100)
 yy = np.linspace(y_min, y_max, 100)

 X1, X2 = np.meshgrid(xx, yy)
 X_grid = np.c_[X1.ravel(), X2.ravel()]
 if function is None:
 function = getattr(classifier, "decision_function",
 getattr(classifier, "predict_proba"))
 else:
 function = getattr(classifier, function)
 decision_values = function(X_grid)
 if decision_values.ndim > 1 and decision_values.shape[1] > 1:
 # predict_proba
 decision_values = decision_values[:, 1]
 grr = ax.imshow(decision_values.reshape(X1.shape),
 extent=(x_min, x_max, y_min, y_max), aspect='auto',
 origin='lower', alpha=alpha, cmap=cm)

 ax.set_xlim(x_min, x_max)
 ax.set_ylim(y_min, y_max)
 ax.set_xticks(())
 ax.set_yticks(())
 return grr

 def plot_2d_separator(classifier, X, fill=False, ax=None, eps=None, alpha=1,
 cm=cm2, linewidth=None, threshold=None,
 linestyle="solid"):
 # binary?
 if eps is None:
 eps = X.std() / 2.

 if ax is None:
 ax = plt.gca()

 x_min, x_max = X[:, 0].min() - eps, X[:, 0].max() + eps
 y_min, y_max = X[:, 1].min() - eps, X[:, 1].max() + eps
 xx = np.linspace(x_min, x_max, 1000)
 yy = np.linspace(y_min, y_max, 1000)

 X1, X2 = np.meshgrid(xx, yy)
 X_grid = np.c_[X1.ravel(), X2.ravel()]
 if hasattr(classifier, "decision_function"):
 decision_values = _call_classifier_chunked(classifier.decision_function,
 X_grid)
 levels = [0] if threshold is None else [threshold]
 fill_levels = [decision_values.min()] + levels + [
 decision_values.max()]
 else:
 # no decision_function
 decision_values = _call_classifier_chunked(classifier.predict_proba,
 X_grid)[:, 1]
 levels = [.5] if threshold is None else [threshold]
 fill_levels = [0] + levels + [1]
 if fill:
 ax.contourf(X1, X2, decision_values.reshape(X1.shape),
 levels=fill_levels, alpha=alpha, cmap=cm)
 else:
 ax.contour(X1, X2, decision_values.reshape(X1.shape), levels=levels,
 colors="black", alpha=alpha, linewidths=linewidth,
 linestyles=linestyle, zorder=5)

 ax.set_xlim(x_min, x_max)
 ax.set_ylim(y_min, y_max)
 ax.set_xticks(())
 ax.set_yticks(())

 if __name__ == '__main__':
 from sklearn.datasets import make_blobs
 from sklearn.linear_model import LogisticRegression
 X, y = make_blobs(centers=2, random_state=42)
 clf = LogisticRegression(solver='lbfgs').fit(X, y)
 plot_2d_separator(clf, X, fill=True)
 discrete_scatter(X[:, 0], X[:, 1], y)
 plt.show()