PC & Mobile

Moteur de simulation Monte Carlo en python – FinTechExplained – Medium

Moteur de simulation Monte Carlo en python - FinTechExplained - Medium


Solution de bout en bout des opérations de tarification à l'aide du moteur de simulation Monte Carlo

Cet article décrit les étapes requises pour implémenter un moteur de simulation Monte-Carlo en Python.

Le moteur de simulation de Monte-Carlo évaluera un portefeuille avec une option d’échange. Je vais d'abord expliquer les bases du modèle, puis je vais concevoir la solution, puis celle-ci sera implémentée en python.

Cet article dissipera de nombreux doutes sur le fonctionnement du moteur Monte-Carlo.

Comprenons d'abord la théorie

Nous allons estimer le prix d'une option d'achat européenne. Une option est un contrat financier dérivé entre deux ou plusieurs entités financières. La valeur d'une option est calculée à partir du prix de son actif sous-jacent (par exemple, un titre ou un stock, etc.). Une option d'achat européenne est un type d'option dans laquelle l'acheteur a le droit, et non l'obligation, d'acheter le titre sous-jacent à la date d'expiration.

Pour comprendre comment les options fonctionnent en détail, veuillez consulter mon article:

Comment fonctionne la simulation Monte-Carlo

Les techniques de simulation Monte-Carlo sont utilisées dans un certain nombre de domaines, de l'ingénierie à la finance. Ils aident les particuliers et les institutions telles que les banques à prendre des décisions calculées.

La simulation Monte-Carlo implique la création de variables aléatoires. Ces variables ont des propriétés similaires aux facteurs de risque que la simulation tente de simuler.

La simulation de Monte-Carlo simule et produit un certain nombre de résultats pour un certain nombre de scénarios (généralement plus de 2000) sur un grand nombre de pas de temps (environ 100). En conséquence, la technique produit un grand nombre de résultats possibles pour les variables, ainsi que leurs probabilités. La simulation Monte-Carlo peut être utilisée pour imiter des scénarios réels et générer des valeurs aberrantes.

Parmi les résultats possibles des valeurs, une valeur moyenne est choisie. La mesure moyenne dépend généralement du cas d'utilisation. Pour l’exemple d’aujourd’hui, nous allons utiliser signifier comme notre mesure.

Remarque: Plus le nombre de scénarios est important, plus la précision des résultats est élevée, mais plus le calcul de la simulation est lent.

Comme l’exécution d’une simulation Monte-Carlo est généralement un processus lent, un certain nombre d’ordinateurs hautes performances sont utilisés pour simuler une variable.

Qu'allons-nous simuler aujourd'hui?

Nous allons simuler le stock sous-jacent d'une option d'achat européenne à l'aide de la simulation Monte Carlo. Ensuite, le prix de l'option d'achat sera calculé. Nous pouvons chiffrer une option d'achat européenne à l'aide de la formule Black-Scholes, qui est une formule fermée. Toutefois, je montrerai comment fonctionne la valorisation de Monte-Carlo car elle peut être utilisée pour valoriser des transactions plus complexes telles que l'option d'achat américaine qui peut expirer plus tôt. que le délai d'expiration.

Nous utiliserons l’évaluation neutre du risque de Monte-Carlo.

Photo par JESHOOTS.COM sur Unsplash

Nous commencerons par un portefeuille avec une option d’achat européenne.

  1. Dans un premier temps, nous calculerons le prix de l'option à l'aide de la formule standard de Black Scholes. Ce sera notre référence.
  2. Nous construirons ensuite le moteur de simulation Monte-Carlo en Python. Ce moteur calculera le prix de l'actif sous-jacent, noté S, sur 2000 scénarios. La source d'incertitude est le prix de l'action sous-jacente. Nous allons supposer que la dérive et la volatilité sont constantes pour notre moteur de simulation de base de Monte-Carlo. Pour simuler l'incertitude, nous allons générer une variable aléatoire supposée avoir une distribution normale.
  3. Nous calculerons ensuite l'option de remboursement pour chaque chemin de scénario où le remboursement d'une option d'achat est calculé comme suit:

Rendement = Max (S (t) - K, 0)

Ici, S (t) signifie stock à l'instant t.

4. Nous additionnerons ensuite tous les gains et les actualiserons au taux sans risque. En effet, le cours de l'action sera généré pour l'échéance de l'option. Nous allons utiliser une remise continue.

5. La dernière étape consiste à calculer le prix de l’option à partir de la somme actualisée des gains. Cela impliquera de calculer une moyenne de la somme actualisée des gains générés pour chaque chemin du scénario.

Le prix des options pour notre modèle de Monte Carlo est la moyenne des gains générés par les prix de la simulation de Monte-Carlo.

Critères de succès: Le prix calculé à l'étape 5 devrait être très proche du prix de l'option calculée à l'étape 1. Nous allons augmenter le nombre de scénarios pour voir son impact sur la précision.

Avant de commencer, construisons des connaissances en modélisation

Construire des connaissances en calcul stochastique

Notre modèle va être très basique. Avant de concevoir et d’implémenter le code en Python, comprenons rapidement les termes clés et la théorie sous-jacente au processus:

Processus de Markov

Les prix des transactions financières suivent une marche aléatoire. Cette marche aléatoire est connue sous le nom de processus de Markov. Cela indique que le processus est de nature stochastique et que les valeurs de prix futurs ne dépendent que du prix actuel.

L'histoire passée est sans importance dans le processus de Markov

Processus de Wiener

Si nous évaluons une variable qui suit une marche aléatoire et que son changement est mesuré sur l'intervalle de temps t, le processus de Wiener est une variable dont le changement moyen est égal à 0 et la variance de la variable est proportionnelle à l'intervalle de temps.

Les incréments de la variable dans le temps ne dépendent pas les uns des autres.

Nous pouvons écrire un processus de Wiener en tant que:

ε √Δt où ε est une variable normale standard avec moyenne 0 et variance 1

Processus de Wiener généralisé

Le processus de Wiener généralisé est une variable qui se comporte non seulement comme un processus de Wiener, mais présente également une tendance constante par unité de temps et une volatilité constante.

Processus Ito

Cela nous amène au processus Ito. Il s’agit essentiellement d’un processus de saucisse généralisé, sauf que sa tendance et sa volatilité dépendent du temps et de la valeur actuelle de la variable sous-jacente. Il s'agit d'un processus de Markov, car le passé n'a aucune importance dans le processus Ito.

Nous pouvons l'écrire comme

δS (t) = dérive + incertitude

Comprendre notre modèle choisi - approfondissons le processus Ito

Le processus de Wiener est également appelé mouvement brownien. Le mouvement brownien géométrique est l'exponentielle du processus de Wiener avec dérive. Geometric Brownian Motion (GBM) est un exemple du processus de Ito.

Nous savons que Ito lemma peut s’écrire comme suit:

δS (t) = dérive + incertitude

GBM pour une variable S est:

δS (t) = S (t) μ δt + S (t) σ √Δt ε

σ est la volatilité

Le processus de GBM est de nature basique car il n’intègre pas de volatilité à inversion de moyenne et de temps. Par conséquent, GBM n’est pas compatible avec les prix des obligations qui affichent un retour à long terme à la valeur nominale.

Comme son nom l'indique, le processus est de nature géométrique car la dérive et la volatilité sont proportionnelles à la valeur actuelle de S.

L'objectif du moteur de simulation de Monte-Carlo est de calculer le prix de l'option en simulant le processus stochastique de Wiener.

Notre modèle est supposé être neutre au risque. L’approche neutre en matière de risque consiste à faire croître le prix d’une option sur une action au même taux sans risque que le taux sans risque utilisé pour l’actualiser.

La règle Ito Lemma calcule le différentiel d'une variable en fonction du temps et d'un processus stochastique. Par conséquent, la solution de l’équation différentielle stochastique de GBM en utilisant le lemme de Ito est la suivante:

S (t) = S (0) exp[(r-0.5σ²)t + σ√tε)]

Remarque: ε est une variable aléatoire de distribution normale normale N (0,1)

Jetez un oeil à mon article dans lequel j'explique comment fonctionne le processus stochastique:

Conception du moteur de simulation Python Monte Carlo

Mon plan est de simplifier la conception et de la rendre extensible afin que nous puissions facilement ajouter plus de métiers et injecter des modèles avancés dans le futur.

La solution python contiendra les classes de clés suivantes:

1. MonteCarloEngineSimulator

La classe MonteCarloEngineSimulator sera responsable de:

  1. Appel du modèle de simulation pour simuler le facteur de risque qui, dans ce cas, est le prix des actions / actions.
  2. Transmettre les valeurs de facteur de risque simulées à la transaction est rentable afin de lui permettre d'évaluer la transaction.

2. GBMModèle

La classe GBMModel contiendra l'équation différentielle stochastique GBM décrite ci-dessus. Il faudra effectuer un échange et générer des cours boursiers simulés.

3. OptionTradePayoffPricer

La classe OptionTradePayoffPricer prendra l’opération en tant que paramètre et générera une option d’achat moyenne payante. Le commerce dans ce cas sera un commerce d'option.

Je vais implémenter une classe OptionTrade pour stocker des propriétés spécifiques aux transactions sur options telles que le prix d'exercice, le cours initial, le taux sans risque et la volatilité de l'action sous-jacente. À l'avenir, nous pourrons passer à SwapTrade, AmericalCallOptionTrade, etc.

Je vais également implémenter une classe de configuration pour stocker le nombre de scénarios et le nombre de pas de temps.

Séquence de flux de processus

En un mot, GBMModel.SimulateRiskFactor () renverra un vecteur numérique en sortie. La sortie sera le prix du stock sous-jacent dans ce cas. Il utilisera la formule GBM SDE pour calculer un nombre de cours d’actions.

Le vecteur numérique des cours des actions sous-jacentes sera transmis à un OptionPricer. OptionPricer calculera ensuite le PayOff pour chaque chemin du scénario et renverra la moyenne des gains.

Ce sera le prix de l'option.

À l'avenir, je mettrai en œuvre d'autres modèles pouvant fonctionner avec une volatilité dépendant du temps et à inversion de moyenne et substituant les instances de modèle à la classe MonteCarloEngineSimulator. De plus, nous augmenterons la taille de notre portefeuille en augmentant le nombre de transactions avec différents types de transactions et nous fournirons également une matrice de corrélation pour modéliser avec précision les relations entre les facteurs de risque.

Implémentation du moteur de simulation Python Monte Carlo

Codons la conception comme indiqué ci-dessus. La conception doit faciliter la mise en œuvre:

  1. Importer les bibliothèques requises
importer numpy en tant que np

2. Créez une classe de configuration pour stocker les paramètres de configuration.

Configuration de la classe:
def __init __ (self, NumberOfScenarios, NumberOfTimesteps):
self.NumberOfScenarios = NumberOfScenarios
self.NumberOfTimesteps = NumberOfTimesteps

3. Créez une classe de commerce qui stockera les détails des options

classe OptionTrade:
def __init __ (self, stock_price, strike_price, risk_free_rate, volatilité, time_to_maturity):
self.stock_price = stock_price
self.strike_price = strike_price
self.risk_free_rate = risk_free_rate
auto.volatilité = volatilité
self.time_to_maturity = time_to_maturity

4. Créer un simulateur de modèle GBM

classe GBMModel:
def __init __ (auto, configuration):
self.Configuration = Configuration

#simuler les facteurs de risque en utilisant l'équation différentielle stochastique de GBM
def SimulateRiskFactor (auto, commerce):
prix = []
# pour cet exemple, nous ne nous intéressons qu’à un pas de temps car c’est une option européenne
timestep = 1
pour scenarioNumber dans l'intervalle (self.Configuration.NumberOfScenarios):
normal_random_number = np.random.normal (0, 1)
drift = trade.risk_free_rate-0.5 * (trade.volatility ** 2) * timestep
incertitude = trade.volatility * np.sqrt (timestep) * normal_random_number
price = trade.stock_price * np.exp (dérive + incertitude)
prices.append (price)
prix de retour

4. Créer un prix d’option payant

classe OptionTradePayoffPricer:
def CalculerPrix (auto, échange, prix_per_scenario):
pay_offs = 0
total_scenarios = len (prices_per_scenario)
pour i dans la plage (total_scenarios):
price = prices_per_scenario[i]
pay_off = price - trade.strike_price
si (pay_off> 0):
pay_offs = pay_offs + pay_off

discounted_price = (np.exp (-1.0 * trade.risk_free_rate * trade.time_to_maturity) * pay_offs)
résultat = discounted_price / total_scenarios
résultat retourné

5. Enfin, implémentons un moteur Monte Carlo

classe MonteCarloEngineSimulator:

#instationate avec la configuration et le modèle
def __init __ (auto, configuration, modèle):
self.configuration = configuration
self.model = model

#simuler le commerce et calculer le prix
def Simulate (self, trade, tradePricer):
prices_per_scenario = self.model.SimulateRiskFactor (commerce)

price = tradePricer.CalculatePrice (trade, prices_per_scenario)

retour prix

Exécutons le code

Photo de Caspar Camille Rubin sur Unsplash

Étape 1: Évaluez une option avec la formule de scholes noirs:

Nous allons tarifer une option d'achat avec les caractéristiques suivantes:

  • Prix ​​du stock: 200
  • Prix ​​d'exercice: 200
  • Délai jusqu'à maturité: 1 an
  • Volatilité: 10%
  • Taux sans risque: 15%

Black Scholes donne son prix comme £ 28.40. Ceci est notre référence

Étape 2.1: Tarification de l’option avec simulation de Monte-Carlo avec 10 scénarios:

def Main ():
#préparer les données
configuration = Configuration (10, 1) # config
trade = OptionTrade (200, 200, 0.15, 0.1,1) # trade
model = GBMModel (configuration)
tradePricer = OptionTradePayoffPricer ()
simulateur = MonteCarloEngineSimulator (configuration, modèle)

# simuler le prix
price = simulator.Simulate (trade, tradePricer)
imprimer (prix)

Le prix de l’option d’achat est de 24,8706 £. C'est proche mais pas assez.

Étape 2.2 Augmentons le nombre de scénarios. Prix ​​de l'option avec simulation Monte-Carlo avec 100 scénarios:

def Main ():
#préparer les données
configuration = Configuration (100, 1) # config
trade = OptionTrade (200, 200, 0.15, 0.1,1) # trade
model = GBMModel (configuration)
tradePricer = OptionTradePayoffPricer ()
simulateur = MonteCarloEngineSimulator (configuration, modèle)

# simuler le prix
price = simulator.Simulate (trade, tradePricer)
imprimer (prix)

Le prix de l’option d’achat est de 26,726 £. C'est proche mais pas assez.

Étape 2.3 Augmentons le nombre de scénarios. Prix ​​de l'option avec la simulation Monte-Carlo avec 1000 scénarios:

def Main ():
#préparer les données
configuration = Configuration (1000, 1) # config
trade = OptionTrade (200, 200, 0.15, 0.1,1) # trade
model = GBMModel (configuration)
tradePricer = OptionTradePayoffPricer ()
simulateur = MonteCarloEngineSimulator (configuration, modèle)

# simuler le prix
price = simulator.Simulate (trade, tradePricer)
imprimer (prix)

Le prix de l’option d’achat est de 28.385 £. Ceci est très proche du prix Black Scholes.

Nous pouvons constater qu’augmenter le nombre de scénarios améliorait la précision du moteur de simulation Monte-Carlo. Cependant, il a fallu un peu plus longtemps pour obtenir le prix demandé.

C’est tout. Nous avons construit notre premier moteur de simulation Monte-Carlo. Nous pouvons maintenant ajouter plus de métiers, augmenter les pas de temps, augmenter le nombre de scénarios, injecter des modèles supérieurs, etc.

Résumé

Il s'agit de notre moteur de simulation Monte-Carlo de base, qui simulait les cours des actions à l'aide de GBM et produisait un ensemble de cours. Nous avons ensuite pris la moyenne des gains qui s’est très proche du prix réel des options.

La clé à noter est que, bien que le modèle soit basique, nous pouvons l’étendre facilement.

Dans mes articles suivants, je montrerai comment nous pouvons utiliser des modèles plus complexes.

J'espère que ça aide.

Faites-moi savoir si vous avez des commentaires.

Show More

SupportIvy

SupportIvy.com : Un lieu pour partager le savoir et mieux comprendre le monde. Meilleure plate-forme de support gratuit pour vous, Documentation &Tutoriels par les experts.

Related Articles

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Close
Close