Mengaktifkan siklus hidup risiko layanan keuangan dengan Azure dan R

  • Artikel

Perhitungan risiko sangat penting pada beberapa tahap dalam siklus hidup operasi layanan keuangan utama. Misalnya, bentuk yang disederhanakan dari siklus hidup manajemen produk asuransi mungkin terlihat seperti diagram di bawah ini. Aspek perhitungan risiko ditampilkan dalam teks biru.

Diagram menunjukkan faktor perhitungan risiko.

Skenario di perusahaan pasar modal mungkin terlihat seperti ini:

Diagram menunjukkan skenario perhitungan risiko untuk perusahaan pasar modal.

Dalam proses seperti ini, ada kebutuhan pemodelan risiko umum, termasuk:

  • Kebutuhan akan eksperimen terkait risiko ad-hoc oleh analis risiko, seperti actuaries di perusahaan asuransi atau kuant di perusahaan pasar modal. Analis ini biasanya bekerja dengan alat kode dan pemodelan yang populer di domain mereka: R dan Python. Banyak kurikulum universitas termasuk pelatihan dalam R atau Python dalam keuangan matematika dan kursus MBA. Kedua bahasa memiliki akses ke berbagai pustaka sumber terbuka yang mendukung perhitungan risiko populer.
  • Seiring dengan alat yang sesuai, analis sering memerlukan akses ke:
    • Data harga pasar yang akurat.
    • Data kebijakan dan klaim.
    • Data posisi pasar.
    • Data eksternal lainnya seperti:
      • Data terstruktur seperti tabel kematian dan data harga yang kompetitif.
      • Jenis yang kurang tradisional seperti cuaca dan berita.
    • Kapasitas komputasi untuk investigasi data interaktif cepat.
  • Dalam beberapa kasus, algoritma pembelajaran mesin ad-hoc untuk harga atau menentukan strategi pasar.
  • Kemampuan untuk memvisualisasikan dan menyajikan data untuk digunakan dalam perencanaan produk, strategi perdagangan, dan diskusi serupa.
  • Eksekusi cepat model yang ditentukan, dikonfigurasi oleh analis untuk harga, valuasi, dan risiko pasar. Valuasi menggunakan kombinasi pemodelan risiko khusus, alat risiko pasar, dan kode kustom. Analisis dijalankan dalam batch dengan berbagai perhitungan malam, mingguan, bulanan, triwulanan, dan tahunan. Analisis ini menghasilkan lonjakan beban kerja.
  • Integrasi data dengan langkah-langkah risiko di seluruh perusahaan lainnya untuk pelaporan risiko terkonsolidasi. Di organisasi yang lebih besar, perkiraan risiko tingkat bawah dapat ditransfer ke alat untuk pemodelan dan pelaporan risiko perusahaan.
  • Hasil yang dilaporkan dalam format yang ditentukan pada waktu yang diperlukan untuk memenuhi persyaratan investor dan peraturan.

Microsoft membantu memenuhi kebutuhan ini melalui kombinasi layanan Azure dan penawaran mitra di Marketplace Azure. Dalam artikel ini, ada contoh praktis yang menunjukkan cara melakukan eksperimen ad-hoc dengan menggunakan R. Kita mulai dengan menjelaskan cara menjalankan eksperimen pada satu komputer. Selanjutnya, kami menunjukkan kepada Anda cara menjalankan eksperimen yang sama di Azure Batch, dan kami menutup dengan menunjukkan kepada Anda cara memanfaatkan layanan eksternal untuk pemodelan. Opsi dan pertimbangan untuk eksekusi model yang ditentukan di Azure dijelaskan dalam artikel ini yang berfokus pada perbankan dan asuransi.

Pemodelan analis di R

Mari kita mulai dengan melihat bagaimana R dapat digunakan oleh analis dalam skenario pasar modal yang disederhanakan dan representatif. Anda dapat membangun ini baik dengan mereferensikan pustaka R yang ada untuk perhitungan atau dengan menulis kode dari awal. Dalam contoh kami, kita juga harus mengambil data harga eksternal. Untuk menjaga contoh sederhana tetapi ilustrasi, kami menghitung potensi eksposur di masa depan (PFE) dari kontrak penerusan saham ekuitas. Contoh ini menghindari teknik pemodelan kuantitatif yang kompleks untuk instrumen seperti turunan kompleks dan berfokus pada satu faktor risiko untuk berkonsentrasi pada siklus hidup risiko. Contoh kami memungkinkan Anda melakukan hal berikut:

  • Pilih instrumen yang menarik.
  • Harga historis sumber untuk instrumen.
  • Tindakan harga ekuitas model dengan menggunakan perhitungan Monte Carlo (MC) sederhana, yang menggunakan Geometric Brownian Motion (GBM):
    • Memperkirakan μ pengembalian yang diharapkan (mu) dan volatilitas σ (theta).
    • Kalibrasi model ke data historis.
  • Visualisasikan berbagai jalur untuk mengomunikasikan hasilnya.
  • Plot max(0,Stock Value) untuk menunjukkan arti PFE, perbedaan terhadap value at risk (VaR). Untuk mengklarifikasi:

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

  • Ambil Kuantil 0,95 untuk mendapatkan nilai PFE pada setiap langkah/akhir periode simulasi.

Kami akan menghitung PFE untuk penerusan ekuitas berdasarkan saham Microsoft (MSFT). Seperti disebutkan sebelumnya, untuk memodelkan harga saham, harga historis untuk saham MSFT diperlukan sehingga kita dapat mengkalibrasi model ke data historis. Ada banyak cara untuk memperoleh harga saham historis. Dalam contoh kami, kami menggunakan versi gratis layanan harga saham dari penyedia layanan eksternal, Quandl.

Catatan

Contohnya menggunakan himpunan data HARGA WIKI yang dapat digunakan untuk konsep pembelajaran. Untuk penggunaan produksi ekuitas berbasis AS, Quandl merekomendasikan penggunaan himpunan data Harga Saham AS Akhir Hari.

Untuk memproses data dan menentukan risiko yang terkait dengan ekuitas, kita perlu melakukan hal-hal berikut:

  • Mengambil data riwayat dari ekuitas.
  • Tentukan μ pengembalian dan volatilitas yang diharapkan σ dari data historis.
  • Model harga saham yang mendasar menggunakan beberapa simulasi.
  • Jalankan model.
  • Tentukan paparan ekuitas di masa depan.

Kita mulai dengan mengambil saham dari layanan Quandl dan merencanakan riwayat harga penutupan selama 180 hari terakhir.

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

Dengan data di tangan, kami mengkalibrasi 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])

Selanjutnya, kami memodelkan harga saham yang mendasar. Kita dapat menerapkan proses GBM diskrit dari awal atau menggunakan salah satu dari banyak paket R yang menyediakan fungsionalitas ini. Kami menggunakan sde paket R (Simulasi dan Inferensi untuk Persamaan Diferensial Stochastic) yang menyediakan metode pemecahan masalah ini. Metode GBM memerlukan serangkaian parameter yang dikalibrasi ke data historis atau diberikan sebagai parameter simulasi. Kami menggunakan data historis, menyediakan μ, σ, dan harga saham di awal simulasi (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)

Kami sekarang siap untuk memulai simulasi Monte Carlo untuk memodelkan potensi paparan untuk beberapa jumlah jalur simulasi. Kami akan membatasi simulasi hingga 50 jalur Monte Carlo dan 256 langkah waktu. Sebagai persiapan untuk menskalakan simulasi dan memanfaatkan paralelisasi di R, perulangan simulasi Monte Carlo menggunakan pernyataan 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)

Kami sekarang telah mensimulasikan harga saham MSFT yang mendasar. Untuk menghitung paparan ekuitas ke depan, kami mengurangi premium dan membatasi paparan ke hanya nilai positif.

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

Dua gambar berikutnya menunjukkan hasil simulasi. Gambar pertama menunjukkan simulasi Monte Carlo dari harga saham dasar untuk 50 jalur. Gambar kedua menggambarkan paparan kredit yang mendasar untuk ekuitas ke depan setelah mengurangi premi ekuitas ke depan dan membatasi paparan nilai positif.

Gambar 1 - 50 Jalur Monte Carlo

Gambar 1 - 50 jalur Monte Carlo

Gambar 2 - Paparan Kredit untuk Ekuitas Maju

Gambar 2 - Paparan kredit untuk ekuitas ke depan

Pada langkah terakhir, PFE kuantil 0,95 1 bulan dihitung dengan kode berikut.

# 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")
Potensi paparan masa depan untuk MSFT Equity Forward

Gambar 3 Potensi paparan masa depan untuk ekuitas MSFT ke depan

Menggunakan Azure Batch dengan R

Solusi R yang dijelaskan di atas dapat dihubungkan ke Azure Batch dan memanfaatkan cloud untuk perhitungan risiko. Ini membutuhkan sedikit upaya ekstra untuk perhitungan paralel seperti kita. Tutorial ini, Jalankan simulasi R paralel dengan Azure Batch, menyediakan informasi terperinci tentang menyambungkan R ke Azure Batch. Di bawah ini kami menunjukkan kode dan ringkasan proses untuk menyambungkan ke Azure Batch dan cara memanfaatkan ekstensi ke cloud dalam perhitungan PFE yang disederhanakan.

Contoh ini menangani model yang sama yang dijelaskan sebelumnya. Seperti yang telah kita lihat sebelumnya, perhitungan ini dapat berjalan di komputer pribadi kita. Peningkatan ke jumlah jalur Monte Carlo atau penggunaan langkah-langkah waktu yang lebih kecil akan mengakibatkan waktu eksekusi yang jauh lebih lama. Hampir semua kode R akan tetap tidak berubah. Kami akan menyoroti perbedaan di bagian ini.

Setiap jalur simulasi Monte Carlo berjalan di Azure. Kita dapat melakukan ini karena setiap jalur independen dari yang lain, memberi kita perhitungan yang mudah diparalelkan.

Untuk menggunakan Azure Batch, kami menentukan kluster yang mendasar dan mereferensikannya dalam kode sebelum kluster dapat digunakan dalam perhitungan. Untuk menjalankan perhitungan, kami menggunakan definisi cluster.json berikut:

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

Dengan definisi kluster ini, kode R berikut menggunakan kluster:


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

Terakhir, kami memperbarui pernyataan foreach dari sebelumnya untuk menggunakan paket doAzureParallel. Ini adalah perubahan kecil, menambahkan referensi ke paket sde dan mengubah %do% menjadi %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()

Setiap simulasi Monte Carlo dikirimkan sebagai tugas ke Azure Batch. Tugas dijalankan di cloud. Hasil digabungkan sebelum dikirim kembali ke workbench analis. Pengangkatan berat dan komputasi dijalankan di cloud untuk mengambil keuntungan penuh dari penskalaan dan infrastruktur yang mendasar yang diperlukan oleh perhitungan yang diminta.

Setelah penghitungan selesai, sumber daya tambahan dapat dengan mudah dimatikan dengan memanggil satu instruksi berikut:

# Stop the cloud cluster
stopCluster(cluster)

Menggunakan penawaran SaaS

Dua contoh pertama menunjukkan cara menggunakan infrastruktur lokal dan cloud untuk mengembangkan model valuasi yang memadai. Paradigma ini sudah mulai bergeser. Dengan cara yang sama seperti infrastruktur lokal telah berubah menjadi layanan IaaS dan PaaS berbasis cloud, pemodelan angka risiko yang relevan berubah menjadi proses yang berorientasi pada layanan. Analis saat ini menghadapi dua tantangan besar:

  • Persyaratan peraturan menggunakan peningkatan kapasitas komputasi untuk ditambahkan ke persyaratan pemodelan. Regulator meminta angka risiko yang lebih sering dan terbaru.
  • Infrastruktur risiko yang ada telah tumbuh secara organik dengan waktu dan menciptakan tantangan ketika menerapkan persyaratan baru dan pemodelan risiko yang lebih maju dengan cara yang gesit.

Layanan berbasis cloud dapat memberikan fungsionalitas yang diperlukan dan mendukung analisis risiko. Pendekatan ini memiliki beberapa keuntungan:

  • Perhitungan risiko paling umum yang diperlukan oleh regulator harus diimplementasikan oleh semua orang berdasarkan peraturan. Dengan menggunakan layanan dari penyedia layanan khusus, analis mendapat manfaat dari penghitungan risiko yang siap digunakan dan sesuai peraturan. Layanan tersebut dapat mencakup perhitungan risiko pasar, perhitungan risiko mitra, X-Value Adjustment (XVA), dan bahkan perhitungan Fundamental Review of Trading Book (FRTB).
  • Layanan ini mengekspos antarmuka mereka melalui layanan web. Infrastruktur risiko yang ada dapat ditingkatkan oleh layanan lain ini.

Dalam contoh kami, kami ingin memanggil layanan berbasis cloud untuk perhitungan FRTB. Beberapa di antaranya dapat ditemukan di AppSource. Untuk artikel ini, kami memilih opsi uji coba dari Risiko Vektor. Kami akan terus memodifikasi sistem kami. Kali ini, kami menggunakan layanan untuk menghitung angka risiko yang menarik. Prosesnya terdiri dari langkah berikut:

  1. Panggil layanan risiko yang relevan dengan parameter yang tepat.
  2. Tunggu hingga layanan menyelesaikan penghitungan.
  3. Ambil dan masukkan hasilnya ke dalam analisis risiko.

Diterjemahkan ke dalam kode R, kode R kami dapat ditingkatkan dengan definisi nilai input yang diperlukan dari templat input yang disiapkan.

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)

Selanjutnya, kita perlu memanggil layanan web. Dalam hal ini, kami memanggil metode StartCreditExposure untuk memicu perhitungan. Kami menyimpan titik akhir untuk API dalam variabel bernama titik akhir.

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

Setelah perhitungan selesai, kami mengambil hasilnya.

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

Ini meninggalkan analis untuk melanjutkan dengan hasil yang diterima. Angka risiko yang relevan minat diekstrak dari hasil dan diplot.

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

Plot yang dihasilkan terlihat seperti ini:

Gambar 4 - Paparan kredit untuk ekuitas MSFT ke depan - Dihitung dengan mesin risiko berbasis cloud.

Gambar 4 - Paparan kredit untuk ekuitas MSFT ke depan - Dihitung dengan mesin risiko berbasis cloud

Gambar 5 - Potensi paparan masa depan untuk ekuitas MSFT ke depan - Dihitung dengan mesin risiko berbasis cloud

Gambar 5 - Potensi paparan masa depan untuk ekuitas MSFT ke depan - Dihitung dengan mesin risiko berbasis cloud

Pertimbangan

Akses fleksibel ke cloud melalui infrastruktur komputasi dan layanan analisis risiko berbasis SaaS dapat memberikan peningkatan kecepatan dan kelincahan bagi analis risiko yang bekerja di pasar modal dan asuransi. Dalam artikel ini kami bekerja melalui contoh yang menggambarkan cara menggunakan Azure dan layanan lain menggunakan alat yang diketahui analis risiko. Coba manfaatkan kemampuan Azure saat Anda membuat dan meningkatkan model risiko Anda.

Kontributor

Artikel ini dikelola oleh Microsoft. Ini awalnya ditulis oleh kontributor berikut.

Penulis utama:

Langkah berikutnya