scikit-learn · avidale · avidale · avidale · Oct 22, 2017 · David Dale
diff --git a/sklearn/linear_model/quantile.py b/sklearn/linear_model/quantile.py
+        total_iter = []
+        loss_args = (X, y, self.quantile, self.alpha, self.l1_ratio,
+                     sample_weight)
+        for i in range(10):
diff --git a/sklearn/linear_model/tests/test_quantile.py b/sklearn/linear_model/tests/test_quantile.py
@@ -0,0 +1,102 @@
+# Authors: David Dale [email protected]
+# License: TBD
+
+def test_quantile_is_approximately_sparse():
+    # now most of coefficients are not exact zero, but with large n_samples they are close enough
+    X, y = make_regression(n_samples=3000, n_features=100, n_informative=10, random_state=0, noise=1.0)
+    assert_array_almost_equal(warm.coef_, warm_coef, 1)
+
+
+def test_quantile_convergence():
+===================
+
+Quantile regression estimates median or other quantiles of :math:`y` conditional on :math:`X`,
+    while OLS estimates conditional mean.
+coefficients, not its absolute value.
+
+Quantile loss function can be used with models other than linear.
+:class:`GradientBoostingRegressor` also has an option to predict conditional quantiles.
+(namely, Pareto).
+
+The second part of the code shows that LinearRegression minimizes RMSE,
+while QuantileRegressor minimizes MAE, and both do their own job well.
+
+plt.figure(figsize=(15, 5))
+
+plt.subplot(121)
+
+plt.subplot(122)
+
+y = 20 + x * 0.5 + np.random.pareto(10, size=x.shape[0])*10
+
+    Read more in the :ref:`User Guide <quantile_regression>`
+
+    .. versionadded:: 0.20
+    if fit_intercept:
+        grad = np.zeros(n_features + 1)
+    else:
+        grad = np.zeros(n_features + 0)
+                 max_iter=10000, alpha=0.0001, l1_ratio=0.0,
+                 warm_start=False, fit_intercept=True,
+                 normalize=False, copy_X=True,
+                 gamma=1e-2, gtol=1e-4, xtol=1e-6,
+    # if positive error costs more, the slope is maximal
+    model = QuantileRegressor(quantile=0.51, alpha=0).fit(X, y)
+    assert_almost_equal(model.intercept_, 1, 2)
+    assert_almost_equal(model.coef_[0], 10, 2)
+    X, y = make_regression(n_samples=1000, n_features=20, random_state=0,
+                           noise=10.0)
+    X += np.random.normal(size=X.shape[1], scale=3)
+    X *= np.random.normal(size=X.shape[1], scale=3)
+                           noise=1.0)
+
+    # check that for small n_iter, warning is thrown
+    with warnings.catch_warnings(record=True) as w:
+The :class:`QuantileRegressor` applies linear loss to all samples. It is thus more radical than
+:class:`HuberRegressor`, that applies linear penalty to small fraction of outliers and quadratic loss
+to the rest of observations. :class:`QuantileRegressor` also supports L1 and L2 regularization,
+like :class:`ElasticNet`. It solves
+Quantile regression estimates median or other quantiles of :math:`y` conditional on :math:`X`, while OLS estimates
+conditional mean.
+
+The :class:`QuantileRegressor` applies linear loss to all samples. It is thus more radical than
+   :align: center
+   :scale: 50%
+
+Another possible advantage of quantile regression over OLS is its robustness
+The right figure shows example of an asymmetric error distribution
+(namely, Pareto).
+"""
+from __future__ import division
+            sample_weight = np.array(sample_weight)
+            check_consistent_length(y, sample_weight)
+        else:
+            sample_weight = np.ones_like(y)
+        loss_args = (X, y, self.quantile, self.alpha, self.l1_ratio,
+                     self.fit_intercept, sample_weight)
+        for i in range(self.n_gamma_decreases):
+            gamma = self.gamma * self.gamma_decrease ** i
+                           noise=1.0)
+
+    # check that for small n_iter, warning is thrown
+    with pytest.warns(None) as record:
+            warnings.warn("QuantileRegressor did not converge:" +
+                          " Scipy solver terminated with '%s'."
+                          % str(result['message'])
+                          )
+                            or np.abs(old_param) < self.xtol \
+                            and new_value < value + self.gtol:
+                        value = new_value
+                        parameters = new_parameters
+
+Another possible advantage of quantile regression over OLS is its robustness
+to outliers, because it is only sign of an error that influences estimated
+coefficients, not its absolute value.
		@@ -0,0 +1,102 @@
		# Authors: David Dale [email protected]
		# License: TBD
		assert_array_almost_equal(warm.coef_, warm_coef, 1)


		def test_quantile_convergence():

		plt.subplot(122)

		y = 20 + x * 0.5 + np.random.pareto(10, size=x.shape[0])*10

		Read more in the :ref:`User Guide <quantile_regression>`

		.. versionadded:: 0.20