def transform(self, X, y=None, **kwargs):
"""
Calls the internal `transform` method of the scikit-learn PCA transformer, which
performs a dimensionality reduction on the input features ``X``. Next calls the
``draw`` method of the Yellowbrick visualizer, finally returning a new array of
transformed features of shape ``(len(X), projection)``.
Parameters
----------
X : ndarray or DataFrame of shape n x m
A matrix of n instances with m features.
y : ndarray or Series of length n
An array or series of target or class values.
Returns
-------
Xp : ndarray or DataFrame of shape n x m
Returns a new array-like object of transformed features of shape
``(len(X), projection)``.
"""
try:
Xp = self.pca_transformer.transform(X)
self.draw(Xp, y)
return Xp
except NotFittedError:
raise NotFitted.from_estimator(self, "transform")
def score(self, X, y):
"""
Generates the Precision-Recall curve on the specified test data.
Returns
-------
score_ : float
Average precision, a summary of the plot as a weighted mean of
precision at each threshold, weighted by the increase in recall from
the previous threshold.
"""
# If we don't do this check, then it is possible that OneVsRestClassifier
# has not correctly been fitted for multi-class targets.
if not hasattr(self, "target_type_"):
raise NotFitted.from_estimator(self, "score")
# Must perform label binarization before calling super
if self.target_type_ == MULTICLASS:
# Use label_binarize to create multi-label output for OneVsRestClassifier
y = label_binarize(y, classes=self._target_labels)
# Call super to check if fitted and to compute classes_
# Note that self.score_ computed in super will be overridden below
super(PrecisionRecallCurve, self).score(X, y)
# Compute the prediction/threshold scores
y_scores = self._get_y_scores(X)
# Handle binary and multiclass cases to create correct data structure
if self.target_type_ == BINARY:
self.precision_, self.recall_, _ = sk_precision_recall_curve(
y, y_scores)
self.score_ = average_precision_score(y, y_scores)
else:
self.precision_, self.recall_, self.score_ = {}, {}, {}
# Compute PRCurve for all classes
for i, class_i in enumerate(self.classes_):
self.precision_[class_i], self.recall_[
class_i], _ = sk_precision_recall_curve(
y[:, i], y_scores[:, i])
self.score_[class_i] = average_precision_score(
y[:, i], y_scores[:, i])
# Compute micro average PR curve
self.precision_[MICRO], self.recall_[
MICRO], _ = sk_precision_recall_curve(y.ravel(),
y_scores.ravel())
self.score_[MICRO] = average_precision_score(y,
y_scores,
average=MICRO)
# Draw the figure
self.draw()
# Return a score between 0 and 1
if self.target_type_ == BINARY:
return self.score_
return self.score_[MICRO]
def test_not_fitted_from_estimator(self, method):
"""
Ensure not fitted can be raised directly from an estimator
"""
msg = "instance is not fitted yet, please call fit"
with pytest.raises(NotFitted, match=msg):
raise NotFitted.from_estimator(self, method)
def draw(self):
"""
Renders the class prediction error across the axis.
Returns
-------
ax : Matplotlib Axes
The axes on which the figure is plotted
"""
if not hasattr(self, "predictions_") or not hasattr(self, "classes_"):
raise NotFitted.from_estimator(self, "draw")
legend_kws = {"bbox_to_anchor": (1.04, 0.5), "loc": "center left"}
bar_stack(
self.predictions_,
self.ax,
labels=list(self.classes_),
ticks=self.classes_,
colors=self.class_colors_,
legend_kws=legend_kws,
)
return self.ax
def transform(self, X, y=None, **kwargs):
"""
Returns the transformed data points from the manifold embedding.
Parameters
----------
X : array-like of shape (n, m)
A matrix or data frame with n instances and m features
y : array-like of shape (n,), optional
The target, used to specify the colors of the points.
Returns
-------
Xprime : array-like of shape (n, 2)
Returns the 2-dimensional embedding of the instances.
Note
----
This method does not work with MDS, TSNE and SpectralEmbedding because
it is yet to be implemented in sklearn.
"""
# Because some manifolds do not have transform we cannot call super
try:
Xp = self.manifold.transform(X)
self.draw(Xp, y)
return Xp
except NotFittedError:
raise NotFitted.from_estimator(self, "transform")
except AttributeError:
name = self.manifold.__class__.__name__
raise ModelError(
("{} requires data to be simultaneously fit and transformed, "
"use fit_transform instead").format(name))
return Xp