La programmation intégrale est une technique mathématique d'optimisation très utilisée en ingénierie financière, en particulier pour l'optimisation de portefeuille. Elle implique des variables de décision qui sont limitées à être des intégrateurs, ce qui la rend idéale pour les problèmes qui nécessitent des choix discrets, comme la sélection d'actifs ou les niveaux d'investissement.En intégrant des décisions discrètes, la programmation intégrale aligne la construction de portefeuille sur les réalités des marchés financiers – où les transactions impliquent des unités entières, des investissements minimums et des décisions d'inclusion binaire.

Comprendre l'optimisation du portefeuille

L'optimisation du portefeuille vise à répartir les actifs de manière à maximiser les rendements tout en minimisant les risques.Le cadre de variation moyenne introduit par Harry Markowitz en 1952 demeure le fondement de la théorie moderne du portefeuille. Dans cette approche, un investisseur cherche à trouver l'ensemble de pondérations des actifs qui minimisent les écarts de portefeuille pour un rendement prévu donné, ou de façon équivalente, maximiser le rendement prévu pour un niveau de risque donné.

La gestion pratique du portefeuille doit faire face à des contraintes distinctes telles que :

  • Montants minimaux de placement qui exigent une certaine valeur monétaire par actif.
  • Restrictions de taille de la masse lorsque les actifs se négocient sur des multiples spécifiques (p. ex., lots ronds de 100 actions).
  • Contraintes de cardinalité limitant le nombre total d'actifs détenus.
  • Seuils d'achat lorsqu'un actif doit être détenu à un poids minimum s'il est inclus du tout.
  • Les structures de coûts de transaction[ qui sont linéaires ou fixes par pièce, fondées sur des décisions de négociation distinctes.

Ces aspects discrets rendent les modèles d'optimisation continue inadéquates. La programmation Integer fournit un cadre mathématique rigoureux pour intégrer ces contraintes directement dans le problème d'optimisation.

Le rôle de la programmation intégrale dans le génie financier

L'ingénierie financière applique des méthodes mathématiques et informatiques pour résoudre les problèmes de finance. La programmation entière s'adapte naturellement parce que de nombreuses décisions financières sont intrinsèquement discrètes : inclure un actif, combien de contrats à trader, ou quels instruments de couverture à utiliser. Contrairement à la programmation linéaire ou quadratique, qui suppose une continuité variable, la programmation intégrale utilise binary (0/1) ou des variables entières pour représenter ces choix.

Variables binaires et sélection des actifs

Pour chaque actif candidat, une variable binaire indique inclusion (1) ou exclusion (0). La fonction objective et les contraintes peuvent alors être exprimées en termes de ces décisions binaires. Par exemple, un fonds peut vouloir sélectionner un sous-ensemble de 20 actions dans un univers éligible de 500. La contrainte que exactement 20 actifs sont choisis est une somme linéaire de variables binaires égale à 20. Sans programmation entière, il faudrait se fier à des méthodes heuristiques de dépistage ou de classement qui manquent de garanties formelles d'optimalité.

Les variables binaires permettent également de modéliser l'exclusivité mutuelle (choisir l'actif A ou l'actif B, mais pas les deux), les conditions logiques (si l'actif X est inclus alors l'actif Y doit également être inclus) et les stratégies d'investissement à plusieurs niveaux.

Variables entières pour les quantités d'investissement

Les variables entières précisent le nombre d'unités à acheter pour chaque actif, ce qui est crucial pour traiter des limites minimales de la taille des lots ou des contraintes entières qui reflètent les règles de négociation et les considérations de liquidité. Par exemple, si un stock se négocie en plusieurs de 100 actions, le nombre d'actions détenues doit être un nombre entier multiple de 100. Ces contraintes empêchent les parts fractionnelles, qui ne sont souvent pas admissibles dans les comptes de courtage standard.

En outre, les variables entières peuvent représenter le nombre de contrats dans les stratégies dérivées. Un programme d'écriture d'appels couvert, par exemple, pourrait exiger que le nombre d'options d'appels vendues soit un entier et ne dépasse pas le nombre d'actions détenues. Ces liens discrets sont naturellement exprimés avec des variables entières.

Manipulation des contraintes du monde réel

Au-delà de la simple sélection des actifs et des décisions quant à la quantité, la programmation intégrale peut encoder une grande variété de règles pratiques d'investissement:

  • Contraintes de report[ : Limiter la fraction du portefeuille achetée ou vendue peut être modélisé avec des variables binaires indiquant si un échange se produit, ainsi que des variables entières pour le montant échangé.
  • Limites d'exposition au secteur[: Les variables binaires peuvent imposer qu'au plus un actif par secteur est choisi, ou que les pondérations du secteur restent dans une fourchette.
  • Contraintes de seuil[ : Un actif ne peut être détenu que si son poids dépasse un seuil minimum. Ceci est mis en œuvre en reliant une variable de poids continu à un indicateur binaire.
  • Considérations fiscales : La sélection de lots pour la récolte de pertes fiscales implique des choix entiers pour déterminer quels lots fiscaux spécifiques à vendre.

La flexibilité d'intégrer ces contraintes réelles fait de la programmation intégrale une pierre angulaire des systèmes de négociation algorithmique et de construction de portefeuille.

Formuler le modèle de programmation entier

Un modèle de programmation entier pour l'optimisation du portefeuille consiste en une fonction objective et un ensemble de contraintes linéaires, avec certaines ou toutes les variables de décision limitées aux valeurs entières. La formulation générale peut être exprimée comme suit:

Maximiser (ou minimiser) f(x) sous réserve de A x ≤ b, l ≤ x ≤ u, x i ..... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

où x est le vecteur des variables de décision, A est la matrice de contrainte, b est le vecteur de droite, et I est l'ensemble d'indices pour les variables entières. L'objectif f(x) est souvent linéaire ou quadrimatique, représentant le retour attendu, la variance ou une combinaison.

Fonctions objectives

Dans la pratique, l'objectif peut être choisi pour correspondre aux objectifs de l'investisseur:

  • Maximiser le rendement attendu sous réserve d'un budget de risque. Il s'agit d'un objectif linéaire si les rendements attendus sont fixés.
  • Minimiser la variance du portefeuille (ou écart type) sous réserve d'un rendement cible. Cela donne un objectif quadratique, menant à un programme quadrimatique mixte (PQMI).
  • Maximiser le rendement ajusté au risque, comme le rapport Sharpe, qui est un rapport de deux fonctions linéaires et nécessite des reformulations spécialisées.
  • Minimiser l'erreur de suivi par rapport à un point de référence, souvent avec une contrainte de cardinalité sur le nombre de titres détenus.

Le choix de l'objectif affecte de façon significative la difficulté de calcul. Les objectifs linéaires sont généralement plus faciles, tandis que les objectifs quadratiques nécessitent des résolveurs plus avancés.

Contraintes

Les contraintes typiques d'un modèle de portefeuille de programmation entier comprennent :

  • Contrainte budgétaire: La somme des investissements équivaut au capital total. Pour les tailles de lots entiers, la contrainte budgétaire peut impliquer une variable entière multipliée par le prix du lot.
  • Contrainte de cardinalité: Somme des variables binaires de sélection des actifs ≤ K (nombre maximal d'actifs).
  • Low lied on actif heavy: si l'actif i est inclus, son poids ≥ L i. Ceci utilise une variable binaire pour activer ou désactiver la contrainte.
  • L'avantage est lié au poids de l'actif: logique similaire avec des variables binaires pour imposer des limites de détention maximales.
  • Contraintes d'exposition au secteur ou au facteur[: combinaisons linéaires de variables de décision délimitées ci-dessus et ci-dessous.
  • Contraintes de coûts de transaction[ : un coût fixe par trade peut être modélisé à l'aide de variables binaires qui entraînent un coût si un trade se produit.

Beaucoup de ces contraintes sont linéaires, préservant la structure de programmation linéaire mixte-entier (MILP) lorsque l'objectif est linéaire, ou MIQP lorsque quadratique.

Modèle d'échantillon

Considérez un problème simplifié de sélection de portefeuille avec les actifs N. Que x i soit le poids continu de l'actif i (fraction de richesse), et y i une variable binaire indiquant si l'actif i est détenu. Le modèle pourrait ressembler à:

Minimiser ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Il s'agit d'un programme quadrimatique à intégration mixte. Les contraintes liant x i et y i garantissent que si y i = 0, le poids x i doit être zéro; si y i = 1, le poids est limité entre l i et u i. La contrainte de cardinalité limite le nombre d'actifs.

Résoudre les modèles de programmation entiers

Les modèles de programmation entiers sont difficiles à utiliser en général, ce qui signifie que, à mesure que le nombre de variables entiers augmente, le temps de la solution le plus défavorable peut augmenter de façon exponentielle. Cependant, les résolveurs modernes utilisent des techniques sophistiquées pour résoudre efficacement de nombreux problèmes de taille pratique.

Branche et Bound

Branche et liée est l'épine dorsale des résolveurs de programmation à intégration mixte. L'algorithme fonctionne en résolvant une séquence de relaxations linéaires ou continues (où les restrictions à l'intégration sont abandonnées) et en ramifiant ensuite sur des variables entières qui prennent des valeurs fractionnelles dans la relaxation. Pour chaque branche, une liaison est calculée; les branches avec des limites pires que la meilleure solution entière courante sont taillées. Le processus se poursuit jusqu'à ce que toutes les branches soient explorées ou taillées. Branche et liée peuvent être améliorées par des règles de branchement intelligentes (p. ex., branchement fort, branchement pseudo-coût) et stratégies de sélection des nœuds (meilleure première, profondeur-première).

Méthodes de coupe du plan

Les plans de coupe ajoutent de nouvelles contraintes linéaires (coupes) à la relaxation continue qui resserre la région possible sans enlever de points entiers possibles. Ces coupes réduisent l'écart d'intégrité – la différence entre l'objectif optimal de la relaxation et le véritable entier optimal. Les coupes courantes utilisées dans l'optimisation du portefeuille comprennent les coupes de gomory, les coupes d'arrondis mixtes et les coupes de couverture.

Heuristique et métaheuristique

Pour les très grands portefeuilles ou les contraintes de temps serrées, les méthodes exactes peuvent être trop lentes. L'heuristique fournit des solutions presque optimales rapidement.

  • Heuristiques rondes: résoudre les variables de relaxation continue et de nombre entier fractionnaire rond à 0 ou 1 en fonction des seuils.
  • Recherche locale : à partir d'une solution d'entier réalisable et explorer de petits changements (p. ex., échange d'un actif entre et en dehors) pour améliorer l'objectif.
  • Algorithmes génétiques et simulation du recuit[: méthodes basées sur la population ou la marche aléatoire qui peuvent gérer des non-convexités.
  • La relaxation lagrangien: détendez les contraintes qui compliquent et utilisez l'optimisation des sous-gradients pour générer de bonnes solutions dual, qui peuvent être converties en solutions primaires.

Ces heuristiques produisent souvent des solutions de haute qualité en quelques secondes, ce qui les rend aptes à rééquilibrer les portefeuilles dans un environnement commercial en direct.

Mise en œuvre pratique

Les solutions de rechange en libre-service comme le SCIP, le GLPK et le COIN-OR , sont également disponibles, mais elles peuvent être plus lentes pour les grandes instances. Les interfaces de programmation sont fournies dans Python (PuLP, Pyomo, CVXOPT), MATLAB, R et C++. Pour les applications de portefeuille, il est courant de précalculer les matrices de covariance et les retours attendus, puis de transmettre le problème à un résolveur via une API. Le traitement parallèle et le cloud computing peuvent accélérer les temps de solution.

Un conseil pratique : les problèmes d'optimisation du portefeuille ont souvent une structure spéciale – comme une matrice de covariance de bas rang ou des contraintes peu nombreuses – que les résolveurs peuvent exploiter. La reformulation du problème pour utiliser moins de variables entières ou pour linéariser des termes quadratiques peut améliorer considérablement les performances.

Avantages et limites

La programmation Integer apporte plusieurs avantages à l'optimisation de portefeuille :

  • Réalisme: Il capture des contraintes discrètes que les modèles continus ignorent, comme les tailles minimales d'achat, les tailles de lot et les limites de cardinalité.
  • Optimalité: Contrairement aux méthodes heuristiques, la programmation intégrale peut garantir l'optimalité globale (ou une probabilité liée à la sous-optimisation) pour les problèmes de taille modérée.
  • Flexibilité : Une grande variété de fonctions et de contraintes objectives peuvent être exprimées sous une forme linéaire ou quadratique, ce qui rend le cadre adaptable à différents mandats d'investissement.
  • Transparence: Les hypothèses et les contraintes du modèle sont explicites et reproductibles.

Toutefois, il existe des limites notables:

  • Compétitivité informatique[: Les problèmes de programmation entiers sont difficiles à résoudre. Même des instances de taille moyenne avec des centaines de variables binaires peuvent être difficiles. L'exécution du solvant peut être imprévisible, ce qui est une préoccupation pour les applications en temps réel.
  • Sensibilité des données: L'optimisation du portefeuille repose sur des estimations des rendements attendus, des volatilités et des corrélations. De petites erreurs d'estimation peuvent conduire à des solutions radicalement différentes, un phénomène appelé maximisation des erreurs. La programmation entière ne résout pas intrinsèquement ce problème; des formulations d'optimisation robustes sont parfois combinées avec IP pour gérer l'incertitude.
  • Grandes tailles de portefeuille: Pour les univers de milliers d'actifs, la programmation intégrale exacte peut devenir peu pratique.
  • Modèler la complexité[: Traduire des règles du monde réel en contraintes entières linéaires peut être difficile et peut nécessiter des variables binaires pour chaque règle, explorant la taille du problème.

Malgré ces limites, les progrès dans les algorithmes (p. ex., les résolveurs basés sur le cloud, les réducteurs parallèles de branche et de limite et les réductions présolvables) continuent d'élargir la frontière de ce qui est solvable.

Applications du monde réel

Des méthodes de programmation intégrale ont été appliquées dans de nombreux contextes financiers au-delà de la sélection de portefeuilles de base :

  • : construction d'un portefeuille de stocks K qui minimise l'erreur de suivi par rapport à un large indice comme le S&P 500. Il s'agit d'un programme quadrimatique limité par la cardinalité, souvent résolu par le biais du MAQP.
  • Réplication des fonds de couverture[: en utilisant des contraintes entières pour imiter le profil risque-rendement d'une stratégie de fonds de couverture avec un ensemble limité d'instruments liquides.
  • Gestion de la responsabilité[: pour les fonds de pension et les compagnies d'assurance, la programmation intégrale permet de comparer les flux de trésorerie des actifs aux paiements de responsabilité, où les échéances des obligations sont distinctes.
  • Exécution de trading algorithmique: optimiser la séquence et le calibrage des commandes pour minimiser l'impact du marché et les coûts de transaction, souvent projetés comme un programme dynamique mixte.
  • Budgétisation des risques[: répartition du capital-risque dans différentes stratégies ou catégories d'actifs, chaque allocation étant soit un pourcentage fixe, soit zéro (décision binaire).
  • Construction de portefeuilles verts[: y compris les critères environnementaux, sociaux et de gouvernance (ESG) comme contraintes binaires (p. ex. exclure toutes les entreprises exposées au charbon).

Par exemple, un article de 2018 publié dans Opérations Research[ a démontré qu'un résolveur de branches et de coupes pouvait résoudre des problèmes de suivi d'indices avec jusqu'à 1000 stocks et cardinalité de 50 en quelques minutes (voir Bertsimas et Stellato, 2018.Les praticiens combinent souvent la programmation intégrale avec les prévisions d'apprentissage automatique pour intégrer les signaux alpha dans l'optimisation.

Conclusion

Les méthodes de programmation intégrées sont des outils précieux en ingénierie financière pour l'optimisation des portefeuilles, offrant la possibilité de modéliser de façon réaliste les décisions d'investissement discrètes. Au fur et à mesure que les techniques de calcul évoluent, leur application devrait s'étendre, ce qui permettra d'adopter des stratégies d'investissement plus efficaces et plus pratiques. La clé du succès de l'adoption réside dans le choix de la bonne taille du problème, la mise à profit des solutions les plus modernes et la reconnaissance des approximations ou des heuristiques justifiées.

Pour plus de détails, les lecteurs intéressés peuvent explorer l'entrée Wikipedia sur la programmation entière, la documentation pour Gurobi Optimizer, ou le manuel Programmation intégrale[ par Conforti, Cornuéjols et Zambelli. Un guide pratique pour l'optimisation du portefeuille avec des variables entières peut être trouvé dans la documentation CVXPY.