scikit-learn
diff --git a/‎sklearn/linear_model/ransac.py
Lines changed: 3 additions & 29 deletions b/‎sklearn/linear_model/ransac.py
Lines changed: 3 additions & 29 deletions
diff --git a/‎sklearn/linear_model/tests/test_ransac.py
Lines changed: 0 additions & 33 deletions b/‎sklearn/linear_model/tests/test_ransac.py
Lines changed: 0 additions & 33 deletions
diff --git a/‎sklearn/multioutput.py
Lines changed: 37 additions & 0 deletions b/‎sklearn/multioutput.py
Lines changed: 37 additions & 0 deletions
@@ -135,17 +135,6 @@ class RANSACRegressor(BaseEstimator, MetaEstimatorMixin, RegressorMixin):
         as 0.99 (the default) and e is the current fraction of inliers w.r.t.
         the total number of samples.
 
-    residual_metric : callable, optional
-        Metric to reduce the dimensionality of the residuals to 1 for
-        multi-dimensional target values ``y.shape[1] > 1``. By default the sum
-        of absolute differences is used::
-
-            lambda dy: np.sum(np.abs(dy), axis=1)
-
-        .. deprecated:: 0.18
-           ``residual_metric`` is deprecated from 0.18 and will be removed in
-           0.20. Use ``loss`` instead.
-
     loss : string, callable, optional, default "absolute_loss"
         String inputs, "absolute_loss" and "squared_loss" are supported which
         find the absolute loss and squared loss per sample
@@ -205,8 +194,8 @@ def __init__(self, base_estimator=None, min_samples=None,
                  residual_threshold=None, is_data_valid=None,
                  is_model_valid=None, max_trials=100, max_skips=np.inf,
                  stop_n_inliers=np.inf, stop_score=np.inf,
-                 stop_probability=0.99, residual_metric=None,
-                 loss='absolute_loss', random_state=None):
+                 stop_probability=0.99, loss='absolute_loss',
+                 random_state=None):
 
         self.base_estimator = base_estimator
         self.min_samples = min_samples
@@ -218,7 +207,6 @@ def __init__(self, base_estimator=None, min_samples=None,
         self.stop_n_inliers = stop_n_inliers
         self.stop_score = stop_score
         self.stop_probability = stop_probability
-        self.residual_metric = residual_metric
         self.random_state = random_state
         self.loss = loss
 
@@ -281,12 +269,6 @@ def fit(self, X, y, sample_weight=None):
         else:
             residual_threshold = self.residual_threshold
 
-        if self.residual_metric is not None:
-            warnings.warn(
-                "'residual_metric' was deprecated in version 0.18 and "
-                "will be removed in version 0.20. Use 'loss' instead.",
-                DeprecationWarning)
-
         if self.loss == "absolute_loss":
             if y.ndim == 1:
                 loss_function = lambda y_true, y_pred: np.abs(y_true - y_pred)
@@ -379,15 +361,7 @@ def fit(self, X, y, sample_weight=None):
 
             # residuals of all data for current random sample model
             y_pred = base_estimator.predict(X)
-
-            # XXX: Deprecation: Remove this if block in 0.20
-            if self.residual_metric is not None:
-                diff = y_pred - y
-                if diff.ndim == 1:
-                    diff = diff.reshape(-1, 1)
-                residuals_subset = self.residual_metric(diff)
-            else:
-                residuals_subset = loss_function(y, y_pred)
+            residuals_subset = loss_function(y, y_pred)
 
             # classify data into inliers and outliers
             inlier_mask_subset = residuals_subset < residual_threshold
 
@@ -352,39 +352,6 @@ def test_ransac_multi_dimensional_targets():
     assert_equal(ransac_estimator.inlier_mask_, ref_inlier_mask)
 
 
-# XXX: Remove in 0.20
-def test_ransac_residual_metric():
-    residual_metric1 = lambda dy: np.sum(np.abs(dy), axis=1)
-    residual_metric2 = lambda dy: np.sum(dy ** 2, axis=1)
-
-    yyy = np.column_stack([y, y, y])
-
-    base_estimator = LinearRegression()
-    ransac_estimator0 = RANSACRegressor(base_estimator, min_samples=2,
-                                        residual_threshold=5, random_state=0)
-    ransac_estimator1 = RANSACRegressor(base_estimator, min_samples=2,
-                                        residual_threshold=5, random_state=0,
-                                        residual_metric=residual_metric1)
-    ransac_estimator2 = RANSACRegressor(base_estimator, min_samples=2,
-                                        residual_threshold=5, random_state=0,
-                                        residual_metric=residual_metric2)
-
-    # multi-dimensional
-    ransac_estimator0.fit(X, yyy)
-    assert_warns(DeprecationWarning, ransac_estimator1.fit, X, yyy)
-    assert_warns(DeprecationWarning, ransac_estimator2.fit, X, yyy)
-    assert_array_almost_equal(ransac_estimator0.predict(X),
-                              ransac_estimator1.predict(X))
-    assert_array_almost_equal(ransac_estimator0.predict(X),
-                              ransac_estimator2.predict(X))
-
-    # one-dimensional
-    ransac_estimator0.fit(X, y)
-    assert_warns(DeprecationWarning, ransac_estimator2.fit, X, y)
-    assert_array_almost_equal(ransac_estimator0.predict(X),
-                              ransac_estimator2.predict(X))
-
-
 def test_ransac_residual_loss():
     loss_multi1 = lambda y_true, y_pred: np.sum(np.abs(y_true - y_pred), axis=1)
     loss_multi2 = lambda y_true, y_pred: np.sum((y_true - y_pred) ** 2, axis=1)
 
@@ -247,6 +247,43 @@ def partial_fit(self, X, y, sample_weight=None):
         super(MultiOutputRegressor, self).partial_fit(
             X, y, sample_weight=sample_weight)
 
+    def score(self, X, y, sample_weight=None):
+        """Returns the coefficient of determination R^2 of the prediction.
+
+        The coefficient R^2 is defined as (1 - u/v), where u is the residual
+        sum of squares ((y_true - y_pred) ** 2).sum() and v is the regression
+        sum of squares ((y_true - y_true.mean()) ** 2).sum().
+        Best possible score is 1.0 and it can be negative (because the
+        model can be arbitrarily worse). A constant model that always
+        predicts the expected value of y, disregarding the input features,
+        would get a R^2 score of 0.0.
+
+        Notes
+        -----
+        R^2 is calculated by weighting all the targets equally using
+        `multioutput='uniform_average'`.
+
+        Parameters
+        ----------
+        X : array-like, shape (n_samples, n_features)
+            Test samples.
+
+        y : array-like, shape (n_samples) or (n_samples, n_outputs)
+            True values for X.
+
+        sample_weight : array-like, shape [n_samples], optional
+            Sample weights.
+
+        Returns
+        -------
+        score : float
+            R^2 of self.predict(X) wrt. y.
+        """
+        # XXX remove in 0.19 when r2_score default for multioutput changes
+        from .metrics import r2_score
+        return r2_score(y, self.predict(X), sample_weight=sample_weight,
+                        multioutput='uniform_average')
+
 
 class MultiOutputClassifier(MultiOutputEstimator, ClassifierMixin):
     """Multi target classification