De levenscyclus van financiële servicesrisico's inschakelen met Azure en R

Risicoberekeningen zijn centraal in verschillende fasen in de levenscyclus van belangrijke financiële dienstverleningsbewerkingen. Een vereenvoudigde vorm van de levenscyclus van het verzekeringsproductbeheer kan er bijvoorbeeld uitzien als in het onderstaande diagram. De risicoberekeningsaspecten worden in blauwe tekst weergegeven.

Een scenario in een kapitaalmarktbedrijf kan er als volgt uitzien:

In processen zoals deze zijn er veelvoorkomende risicomodelleringsbehoeften, waaronder:

• De noodzaak van ad-hoc risicogerelateerde experimenten door risicoanalisten, zoals actuarissen in een verzekeringsonderneming of kwanties in een kapitaalmarktbedrijf. Deze analisten werken doorgaans met hulpprogramma's voor code en modellering die populair zijn in hun domein: R en Python. Veel universiteitscurriculums omvatten trainingen in R of Python in wiskundige financiële en MBA-cursussen. Beide talen hebben toegang tot een breed scala aan opensource-bibliotheken die populaire risicoberekeningen ondersteunen.
• Naast de juiste hulpprogramma's hebben analisten vaak toegang nodig tot:
  • Nauwkeurige marktprijsgegevens.
  • Beleid- en claimgegevens.
  • Marktpositiegegevens.
  • Andere externe gegevens, zoals:
    • Gestructureerde gegevens, zoals sterfelijkheidstabellen en concurrerende prijsgegevens.
    • Minder traditionele soorten zoals weer en nieuws.
  • Rekencapaciteit voor snelle interactieve gegevensonderzoeken.
• In sommige gevallen ad-hoc machine learning-algoritmen voor prijzen of het bepalen van de marktstrategie.
• De mogelijkheid om gegevens te visualiseren en te presenteren voor gebruik in productplanning, handelsstrategie en vergelijkbare discussies.
• De snelle uitvoering van gedefinieerde modellen, geconfigureerd door de analisten voor prijzen, waarderingen en marktrisico's. De waarderingen maken gebruik van een combinatie van toegewezen risicomodellering, marktrisicotools en aangepaste code. De analyse wordt uitgevoerd in een batch met verschillende nacht-, wekelijkse, maandelijkse, kwartaal- en jaarlijkse berekeningen. Met deze analyse worden pieken in workloads gegenereerd.
• De integratie van gegevens met andere risicomaatregelen voor de hele onderneming voor geconsolideerde risicorapportage. In grotere organisaties kunnen risicoramingen op lager niveau worden overgedragen naar een hulpprogramma voor het modelleren en rapporteren van bedrijfsrisico's.
• Resultaten die zijn gerapporteerd in een gedefinieerde indeling op de vereiste momenten om te voldoen aan de vereisten voor investeerders en regelgeving.

Microsoft helpt om aan deze behoeften te voldoen via een combinatie van Azure-services en partneraanbiedingen in Azure Marketplace. In dit artikel zijn er praktische voorbeelden die laten zien hoe u ad-hoc experimenten kunt uitvoeren met behulp van R. We beginnen met het uitleggen hoe u het experiment uitvoert op één computer. Vervolgens laten we u zien hoe u hetzelfde experiment uitvoert in Azure Batch, en we laten u in de buurt zien hoe u kunt profiteren van externe services voor de modellering. De opties en overwegingen voor de uitvoering van gedefinieerde modellen in Azure worden beschreven in deze artikelen die zich richten op banken en verzekeringen.

Analistmodellering in R

Laten we beginnen met kijken hoe R kan worden gebruikt door een analist in een vereenvoudigd scenario met representatieve kapitaalmarkten. U kunt dit bouwen door te verwijzen naar een bestaande R-bibliotheek voor de berekening of door helemaal zelf code te schrijven. In ons voorbeeld moeten we ook externe prijsgegevens ophalen. Om het voorbeeld eenvoudig maar illustratief te houden, berekenen we de potentiële toekomstige blootstelling (PFE) van een aandelenaanstuurcontract. In dit voorbeeld worden complexe kwantitatieve modelleringstechnieken voor instrumenten zoals complexe derivaten vermeden en is gericht op één risicofactor om zich te concentreren op de levenscyclus van het risico. In ons voorbeeld kunt u het volgende doen:

• Selecteer een interessant instrument.
• Bron historische prijzen voor het instrument.
• Model equity price action by using simple Monte Carlo (MC) calculation, which using Geometric Brownian Motion (GBM):
  • Geschatte verwachte rentabiliteit μ (mu) en volatiliteit σ (theta).
  • Kalibreer het model naar historische gegevens.
• Visualiseer de verschillende paden om de resultaten te communiceren.
• Plot max(0,Aandelenwaarde) om de betekenis van PFE te demonstreren, het verschil in waarde in risico (VaR). Om het volgende te verduidelijken:

  PFE = Share Price (T) -- Forward Contract Price K

• Neem de 0,95 Kwantiel om de PFE-waarde op te halen bij elke stap/einde van de simulatieperiode.

We berekenen de PFE voor een aandelenaanstuur op basis van microsoft (MSFT). Zoals eerder vermeld, zijn historische prijzen voor de MSFT-aandelen vereist om het model te kalibreren naar historische gegevens. Er zijn veel manieren om historische aandelenkoersen te verkrijgen. In ons voorbeeld gebruiken we een gratis versie van een voorraadprijsservice van een externe serviceprovider, Quandl.

Notitie

In het voorbeeld wordt de gegevensset WIKI-prijzen gebruikt die kan worden gebruikt voor leerconcepten. Voor productiegebruik van amerikaanse aandelen wordt aanbevolen door Quandl om de gegevensset Aandelenprijzen van einddag te gebruiken.

Voor het verwerken van de gegevens en het definiëren van het risico dat aan het vermogen is gekoppeld, moeten we het volgende doen:

• Haal geschiedenisgegevens op uit het eigen vermogen.
• Bepaal het verwachte rendement μ en de volatiliteit σ uit de historische gegevens.
• Modelleer de onderliggende aandelenkoersen met behulp van een simulatie.
• Voer het model uit.
• Bepaal de blootstelling van het vermogen in de toekomst.

We beginnen met het ophalen van de voorraad van de Quandl-service en het plotten van de slotkoersgeschiedenis in de afgelopen 180 dagen.

# 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)

Met de gegevens in handen kalibreren we het GBM-model.

# 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])

Vervolgens modelleren we de onderliggende aandelenkoersen. We kunnen het discrete GBM-proces helemaal zelf implementeren of een van de vele R-pakketten gebruiken die deze functionaliteit bieden. We gebruiken de R-pakket-sde (simulatie en deductie voor Stochastische differentiële vergelijkingen) die een methode biedt om dit probleem op te lossen. De GBM-methode vereist een set parameters die zijn gekalibreerd naar historische gegevens of worden gegeven als simulatieparameters. We gebruiken de historische gegevens, met μ, σ en de aandelenkoersen aan het begin van de simulatie (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)

We zijn nu klaar om een Monte Carlo-simulatie te starten om de potentiële blootstelling voor een aantal simulatiepaden te modelleren. We beperken de simulatie tot 50 Monte Carlo-paden en 256 tijdstappen. Ter voorbereiding op het uitschalen van de simulatie en het profiteren van parallelle uitvoering in R, gebruikt de Monte Carlo-simulatielus een foreach-instructie.

# 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)

We hebben nu de prijs van het onderliggende MSFT-aandeel gesimuleerd. Om de blootstelling van de aandelen vooruit te berekenen, trekken we de premie af en beperken we de blootstelling tot alleen positieve waarden.

# 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)
}

In de volgende twee foto's ziet u het resultaat van de simulatie. In de eerste afbeelding ziet u de Monte Carlo-simulatie van de onderliggende aandelenkoers voor 50 paden. In de tweede afbeelding ziet u de onderliggende kredietblootstelling voor de aandelenvervroeging na het aftrekken van de premie van de aandelenaanstuur en het beperken van de blootstelling aan positieve waarden.

Afbeelding 1 - 50 Monte Carlo paden

Afbeelding 2- Kredietblootstelling voor aandelenvervroegde aandelen

In de laatste stap wordt de kwantiel PFE van 1 maand 0,95 berekend door de volgende code.

# 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")

Afbeelding 3 Potentiële toekomstige blootstelling voor MSFT equity forward

Azure Batch gebruiken met R

De hierboven beschreven R-oplossing kan worden verbonden met Azure Batch en gebruikmaken van de cloud voor risicoberekeningen. Dit kost weinig extra moeite voor een parallelle berekening, zoals die van ons. De zelfstudie, Een parallelle R-simulatie uitvoeren met Azure Batch, biedt gedetailleerde informatie over het verbinden van R met Azure Batch. Hieronder ziet u de code en samenvatting van het proces om verbinding te maken met Azure Batch en hoe u kunt profiteren van de uitbreiding naar de cloud in een vereenvoudigde PFE-berekening.

In dit voorbeeld wordt hetzelfde model behandeld dat eerder is beschreven. Zoals we eerder hebben gezien, kan deze berekening worden uitgevoerd op onze persoonlijke computer. Verhogingen van het aantal Monte Carlo-paden of het gebruik van kleinere tijdstappen leiden tot veel langere uitvoeringstijden. Bijna alle R-code blijft ongewijzigd. De verschillen in deze sectie worden gemarkeerd.

Elk pad van de Monte Carlo-simulatie wordt uitgevoerd in Azure. We kunnen dit doen omdat elk pad onafhankelijk is van de andere, waardoor we een berekening kunnen maken die eenvoudig kan worden geparallelliseerd.

Als u Azure Batch wilt gebruiken, definiëren we het onderliggende cluster en verwijzen we ernaar in de code voordat het cluster kan worden gebruikt in de berekeningen. Voor het uitvoeren van de berekeningen gebruiken we de volgende cluster.json definitie:

{
  "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": ""
}

Met deze clusterdefinitie maakt de volgende R-code gebruik van het 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()

Ten slotte werken we de foreach-instructie van eerder bij om het doAzureParallel-pakket te gebruiken. Het is een kleine wijziging, het toevoegen van een verwijzing naar het sde-pakket en het wijzigen van %do% in %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()

Elke Monte Carlo-simulatie wordt als een taak verzonden naar Azure Batch. De taak wordt uitgevoerd in de cloud. Resultaten worden samengevoegd voordat ze worden teruggestuurd naar de workbench van de analist. De zware werk- en berekeningen worden uitgevoerd in de cloud om optimaal te profiteren van schalen en de onderliggende infrastructuur die is vereist voor de aangevraagde berekeningen.

Nadat de berekeningen zijn voltooid, kunnen de extra resources eenvoudig worden afgesloten door de volgende instructie aan te roepen:

# Stop the cloud cluster
stopCluster(cluster)

Een SaaS-aanbieding gebruiken

In de eerste twee voorbeelden ziet u hoe u lokale en cloudinfrastructuur gebruikt om een adequaat waarderingsmodel te ontwikkelen. Dit paradigma is begonnen te verschuiven. Op dezelfde manier als de on-premises infrastructuur is getransformeerd in IaaS- en PaaS-services in de cloud, wordt het modelleren van relevante risicocijfers omgezet in een servicegericht proces. De analisten van vandaag staan voor twee belangrijke uitdagingen:

• De wettelijke vereisten maken gebruik van toenemende rekencapaciteit om toe te voegen aan modelleringsvereisten. De toezichthouders vragen om frequentere en actuelere risicocijfers.
• De bestaande risicoinfrastructuur is organisch gegroeid met tijd en creëert uitdagingen bij het implementeren van nieuwe vereisten en geavanceerdere risicomodellering op een flexibele manier.

Cloudservices kunnen de vereiste functionaliteit leveren en risicoanalyse ondersteunen. Deze aanpak heeft enkele voordelen:

• De meest voorkomende risicoberekeningen die door de regelgever zijn vereist, moeten door iedereen in het kader van de verordening worden uitgevoerd. Door gebruik te maken van services van een gespecialiseerde serviceprovider profiteert de analist van kant-en-klare risicoberekeningen die voldoen aan de regelgeving. Dergelijke diensten kunnen marktrisicoberekeningen, berekeningen van tegenhangersrisico's, X-Value Adjustment (XVA) en zelfs Fundamental Review of Trading Book (FRTB) caculations omvatten.
• Deze services maken hun interfaces beschikbaar via webservices. De bestaande risicoinfrastructuur kan worden verbeterd door deze andere services.

In ons voorbeeld willen we een cloudservice aanroepen voor FRTB-berekeningen. Een aantal hiervan vindt u op AppSource. Voor dit artikel hebben we gekozen voor een proefoptie van Vector Risk. We blijven ons systeem wijzigen. Deze keer gebruiken we een service om het risicocijfer van rente te berekenen. Dit proces bestaat uit de volgende stappen:

1. Roep de relevante risicoservice aan met de juiste parameters.
2. Wacht totdat de service de berekening heeft voltooid.
3. Haal de resultaten op en neem deze op in de risicoanalyse.

Vertaald in R-code, kan onze R-code worden verbeterd door de definitie van de vereiste invoerwaarden van een voorbereide invoersjabloon.

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)

Vervolgens moeten we de webservice aanroepen. In dit geval roepen we de methode StartCreditExposure aan om de berekening te activeren. Het eindpunt voor de API wordt opgeslagen in een variabele met de naam van het eindpunt.

# 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)

Zodra de berekeningen zijn voltooid, halen we de resultaten op.

# 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)

Hierdoor blijft de analist doorgaan met de ontvangen resultaten. De relevante risicocijfers van belang worden geëxtraheerd uit de resultaten en uitgezet.

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")

De resulterende plots zien er als volgt uit:

Afbeelding 4 - Kredietblootstelling voor MSFT Equity Forward - Berekend met een risico-engine in de cloud

Afbeelding 5 - Potentiële toekomstige blootstelling voor MSFT Equity Forward - Berekend met een risico-engine in de cloud

Overwegingen

Flexibele toegang tot de cloud via rekeninfrastructuur en op SaaS gebaseerde risicoanalyseservices kunnen verbeteringen leveren in snelheid en flexibiliteit voor risicoanalisten die op kapitaalmarkten en verzekeringen werken. In dit artikel hebben we een voorbeeld besproken waarin wordt uitgelegd hoe u Azure en andere services gebruikt met behulp van hulpprogramma's die risicoanalisten kennen. Probeer te profiteren van de mogelijkheden van Azure tijdens het maken en verbeteren van uw risicomodellen.

Medewerkers

Dit artikel wordt onderhouden door Microsoft. De tekst is oorspronkelijk geschreven door de volgende Inzenders.

Belangrijkste auteurs:

• Dr. Darko Mocelj | HPC Global Blackbelt & AI Sr. Technology Specialist
• Rupert Nicolay | Lead voor oplossingen voor financiële dienstverlening

Volgende stappen

• R-ontwikkelaars: een parallelle R-simulatie uitvoeren met Azure Batch
• Basic R-opdrachten en RevoScaleR-functies: 25 algemene voorbeelden
• Gegevens visualiseren en analyseren met RevoScaleR
• Inleiding tot ML-services en opensource R-mogelijkheden in HDInsight

Verwante resources

• Actuariele risicoanalyse en financiële modellering
• Oplossing voor risicorastercomputing
• HPC-sjabloon voor risicoanalyse
• Een financieel instellingsscenario voor data mesh
• Kredietrisico en standaardmodellering van leningen