Abilitare il ciclo di vita dei rischi per i servizi finanziari con Azure e R
I calcoli dei rischi sono fondamentali in varie fasi del ciclo di vita delle operazioni principali dei servizi finanziari. Ad esempio, un modulo semplificato del ciclo di vita di gestione del prodotto di assicurazione potrebbe essere simile al diagramma seguente. Gli aspetti di calcolo del rischio vengono visualizzati nel testo in blu.
Uno scenario in un'azienda del mercato dei capitali potrebbe essere simile al seguente:
Nei processi come questi, esistono esigenze comuni di modellazione dei rischi, tra cui:
- La necessità di sperimentazione ad hoc correlata ai rischi da parte di analisti del rischio, ad esempio i attuari di una società assicurativa o quanti in una società di mercati di capitali. Questi analisti riguardano in genere gli strumenti di codice e modellazione più diffusi nel proprio dominio: R e Python. Molti programmi universitari includono corsi di formazione in R o Python nei corsi matematici finanziari e MBA. Entrambi i linguaggi hanno accesso a un'ampia gamma di librerie open source che supportano calcoli di rischio comuni.
- Oltre agli strumenti appropriati, gli analisti spesso richiedono l'accesso a:
- Dati accurati sui prezzi di mercato.
- Dati relativi a criteri e attestazioni.
- Dati sulla posizione del mercato.
- Altri dati esterni, ad esempio:
- Dati strutturati, ad esempio tabelle di mortalità e dati sui prezzi competitivi.
- Tipi meno tradizionali, ad esempio meteo e notizie.
- Capacità di calcolo per indagini rapide interattive dei dati.
- In alcuni casi, algoritmi di Machine Learning ad hoc per prezzi o determinazione della strategia di mercato.
- Possibilità di visualizzare e presentare i dati da usare nella pianificazione del prodotto, nella strategia di trading e in discussioni simili.
- L'esecuzione rapida dei modelli definiti, configurati dagli analisti per prezzi, valutazioni e rischi di mercato. Le valutazioni usano una combinazione di modelli di rischio dedicati, strumenti di rischio di mercato e codice personalizzato. L'analisi viene eseguita in un batch con calcoli notturni, settimanali, mensili, trimestrali e annuali diversi. Questa analisi genera picchi nei carichi di lavoro.
- Integrazione dei dati con altre misure di rischio a livello aziendale per la creazione di report dei rischi consolidati. Nelle organizzazioni di grandi dimensioni, le stime dei rischi di livello inferiore possono essere trasferite a uno strumento per la modellazione e la creazione di report dei rischi aziendali.
- Risultati segnalati in un formato definito nei tempi necessari per soddisfare i requisiti normativi e degli investitori.
Microsoft consente di soddisfare queste esigenze tramite una combinazione di servizi di Azure e offerte di partner in Azure Marketplace. In questo articolo sono disponibili esempi pratici che illustrano come eseguire esperimenti ad hoc usando R. Iniziamo spiegando come eseguire l'esperimento in un singolo computer. Verrà quindi illustrato come eseguire lo stesso esperimento in Azure Batch e verrà illustrato come sfruttare i servizi esterni per la modellazione. Le opzioni e le considerazioni per l'esecuzione di modelli definiti in Azure sono descritte in questi articoli incentrati sul settore bancario e assicurativo.
Modellazione analista in R
Iniziamo esaminando come R può essere usata da un analista in uno scenario semplificato e rappresentativo dei mercati finanziari. È possibile compilare questo facendo riferimento a una libreria R esistente per il calcolo o scrivendo del codice da zero. In questo esempio è necessario recuperare anche i dati dei prezzi esterni. Per mantenere l'esempio semplice ma illustrativo, calcoliamo la potenziale esposizione futura (PFE) di un contratto a termine del capitale sociale. Questo esempio evita tecniche di modellazione quantitative complesse per strumenti come derivati complessi e si concentra su un singolo fattore di rischio per concentrarsi sul ciclo di vita dei rischi. L'esempio consente di eseguire le operazioni seguenti:
- Selezionare uno strumento di interesse.
- Prezzi cronologici di origine per lo strumento.
- Azione del prezzo azionario del modello usando un semplice calcolo monte carlo (MC), che usa il movimento browniano geometrico (GBM):
- Stimare μ (mu) restituito previsto (mu) e la volatilità σ (theta).
- Calibrare il modello sui dati cronologici.
- Visualizzare i percorsi diversi per comunicare i risultati.
- Tracciare max(0,Stock Value) per illustrare il significato di PFE, la differenza con il valore a rischio (VaR). Per chiarire:
PFE = Share Price (T) -- Forward Contract Price K - Prendere il quantile 0,95 per ottenere il valore PFE in ogni passaggio/fine del periodo di simulazione.
Il PFE verrà calcolato per un capitale azionario in base alle azioni Microsoft (MSFT). Come accennato in precedenza, per modellare i prezzi azionari, sono necessari prezzi cronologici per le azioni MSFT, in modo da poter calibrare il modello in dati cronologici. Esistono diversi modi per acquisire i prezzi cronologici delle azioni. In questo esempio, viene usata una versione gratuita di un servizio di prezzi delle azioni da un provider di servizi esterni Quandl.
Nota
l'esempio usa il set di dati dei prezzi di WIKI che può essere usato per apprendere i concetti. Per l'utilizzo della produzione di capitali basati su US, Quandl consiglia di usare il set di dati dei prezzi delle azioni US alla fine della giornata.
Per elaborare i dati e definire i rischi associati al capitale, è necessario eseguire le operazioni seguenti:
- Recuperare i dati della cronologia dal capitale.
- Determinare μ restituito previsto e la volatilità σ dai dati cronologici.
- Modellare i prezzi delle azioni sottostanti usando alcune simulazioni.
- Esegui il modello.
- Determinare l'esposizione del capitale in futuro.
Si inizia recuperando le azioni dal servizio Quandl e tracciando la cronologia dei prezzi di chiusura negli ultimi 180 giorni.
# 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)
Con i dati a disposizione, si calibra il modello 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])
Successivamente, si modellano i prezzi delle azioni sottostanti. È possibile implementare il processo GBM discreto da zero o usare uno dei numerosi pacchetti R che forniscono questa funzionalità. Viene usato il pacchetto R sde (simulazione e inferenza per equazioni differenziali stocastiche) che fornisce un metodo per risolvere questo problema. Il metodo GBM richiede un set di parametri che vengono calibrati ai dati cronologici o forniti come parametri di simulazione. Vengono usati i dati cronologici, fornendo μ, σ e i prezzi delle azioni all'inizio della simulazione (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)
A questo punto è possibile avviare una simulazione Monte Carlo per modellare la potenziale esposizione per alcuni percorsi di simulazione. La simulazione verrà limitata a 50 percorsi Monte Carlo e 256 passaggi temporali. Nel preparare la scalabilità orizzontale della simulazione e nel trarre vantaggio dalla parallelizzazione in R, il ciclo di simulazione di Monte Carlo usa un'istruzione 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)
A questo punto è stato simulato il prezzo del titolo MSFT sottostante. Per calcolare l'esposizione del capitale a termine, si sottrae il piano premium e si limita l'esposizione ai soli valori positivi.
# 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)
}
Le due immagini successive mostrano il risultato della simulazione. La prima immagine mostra la simulazione di Monte Carlo del prezzo dell'azione sottostante per 50 percorsi. Il secondo quadro illustra l'esposizione del credito sottostante per il capitale netto dopo aver sottratto il premio del capitale netto in avanti e limitando l'esposizione a valori positivi.
Figura 1 - 50 percorsi di Monte Carlo
Figura 2 - Esposizione del credito per l'avanzamento azionario
Nell'ultimo passaggio, il valore PFE quantile di 0,95 mesi viene calcolato dal codice seguente.
# 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")
Figura 3 Potenziale esposizione futura per il capitale azionario MSFT
Uso di Azure Batch con R
La soluzione R descritta in precedenza può essere connessa ad Azure Batch e sfruttare il cloud per i calcoli del rischio. Ciò richiede qualche sforzo in più per un calcolo parallelo, come ad esempio il nostro. L'esercitazione Eseguire una simulazione R in parallelo con Azure Batch fornisce informazioni dettagliate sulla connessione di R per Azure Batch. Di seguito viene mostrato il codice e il riepilogo del processo per connettersi a Azure Batch e come sfruttare i vantaggi dell'estensione nel cloud in un calcolo PFE semplificato.
In questo esempio si affronta lo stesso modello descritto in precedenza. Come abbiamo visto in precedenza, questo calcolo può essere eseguito sul nostro personal computer. Gli aumenti del numero di percorsi di Monte Carlo o l'utilizzo di intervalli temporali più piccoli comporteranno tempi di esecuzione molto più lunghi. Quasi tutto il codice R rimarrà invariato. In questa sezione verranno evidenziate le differenze.
Ogni percorso della simulazione di Monte Carlo viene eseguito in Azure. È possibile farlo perché ogni percorso è indipendente dagli altri, fornendo un calcolo facilmente parallelizzato.
Per usare Azure Batch, viene definito il cluster sottostante e vi si fa riferimento nel codice prima che il cluster possa essere usato nei calcoli. Per eseguire i calcoli, si utilizza la seguente definizione cluster.json:
{
"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": ""
}
Con questa definizione del cluster, il codice R seguente usa il 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()
Infine, viene aggiornata l'istruzione foreach rispetto a quella precedente per usare il pacchetto doAzureParallel. È una piccola modifica, con l'aggiunta di un riferimento al pacchetto sde e la modifica di %do% to %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()
Ogni simulazione di Monte Carlo viene inviata come un'attività ad Azure Batch. L'attività viene eseguita nel cloud. I risultati vengono uniti prima di essere inviati a workbench analista. Il sollevamento e i calcoli pesanti vengono eseguiti nel cloud per trarre vantaggio al meglio dalla scalabilità e dall'infrastruttura sottostante necessaria per i calcoli richiesti.
Dopo aver completato i calcoli, le risorse aggiuntive possono facilmente essere arrestate richiamando la seguente istruzione singola:
# Stop the cloud cluster
stopCluster(cluster)
Usare un'offerta SaaS
I primi due esempi illustrano come usare l'infrastruttura locale e cloud per sviluppare un modello di valutazione adeguato. Questo paradigma ha iniziato a spostarsi. Allo stesso modo in cui l'infrastruttura locale è stata trasformata in servizi IaaS e PaaS basati sul cloud, la modellazione dei dati di rischio pertinenti sta trasformando in un processo orientato ai servizi. Gli analisti di oggi devono affrontare due problematiche principali:
- I requisiti normativi usano una capacità di calcolo aumentata da aggiungere alla modellazione dei requisiti. I regolatori chiedono figure di rischio più frequenti e aggiornate.
- L'infrastruttura del rischio esistente è aumentata in modo organico con il tempo e consente di creare problematiche quando si implementano i nuovi requisiti e i rischi più avanzati di modellazione in modo agile.
I servizi basati su cloud possono fornire le funzionalità necessarie e supportare le analisi dei rischi. Questo approccio presenta alcuni vantaggi:
- I calcoli di rischio più comuni richiesti dal regolatore devono essere implementati da tutti gli utenti con le normative. Usando i servizi di un provider di servizi specializzato, l'analista trae vantaggio da calcoli di rischio conformi alle autorità di regolamentazione pronti all'uso. Tali servizi possono includere calcoli dei rischi di mercato, calcoli di rischio controparte, rettifica X-Value (XVA) e persino revisioni fondamentali del libro di trading (FRTB).
- Questi servizi espongono le relative interfacce tramite i servizi web. L'infrastruttura del rischio esistente può essere migliorata con questi altri servizi.
In questo esempio, si desidera richiamare un servizio basato sul cloud per i calcoli di FRTB. Alcuni di questi possono essere trovati in AppSource. Per questo articolo è stata scelta un'opzione della versione di valutazione dal Vettore di rischio. Continueremo a modificare il sistema. Questa volta si usa un servizio per calcolare la figura di rischio di interesse. Questo processo comprende i passaggi seguenti:
- Chiamare il servizio di rischio pertinente con i parametri corretti.
- Attendere che il servizio termini il calcolo.
- Recuperare e incorporare i risultati nelle analisi dei rischi.
Convertito in codice R, il nostro codice R può essere migliorato dalla definizione dei valori di input richiesti da un modello di input preparato.
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)
Successivamente, è necessario chiamare il servizio web. In questo caso, si chiama il metodo StartCreditExposure per attivare il calcolo. L'endpoint viene archiviato per l'API in una variabile denominata endpoint.
# 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)
Dopo aver completato i calcoli, si recuperano i risultati.
# 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)
Ciò consente all'analista di continuare con i risultati ricevuti. Le figure di rischio pertinenti di interesse vengono estratte dai risultati e tracciate.
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")
I tracciati risultanti sono simili a quello seguente:
Figura 4 - Esposizione del credito per l'inoltro azionario MSFT - Calcolato con un motore di rischio basato sul cloud
Figura 5 - Potenziale esposizione futura per il capitale azionario MSFT - Calcolato con un motore di rischio basato sul cloud
Considerazioni
L'accesso flessibile al cloud tramite un'infrastruttura di calcolo e i servizi di analisi del rischio basati su SaaS possono offrire miglioramenti nella velocità e nella flessibilità per gli analisti del rischio utilizzando il settore assicurativo e i mercati finanziari. In questo articolo è stato esaminato un esempio che illustra come usare Azure e altri servizi usando il rischio degli strumenti conosciuti dagli analisti. Provare a trarre vantaggio dalle funzionalità di Azure durante la creazione e il miglioramento dei modelli di rischio.
Collaboratori
Questo articolo viene gestito da Microsoft. Originariamente è stato scritto dai seguenti contributori.
Autori principali:
- Dr. Darko Mocelj | HPC Global Blackbelt & AI Sr. Technology Specialist
- Rupert Nicolay | Responsabile soluzioni del settore dei servizi finanziari
Passaggi successivi
- Sviluppatori R: Eseguire una simulazione R parallela con Azure Batch
- I comandi R di base e le funzioni RevoScaleR: 25 esempi comuni
- Visualizzare e analizzare i dati con RevoScaleR
- Introduzione ai servizi ml e alle funzionalità R open source in HDInsight
Risorse correlate
Commenti e suggerimenti
Presto disponibile: Nel corso del 2024 verranno gradualmente disattivati i problemi di GitHub come meccanismo di feedback per il contenuto e ciò verrà sostituito con un nuovo sistema di feedback. Per altre informazioni, vedere https://aka.ms/ContentUserFeedback.
Invia e visualizza il feedback per