Mettre en œuvre le cycle de vie des risques des services financiers avec Azure et R
Les calculs de risques sont essentiels à différentes étapes du cycle de vie des principales opérations de services financiers. Le schéma ci-dessous présente un exemple de cycle de vie de gestion de produits d’assurance au format simplifié. Les éléments liés au calcul de risque sont affichés en bleu.
Voici un exemple de scénario dans une entreprise du secteur des marchés financiers :
De tels processus présentent des besoins courants en modélisation des risques, notamment :
- Expérimentation des risques ad hoc par des analystes spécialisés comme les actuaires dans une compagnie d’assurance ou les analystes quantitatifs dans une entreprise de marchés financiers. Ces analystes utilisent généralement du code et des outils de modélisation qui sont reconnus dans leur domaine : R et Python. De nombreuses universités incluent une formation à R ou Python dans le cadre des cours de mathématiques appliquées à la finance et d’administration des entreprises. Les deux langages donnent accès à un large éventail de bibliothèques open source qui prennent en charge les calculs de risques les plus courants.
- Outre les outils appropriés, les analystes ont souvent besoin d’avoir accès à :
- Des données précises sur les prix du marché.
- Des données sur les stratégies et les revendications.
- Des données de positionnement sur le marché.
- D’autres données externes, par exemple :
- Des données structurées telles que les tables de mortalité et les données de tarification concurrentielle.
- Des types de données moins traditionnels tels que la météo et les actualités.
- Une capacité de calcul suffisante pour l’analyse rapide et interactive des données.
- Dans certains cas, des algorithmes de machine learning ad hoc pour la tarification ou l’identification des stratégies de marché.
- La visualisation et la présentation des données à utiliser dans la planification produit, les stratégies commerciales et autres sujets similaires.
- L’exécution rapide de modèles définis, configurés par les analystes, pour la tarification, les évaluations et les risques de marché. Les évaluations utilisent une combinaison de code personnalisé, de processus de modélisation des risques dédié et d’outils d’analyse des risques de marché. L’analyse est exécutée par lot avec des fréquences de calcul variables (quotidienne, hebdomadaire, mensuelle, trimestrielle et annuelle). Cette analyse génère des pics dans les charges de travail.
- L’intégration des données avec d’autres mesures de risque à l’échelle de l’entreprise pour créer des rapports consolidés sur les risques. Dans les organisations de plus grande taille, les estimations de risques de niveau inférieur peuvent être transférées vers un outil de création de rapports et de modélisation des risques d’entreprise.
- Les résultats générés dans un format défini et selon la fréquence requise pour répondre aux exigences réglementaires et à celles des investisseurs.
Microsoft vous aide à répondre à ces besoins en fournissant une combinaison de services Azure et d’offres partenaires disponibles via la Place de marché Azure. Cet article présente des exemples pratiques qui montrent comment faire une expérimentation ad hoc du langage R. Nous commencerons par expliquer comme lancer l’expérience sur une seule machine. Ensuite, nous vous montrerons comment faire la même expérimentation sur Azure Batch. Enfin, nous terminerons en vous expliquant comment tirer parti des services externes pour la modélisation. Les options et considérations pour l’exécution des modèles définis dans Azure sont décrites dans ces articles qui sont consacrés aux secteurs de la banque et des assurances.
Modélisation d’analyste dans R
Commençons par découvrir comment R peut être utilisé par un analyste dans un scénario simplifié et représentatif de marchés financiers. Vous pouvez reproduire ce scénario en faisant référence à une bibliothèque R existante pour le calcul ou en écrivant du code à partir de zéro. Dans notre exemple, nous devons également extraire des données de tarification externes. Pour que l’exemple reste simple mais efficace, nous calculons le risque futur potentiel d’un contrat d’actions à terme. Cet exemple évite les techniques de modélisation quantitative complexes pour des instruments tels que des dérivés complexes et tient compte d’un seul facteur de risque afin de se concentrer sur le cycle de vie des risques. Notre exemple vous permet d’effectuer les opérations suivantes :
- Sélection d’un instrument financier.
- Collecte de l’historique des prix de l’instrument.
- Modélisation de l’évolution des prix des actions par simple calcul Monte-Carlo (MC), qui utilise le processus GBM (mouvement brownien géométrique) :
- Estimation du rendement attendu μ (mu) et de la volatilité σ (thêta).
- Étalonnage du modèle en fonction des données historiques.
- Visualisation des chemins de communication des résultats.
- Traçage des valeurs max (0, valeur en bourse) pour illustrer la signification du risque futur potentiel, la différence avec la valeur à risque (VaR). Quelques précisions :
PFE = Share Price (T) -- Forward Contract Price K - Sélection du quantile 0,95 pour obtenir la valeur de risque futur potentiel à chaque intervalle/fin de période de simulation.
Nous calculerons le risque futur potentiel (PFE) pour une action à terme basée sur l’action Microsoft (MSFT). Comme mentionné ci-dessus, pour modéliser les prix des actions, nous avons besoin de l’historique du cours de l’action MSFT pour ajuster le modèle en fonction des données historiques. Il existe de nombreuses façons d’acquérir l’historique du cours d’une action. Dans notre exemple, nous utilisons une version gratuite d’un service de cotation en bourse d’un fournisseur externe, Quandl.
Notes
l’exemple utilise le jeu de données WIKI Prices qui peut être utilisé à des fins de formation. Pour une utilisation en production pour des actions américaines, Quandl recommande d’utiliser le jeu de données End of Day US Stock Prices.
Pour traiter les données et définir les risques liés à l’action, nous devons effectuer les opérations suivantes :
- Récupérer les données historiques de l’action.
- Calculer le rendement attendu μ et la volatilité σ à partir des données historiques.
- Modéliser le cours sous-jacent de l’action en effectuant une simulation.
- Exécuter le modèle.
- Déterminer le risque futur de l’action.
Nous commençons par récupérer l’action auprès du service Quandl et tracer son historique de prix au cours des 180 derniers jours.
# Lubridate package must be installed
if (!require(lubridate)) install.packages('lubridate')
library(lubridate)
# Quandl package must be installed
if (!require(Quandl)) install.packages('Quandl')
library(Quandl)
# Get your API key from quandl.com
quandl_api = "enter your key here"
# Add the key to the Quandl keychain
Quandl.api_key(quandl_api)
quandl_get <-
function(sym, start_date = "2018-01-01") {
require(devtools)
require(Quandl)
# Retrieve the Open, High, Low, Close and Volume Column for a given Symbol
# Column Indices can be deduced from this sample call
# data <- Quandl(c("WIKI/MSFT"), rows = 1)
tryCatch(Quandl(c(
paste0("WIKI/", sym, ".8"), # Column 8 : Open
paste0("WIKI/", sym, ".9"), # Column 9 : High
paste0("WIKI/", sym, ".10"), # Column 10: Low
paste0("WIKI/", sym, ".11"), # Column 11: Close
paste0("WIKI/", sym, ".12")), # Column 12: Volume
start_date = start_date,
type = "raw"
))
}
# Define the Equity Forward
instrument.name <- "MSFT"
instrument.premium <- 100.1
instrument.pfeQuantile <- 0.95
# Get the stock price for the last 180 days
instrument.startDate <- today() - days(180)
# Get the quotes for an equity and transform them to a data frame
df_instrument.timeSeries <- quandl_get(instrument.name,start_date = instrument.startDate)
#Rename the columns
colnames(df_instrument.timeSeries) <- c()
colnames(df_instrument.timeSeries) <- c("Date","Open","High","Low","Close","Volume")
# Plot the closing price history to get a better feel for the data
plot(df_instrument.timeSeries$Date, df_instrument.timeSeries$Close)
À partir de ces données, nous étalonnons le modèle GBM.
# Code inspired by the book Computational Finance, An Introductory Course with R by
# A. Arratia.
# Calculate the daily return in order to estimate sigma and mu in the Wiener Process
df_instrument.dailyReturns <- c(diff(log(df_instrument.timeSeries$Close)), NA)
# Estimate the mean of std deviation of the log returns to estimate the parameters of the Wiener Process
estimateGBM_Parameters <- function(logReturns,dt = 1/252) {
# Volatility
sigma_hat = sqrt(var(logReturns)) / sqrt(dt)
# Drift
mu_hat = mean(logReturns) / dt + sigma_hat**2 / 2.0
# Return the parameters
parameter.list <- list("mu" = mu_hat,"sigma" = sigma_hat)
return(parameter.list)
}
# Calibrate the model to historic data
GBM_Parameters <- estimateGBM_Parameters(df_instrument.dailyReturns[1:length(df_instrument.dailyReturns) - 1])
Ensuite, nous modélisons le cours sous-jacent de l’action. Nous pouvons implémenter le processus GBM à partir de zéro ou utiliser l’un des nombreux packages R qui offrent cette fonctionnalité. Nous utilisons le package R sde (Simulation and Inference for Stochastic Differential Equations). La méthode GBM nécessite un ensemble de paramètres qui sont calibrés selon les données historiques ou fournis en tant que paramètres de simulation. Nous utilisons les données historiques, en indiquant les valeurs μ, σ et du cours de l’action au début de la simulation (P0).
if (!require(sde)) install.packages('sde')
library(sde)
sigma <- GBM_Parameters$sigma
mu <- GBM_Parameters$mu
P0 <- tail(df_instrument.timeSeries$Close, 1)
# Calculate the PFE looking one month into the future
T <- 1 / 12
# Consider nt MC paths
nt=50
# Divide the time interval T into n discrete time steps
n = 2 ^ 8
dt <- T / n
t <- seq(0,T,by=dt)
Nous pouvons maintenant lancer une simulation Monte-Carlo pour modéliser le risque potentiel pour un certain nombre de tracés de simulation. Nous limiterons la simulation à 50 tracés Monte-Carlo et 256 intervalles. En vue d’une montée en charge de la simulation et d’un processus de parallélisation dans R, la boucle de simulation Monte-Carlo utilise une instruction foreach.
# Track the start time of the simulation
start_s <- Sys.time()
# Instead of a simple for loop to execute a simulation per MC path, call the
# simulation with the foreach package
# in order to demonstrate the similarity to the AzureBatch way to call the method.
library(foreach)
# Execute the MC simulation for the wiener process by using the GBM method from the sde package
exposure_mc <- foreach (i=1:nt, .combine = rbind ) %do% GBM(x = P0, r = mu, sigma = sigma, T = T, N = n)
rownames(exposure_mc) <- c()
# Track the end time of the simulation
end_s <- Sys.time()
# Duration of the simulation
difftime(end_s, start_s)
Nous avons maintenant simulé le prix de l’action MSFT sous-jacent. Pour calculer l’exposition de l’action à terme, nous déduisons la prime et limitons le risque uniquement aux valeurs positives.
# Calculate the total Exposure as V_i(t) - K, put it to zero for negative exposures
pfe_mc <- pmax(exposure_mc - instrument.premium ,0)
ymax <- max(pfe_mc)
ymin <- min(pfe_mc)
plot(t, pfe_mc[1,], t = 'l', ylim = c(ymin, ymax), col = 1, ylab="Credit Exposure in USD", xlab="time t in Years")
for (i in 2:nt) {
lines(t, pfe_mc[i,], t = 'l', ylim = c(ymin, ymax), col = i)
}
Les deux images suivantes montrent le résultat de la simulation. La première image montre la simulation Monte-Carlo du cours de l’action sous-jacent pour 50 tracés. La deuxième image illustre le risque de crédit sous-jacent pour l’action à terme après soustraction de la prime de l’action à terme et en limitant le risque aux valeurs positives.
Figure 1 – 50 tracés Monte-Carlo
Figure 2 – Risque de crédit pour l’action à terme
Dans la dernière étape, le risque futur potentiel du quantile 0,95 à 1 mois est calculé à l’aide du code suivant.
# Calculate the PFE at each time step
df_pfe <- cbind(t,apply(pfe_mc,2,quantile,probs = instrument.pfeQuantile ))
resulting in the final PFE plot
plot(df_pfe, t = 'l', ylab = "Potential future exposure in USD", xlab = "time t in Years")
Figure 3 – Risque futur potentiel pour l’action à terme MSFT
Utilisation d’Azure Batch avec R
La solution R décrite ci-dessus peut être connectée à Azure Batch et tirer parti du cloud pour les opérations de calculs des risques. Cela nécessite quelques étapes supplémentaires pour un calcul parallèle tel que celui de notre exemple. Le didacticiel Exécuter une simulation de R parallèle avec Azure Batch fournit des informations détaillées pour connecter R à Azure Batch. Nous vous montrons ci-dessous le code et le résumé du processus de connexion à Azure Batch, et vous expliquons comment tirer parti de l’extension vers le cloud dans une opération de calcul du risque futur potentiel simplifié.
Cet exemple utilise le même modèle que celui décrit précédemment. Comme nous l’avons vu précédemment, ce calcul peut être exécuté sur un ordinateur personnel. L’augmentation du nombre de tracés Monte-Carlo ou l’utilisation d’intervalles plus courts allongera les délais d’exécution. La quasi totalité du code R restera inchangé. Les différences seront décrites dans cette section.
Chaque tracé de la simulation Monte-Carlo s’exécute dans Azure. Cela est rendu possible par le fait que chaque tracé est indépendant des autres, ce qui nous donne un calcul pouvant être facilement parallélisé.
Pour utiliser Azure Batch, nous définissons le cluster sous-jacent et le référençons dans le code pour qu’il puisse être utilisé dans les calculs. Pour exécuter les calculs, nous utilisons la définition cluster.json suivante :
{
"name": "myMCPool",
"vmSize": "Standard_D2_v2",
"maxTasksPerNode": 4,
"poolSize": {
"dedicatedNodes": {
"min": 1,
"max": 1
},
"lowPriorityNodes": {
"min": 3,
"max": 3
},
"autoscaleFormula": "QUEUE"
},
"containerImage": "rocker/tidyverse:latest",
"rPackages": {
"cran": [],
"github": [],
"bioconductor": []
},
"commandLine": [],
"subnetId": ""
}
Avec cette définition de cluster, le code R suivant peut désormais utiliser le cluster :
# Define the cloud burst environment
library(doAzureParallel)
# set your credentials
setCredentials("credentials.json")
# Create your cluster if not exist
cluster <- makeCluster("cluster.json")
# register your parallel backend
registerDoAzureParallel(cluster)
# check that your workers are up
getDoParWorkers()
Enfin, nous mettons à jour l’instruction foreach définie précédemment afin d’utiliser le package doAzureParallel. Il s’agit d’une modification mineure qui ajoute une référence au package sde et modifie l’instruction %do% en %dopar% :
# Execute the MC simulation for the wiener process using the GBM method from the sde package and extend the computation to the cloud
exposure_mc <- foreach(i = 1:nt, .combine = rbind, .packages = 'sde') %dopar% GBM(x = P0, r = mu, sigma = sigma, T = T, N = n)
rownames(exposure_mc) <- c()
Chaque simulation Monte-Carlo est soumise en tant que tâche dans Azure Batch. La tâche s’exécute dans le cloud. Les résultats sont fusionnés avant d’être renvoyés sur le poste de travail de l’analyste. Les opérations et calculs les plus complexes s’exécutent dans le cloud pour tirer pleinement parti des capacités de mise à l’échelle et de l’infrastructure sous-jacente requise par les calculs à effectuer.
Une fois les calculs terminés, les ressources supplémentaires peuvent facilement être désactivées en exécutant l’instruction suivante :
# Stop the cloud cluster
stopCluster(cluster)
Utiliser une solution SaaS
Les deux premiers exemples montrent comment utiliser une infrastructure locale et une infrastructure cloud pour développer un modèle d’évaluation adapté. Nous assistons toutefois à un changement de paradigme. De la même façon que l’infrastructure locale a été remplacée par des services IaaS et PaaS basés dans le cloud, la modélisation des chiffres des risques pertinents devient progressivement un processus orienté services. Aujourd’hui, les analystes sont confrontés à deux défis majeurs :
- La réglementation impose d’utiliser toujours plus de capacité de calcul pour les opérations de modélisation. Les organismes de réglementation demandent aux entreprises de calculer leurs risques de manière plus fréquente.
- Si l’infrastructure de risque existante s’est développée au fil du temps, elle ne permet pas toujours de respecter les nouvelles exigences et de procéder à une modélisation plus avancée et plus flexible des risques.
Les services basés dans le cloud peuvent répondre à ces problématiques d’analyse des risques. Cette approche offre plusieurs avantages :
- Les calculs de risques les plus couramment requis par les organismes de réglementation doivent être mis en œuvre par toutes les entités soumises à ladite réglementation. En utilisant les services d’un fournisseur de services spécialisés, l’analyste bénéficie de solutions de calcul des risques prêtes à l’emploi et conformes à la réglementation. Ces services peuvent inclure des calculs de risques de marché, des calculs de risque de tiers, l’ajustement de valeur X (XVA), ainsi que des calculs de révision complète du portefeuille de transaction (FRTB).
- Ces services exposent leurs interfaces via des services web. L’infrastructure de risque existante peut être optimisée à l’aide de ces services complémentaires.
Dans notre exemple, nous voulons appeler un service cloud de calcul FRTB. Plusieurs solutions sont disponibles dans AppSource. Pour cet article, nous avons choisi une version d’évaluation proposée par Vector Risk. Nous allons continuer à modifier notre système. Cette fois-ci, nous utilisons un service pour calculer le risque d’intérêt. Le processus se déroule comme suit :
- Appel du service de risque pertinent avec les paramètres appropriés.
- Observation d’un temps d’attente jusqu’à finalisation du calcul.
- Récupération et intégration des résultats à l’analyse des risques.
Converti en code R, notre code R peut être amélioré par la définition des valeurs d’entrée requises à partir d’un modèle d’entrée prédéfini.
Template <- readLines('RequiredInputData.json')
data <- list(
# drilldown setup
timeSteps = seq(0, n, by = 1),
paths = as.integer(seq(0, nt, length.out = min(nt, 100))),
# calc setup
calcDate = instrument.startDate,
npaths = nt,
price = P0,
vol = sigma,
drift = mu,
premium = instrument.premium,
maturityDate = today()
)
body <- whisker.render(template, data)
Nous devons ensuite appeler le service web. Dans ce cas, nous appelons la méthode StartCreditExposure pour déclencher le calcul. Nous enregistrons le point de terminaison pour l’API dans une variable nommée point de terminaison.
# make the call
result <- POST( paste(endpoint, "StartCreditExposure", sep = ""),
authenticate(username, password, type = "basic"),
content_type("application/json"),
add_headers(`Ocp-Apim-Subscription-Key` = api_key),
body = body, encode = "raw"
)
result <- content(result)
Une fois les calculs terminés, nous récupérons les résultats.
# get back high level results
result <- POST( paste(endpoint, "GetCreditExposureResults", sep = ""),
authenticate(username, password, type = "basic"),
content_type("application/json"),
add_headers(`Ocp-Apim-Subscription-Key` = api_key),
body = sprintf('{"getCreditExposureResults": {"token":"DataSource=Production;Organisation=Microsoft", "ticket": "%s"}}', ticket), encode = "raw")
result <- content(result)
L’analyste peut utiliser les résultats obtenus pour la suite de la procédure. Les chiffres de risques d’intérêt pertinents sont extraits à partir des résultats et représentés sous forme de tracés.
if (!is.null(result$error)) {
cat(result$error$message)
} else {
# plot PFE
result <- result$getCreditExposureResultsResponse$getCreditExposureResultsResult
df <- do.call(rbind, result$exposures)
df <- as.data.frame(df)
df <- subset(df, term <= n)
}
plot(as.numeric(df$term[df$statistic == 'PFE']) / 365, df$result[df$statistic == 'PFE'], type = "p", xlab = ("time t in Years"), ylab = ("Potential future exposure in USD"), ylim = range(c(df$result[df$statistic == 'PFE'], df$result[df$statistic == 'PFE'])), col = "red")
Les tracés obtenus ressemblent à ce qui suit :
Figure 4 – Risque de crédit pour les actions à terme MSFT, calculé à l’aide d’un moteur de risque informatique
Figure 5 – Risque potentiel futur pour les actions à terme MSFT, calculé à l’aide d’un moteur de risque informatique
Considérations
L’accès flexible au cloud via l’infrastructure de calcul et les services SaaS d’analyse des risques améliorent la productivité et l’agilité des analystes de risques travaillant dans les secteurs des marchés financiers et des assurances. Dans cet article, nous avons utilisé un exemple pour expliquer comment utiliser Azure et d’autres services en complément d’outils déjà connus des analystes. N’hésitez pas à faire appel aux fonctionnalités d’Azure pour créer et optimiser vos modèles de calcul des risques.
Contributeurs
Cet article est géré par Microsoft. Il a été écrit à l’origine par les contributeurs suivants.
Principaux auteurs :
- Dr. Darko Mocelj | HPC Global Blackbelt & AI Sr. Technology Specialist
- Rupert Nicolay | Chargé des solutions du secteur des services financiers
Étapes suivantes
- Développeurs R : Exécuter une simulation de R parallèle avec Azure Batch
- Commandes R de base et fonctions RevoScaleR : 25 exemples courants
- Visualiser et analyser des données à l’aide de RevoScaleR
- Présentation de services ML et des fonctionnalités R open source sur HDInsight
Ressources associées
Commentaires
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez https://aka.ms/ContentUserFeedback.
Envoyer et afficher des commentaires pour