Show Sidebar Hide Sidebar

# Multinomial and One-vs-Rest Logistic Regression in Scikit-learn

Plot decision surface of multinomial and One-vs-Rest Logistic Regression. The hyperplanes corresponding to the three One-vs-Rest (OVR) classifiers are represented by the dashed lines.

#### New to Plotly?¶

You can set up Plotly to work in online or offline mode, or in jupyter notebooks.
We also have a quick-reference cheatsheet (new!) to help you get started!

### Version¶

In [1]:
import sklearn
sklearn.__version__
Out[1]:
'0.18.1'

### Imports¶

This tutorial imports make_blobs and LogisticRegression.

In [2]:
print(__doc__)

import plotly.plotly as py
import plotly.graph_objs as go
from plotly import tools

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_blobs
from sklearn.linear_model import LogisticRegression
Automatically created module for IPython interactive environment

### Calculations¶

In [3]:
# make 3-class dataset for classification
centers = [[-5, 0], [0, 1.5], [5, -1]]
X, y = make_blobs(n_samples=1000, centers=centers, random_state=40)
transformation = [[0.4, 0.2], [-0.4, 1.2]]
X = np.dot(X, transformation)
fignum = 1
colors = ['blue', 'red', 'yellow']

### Plot Results¶

In [4]:
def matplotlib_to_plotly(cmap, pl_entries):
h = 1.0/(pl_entries-1)
pl_colorscale = []

for k in range(pl_entries):
C = map(np.uint8, np.array(cmap(k*h)[:3])*255)
pl_colorscale.append([k*h, 'rgb'+str((C[0], C[1], C[2]))])

return pl_colorscale

cmap = matplotlib_to_plotly(plt.cm.Paired, 4)
In [5]:
fig = tools.make_subplots(rows=1, cols=2,
print_grid=False,
subplot_titles=('Decision surface of LogisticRegression (multinomial)',
'Decision surface of LogisticRegression (ovr)'))

for multi_class in ('multinomial', 'ovr'):
clf = LogisticRegression(solver='sag', max_iter=100, random_state=42,
multi_class=multi_class).fit(X, y)

# print the training scores
print("training score : %.3f (%s)" % (clf.score(X, y), multi_class))

# create a mesh to plot in
h = .02  # step size in the mesh
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
x_ = np.arange(x_min, x_max, h)
y_ =  np.arange(y_min, y_max, h)
xx, yy = np.meshgrid(x_, y_)

# Plot the decision boundary. For that, we will assign a color to each
# point in the mesh [x_min, x_max]x[y_min, y_max].
Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])
# Put the result into a color plot
Z = Z.reshape(xx.shape)

trace = go.Contour(x=x_, y=y_, z=Z,
colorscale=cmap, showscale=False)
fig.append_trace(trace, 1, fignum)

# Plot also the training points

for i, color in zip(clf.classes_, colors):
idx = np.where(y == i)
trace = go.Scatter(x=X[idx, 0][0], y=X[idx, 1][0],
mode='markers',
marker=dict(color=color,
line=dict(color='black', width=1))
)
fig.append_trace(trace, 1, fignum)

# Plot the three one-against-all classifiers
coef = clf.coef_
intercept = clf.intercept_

def plot_hyperplane(c, color):
def line(x0):
return (-(x0 * coef[c, 0]) - intercept[c]) / coef[c, 1]
trace = go.Scatter(x=[x_min, x_max], y=[line(x_min), line(x_max)],
mode='lines',
line=dict(color=color, dash='dash'))
return trace

for i, color in zip(clf.classes_, colors):
trace = plot_hyperplane(i, color)
fig.append_trace(trace, 1, fignum)

fignum += 1
training score : 0.995 (multinomial)
training score : 0.976 (ovr)
In [6]:
fig['layout']['xaxis1'].update(range=[min(x_), max(x_)])
fig['layout']['xaxis2'].update(range=[min(x_), max(x_)])
fig['layout']['yaxis1'].update(range=[min(y_), max(y_)])
fig['layout']['yaxis2'].update(range=[min(y_), max(y_)])
fig['layout'].update(showlegend=False)

py.iplot(fig)
Out[6]: