Programmation mathématique étendue (applications de trading)

Climax · 10-02-2024 16:30:02

Programmation mathématique étendue (applications de trading et d'investissement)

La programmation mathématique étendue (PME) est un cadre qui permet de formuler et de résoudre des problèmes d'optimisation complexes en intégrant divers paradigmes de programmation, tels que la programmation quadratique, non linéaire, en nombres entiers mixtes et stochastique.

Cette méthode va au-delà des techniques traditionnelles de programmation linéaire et non linéaire, ce qui permet un traitement plus nuancé des scénarios financiers du monde réel.

Principaux enseignements :

Mélange de plusieurs paradigmes de programmation et d'optimisation.
Elle va plus loin que la maximisation d'une chose (par exemple, le profit). La PME gère des objectifs, des contraintes et des risques complexes et peut s'adapter à un large éventail d'objectifs et de contraintes de la vie réelle.

Principes fondamentaux de la PME

La PME consiste à construire des modèles mathématiques pour représenter des stratégies de négociation, des portefeuilles d'investissement ou d'autres questions impliquant une prise de décision financière.

Ces modèles prennent en compte de multiples facteurs tels que la volatilité du marché, les coûts de transaction et les contraintes de liquidité.

La PME excelle dans l'optimisation de ces modèles en trouvant la meilleure combinaison possible de décisions d'allocation qui répondent aux objectifs souhaités, tels que la maximisation des rendements ou la minimisation des risques.

Applications de la PME dans le domaine du trading

Dans le domaine du trading, la PME est utilisée pour formuler et résoudre des problèmes d'optimisation de portefeuilles multi-périodes.

Gestion du risque

Les traders utilisent la PME pour gérer le risque de manière dynamique dans le temps.

Il s'agit notamment d'ajuster les portefeuilles en fonction de l'évolution du marché, de gérer les coûts de transaction et de respecter les exigences réglementaires.

Les modèles PME peuvent également intégrer des prévisions et des processus stochastiques pour prendre en compte les aléas.

Trading algorithmique

La PME est utilisé dans le trading algorithmique, où il sert à développer des stratégies capables d'exécuter des transactions aux moments les plus opportuns, en tenant compte de facteurs tels que le prix, le volume et le temps.

Ces modèles sont capables de traiter de vastes ensembles de données, d'extraire des modèles et de prendre des décisions à grande vitesse qui dépassent les capacités humaines.

Optimisation de portefeuille

L'optimisation de portefeuille est l'une des principales applications due la PME dans le domaine du trading.

Ces modèles aident à identifier la combinaison optimale d'actifs qui produit le rendement attendu le plus élevé pour un niveau de risque donné, ou alternativement, le risque le plus faible pour un niveau de rendement attendu donné, ou une combinaison des deux.

Ils peuvent intégrer diverses contraintes du monde réel, telles que l'impact du marché, les coûts de transaction et la rotation du portefeuille.

Traitement des inconnues dans la PME

L'un des principaux avantages de la PME est sa capacité à gérer les incertitudes et à modéliser des scénarios complexes.

La programmation stochastique, un sous-ensemble de la PME, est utile à cet égard.

Elle permet de modéliser des scénarios dans lesquels certains paramètres ont des résultats probabilistes (et les paramètres eux-mêmes peuvent avoir des résultats probabilistes dans un type de structure probabiliste multi-ordre), ce qui fournit un cadre pour la prise de décision dans l'incertitude.

Analyse de scénarios

La PME permet aux investisseurs et aux traders d'effectuer des analyses de scénarios, qui prennent en compte un large éventail de conditions économiques/de marché futures possibles.

Ceci est important pour tester les portefeuilles et les stratégies face à des événements de marché extrêmes.

Les mathématiques derrière la programmation mathématique étendue

Voici un aperçu des mathématiques qui sous-tendent la PME:

Formulation standard de la programmation mathématique

Minimiser f(x)
Sous réserve que g(x) ≤ 0
h(x) = 0

Où x sont les variables de décision.

La PME complète cette formule avec :

1. Incertitude endogène

Eξ[Q(x, ξ)]

Où ξ est un vecteur aléatoire avec une espérance Eξ.

Cela conduit à la programmation stochastique.

2. Conditions d'équilibre

y = arg min/max {g(x,y)}

Où y représente les décisions d'équilibre comme dans la programmation à deux niveaux.

3. Conditions de complémentarité

0 ≤ y ⊥ g(x) ≥ 0

Où ⊥ désigne la complémentarité entre les variables y et la fonction de contrainte g(x).

Cela permet de gérer les équilibres et les compromis.

4. Décisions logiques/discrètes

x ∈ S
S = combinaisons vrai/faux

Ce qui permet de mélanger des contraintes entières, binaires et logiques.

L'idée clé est que la modélisation de systèmes complexes nécessite l'extension de l'optimisation de base.

Cela permet d'étendre la syntaxe et la sémantique de la programmation mathématique à de nouvelles formes tout en conservant la traçabilité des calculs.

Exemple de codage - Programmation mathématique étendue

Suivant un exemple que nous avons utilisé dans d'autres articles, nous allons faire un exemple de codage de la programmation mathématique étendue pour optimiser ce portefeuille :

Actions : Rendement à terme de +4-7%, volatilité annualisée de 15% en utilisant l'écart-type
Obligations : +0-5% de rendement à terme, 10% de volatilité annualisée en utilisant l'écart-type
Matières premières : +0-4% de rendement à terme, 15% de volatilité annualisée en utilisant l'écart-type
Or : +2-5% de rendement à terme, 15% de volatilité annualisée en utilisant l'écart type +2-5% de rendement à terme, 15% de volatilité annualisée en utilisant l'écart-type

Approche conceptuelle

Nous allons présenter une approche conceptuelle de la manière dont vous pourriez résoudre ce problème à l'aide des principes du PME, en vous concentrant sur la maximisation du rendement attendu pour un niveau de risque donné, tout en tenant compte des fourchettes de rendement possibles pour chaque catégorie d'actifs.

Définir les variables

Pondérations du portefeuille pour chaque classe d'actifs (actions, obligations, matières premières, or), en veillant à ce que leur somme soit égale à 1.

Fonction objectif

Maximiser le rendement attendu du portefeuille, en tenant compte de l'éventail des rendements possibles pour chaque actif.

Contraintes

Le total des pondérations du portefeuille est égal à 1 (contrainte d'investissement intégral).
La volatilité du portefeuille ne dépasse pas un objectif spécifié, calculé sur la base de la volatilité des actifs et des pondérations du portefeuille.
Contraintes supplémentaires si nécessaire (par exemple, niveaux d'investissement minimum ou maximum pour chaque actif).

Modélisation de l'incertitude

Utiliser les éléments de programmation stochastique dans la PME pour modéliser l'incertitude des rendements à terme, en définissant éventuellement des scénarios basés sur les fourchettes de rendement de chaque actif.

Résolution du problème

Cette configuration nécessiterait la résolution d'un problème d'optimisation non linéaire, éventuellement avec des éléments stochastiques, à l'aide d'un solveur capable de traiter de tels problèmes.

Exemple 1 - Bibliothèque Pyomo

Nous utiliserons la bibliothèque Pyomo, une bibliothèque Python permettant de définir et de résoudre des programmes mathématiques.

Cet exemple nécessite la bibliothèque Pyomo et un solveur tel que GLPK, CPLEX ou Gurobi installé dans votre environnement Python.

Nous simulerons les rendements attendus sur la base de la moyenne des fourchettes fournies et utiliserons directement les volatilités données.

from pyomo.environ import *

# Define model
model = ConcreteModel()

# Decision Variables: proportion of the portfolio allocated to each asset class
model.stocks = Var(bounds=(0, 1))
model.bonds = Var(bounds=(0, 1))
model.commodities = Var(bounds=(0, 1))
model.gold = Var(bounds=(0, 1))

# Parameters: Expected returns (average of provided ranges) & volatilities
expected_returns = {'stocks': 0.055, 'bonds': 0.025, 'commodities': 0.02, 'gold': 0.035}
volatilities = {'stocks': 0.15, 'bonds': 0.10, 'commodities': 0.15, 'gold': 0.15}

# Objective: Maximize expected portfolio return
def portfolio_return(model):
return sum(expected_returns[asset] * getattr(model, asset) for asset in expected_returns)

model.objective = Objective(rule=portfolio_return, sense=maximize)

# Constraint: Sum of allocations = 1 (100%)
def allocation_constraint(model):
return model.stocks + model.bonds + model.commodities + model.gold == 1

model.total_allocation = Constraint(rule=allocation_constraint)

# Solve the model
solver = SolverFactory('glpk') # or use 'cplex', 'gurobi', etc. depending on what you have installed
solver.solve(model)

# Print the optimized allocation
print("Optimized Portfolio Allocation:")
for asset in expected_returns:
print(f"{asset.capitalize()}: {getattr(model, asset).value():.4f}")

Exemple #2 - Sans Pyomo

Et avec les bibliothèques numpy et scipy standard.

Ici, nous essayons d'optimiser tout en obtenant une contribution égale au risque de chaque classe d'actifs.

import numpy as np
from scipy.optimize import minimize

# Asset expected returns & volatilities
expected_returns = np.array([0.055, 0.025, 0.02, 0.035]) # Stocks, Bonds, Commodities, Gold
volatilities = np.array([0.15, 0.10, 0.15, 0.15])

# Assuming uncorrelated assets for simplicity, construct diagonal covariance matrix
covariance_matrix = np.diag(volatilities ** 2)

# Risk contribution function
def risk_contributions(weights, covariance_matrix):
portfolio_volatility = np.sqrt(np.dot(weights.T, np.dot(covariance_matrix, weights)))
marginal_contrib = np.dot(covariance_matrix, weights)
risk_contributions = np.divide(marginal_contrib, portfolio_volatility)
return risk_contributions

# Objective function: minimize the variance of risk contributions
def objective(weights):
contributions = risk_contributions(weights, covariance_matrix)
return np.std(contributions) # Minimize the standard deviation of contributions

# Constraints & bounds
constraints = [{'type': 'eq', 'fun': lambda x: np.sum(x) - 1}] # Sum of weights must be 1
bounds = [(0, 1) for _ in range(len(expected_returns))] # Weights between 0 and 1

# Initial guess
x0 = np.array([0.25, 0.25, 0.25, 0.25])

# Optimization
result = minimize(objective, x0, method='SLSQP', bounds=bounds, constraints=constraints)

# Show optimized allocations
optimized_allocations = pd.Series(result.x, index=['Stocks', 'Bonds', 'Commodities', 'Gold'])
optimized_allocations

Exemple n° 3 - Rendement le plus élevé par unité de risque à l'aide de simulations de Monte Carlo

Nous allons maintenant utiliser une approche de Monte Carlo :

Simuler les rendements des actifs

Utilisez les simulations de Monte Carlo pour générer des rendements futurs possibles pour chaque classe d'actifs en tenant compte de leurs fourchettes de rendement et de leurs volatilités attendues.

Calculer le risque et le rendement du portefeuille

Pour une allocation donnée, calculez le rendement et le risque attendus du portefeuille en tenant compte des résultats de la simulation.

Optimisation

Nous utiliserons un optimiseur numérique pour trouver l'allocation qui égalise les contributions au risque de chaque classe d'actifs tout en maximisant le rendement attendu du portefeuille.

import numpy as np
from scipy.optimize import minimize

# Parameters
n_simulations = 10000
n_assets = 4
expected_returns = np.array([5.5, 2.5, 2, 3.5]) / 100 # Midpoints of expected return ranges
volatilities = np.array([15, 10, 15, 15]) / 100
n_years = 1

# Sim future returns
np.random.seed(42)
simulated_returns = np.random.normal(loc=expected_returns, scale=volatilities, size=(n_simulations, n_assets))

# Function to calculate portfolio return and risk
def portfolio_performance(weights, simulated_returns):
weighted_returns = simulated_returns @ weights
expected_return = np.mean(weighted_returns)
risk = np.std(weighted_returns)
return expected_return, risk

# Objective function: Maximize expected return for equal risk contributions
def objective(weights):
expected_return, risk = portfolio_performance(weights, simulated_returns)
risk_contributions = weights * np.std(simulated_returns, axis=0) / risk
risk_parity_penalty = np.sum((risk_contributions - 1 / n_assets) ** 2)
return -(expected_return - risk_parity_penalty)

# Constraints & bounds
constraints = ({'type': 'eq', 'fun': lambda x: np.sum(x) - 1})
bounds = tuple((0, 1) for _ in range(n_assets))

# Initial guess
initial_guess = np.full(n_assets, 1 / n_assets)

# Optimization
result = minimize(objective, initial_guess, method='SLSQP', bounds=bounds, constraints=constraints)

# Optimized weights
optimized_weights = result.x
optimized_weights

Résultats

Actions : 21,60%
Obligations : 34.04%
Matières premières : 22,05%
Or : 22,31%

Cette répartition suggère un portefeuille bien diversifié qui équilibre les contributions au risque entre les différentes classes d'actifs.

Nous adhérons au cadre de la parité des risques et prenons également en compte les rendements attendus de chaque actif.

Le processus d'optimisation a permis de répartir le risque total du portefeuille entre les quatre actifs et de s'assurer qu'aucune classe d'actifs ne contribue de manière disproportionnée au risque global, tout en cherchant à maximiser le rendement attendu du portefeuille.

Défis et considérations

Les modèles PME peuvent être complexes et nécessiter d'importantes ressources informatiques.

La qualité des résultats dépend fortement de l'exactitude des données d'entrée et des hypothèses qui sous-tendent les modèles.

Il est donc important d'assurer un suivi, une mise à jour et une validation continus des modèles pour garantir leur pertinence et leur précision.

#1 10-02-2024 16:30:02