API Reference
Ceci est la documentation de l’API du package BsplineQuantRegpy.
Module principal
BsplineQuantRegpy - Quantile Regression with Constrained B-Splines
Package for quantile regression with shape-constrained splines (monotonicity, convexity, third derivative).
DESCRIPTION
This package implements quantile regression with B-splines of degrees 1 to 4, under shape constraints (monotonicity, convexity, third derivative). Constraints are applied via the Karlin-Studden characterization, formulated as a second-order cone programming (SOCP) problem.
This package uses SciPy’s B-spline libraries for spline construction and CVXPY for SOCP optimization.
FEATURES
Quantile regression with splines of degree 1 to 4
Monotonicity constraints (increasing/decreasing)
Convexity constraints (convex/concave)
Third derivative constraints
Uniform or region-specific constraints
Graphical user interface (Tkinter)
Multiple supported solvers (CLARABEL, ECOS, SCS, MOSEK)
MODULES
core/ - B-spline construction and Karlin constraints
models/ - Quantile regression functions (degrees 1 to 4)
gui/ - Tkinter graphical user interface
examples/ - Usage examples
MAIN FUNCTIONS
SplineLinearQuant - Regression with linear splines (degree 1)
SplineQuadraticQuant - Regression with quadratic splines (degree 2)
SplineCubicQuant - Regression with cubic splines (degree 3)
SplineQuarticQuant - Regression with quartic splines (degree 4)
quantile_spline - Unified interface for all degrees
run_gui - Launch the graphical user interface
Exemples
Here is an example of using the package:
import numpy as np
from BsplineQuantRegpy import SplineCubicQuant, run_gui
# Generate data
x = np.linspace(0, 1, 100)
y = 3*x + 0.2*np.sin(10*np.pi*x) + 0.05*np.random.randn(100)
knots = np.quantile(x, np.linspace(0, 1, 11))
# Regression with increasing constraint
result = SplineCubicQuant(x, y, knots, tau=0.5, monot=1)
# Evaluate the spline
x_eval = np.linspace(0, 1, 200)
y_eval = result(x_eval)
# Launch the graphical user interface
run_gui()
Références
Abbes, A. (2025). Quantile regression with cubic polynomial splines under shape constraints with applications. doi:10.5281/zenodo.17427913
He, X., & Shi, P. (1998). Monotone B-spline smoothing. Journal of the American Statistical Association, 93(442), 643-650.
Karlin, S., & Studden, W.J. (1966). Tchebycheff Systems: With Applications in Analysis and Statistics. Interscience Publishers.
Papp, D., & Alizadeh, F. (2014). Shape-Constrained Estimation Using Nonnegative Splines. Journal of Computational and Graphical Statistics, 23(1), 211-231.
- BsplineQuantRegpy.SplineCubicQuant(xtab, ytab, knots, tau, monot=0, cv=0, der3=0, solver='CLARABEL', weight=None)[source]
Régression quantile avec B-splines cubiques (degré 3).
Cette fonction ajuste un modèle de régression quantile avec des B-splines cubiques, avec possibilité de contraintes de forme (monotonie, convexité, dérivée troisième).
La méthode utilise la caractérisation de Karlin-Studden (1966) pour le signe d’un polynôme du second degré (dérivée première ».
- Paramètres:
x (array-like) – Variables explicatives (1D).
y (array-like) – Variables à expliquer (1D).
knots (array-like) – Nœuds pour les B-splines.
tau (float, default=0.5) – Quantile à estimer (entre 0 et 1).
monot (int, default=0) – Contrainte de monotonie : 0 = aucune, 1 = croissante, -1 = décroissante.
convex (int, default=0) – Contrainte de convexité : 0 = aucune, 1 = convexe, -1 = concave.
deriv3 (int, default=0) – Contrainte sur la dérivée troisième : 0 = aucune, 1 = dérivée troisième >= 0, -1 = dérivée troisième <= 0.
n_int (int, default=100) – Nombre de points d’évaluation pour les contraintes.
solver (str, default='CLARABEL') – Solveur SOCP à utiliser (“CLARABEL”, “ECOS”, “SCS”, “MOSEK”).
**kwargs (dict) – Arguments supplémentaires pour CVXPY (verbose, etc.).
- Renvoie:
Une fonction d’évaluation de la spline ajustée.
- Type renvoyé:
callable
Exemples
Exemple d’utilisation avec contrainte croissante
import numpy as np from BsplineQuantRegpy import SplineCubicQuant x = np.linspace(0, 1, 100) y = 3*x + 0.2*np.sin(10*np.pi*x) + 0.05*np.random.randn(100) knots = np.quantile(x, np.linspace(0, 1, 11)) result = SplineCubicQuant(x, y, knots, tau=0.5, monot=1) y_pred = result(np.linspace(0, 1, 200))
Voir aussi
SplineLinearQuantRégression avec splines linéaires
SplineQuadraticQuantRégression avec splines quadratiques
SplineQuarticQuantRégression avec splines quartiques
quantile_splineInterface unifiée pour tous les degrés
- BsplineQuantRegpy.SplineLinearQuant(xtab, ytab, knots, tau, monot=0, solver='CLARABEL', weight=None)[source]
Régression quantile avec B-splines de degré 1 (affines par morceaux) et contraintes de monotonie.
Les splines linéaires sont des fonctions continues et linéaires sur chaque intervalle entre les nœuds. La monotonie est contrôlée par le signe de la dérivée (constante par morceaux).
- Paramètres:
xtab (array-like) – Données x et y
ytab (array-like) – Données x et y
tau (float) – Paramètre quantile (entre 0 et 1)
monot (int or list, default=0) – Contrainte de monotonie (+1 croissant, -1 décroissant, 0 aucune)
solver (str, default='CLARABEL') – Solveur CVXPY à utiliser
weight (array-like, optional) – Poids des observations
- Renvoie:
polyn – Fonction spline résultante (degré 1)
- Type renvoyé:
BSpline object
Exemples
>>> import numpy as np >>> from BsplineQuantRegpy import SplineLinearQuant >>> x = np.linspace(0, 1, 50) >>> y = 2*x + 0.1*np.random.randn(50) >>> knots = np.quantile(x, np.linspace(0, 1, 6)) >>> result = SplineLinearQuant(x, y, knots, tau=0.5, monot=1) >>> y_pred = result(np.linspace(0, 1, 100))
- BsplineQuantRegpy.SplineQuadraticQuant(xtab, ytab, knots, tau, monot=0, cv=0, solver='CLARABEL', weight=None)[source]
Régression quantile avec B-splines de degré 2 et contraintes de forme.
Les splines quadratiques sont des fonctions continues, dérivables une fois, et quadratiques sur chaque intervalle entre les nœuds.
- Paramètres:
xtab (array-like) – Données x et y
ytab (array-like) – Données x et y
tau (float) – Paramètre quantile (entre 0 et 1)
monot (int or list, default=0) – Contrainte de monotonie (+1 croissant, -1 décroissant, 0 aucune)
cv (int or list, default=0) – Contrainte de convexité (+1 convexe, -1 concave, 0 aucune)
solver (str, default='CLARABEL') – Solveur CVXPY à utiliser
weight (array-like, optional) – Poids des observations
- Renvoie:
polyn – Fonction spline résultante (degré 2)
- Type renvoyé:
BSpline object
Notes
-Pour une spline quadratique, la monotonie sur chaque intervalle est implémentée par des contraintes suffisantes et nécessaires aux noeuds de la dérivée affine par morceaux. -La convexité est contrôlée par le signe d’un point quelconque de chaque intervalle (la dérivée seconde est constante par morceaux). L’ensemble des contraintes est un problème linéaire.
Exemples
>>> import numpy as np >>> from BsplineQuantRegpy import SplineQuadraticQuant >>> x = np.linspace(0, 1, 50) >>> y = 2*x**2 + 0.1*np.random.randn(50) >>> knots = np.quantile(x, np.linspace(0, 1, 6)) >>> result = SplineQuadraticQuant(x, y, knots, tau=0.5, cv=1)
- BsplineQuantRegpy.SplineQuarticQuant(xtab, ytab, knots, tau, monot, cv, der3=None, solver='CLARABEL', weight=None)[source]
Régression quantile avec B-splines de degré 4 et contraintes de forme.
Les splines quartiques sont des fonctions continues, trois fois dérivables, et quartiques sur chaque intervalle entre les nœuds.
- Paramètres:
xtab (array-like) – Données x et y
ytab (array-like) – Données x et y
tau (float) – Paramètre quantile
monot (int or list) – Contrainte de monotonie (+1 croissant, -1 décroissant, 0 aucune)
cv (int or list) – Contrainte de convexité (+1 convexe, -1 concave, 0 aucune)
der3 (int or list, optional) – Contrainte sur la dérivée troisième (+1 positive, -1 négative, 0 aucune)
solver (str, default='CLARABEL') – Solveur CVXPY à utiliser
weight (array-like, optional) – Poids des observations
- Renvoie:
polyn – Fonction spline résultante (degré 4)
- Type renvoyé:
BSpline object
Notes
Les contraintes monotones (resp. convexes) sont implémentées via la caractérisation de Karlin-Studden (1966) pour les polynômes positifs de degré 3 (resp degré 2). Le problème d’optimisation est formulé comme un problème de programmation conique du second ordre (SOCP) et résolu avec CVXPY.
La dérivée troisième étant affine par morceaux, les contraintes sont implémentées aux noeuds (problèmes linéaire).
Exemples
>>> import numpy as np >>> from BsplineQuantRegpy import SplineQuarticQuant >>> x = np.linspace(0, 1, 50) >>> y = 4*x**3 + 0.1*np.random.randn(50) >>> knots = np.quantile(x, np.linspace(0, 1, 6)) >>> result = SplineQuarticQuant(x, y, knots, tau=0.5, monot=1, cv=1)
- BsplineQuantRegpy.apply_karlin_constraints_cubic(coeffs_cubic, sign=1)[source]
Applique les contraintes de Karlin pour un polynôme cubique (dérivée première) selon le théorème 3 de l’article
sign > 0 : p(u) >= 0 sur [0,1] sign < 0 : p(u) <= 0 sur [0,1] (soit -p(u) >= 0)
- BsplineQuantRegpy.apply_karlin_constraints_quadratic(coeffs_quad, const_sign=1)[source]
Applique les contraintes de Karlin pour un polynôme quadratique (dérivée seconde) selon la Proposition 5 du document PDF
- BsplineQuantRegpy.apply_val_constraints(const, sign=1)[source]
Applique les contraintes pour un polynôme linéaire (dérivée troisième) p(u) = a*u + b >= 0 (ou <= 0) pour u ∈ [0,1]
- BsplineQuantRegpy.build_bsplines_and_deriv(knots, degree)[source]
Returns the derivatives of the B-spline according to the degree.
For linear and constant derivatives returns a vector of values at knots. When derivatives are splines of degree 2 or 3, returns a matrix of normalised coefficients on the local power basis, i.e. the PP-form of the derivative of the spline prepared for applying Karlin-Studden constraints.
- Paramètres:
knots (array-like) – Knots positions
degree (int) – Degree of the spline (1, 2, 3, or 4)
- Renvoie:
List_Bsplines (list) – List of B-spline basis functions
Der1_array (ndarray) – First derivative coefficients or values
Der2_array (ndarray, optional) – Second derivative coefficients or values
Der3_array (ndarray, optional) – Third derivative coefficients or values
- BsplineQuantRegpy.quantile_spline(xtab, ytab, knots, tau, degree=3, monot=0, cv=0, der3=0, solver='CLARABEL', weight=None)[source]
Cette fonction permet d’appeler la régression quantile pour tous les degrés de splines (1 à 4) avec une interface unique. Elle redirige vers la fonction appropriée selon le degré choisi.
Les contraintes de monotonie pour les degrés 3 et 4 sont implémentées via la caractérisation de Karlin-Studden (1966) pour les polynômes positifs de degrés 2 et 3, ce sont des contraintes quadratiques. Les autres contraintes sont lineaires.
Le problème d’optimisation est formulé comme un problème de programmation conique du second ordre (SOCP) et résolu avec CVXPY.
Paramètres
- xtabarray-like, shape (n,)
Variables indépendantes (abscisses). Doivent être dans l’intervalle [0, 1].
- ytabarray-like, shape (n,)
Variables dépendantes (ordonnées).
- knotsarray-like
Positions des nœuds pour la base B-spline. Si un entier est fourni, il est interprété comme le nombre de nœuds.
- taufloat, 0 < tau < 1
Quantile à estimer. Par exemple: - tau = 0.5 : médiane - tau = 0.1 : quantile inférieur - tau = 0.9 : quantile supérieur
- degreeint, default=3
Degré de la spline : - 1 : linéaire (affine par morceaux) - 2 : quadratique - 3 : cubique - 4 : quartique
- monotint ou list, default=0
Contrainte de monotonie : - 1 : fonction croissante - -1 : fonction décroissante - 0 : aucune contrainte Si une liste est fournie, chaque élément correspond à un intervalle.
- cvint ou list, default=0
Contrainte de convexité : - 1 : fonction convexe - -1 : fonction concave - 0 : aucune contrainte Si une liste est fournie, chaque élément correspond à un intervalle.
- der3int ou list, default=0
Contrainte sur la dérivée troisième : - 1 : dérivée troisième positive - -1 : dérivée troisième négative - 0 : aucune contrainte (Uniquement pour les splines de degré 3 et 4)
- solverstr, default=”CLARABEL”
Solveur CVXPY à utiliser. Options disponibles : - “CLARABEL” (recommandé, gratuit) - “ECOS” - “SCS” - “GUROBI” (payant, nécessite une licence) - “MOSEK” (payant, nécessite une licence) - “CVXOPT”
- weightarray-like, optional
Poids des observations pour la régression pondérée. Si None, tous les poids sont égaux à 1.
- raises ValueError:
Si le degré n’est pas compris entre 1 et 4.
- returns:
callable – Fonction spline résultante. Elle peut être évaluée en tout point x : >>> y_eval = spline_result(x_eval)
Exemples
——–
>>> import numpy as np
>>> from BsplineQuantRegpy import quantile_spline
>>>
>>> # Générer des données
>>> x = np.linspace(0, 1, 100)
>>> y = 2*x + 0.2*np.sin(10*np.pi*x) + 0.05*np.random.randn(100)
>>> knots = np.quantile(x, np.linspace(0, 1, 11))
>>>
>>> # Régression avec spline cubique et contrainte croissante
>>> result = quantile_spline(x, y, knots, tau=0.5, degree=3, monot=1)
>>>
>>> # Régression avec spline quadratique et contrainte convexe
>>> result = quantile_spline(x, y, knots, tau=0.5, degree=2, cv=1)
>>>
>>> # Régression avec spline quartique et toutes les contraintes
>>> result = quantile_spline(x, y, knots, tau=0.5, degree=4,
… monot=1, cv=1, der3=1)
>>>
>>> # Évaluer la spline
>>> x_eval = np.linspace(0, 1, 200)
>>> y_eval = result(x_eval)
Références
Karlin, S., & Studden, W.J. (1966). Tchebycheff Systems: With Applications in Analysis and Statistics. Interscience Publishers.
He, X., & Shi, P. (1998). Monotone B-spline smoothing. Journal of the American Statistical Association, 93(442), 643-650.
Abbes, A. (2025). Quantile regression with cubic polynomial splines under shape constraints with applications. doi:10.5281/zenodo.17427913
Voir aussi
SplineLinearQuant,SplineQuadraticQuant,SplineCubicQuant,SplineQuarticQuant,statsmodels.regression.quantile_regression.QuantReg,BsplineQuantReg,cobs
- BsplineQuantRegpy.run_comparison_example()
Fonction principale pour exécution indépendante.
- BsplineQuantRegpy.run_gui()[source]
Lance l’interface graphique Tkinter.
Cette fonction est le point d’entrée principal pour l’interface graphique. Elle ouvre une fenêtre interactive permettant de :
Charger des données
Configurer les splines et les contraintes
Lancer des régressions
Visualiser et exporter les résultats
- Renvoie:
La fonction lance l’interface et ne retourne rien.
- Type renvoyé:
None
Exemples
Lancement de l’interface graphique
from BsplineQuantRegpy import run_gui run_gui()
Voir aussi
BsplineQuantRegpy.gui.Quant_reg_tkModule GUI complet
- BsplineQuantRegpy.run_logistic_example(show_plots=True, return_data=False, degree=3)[source]
Exécute le test avec la fonction logistique.
Module core
Core module - Fonctions de base pour les B-splines et contraintes de Karlin
- BsplineQuantRegpy.core.apply_karlin_constraints_cubic(coeffs_cubic, sign=1)[source]
Applique les contraintes de Karlin pour un polynôme cubique (dérivée première) selon le théorème 3 de l’article
sign > 0 : p(u) >= 0 sur [0,1] sign < 0 : p(u) <= 0 sur [0,1] (soit -p(u) >= 0)
- BsplineQuantRegpy.core.apply_karlin_constraints_quadratic(coeffs_quad, const_sign=1)[source]
Applique les contraintes de Karlin pour un polynôme quadratique (dérivée seconde) selon la Proposition 5 du document PDF
- BsplineQuantRegpy.core.apply_val_constraints(const, sign=1)[source]
Applique les contraintes pour un polynôme linéaire (dérivée troisième) p(u) = a*u + b >= 0 (ou <= 0) pour u ∈ [0,1]
- BsplineQuantRegpy.core.build_bsplines_and_deriv(knots, degree)[source]
Returns the derivatives of the B-spline according to the degree.
For linear and constant derivatives returns a vector of values at knots. When derivatives are splines of degree 2 or 3, returns a matrix of normalised coefficients on the local power basis, i.e. the PP-form of the derivative of the spline prepared for applying Karlin-Studden constraints.
- Paramètres:
knots (array-like) – Knots positions
degree (int) – Degree of the spline (1, 2, 3, or 4)
- Renvoie:
List_Bsplines (list) – List of B-spline basis functions
Der1_array (ndarray) – First derivative coefficients or values
Der2_array (ndarray, optional) – Second derivative coefficients or values
Der3_array (ndarray, optional) – Third derivative coefficients or values
Module models
Models module - Quantile regressions with B-splines of degree 1 to 4
Exported functions: - SplineLinearQuant : Regression with linear splines - SplineQuadraticQuant : Regression with quadratic splines - SplineCubicQuant : Regression with cubic splines - SplineQuarticQuant : Regression with quartic splines - quantile_spline : Unified interface
- BsplineQuantRegpy.models.SplineCubicQuant(xtab, ytab, knots, tau, monot=0, cv=0, der3=0, solver='CLARABEL', weight=None)[source]
Régression quantile avec B-splines cubiques (degré 3).
Cette fonction ajuste un modèle de régression quantile avec des B-splines cubiques, avec possibilité de contraintes de forme (monotonie, convexité, dérivée troisième).
La méthode utilise la caractérisation de Karlin-Studden (1966) pour le signe d’un polynôme du second degré (dérivée première ».
- Paramètres:
x (array-like) – Variables explicatives (1D).
y (array-like) – Variables à expliquer (1D).
knots (array-like) – Nœuds pour les B-splines.
tau (float, default=0.5) – Quantile à estimer (entre 0 et 1).
monot (int, default=0) – Contrainte de monotonie : 0 = aucune, 1 = croissante, -1 = décroissante.
convex (int, default=0) – Contrainte de convexité : 0 = aucune, 1 = convexe, -1 = concave.
deriv3 (int, default=0) – Contrainte sur la dérivée troisième : 0 = aucune, 1 = dérivée troisième >= 0, -1 = dérivée troisième <= 0.
n_int (int, default=100) – Nombre de points d’évaluation pour les contraintes.
solver (str, default='CLARABEL') – Solveur SOCP à utiliser (“CLARABEL”, “ECOS”, “SCS”, “MOSEK”).
**kwargs (dict) – Arguments supplémentaires pour CVXPY (verbose, etc.).
- Renvoie:
Une fonction d’évaluation de la spline ajustée.
- Type renvoyé:
callable
Exemples
Exemple d’utilisation avec contrainte croissante
import numpy as np from BsplineQuantRegpy import SplineCubicQuant x = np.linspace(0, 1, 100) y = 3*x + 0.2*np.sin(10*np.pi*x) + 0.05*np.random.randn(100) knots = np.quantile(x, np.linspace(0, 1, 11)) result = SplineCubicQuant(x, y, knots, tau=0.5, monot=1) y_pred = result(np.linspace(0, 1, 200))
Voir aussi
SplineLinearQuantRégression avec splines linéaires
SplineQuadraticQuantRégression avec splines quadratiques
SplineQuarticQuantRégression avec splines quartiques
quantile_splineInterface unifiée pour tous les degrés
- BsplineQuantRegpy.models.SplineLinearQuant(xtab, ytab, knots, tau, monot=0, solver='CLARABEL', weight=None)[source]
Régression quantile avec B-splines de degré 1 (affines par morceaux) et contraintes de monotonie.
Les splines linéaires sont des fonctions continues et linéaires sur chaque intervalle entre les nœuds. La monotonie est contrôlée par le signe de la dérivée (constante par morceaux).
- Paramètres:
xtab (array-like) – Données x et y
ytab (array-like) – Données x et y
tau (float) – Paramètre quantile (entre 0 et 1)
monot (int or list, default=0) – Contrainte de monotonie (+1 croissant, -1 décroissant, 0 aucune)
solver (str, default='CLARABEL') – Solveur CVXPY à utiliser
weight (array-like, optional) – Poids des observations
- Renvoie:
polyn – Fonction spline résultante (degré 1)
- Type renvoyé:
BSpline object
Exemples
>>> import numpy as np >>> from BsplineQuantRegpy import SplineLinearQuant >>> x = np.linspace(0, 1, 50) >>> y = 2*x + 0.1*np.random.randn(50) >>> knots = np.quantile(x, np.linspace(0, 1, 6)) >>> result = SplineLinearQuant(x, y, knots, tau=0.5, monot=1) >>> y_pred = result(np.linspace(0, 1, 100))
- BsplineQuantRegpy.models.SplineQuadraticQuant(xtab, ytab, knots, tau, monot=0, cv=0, solver='CLARABEL', weight=None)[source]
Régression quantile avec B-splines de degré 2 et contraintes de forme.
Les splines quadratiques sont des fonctions continues, dérivables une fois, et quadratiques sur chaque intervalle entre les nœuds.
- Paramètres:
xtab (array-like) – Données x et y
ytab (array-like) – Données x et y
tau (float) – Paramètre quantile (entre 0 et 1)
monot (int or list, default=0) – Contrainte de monotonie (+1 croissant, -1 décroissant, 0 aucune)
cv (int or list, default=0) – Contrainte de convexité (+1 convexe, -1 concave, 0 aucune)
solver (str, default='CLARABEL') – Solveur CVXPY à utiliser
weight (array-like, optional) – Poids des observations
- Renvoie:
polyn – Fonction spline résultante (degré 2)
- Type renvoyé:
BSpline object
Notes
-Pour une spline quadratique, la monotonie sur chaque intervalle est implémentée par des contraintes suffisantes et nécessaires aux noeuds de la dérivée affine par morceaux. -La convexité est contrôlée par le signe d’un point quelconque de chaque intervalle (la dérivée seconde est constante par morceaux). L’ensemble des contraintes est un problème linéaire.
Exemples
>>> import numpy as np >>> from BsplineQuantRegpy import SplineQuadraticQuant >>> x = np.linspace(0, 1, 50) >>> y = 2*x**2 + 0.1*np.random.randn(50) >>> knots = np.quantile(x, np.linspace(0, 1, 6)) >>> result = SplineQuadraticQuant(x, y, knots, tau=0.5, cv=1)
- BsplineQuantRegpy.models.SplineQuarticQuant(xtab, ytab, knots, tau, monot, cv, der3=None, solver='CLARABEL', weight=None)[source]
Régression quantile avec B-splines de degré 4 et contraintes de forme.
Les splines quartiques sont des fonctions continues, trois fois dérivables, et quartiques sur chaque intervalle entre les nœuds.
- Paramètres:
xtab (array-like) – Données x et y
ytab (array-like) – Données x et y
tau (float) – Paramètre quantile
monot (int or list) – Contrainte de monotonie (+1 croissant, -1 décroissant, 0 aucune)
cv (int or list) – Contrainte de convexité (+1 convexe, -1 concave, 0 aucune)
der3 (int or list, optional) – Contrainte sur la dérivée troisième (+1 positive, -1 négative, 0 aucune)
solver (str, default='CLARABEL') – Solveur CVXPY à utiliser
weight (array-like, optional) – Poids des observations
- Renvoie:
polyn – Fonction spline résultante (degré 4)
- Type renvoyé:
BSpline object
Notes
Les contraintes monotones (resp. convexes) sont implémentées via la caractérisation de Karlin-Studden (1966) pour les polynômes positifs de degré 3 (resp degré 2). Le problème d’optimisation est formulé comme un problème de programmation conique du second ordre (SOCP) et résolu avec CVXPY.
La dérivée troisième étant affine par morceaux, les contraintes sont implémentées aux noeuds (problèmes linéaire).
Exemples
>>> import numpy as np >>> from BsplineQuantRegpy import SplineQuarticQuant >>> x = np.linspace(0, 1, 50) >>> y = 4*x**3 + 0.1*np.random.randn(50) >>> knots = np.quantile(x, np.linspace(0, 1, 6)) >>> result = SplineQuarticQuant(x, y, knots, tau=0.5, monot=1, cv=1)
- BsplineQuantRegpy.models.rhotau(u, tau)[source]
Fonction de perte quantile (check function).
La fonction de perte quantile, également appelée fonction de vérification, est définie par ρ_τ(u) = u * (τ - 1_{u < 0}). Elle est utilisée comme fonction objectif en régression quantile.
- Paramètres:
u (cvxpy.Expression) – Résidus (valeurs réelles ou expressions CVXPY)
tau (float, 0 < tau < 1) – Paramètre quantile
- Renvoie:
Somme des pertes quantiles
- Type renvoyé:
cvxpy.Expression
Notes
La fonction est convexe et linéaire par morceaux. Pour τ = 0.5, elle correspond à l’erreur absolue médiane.
#Module gui #———-
#.. automodule:: BsplineQuantRegpy.gui # :members: # :undoc-members: # :no-index:
Module examples
Exemples pour l’utilisation du package BsplineQuantRegpy.
- BsplineQuantRegpy.examples.run_comparison_example()
Fonction principale pour exécution indépendante.
- BsplineQuantRegpy.examples.run_logistic_example(show_plots=True, return_data=False, degree=3)[source]
Exécute le test avec la fonction logistique.