Włączanie cyklu życia ryzyka usług finansowych za pomocą platformy Azure i języka R

  • Artykuł

Obliczenia ryzyka są kluczowe na kilku etapach cyklu życia kluczowych operacji usług finansowych. Na przykład uproszczona forma cyklu życia zarządzania produktami ubezpieczeniowymi może wyglądać podobnie do poniższego diagramu. Aspekty obliczania ryzyka są wyświetlane w niebieskim tekście.

Diagram przedstawia czynniki obliczeniowe ryzyka.

Scenariusz w firmie zajmującej się rynkami kapitałowymi może wyglądać następująco:

Diagram przedstawia scenariusz obliczania ryzyka dla firmy zajmującej się rynkami kapitałowymi.

W takich procesach istnieją typowe potrzeby modelowania ryzyka, w tym:

  • Potrzeba eksperymentów związanych z ryzykiem ad hoc przez analityków ryzyka, takich jak actuaries w firmie ubezpieczeniowej lub kwantach w firmie kapitałowej. Analitycy ci zwykle pracują z narzędziami do tworzenia kodu i modelowania, które są popularne w swojej domenie: R i Python. Wiele programów nauczania uniwersyteckiego obejmuje szkolenia w języku R lub Python w matematycznych kursów finansowych i MBA. Oba języki mają dostęp do szerokiej gamy bibliotek typu open source, które obsługują popularne obliczenia ryzyka.
  • Oprócz odpowiednich narzędzi analitycy często wymagają dostępu do:
    • Dokładne dane dotyczące cen rynkowych.
    • Zasady i dane oświadczeń.
    • Dane dotyczące pozycji rynkowej.
    • Inne dane zewnętrzne, takie jak:
      • Dane ustrukturyzowane, takie jak tabele śmiertelności i konkurencyjne dane cenowe.
      • Mniej tradycyjne typy, takie jak pogoda i wiadomości.
    • Pojemność obliczeniowa na potrzeby szybkich interaktywnych badań danych.
  • W niektórych przypadkach algorytmy uczenia maszynowego ad hoc dotyczące cen lub określania strategii rynkowej.
  • Możliwość wizualizowania i prezentowania danych do użycia w planowaniu produktów, strategii handlowej i podobnych dyskusjach.
  • Szybkie wykonywanie zdefiniowanych modeli skonfigurowanych przez analityków pod kątem cen, wycen i ryzyka rynkowego. Wyceny korzystają z kombinacji dedykowanych modeli ryzyka, narzędzi do ryzyka rynkowego i niestandardowego kodu. Analiza jest wykonywana w partii z różną nocą, co tydzień, co miesiąc, co kwartał i roczne obliczenia. Ta analiza generuje skoki obciążeń.
  • Integracja danych z innymi miarami ryzyka dla całego przedsiębiorstwa na potrzeby skonsolidowanego raportowania ryzyka. W większych organizacjach oszacowania ryzyka niższego poziomu można przenieść do narzędzia do modelowania i raportowania ryzyka przedsiębiorstwa.
  • Wyniki zgłaszane w zdefiniowanym formacie w wymaganych godzinach, aby spełnić wymagania inwestorów i przepisów prawnych.

Firma Microsoft pomaga spełnić te potrzeby dzięki połączeniu usług platformy Azure i ofert partnerskich w witrynie Azure Marketplace. W tym artykule przedstawiono praktyczne przykłady pokazujące sposób przeprowadzania eksperymentów ad hoc przy użyciu języka R. Zaczynamy od wyjaśnienia, jak uruchomić eksperyment na jednej maszynie. Następnie pokażemy, jak uruchomić ten sam eksperyment w usłudze Azure Batch, a my zamkniemy, pokazując, jak korzystać z usług zewnętrznych na potrzeby modelowania. Opcje i zagadnienia dotyczące wykonywania zdefiniowanych modeli na platformie Azure zostały opisane w tych artykułach, które koncentrują się na bankowości i ubezpieczeniach.

Modelowanie analityków w języku R

Zacznijmy od przyjrzenia się, w jaki sposób R może być używany przez analityka w uproszczonym, reprezentatywnym scenariuszu rynków kapitałowych. Można to utworzyć, odwołując się do istniejącej biblioteki języka R dla obliczeń lub pisząc kod od podstaw. W naszym przykładzie musimy również pobrać zewnętrzne dane cennika. Aby zachować przykład prosty, ale ilustracyjny, obliczamy potencjalną przyszłą ekspozycję (PFE) kontraktu na akcje akcji. W tym przykładzie unika się złożonych technik modelowania ilościowego dla instrumentów, takich jak złożone pochodne, i skupia się na pojedynczym czynniku ryzyka, który koncentruje się na cyklu życia ryzyka. W naszym przykładzie można wykonać następujące czynności:

  • Wybierz instrument zainteresowania.
  • Źródłowe ceny historyczne dla instrumentu.
  • Modelowanie akcji ceny akcji przy użyciu prostego obliczenia Monte Carlo (MC), które używa Geometryczny Brownian Motion (GBM):
    • Szacowanie oczekiwanego zwrotu μ (mu) i zmienności σ (theta).
    • Kalibrowanie modelu na dane historyczne.
  • Wizualizuj różne ścieżki, aby komunikować się z wynikami.
  • Wykreślij wartość max(0,Stock Value), aby zademonstrować znaczenie PFE, różnicę do wartości zagrożonej (VaR). Aby wyjaśnić:

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

  • Pobierz wartość 0,95 Quantile, aby uzyskać wartość PFE za każdym razem, gdy krok/koniec okresu symulacji.

Obliczymy PFE dla akcji przekazanej na podstawie akcji firmy Microsoft (MSFT). Jak wspomniano wcześniej, aby modelować ceny akcji, wymagane są historyczne ceny akcji MSFT, abyśmy mogli skalibrować model do danych historycznych. Istnieje wiele sposobów na uzyskanie historycznych cen akcji. W naszym przykładzie używamy bezpłatnej wersji usługi cenowej akcji od zewnętrznego dostawcy usług, Quandl.

Uwaga

W przykładzie użyto zestawu danych WIKI Prices, który może służyć do uczenia się pojęć. W przypadku użycia produkcyjnego akcji opartych na amerykańskich akcjach Quandl zaleca użycie zestawu danych End of Day US Stock Prices( Koniec dnia US Stock Prices).

Aby przetworzyć dane i zdefiniować ryzyko związane z kapitałem własnym, musimy wykonać następujące czynności:

  • Pobieranie danych historii z kapitału własnego.
  • Ustal oczekiwany zwrot μ i zmienność σ z danych historycznych.
  • Modelowanie bazowych cen akcji przy użyciu symulacji.
  • Uruchom model.
  • Określ ekspozycję kapitału własnego w przyszłości.

Zaczynamy od pobierania akcji z usługi Quandl i kreślenia historii cen zamknięcia w ciągu ostatnich 180 dni.

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

Z danymi w ręku skalibrujemy model 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])

Następnie modelujemy bazowe ceny akcji. Możemy zaimplementować dyskretny proces GBM od podstaw lub użyć jednego z wielu pakietów języka R, które zapewniają tę funkcję. Używamy sde pakietu R (Symulacja i wnioskowanie dla równań różnicowych Stochastic), który zapewnia metodę rozwiązywania tego problemu. Metoda GBM wymaga zestawu parametrów, które są skalibrowane do danych historycznych lub podane jako parametry symulacji. Używamy danych historycznych, dostarczając μ, σ i cen akcji na początku symulacji (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)

Teraz możemy rozpocząć symulację Monte Carlo, aby modelować potencjalne narażenie na pewną liczbę ścieżek symulacji. Ograniczymy symulację do 50 ścieżek Monte Carlo i 256 kroków czasowych. W ramach przygotowań do skalowania w poziomie symulacji i korzystania z równoległości w języku R pętla symulacji Monte Carlo używa instrukcji 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)

Teraz zasymulowaliśmy cenę bazowego akcji MSFT. Aby obliczyć ekspozycję na kapitał własny, odejmujemy premię i ograniczymy ekspozycję tylko na dodatnie wartości.

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

Na kolejnych dwóch zdjęciach przedstawiono wynik symulacji. Pierwszy obraz przedstawia symulację Monte Carlo bazowej ceny akcji dla 50 ścieżek. Drugi obraz ilustruje ekspozycję kredytową podstawową dla akcji do przodu po odjęciu premii kapitału własnego do przodu i ograniczenia ekspozycji na dodatnie wartości.

Rysunek 1 — 50 ścieżek Monte Carlo

Rysunek 1 — 50 ścieżek Monte Carlo

Rysunek 2. Ekspozycja kredytowa na rzecz akcji do przodu

Rysunek 2. Ekspozycja kredytowa na akcje do przodu

W ostatnim kroku 1-miesięczne 0,95 kwantylu PFE jest obliczane za pomocą następującego kodu.

# 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")
Potencjalna przyszła ekspozycja na udział MSFT Equity Forward

Rysunek 3 Potencjalna przyszła ekspozycja na kapitał własny MSFT

Używanie usługi Azure Batch z językiem R

Opisane powyżej rozwiązanie języka R można połączyć z usługą Azure Batch i wykorzystać chmurę do obliczeń o ryzyku. Wymaga to niewielkiego nakładu pracy w przypadku obliczeń równoległych, takich jak nasze. Samouczek Run a parallel R simulation with Azure Batch (Uruchamianie równoległej symulacji języka R w usłudze Azure Batch) zawiera szczegółowe informacje na temat łączenia języka R z usługą Azure Batch. Poniżej przedstawiono kod i podsumowanie procesu nawiązywania połączenia z usługą Azure Batch oraz sposób wykorzystania rozszerzenia do chmury w uproszczonym obliczeniu PFE.

W tym przykładzie opisano ten sam model opisany wcześniej. Jak widzieliśmy wcześniej, to obliczenie można uruchomić na naszym komputerze osobistym. Zwiększenie liczby ścieżek Monte Carlo lub użycie mniejszych kroków czasu spowoduje znacznie dłuższy czas wykonywania. Prawie cały kod języka R pozostanie niezmieniony. Wyróżnimy różnice w tej sekcji.

Każda ścieżka symulacji Monte Carlo jest uruchamiana na platformie Azure. Możemy to zrobić, ponieważ każda ścieżka jest niezależna od innych, dając nam obliczenie, które jest łatwo zrównane.

Aby użyć usługi Azure Batch, zdefiniujemy bazowy klaster i odwołamy się do niego w kodzie, zanim klaster będzie mógł być używany w obliczeniach. Aby uruchomić obliczenia, użyjemy następującej definicji 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": ""
}

Korzystając z tej definicji klastra, poniższy kod języka R korzysta z klastra:


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

Na koniec zaktualizujemy instrukcję foreach z wcześniejszej wersji, aby użyć pakietu doAzureParallel. Jest to niewielka zmiana, dodanie odwołania do pakietu sde i zmiana %do% na %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()

Każda symulacja Monte Carlo jest przesyłana jako zadanie do usługi Azure Batch. Zadanie jest wykonywane w chmurze. Wyniki są scalane przed odesłaniem do aplikacji workbench analityka. Duże obciążenia i obliczenia są wykonywane w chmurze, aby w pełni wykorzystać skalowanie i podstawową infrastrukturę wymaganą przez żądane obliczenia.

Po zakończeniu obliczeń dodatkowe zasoby można łatwo zamknąć, wywołując następującą pojedynczą instrukcję:

# Stop the cloud cluster
stopCluster(cluster)

Korzystanie z oferty SaaS

W dwóch pierwszych przykładach pokazano, jak używać infrastruktury lokalnej i chmurowej do opracowania odpowiedniego modelu wyceny. Ten paradygmat zaczął się zmieniać. W ten sam sposób, w jaki infrastruktura lokalna przekształciła się w usługi IaaS i PaaS oparte na chmurze, modelowanie odpowiednich danych o ryzyku przekształca się w proces zorientowany na usługi. Dzisiejszych analityków stoją przed dwoma poważnymi wyzwaniami:

  • Wymagania prawne wykorzystują zwiększenie pojemności obliczeniowej, aby dodać je do wymagań dotyczących modelowania. Organy regulacyjne proszą o częstsze i aktualne dane dotyczące ryzyka.
  • Istniejąca infrastruktura ryzyka wzrosła w sposób organiczny wraz z upływem czasu i stwarza wyzwania związane z wdrażaniem nowych wymagań i bardziej zaawansowanym modelowaniem ryzyka w sposób elastyczny.

Usługi oparte na chmurze mogą dostarczać wymagane funkcje i obsługiwać analizę ryzyka. Takie podejście ma pewne zalety:

  • Najpopularniejsze obliczenia ryzyka wymagane przez regulatora muszą zostać wdrożone przez wszystkich zgodnie z rozporządzeniem. Korzystając z usług od wyspecjalizowanego dostawcy usług, analityk korzysta z gotowych do użycia obliczeń ryzyka zgodnych z regulatorem. Takie usługi mogą obejmować obliczenia ryzyka rynkowego, obliczenia ryzyka odpowiednika, korektę wartości X (XVA), a nawet fundamental review of Trading Book (FRTB) caculations.
  • Te usługi uwidaczniają swoje interfejsy za pośrednictwem usług internetowych. Istniejąca infrastruktura ryzyka może zostać rozszerzona przez te inne usługi.

W naszym przykładzie chcemy wywołać usługę opartą na chmurze na potrzeby obliczeń FRTB. Kilka z nich można znaleźć w usłudze AppSource. W tym artykule wybraliśmy opcję wersji próbnej z obszaru Vector Risk. Będziemy nadal modyfikować nasz system. Tym razem użyjemy usługi do obliczenia wartości ryzyka zainteresowania. Ten proces składa się z następujących kroków:

  1. Wywołaj odpowiednią usługę ryzyka z odpowiednimi parametrami.
  2. Poczekaj na zakończenie obliczeń przez usługę.
  3. Pobierz i uwzględnij wyniki w analizie ryzyka.

Przetłumaczony na kod języka R nasz kod języka R można ulepszyć przy użyciu definicji wymaganych wartości wejściowych z przygotowanego szablonu wejściowego.

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)

Następnie musimy wywołać usługę internetową. W takim przypadku wywołujemy metodę StartCreditExposure, aby wyzwolić obliczenie. Przechowujemy punkt końcowy interfejsu API w zmiennej o nazwie 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)

Po zakończeniu obliczeń pobieramy wyniki.

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

Pozostawia to analitykowi możliwość kontynuowania otrzymywanych wyników. Odpowiednie dane o podwyższonym ryzyku są wyodrębniane z wyników i wykreśliwane.

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

Wynikowe wykresy wyglądają następująco:

Rysunek 4. Ekspozycja kredytowa na rzecz akcji MSFT do przodu — obliczana przy użyciu aparatu ryzyka opartego na chmurze.

Rysunek 4. Ekspozycja kredytowa na wartość akcji MSFT do przodu — obliczana przy użyciu aparatu ryzyka opartego na chmurze

Rysunek 5. Potencjalna przyszła ekspozycja na przyszłość dla akcji MSFT — obliczana przy użyciu aparatu ryzyka opartego na chmurze

Rysunek 5. Potencjalna przyszła ekspozycja na przyszłość dla akcji MSFT — obliczana przy użyciu aparatu ryzyka opartego na chmurze

Kwestie wymagające rozważenia

Elastyczny dostęp do chmury za pośrednictwem infrastruktury obliczeniowej i usług analizy ryzyka opartego na modelu SaaS może zapewnić poprawę szybkości i elastyczności analityków ryzyka pracujących na rynkach kapitałowych i ubezpieczeniach. W tym artykule omówiliśmy przykład, który ilustruje sposób korzystania z platformy Azure i innych usług przy użyciu narzędzi, które wiedzą analitycy ryzyka. Spróbuj skorzystać z możliwości platformy Azure podczas tworzenia i ulepszania modeli ryzyka.

Współautorzy

Ten artykuł jest obsługiwany przez firmę Microsoft. Pierwotnie został napisany przez następujących współautorów.

Autorzy zabezpieczeń:

Następne kroki