Azure ve R ile finansal hizmetler risk yaşam döngüsünü etkinleştirme

  • Makale

Risk hesaplamaları, önemli finansal hizmetler operasyonlarının yaşam döngüsünün çeşitli aşamalarında özetlenir. Örneğin, sigorta ürün yönetimi yaşam döngüsünün basitleştirilmiş bir biçimi aşağıdaki diyagrama benzer olabilir. Risk hesaplaması yönleri mavi metinde gösterilir.

Diyagramda risk hesaplama faktörleri gösterilir.

Sermaye piyasaları firmasındaki bir senaryo şu şekilde görünebilir:

Diyagramda, sermaye piyasaları firması için risk hesaplama senaryosu gösterilmektedir.

Bunlar gibi işlemlerde aşağıdakiler dahil olmak üzere yaygın risk modelleme gereksinimleri vardır:

  • Bir sigorta firmasındaki aktüerler veya sermaye piyasaları firmasındaki miktarlar gibi risk analistleri tarafından geçici riskle ilgili deneme ihtiyacı. Bu analistler genellikle etki alanında popüler olan kod ve modelleme araçlarıyla çalışır: R ve Python. Birçok üniversite müfredatı, matematik finansı ve MBA derslerinde R veya Python eğitimi içerir. Her iki dil de popüler risk hesaplamalarını destekleyen çok çeşitli açık kaynak kitaplıklarına erişebilir.
  • Analistler, uygun araçlarla birlikte genellikle şunlara erişim gerektirir:
    • Doğru pazar fiyatlandırması verileri.
    • İlke ve talep verileri.
    • Pazar konumu verileri.
    • Diğer dış veriler:
      • Mortalite tabloları ve rekabetçi fiyatlandırma verileri gibi yapılandırılmış veriler.
      • Hava durumu ve haber gibi daha az geleneksel türler.
    • Hızlı etkileşimli veri araştırmaları için hesaplama kapasitesi.
  • Bazı durumlarda, fiyatlandırma veya pazar stratejisini belirlemeye yönelik geçici makine öğrenmesi algoritmaları.
  • Ürün planlama, ticaret stratejisi ve benzer tartışmalarda kullanılacak verileri görselleştirme ve sunma becerisi.
  • Analistler tarafından fiyatlandırma, değerlemeler ve pazar riski için yapılandırılan tanımlı modellerin hızlı bir şekilde yürütülmesi. Değerlemeler ayrılmış risk modelleme, pazar riski araçları ve özel kodun bir birleşimini kullanır. Analiz, gece, haftalık, aylık, üç aylık ve yıllık hesaplamalarla toplu olarak yürütülür. Bu analiz, iş yüklerinde ani artışlar oluşturur.
  • Verilerin birleştirilmiş risk raporlaması için kuruluş genelindeki diğer risk ölçüleriyle tümleştirilmesi. Daha büyük kuruluşlarda, düşük düzey risk tahminleri kurumsal risk modelleme ve raporlama aracına aktarılabilir.
  • Sonuçlar, yatırımcı ve mevzuat gereksinimlerini karşılamak için gerekli zamanlarda tanımlanmış bir biçimde bildirilir.

Microsoft, Azure Market Azure hizmetlerinin ve iş ortağı tekliflerinin bir bileşimi aracılığıyla bu ihtiyaçları karşılamaya yardımcı olur. Bu makalede, R kullanarak geçici deneme gerçekleştirmeyi gösteren pratik örnekler verilmiştir. Denemeyi tek bir makinede çalıştırmayı açıklayarak başlıyoruz. Ardından, Azure Batch'te aynı denemeyi nasıl çalıştırabileceğinizi göstereceğiz ve modelleme için dış hizmetlerden nasıl yararlanabileceğinizi göstererek kapatacağız. Azure'da tanımlı modellerin yürütülmesine yönelik seçenekler ve dikkat edilmesi gerekenler, bankacılık ve sigortaya odaklanan bu makalelerde açıklanmıştır.

R'de analist modellemesi

Basitleştirilmiş, temsili sermaye piyasaları senaryosunda bir analist tarafından R'nin nasıl kullanılabileceğini inceleyerek başlayalım. Bunu, hesaplama için mevcut bir R kitaplığına başvurarak veya sıfırdan kod yazarak oluşturabilirsiniz. Örneğimizde dış fiyatlandırma verilerini de getirmemiz gerekir. Örneği basit ama açıklayıcı tutmak için, bir hisse senedi ileriye dönük hisse senedi sözleşmesinin gelecekteki potansiyel maruziyetini (PFE) hesaplıyoruz. Bu örnek, karmaşık türevler gibi araçlar için karmaşık nicel modelleme tekniklerini önler ve risk yaşam döngüsüne odaklanmak için tek bir risk faktörüne odaklanır. Örneğimiz aşağıdakileri yapmanızı sağlar:

  • İlgi çekici bir araç seçin.
  • Araç için kaynak tarihi fiyatlar.
  • Geometrik Kahverengi Hareketi (GBM) kullanan basit Monte Carlo (MC) hesaplaması kullanarak hisse senedi fiyat eylemini modelleyin:
    • Tahmini dönüş μ (mu) ve volatilite σ (teta).
    • Modeli geçmiş verilere göre ayarlama.
  • Sonuçları iletmek için çeşitli yolları görselleştirin.
  • Risk altında değer farkı (VaR) olan PFE'nin anlamını göstermek için maksimum (0,Hisse Senedi Değeri) grafiğini çizin. Açıklığa kavuşturmak için:

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

  • Her zaman adımında /simülasyon döneminin sonunda PFE değerini almak için 0,95 Quantile değerini alın.

Microsoft (MSFT) hisse senedine dayalı bir özkaynak iletme için PFE'yi hesaplayacağız. Daha önce belirtildiği gibi hisse senedi fiyatlarını modellemek için modeli geçmiş verilere göre ayarlayabilmemiz için MSFT hisse senedinin geçmiş fiyatları gereklidir. Geçmiş hisse senedi fiyatlarını almanın birçok yolu vardır. Örneğimizde, quandl adlı dış hizmet sağlayıcısından alınan bir hisse senedi fiyat hizmetinin ücretsiz sürümünü kullanıyoruz.

Not

Örnek, öğrenme kavramları için kullanılabilecek WIKI Fiyatları veri kümesini kullanır. Quandl, ABD tabanlı hisse senetlerinin üretim kullanımı için Gün Sonu ABD Hisse Senedi Fiyatları veri kümesinin kullanılmasını önerir.

Verileri işlemek ve özkaynakla ilişkili riski tanımlamak için aşağıdaki işlemleri yapmamız gerekir:

  • Hisse senedinden geçmiş verilerini alma.
  • Geçmiş verilerden beklenen dönüş μ ve volatilite σ belirleyin.
  • Bazı simülasyonları kullanarak temel hisse senedi fiyatlarını modelle.
  • Modeli çalıştırın.
  • Gelecekte özkaynak maruziyetini belirler.

Quandl hizmetinden hisse senedini alarak ve son 180 gün içindeki kapanış fiyat geçmişini çizerek başlıyoruz.

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

Eldeki veriler sayesinde GBM modelini kalibre ederiz.

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

Ardından, temel hisse senedi fiyatlarını modelleyeceğiz. AyrıK GBM işlemini sıfırdan uygulayabilir veya bu işlevi sağlayan birçok R paketinden birini kullanabiliriz. Bu sorunu çözmek için bir yöntem sağlayan R paket sde (Stokastik Diferansiyel Denklemler için Simülasyon ve Çıkarım) kullanırız. GBM yöntemi, geçmiş verilere göre ayarlanmış veya simülasyon parametresi olarak verilen bir dizi parametre gerektirir. Simülasyonun (P0) başında μ, σ ve hisse senedi fiyatları sağlayarak geçmiş verileri kullanırız.

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)

Artık bir dizi simülasyon yolunun olası açığa çıkabilecek durumunu modellemek için bir Monte Carlo simülasyonu başlatmaya hazırız. Simülasyonu 50 Monte Carlo yolu ve 256 zaman adımıyla sınırlayacağız. Simülasyonun ölçeğini genişletmeye ve R'de paralelleştirmeden yararlanmaya hazırlanırken Monte Carlo simülasyon döngüsü bir foreach deyimi kullanır.

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

Temel alınan MSFT hissesinin fiyatının simülasyonunu yaptık. Özkaynakların ileriye dönük maruz kalma durumunu hesaplamak için, primi çıkarır ve maruziyeti yalnızca pozitif değerlerle sınırlandırdık.

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

Sonraki iki resimde simülasyonun sonucu gösterilir. İlk resimde 50 yol için temel hisse senedi fiyatının Monte Carlo simülasyonu gösterilmektedir. İkinci resimde, özkaynak primi ileriye doğru çıkarıldıktan ve pozitif değerlere maruz kalma sınırlandırıldıktan sonra, özsermayenin ileriye dönük kredi maruziyeti gösterilmektedir.

Şekil 1 - 50 Monte Carlo Yolu

Şekil 1 - 50 Monte Carlo yolu

Şekil 2 - Pay İletme için Kredi Açığa Çıkarma

Şekil 2 - Özkaynaklar için kredi açığa çıkarma

Son adımda, 1 aylık 0,95 nicel PFE aşağıdaki kodla hesaplanır.

# 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")
MSFT Hisse Senedi İletme için gelecekte ortaya çıkabilecek risk

Şekil 3 MSFT hisse senedi ileriye doğru gelecekte ortaya çıkabilecek risk

Azure Batch'i R ile kullanma

Yukarıda açıklanan R çözümü Azure Batch'e bağlanabilir ve risk hesaplamaları için buluttan yararlanabilir. Bu, bizimki gibi paralel bir hesaplama için çok az çaba gerektirir. Azure Batch ile paralel R simülasyonu çalıştırma öğreticisi , R'yi Azure Batch'e bağlama hakkında ayrıntılı bilgi sağlar. Aşağıda Azure Batch'e bağlanma işleminin kodunu ve özetini ve basitleştirilmiş bir PFE hesaplamasında buluta uzantıdan nasıl yararlanabileceğinizi göstereceğiz.

Bu örnek, daha önce açıklanan modelin aynısını ele alır. Daha önce gördüğümüz gibi, bu hesaplama kişisel bilgisayarımızda çalıştırılabilir. Monte Carlo yollarının sayısının artması veya daha küçük zaman adımlarının kullanılması çok daha uzun yürütme süreleriyle sonuçlanır. R kodunun neredeyse tamamı değişmeden kalır. Bu bölümdeki farkları vurgulayacağız.

Monte Carlo benzetiminin her yolu Azure'da çalışır. Bunu yapabiliriz çünkü her yol diğerlerinden bağımsızdır ve bize kolayca paralelleştirilmiş bir hesaplama sağlar.

Azure Batch'i kullanmak için, temel alınan kümeyi tanımlar ve kümenin hesaplamalarda kullanılabilmesi için kodda bu kümeye başvururuz. Hesaplamaları çalıştırmak için aşağıdaki cluster.json tanımını kullanırız:

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

Bu küme tanımıyla, aşağıdaki R kodu kümeyi kullanır:


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

Son olarak, daha önceki foreach deyimini doAzureParallel paketini kullanacak şekilde güncelleştiriyoruz. Bu küçük bir değişikliktir, sde paketine başvuru ekleyip %do% değerini %dopar% olarak değiştirir:

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

Her Monte Carlo simülasyonu Azure Batch'e bir görev olarak gönderilir. Görev bulutta yürütülür. Sonuçlar analist workbench'e geri gönderilmeden önce birleştirilir. Ağır kaldırma ve hesaplamalar, istenen hesaplamaların gerektirdiği ölçeklendirme ve temel altyapıdan tam olarak yararlanmak için bulutta yürütülür.

Hesaplamalar tamamlandıktan sonra aşağıdaki tek yönerge çağrılarak ek kaynaklar kolayca kapatılabilir:

# Stop the cloud cluster
stopCluster(cluster)

SaaS teklifi kullanma

İlk iki örnek, yeterli bir değerleme modeli geliştirmek için yerel ve bulut altyapısının nasıl kullanılacağını gösterir. Bu paradigma değişmeye başladı. Şirket içi altyapının bulut tabanlı IaaS ve PaaS hizmetlerine dönüşmesiyle aynı şekilde, ilgili risk rakamlarının modellenmesi de hizmet odaklı bir sürece dönüşmektedir. Bugünün analistleri iki önemli zorlukla karşı karşıyadır:

  • Mevzuat gereksinimleri, modelleme gereksinimlerine eklemek için artan işlem kapasitesini kullanır. Düzenleyiciler daha sık ve güncel risk rakamları istiyor.
  • Mevcut risk altyapısı zamanla organik olarak büyüdü ve yeni gereksinimleri ve daha gelişmiş risk modellemesini çevik bir şekilde uygularken zorluklar yaratmaktadır.

Bulut tabanlı hizmetler gerekli işlevleri sunabilir ve risk analizini destekleyebilir. Bu yaklaşımın bazı avantajları vardır:

  • Düzenleyicinin gerektirdiği en yaygın risk hesaplamaları, yönetmelik kapsamındaki herkes tarafından uygulanmalıdır. Uzman bir hizmet sağlayıcısının hizmetlerini kullanan analist, kullanıma hazır, mevzuata uyumlu risk hesaplamalarından yararlanır. Bu tür hizmetler arasında piyasa riski hesaplamaları, karşılık gelen risk hesaplamaları, X-Değer Ayarlaması (XVA) ve hatta Ticaret Kitabının Temel Gözden Geçirmesi (FRTB) hesaplamaları yer alabilir.
  • Bu hizmetler, arabirimlerini web hizmetleri aracılığıyla kullanıma sunar. Mevcut risk altyapısı bu diğer hizmetler tarafından geliştirilebilir.

Örneğimizde FRTB hesaplamaları için bulut tabanlı bir hizmeti çağırmak istiyoruz. Bunların birkaçı AppSource'ta bulunabilir. Bu makale için Vektör Riski'nden bir deneme seçeneği belirledik. Sistemimizi değiştirmeye devam edeceğiz. Bu kez, ilgilendiğiniz risk rakamını hesaplamak için bir hizmet kullanırız. Bu işlem aşağıdaki adımlardan oluşur:

  1. Doğru parametrelerle ilgili risk hizmetini çağırın.
  2. Hizmet hesaplamayı bitirene kadar bekleyin.
  3. Sonuçları alın ve risk analizine dahil edin.

R koduna çevrilen R kodumuz, hazırlanan bir giriş şablonundan gerekli giriş değerlerinin tanımıyla geliştirilebilir.

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)

Şimdi web hizmetini çağırmamız gerekiyor. Bu durumda hesaplamayı tetiklemek için StartCreditExposure yöntemini çağırırız. API'nin uç noktasını endpoint adlı bir değişkende depolarız.

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

Hesaplamalar tamamlandıktan sonra sonuçları alırız.

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

Bu, analistin alınan sonuçlara devam etmesi için bırakır. İlgili risk rakamları sonuçlardan çıkarılır ve çizilir.

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

Sonuçta elde edilen çizimler şöyle görünür:

Şekil 4 - MSFT özkaynak ileriye doğru kredi açığa çıkarma - Bulut tabanlı risk altyapısıyla hesaplanır.

Şekil 4 - MSFT özkaynak ileriye doğru kredi açığa çıkarma - Bulut tabanlı risk altyapısıyla hesaplanır

Şekil 5 - MSFT özkaynak ileriye doğru gelecekte ortaya çıkabilecek risk - Bulut tabanlı risk altyapısı ile hesaplanır

Şekil 5 - MSFT özkaynak ileriye doğru gelecekte ortaya çıkabilecek risk - Bulut tabanlı risk altyapısı ile hesaplanır

Dikkat edilmesi gereken noktalar

İşlem altyapısı ve SaaS tabanlı risk analizi hizmetleri aracılığıyla buluta esnek erişim, sermaye piyasalarında ve sigortacılıkta çalışan risk analistleri için hız ve çeviklik açısından iyileştirmeler sağlayabilir. Bu makalede, risk analistlerinin bildiği araçları kullanarak Azure'ın ve diğer hizmetlerin nasıl kullanılacağını gösteren bir örnek üzerinde çalıştık. Risk modellerinizi oluştururken ve geliştirirken Azure'ın özelliklerinden yararlanmayı deneyin.

Katkıda Bulunanlar

Bu makale Microsoft tarafından yönetilir. Başlangıçta aşağıdaki katkıda bulunanlar tarafından yazılmıştır.

Asıl yazarlar:

Sonraki adımlar