A pénzügyi szolgáltatások kockázati életciklusának engedélyezése az Azure-ral és az R-vel

  • Cikk
  • 12 perc alatt elolvasható

A kockázatszámítások a kulcsfontosságú pénzügyi szolgáltatási műveletek életciklusának több szakaszában kulcsfontosságúak. A biztosítási termékkezelési életciklus egyszerűsített formája például az alábbi ábrához hasonló lehet. A kockázatszámítás szempontjai kék szövegben jelennek meg.

Diagram shows risk calculation factors.

Egy tőkepiaci cég forgatókönyve így nézhet ki:

Diagram shows risk calculation scenario for a capital markets firm.

Az ilyen folyamatokban gyakori kockázatmodellezési igények merülnek fel, például:

  • A kockázatelemzők, például egy biztosítótársaság aktuáriusai vagy egy tőkepiaci vállalat kvantitációi által végzett ad-hoc kockázattal kapcsolatos kísérletezés szükségessége. Ezek az elemzők általában olyan kód- és modellezési eszközökkel dolgoznak, amelyek népszerűek a tartományukban: R és Python. Számos egyetemi tanterv tartalmaz R- vagy Python matematikai pénzügyi és MBA-képzéseket. Mindkét nyelv számos olyan nyílt forráskód kódtárhoz fér hozzá, amelyek támogatják a népszerű kockázatszámításokat.
  • A megfelelő eszközökkel együtt az elemzőknek gyakran szükségük van a következő eszközökhöz való hozzáférésre:
    • Pontos piaci díjszabási adatok.
    • Szabályzat- és jogcímadatok.
    • Piaci pozícióra vonatkozó adatok.
    • Egyéb külső adatok, például:
      • Strukturált adatok, például halálozási táblázatok és versenyképes díjszabási adatok.
      • Kevésbé hagyományos típusok, mint az időjárás és a hírek.
    • Számítási kapacitás gyors interaktív adatvizsgálatokhoz.
  • Bizonyos esetekben ad-hoc gépi tanulási algoritmusok a díjszabáshoz vagy a piaci stratégia meghatározásához.
  • A terméktervezésben, a kereskedési stratégiában és hasonló megbeszélésekben való használathoz szükséges adatok vizualizációjának és bemutatásának képessége.
  • Az elemzők által a díjszabásra, az értékelésekre és a piaci kockázatokra konfigurált meghatározott modellek gyors végrehajtása. Az értékelések a dedikált kockázatmodellezés, a piaci kockázati eszközök és az egyéni kód kombinációját használják. Az elemzés egy kötegben történik, amely változó éjszakai, heti, havi, negyedéves és éves számításokkal rendelkezik. Ez az elemzés kiugróan magas számítási feladatokat eredményez.
  • Az adatok integrálása más vállalati szintű kockázati intézkedésekkel az összevont kockázatjelentéshez. Nagyobb szervezetekben az alacsonyabb szintű kockázatbecslések átadhatók a vállalati kockázatmodellezés és -jelentéskészítés eszközeinek.
  • A befektetői és szabályozási követelményeknek való megfeleléshez meghatározott formátumban jelentett eredmények.

A Microsoft azure-szolgáltatások és partnerajánlatok kombinációjával segít ezeknek az igényeknek megfelelni a Azure Marketplace. Ebben a cikkben gyakorlati példákat talál, amelyek bemutatják, hogyan hajthat végre alkalmi kísérletezést az R használatával. Kezdjük azzal, hogy elmagyarázzuk, hogyan futtatható a kísérlet egyetlen gépen. Ezután bemutatjuk, hogyan futtathatja ugyanazt a kísérletet Azure Batch, és a közelben bemutatjuk, hogyan használhatja ki a külső szolgáltatásokat a modellezéshez. A meghatározott modellek Azure-beli végrehajtásának lehetőségeit és szempontjait az alábbi cikkek ismertetik, amelyek a banki szolgáltatásokra és a biztosításra összpontosítanak.

Elemzési modellezés az R-ben

Kezdjük azzal, hogyan használhatja az R-t egy elemző egy egyszerűsített, reprezentatív tőkepiaci forgatókönyvben. Ezt úgy hozhatja létre, hogy hivatkozik egy meglévő R-kódtárra a számításhoz, vagy teljesen új kódot ír. A példánkban külső díjszabási adatokat is le kell hívnunk. A példa egyszerű, de szemléltető jellegű megőrzése érdekében kiszámítjuk egy részvénytőzsdei határidős szerződés lehetséges jövőbeli kitettségét (PFE). Ez a példa elkerüli az olyan eszközök összetett kvantitatív modellezési technikáit, mint az összetett származékos termékek, és egyetlen kockázati tényezőre összpontosít, hogy a kockázati életciklusra koncentráljon. A példánkban a következőket teheti:

  • Válasszon ki egy fontos eszközt.
  • Forrás előzményárak az eszköz.
  • Modell részvényárfolyam-művelet egyszerű Monte Carlo (MC) számítással, amely geometriai Brownian Motion (GBM) használatával:
    • Becsült várható visszatérési μ (mu) és volatilitási σ (theta).
    • Kalibrálja a modellt az előzményadatokhoz.
  • Vizualizálja a különböző útvonalakat az eredmények közléséhez.
  • Ábrázolja a max(0;Stock Value) értéket a PFE jelentésének, a kockázatnak kitett érték különbségének (VaR) bemutatásához. Tisztázandó:

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

  • Vegye a 0,95 Quantile értéket a PFE-érték lekéréséhez a szimulációs időszak minden egyes lépésénél/végén.

Kiszámítjuk a PFE-t a Microsoft (MSFT) részvényei alapján. Ahogy korábban említettük, a tőzsdei árak modellezéséhez az MSFT-részvények előzményáraira van szükség, hogy a modellt előzményadatokhoz kalibrálhassuk. Számos módja van a történelmi tőzsdei árak megszerzésének. Példánkban egy külső szolgáltató, a Quandl árfolyamszolgáltatásának ingyenes verzióját használjuk.

Megjegyzés

A példa a WIKI Árak adatkészletet használja, amely a fogalmak megismeréséhez használható. Az usa-beli részvények termelési felhasználásához a Quandl a nap végén az AMERIKAI részvényárak adatkészlet használatát javasolja.

Az adatok feldolgozásához és a saját tőkével kapcsolatos kockázat meghatározásához a következő lépéseket kell tennünk:

  • Előzményadatok lekérése a saját tőkéből.
  • Határozza meg az előzményadatokból származó várható μ és volatilitási σ.
  • Modellezheti a mögöttes részvényárakat egy szimuláció használatával.
  • Futtassa a modellt.
  • A saját tőke jövőbeli kitettségének meghatározása.

Először lekértük a quandl szolgáltatást, és ábrázoljuk az elmúlt 180 nap záró árelőzményeit.

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

A kéznél lévő adatokkal kalibráljuk a GBM-modellt.

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

Ezután modellezzük az alapul szolgáló részvényárakat. Implementálhatjuk a különálló GBM-folyamatot az alapoktól, vagy használhatjuk az ezt a funkciót biztosító számos R-csomag egyikét. Az R-csomag sde (Sztochasztikus differenciálegyenletek szimulációja és következtetése) használatával oldjuk meg ezt a problémát. A GBM metódushoz olyan paraméterekre van szükség, amelyek előzményadatokra vannak kalibrálva, vagy szimulációs paraméterekként vannak megadva. Az előzményadatokat a szimuláció elején (P0) μ, σ és részvényárak megadásával használjuk fel.

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)

Most már készen állunk egy Monte Carlo-szimuláció elindítására, amely néhány szimulációs útvonal lehetséges expozícióját modellezheti. A szimulációt 50 Monte Carlo-útvonalra és 256 időlépésre korlátozzuk. A szimuláció horizontális felskálázásának előkészítése és az R párhuzamosításának kihasználása során a Monte Carlo szimulációs ciklus egy foreach utasítást használ.

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

Most szimuláltuk a mögöttes MSFT-részvény árát. A saját tőke kitettségének kiszámításához kivonjuk a prémiumot, és csak pozitív értékekre korlátozzuk a kitettséget.

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

A következő két kép a szimuláció eredményét mutatja. Az első képen a Monte Carlo-szimuláció látható az alapul szolgáló részvényárfolyamról 50 útvonalon. A második kép a tőketőkére vonatkozó mögöttes hitelkitettséget mutatja be a határidős tőke prémiumának kivonása és a pozitív értékeknek való kitettség korlátozása után.

Figure 1 - 50 Monte Carlo Paths

1. ábra – 50 Monte Carlo-útvonal

Figure 2 - Credit Exposure for Equity Forward

2. ábra – A sajáttőke-kitettség előre

Az utolsó lépésben az 1 hónapos 0,95 kvantilis PFE kiszámítása az alábbi kóddal történik.

# 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")
Potential future exposure for MSFT Equity Forward

3. ábra Az MSFT határidős részvényeinek jövőbeli kitettsége

A Azure Batch használata az R-vel

A fent leírt R-megoldás csatlakoztatható Azure Batch, és a felhőt használhatja kockázatszámításokhoz. Ez kis többletmunkát igényel egy olyan párhuzamos számításhoz, mint a miénk. A párhuzamos R-szimuláció futtatása Azure Batch című oktatóanyag részletes információkat nyújt az R és Azure Batch összekapcsolásával kapcsolatban. Az alábbiakban bemutatjuk a Azure Batch való kapcsolódási folyamat kódját és összegzését, valamint azt, hogyan használhatja ki a felhőbővítményt egy egyszerűsített PFE-számítással.

Ez a példa a korábban ismertetett modellel foglalkozik. Ahogy korábban láttuk, ez a számítás a személyes számítógépen is futtatható. A Monte Carlo-útvonalak számának növelése vagy a kisebb időlépések használata sokkal hosszabb végrehajtási időket eredményez. Szinte az összes R-kód változatlan marad. Ebben a szakaszban kiemeljük a különbségeket.

A Monte Carlo-szimuláció minden útvonala az Azure-ban fut. Ezt azért tehetjük meg, mert minden elérési út független a többi útvonaltól, így könnyen párhuzamos számítások végezhetők el.

A Azure Batch használatához definiáljuk a mögöttes fürtöt, és hivatkozunk rá a kódban, mielőtt a fürt használható lenne a számításokban. A számítások futtatásához a következő cluster.json definíciót használjuk:

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

Ezzel a fürtdefinícióval a következő R-kód használja a fürtöt:


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

Végül frissítjük a foreach utasítást a doAzureParallel csomag használatára. Ez egy kisebb módosítás, amely az sde-csomagra mutató hivatkozást ad hozzá, és a %do% értékét %dopar%-ra módosítja:

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

Minden Monte Carlo-szimuláció feladatként lesz elküldve Azure Batch. A feladat a felhőben lesz végrehajtva. Az eredmények egyesítve lesznek, mielőtt visszaküldené őket az elemzői workbenchnek. A nehéz emelések és számítások a felhőben hajtanak végre, hogy teljes mértékben kihasználják a skálázást és a kért számításokhoz szükséges mögöttes infrastruktúrát.

A számítások befejezése után a további erőforrások egyszerűen leállíthatók a következő utasítás meghívásával:

# Stop the cloud cluster
stopCluster(cluster)

SaaS-ajánlat használata

Az első két példa bemutatja, hogyan használható a helyi és a felhőinfrastruktúra a megfelelő értékelési modell kidolgozásához. Ez a paradigma elkezdett változni. Ugyanúgy, ahogyan a helyszíni infrastruktúra felhőalapú IaaS- és PaaS-szolgáltatásokká vált, a releváns kockázati adatok modellezése szolgáltatásorientált folyamattá alakul át. A mai elemzők két fő kihívással szembesülnek:

  • A szabályozási követelmények növekvő számítási kapacitást használnak a modellezési követelményekhez való hozzáadáshoz. A szabályozók gyakoribb és naprakészebb kockázati adatokat kérnek.
  • A meglévő kockázati infrastruktúra idővel szervesen bővült, és kihívást jelent az új követelmények megvalósításakor és a fejlettebb kockázatmodellezés agilis módon történő megvalósítása során.

A felhőalapú szolgáltatások biztosítják a szükséges funkciókat, és támogatják a kockázatelemzést. Ennek a megközelítésnek néhány előnye van:

  • A szabályozó által megkövetelt leggyakoribb kockázatszámításokat a rendelet értelmében mindenkinek végre kell hajtania. Egy speciális szolgáltató szolgáltatásainak használatával az elemző a használatra kész, szabályozónak megfelelő kockázatszámítások előnyeit élvezheti. Ilyen szolgáltatások lehetnek piaci kockázatszámítások, partnerkockázati számítások, X-Érték kiigazítás (XVA), valamint a kereskedési könyv (FRTB) kakulációinak alapszintű áttekintése.
  • Ezek a szolgáltatások webszolgáltatásokon keresztül teszik elérhetővé a felületeiket. A meglévő kockázati infrastruktúra továbbfejleszthető ezekkel a más szolgáltatásokkal.

Példánkban egy felhőalapú szolgáltatást szeretnénk meghívni FRTB-számításokhoz. Ezek közül több megtalálható az AppSource-on. Ebben a cikkben a Vector Risk próbaverziós lehetőségét választottuk. Továbbra is módosítjuk a rendszert. Ezúttal egy szolgáltatással számítjuk ki az érdeklődési kör kockázati értékét. Ez a folyamat a következő lépésekből áll:

  1. Hívja meg a megfelelő kockázati szolgáltatást a megfelelő paraméterekkel.
  2. Várja meg, amíg a szolgáltatás befejezi a számítást.
  3. Az eredmények lekérése és beépítése a kockázatelemzésbe.

R-kódra lefordítva az R-kód továbbfejleszthető egy előkészített bemeneti sablon szükséges bemeneti értékeinek meghatározásával.

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)

Ezután meg kell hívnunk a webszolgáltatást. Ebben az esetben a StartCreditExposure metódust hívjuk meg a számítás elindításához. Az API végpontja egy változó nevesített végpontban van tárolva.

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

A számítások befejezése után lekérjük az eredményeket.

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

Így az elemző folytathatja a kapott eredményeket. A releváns kockázati számokat az eredményekből nyerik ki és ábrázolják.

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

Az eredményként kapott diagramok a következőképpen néznek ki:

Figure 4 - Credit exposure for MSFT equity forward - Calculated with a cloud-based risk engine.

4. ábra – Az MSFT-részvénytőkére vonatkozó hitelkitettség előre – Felhőalapú kockázati motorral kiszámítva

Figure 5 - Potential future exposure for MSFT equity forward - Calculated with a cloud-based risk engine

5. ábra – Az MSFT-részvénytőzsdék jövőbeli jövőbeli kitettsége – Felhőalapú kockázati motorral számítva

Megfontolandó szempontok

A felhőhöz való rugalmas hozzáférés a számítási infrastruktúrán és az SaaS-alapú kockázatelemzési szolgáltatásokon keresztül a tőkepiacokon és a biztosításokban dolgozó kockázatelemzők számára sebességet és rugalmasságot biztosíthat. Ebben a cikkben egy példát mutattunk be, amely bemutatja, hogyan használhatja az Azure-t és más szolgáltatásokat a kockázatelemzők által ismert eszközökkel. A kockázati modellek létrehozásakor és továbbfejlesztésekor próbálja kihasználni az Azure képességeit.

Közreműködők

Ezt a cikket a Microsoft tartja karban. Eredetileg a következő közreműködők írták.

Fő szerzők:

Következő lépések