This requires tests, and the loss functions should probably also be weighted.

I just fixed the line length and pushed to my repository, how do I rerun the tests?

I will look into the issue you sent me.

@jnothman, before you said just passing a custom base_estimator that required a sample_weight was enough. When I create this new test, as long as I'm passing the dummy estimator that requires the sample_weight and it runs with no problem, no specific assert statement is really necessary?

How do you propose testing correct handling of weights?

As in where is it?

Found it. Do I just add it to the last version's file?

@glemaitre When it comes to weighting the loss functions, what do you suggest?

What do you mean?

@glemaitre When it comes to weighting the loss functions, what do you suggest?

What do you mean?

jnothman mentions that the loss functions within RANSACRegressor.fit() should probably be weighted, do you have a suggestion for how I should go about it?

jnothman mentions that the loss functions within RANSACRegressor.fit() should probably be weighted, do you have a suggestion for how I should go about it?

I see. I would suggest to first merge this PR and open another one to solve the issue with the loss.
Basically, we just need to define a loss that weight the error y - y_pred. The relevant line are from 285 to 297. Then, in the case we have a loss which is a callable and that sample_weight is not None, we need to check that the callable is taking a sample_weight argument otherwise we should raise an error.

To be more specific, it would be a diff around this:

diff --git a/sklearn/linear_model/_ransac.py b/sklearn/linear_model/_ransac.py
index 40ebb3a084..50a9fecf29 100644
--- a/sklearn/linear_model/_ransac.py
+++ b/sklearn/linear_model/_ransac.py
@@ -283,20 +283,22 @@ class RANSACRegressor(MetaEstimatorMixin, RegressorMixin,
             residual_threshold = self.residual_threshold
 
         if self.loss == "absolute_loss":
-            if y.ndim == 1:
-                loss_function = lambda y_true, y_pred: np.abs(y_true - y_pred)
-            else:
-                loss_function = lambda \
-                    y_true, y_pred: np.sum(np.abs(y_true - y_pred), axis=1)
+
+            def loss_function(y_true, y_pred, sample_weight=None):
+                sample_weight = np.ones(y_true.shape)
+                error = np.abs(sample_weight * (y_true - y_pred))
+                return error if y.ndim == 1 else np.sum(error, axis=1)
 
         elif self.loss == "squared_loss":
-            if y.ndim == 1:
-                loss_function = lambda y_true, y_pred: (y_true - y_pred) ** 2
-            else:
-                loss_function = lambda \
-                    y_true, y_pred: np.sum((y_true - y_pred) ** 2, axis=1)
+
+            def loss_function(y_true, y_pred, sample_weight=None):
+                sample_weight = np.ones(y_true.shape)
+                error = sample_weight * ((y_true - y_pred) ** 2)
+                return error if y.ndim == 1 else np.sum(error, axis=1)
 
         elif callable(self.loss):
+            # FIXME: check that self.loss has `sample_weight` parameters if
+            # it is sample_weight is not None
             loss_function = self.loss
 
         else:
@@ -373,7 +375,12 @@ class RANSACRegressor(MetaEstimatorMixin, RegressorMixin,
 
             # residuals of all data for current random sample model
             y_pred = base_estimator.predict(X)
-            residuals_subset = loss_function(y, y_pred)
+            if sample_weight is None:
+                residuals_subset = loss_function(y, y_pred)
+            else:
+                residuals_subset = loss_function(
+                    y, y_pred, sample_weight=sample_weight
+                )
 
             # classify data into inliers and outliers
             inlier_mask_subset = residuals_subset < residual_threshold

I would need to think a bit more regarding the testing. But in some way, we want to check some model equivalence or differences.

loss_has_sample_weight = `sample_weight` in signature(self.loss).parameters
if sample_weight is not None and loss_has_sample_weight:
    loss_function = self.loss
else:
   raise ValueError()

Do we automatically raise a ValueError here if both conditions aren't met?
I would use a function to test for the sample_weight parameter, but I couldn't find a general parameter testing function like has_fit_parameter().

Also, this statement is not automatically wiping out whatever value sample_weight had?:

sample_weight = np.ones(y_true.shape)

Should it be this?:

if sample_weight is None:
    sample_weight = np.ones(y_true.shape)

Also, this pull request is ready?

@jnothman do you want to have a look at it. Basically, I would be interested to know if we should add sample_weight to the loss right now or if it can be in a subsequent PR.

Also, this statement is not automatically wiping out whatever value sample_weight had?:

yes I made a mistake. Basically this is just to have an idea of what to do :)

Do we automatically raise a ValueError here if both conditions aren't met?

I think that this fine if the loss defined handle sample_weight but a user does not give one. But again this is along these line.

What will be important is to have some proper tests.

@jnothman, I fixed the what's new entry.

Please resolve conflicts, ensuring the change log remains in sorted order

Thanks @J-A16

@J-A16 Thanks for your efforts.

Do you want to make th next PR to include sample_weight in the loss function? If you like of time, I can make the PR then.

@glemaitre, you mentioned the tests should check for equivalences or differences, so perhaps I should implement the different loss functions in the tests, instantiate different RANSACRegressor objects, each with it's own loss function, and assert that the results are the same for corresponding loss functions?

equivalences or differences

I was thinking about checking that sample_weight will have an impact on the loss and therefore on the final estimator found.

assert that the results are the same for corresponding loss functions?

It could be a start.