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