computação em finanças em hardware gráfico

Computação em Finanças em Hardware Gráfico

SEMAC 2012 - UNESP

Thársis T. P. Souza [email protected]

Instituto de Matemática e Estatística - Universidade de São Paulo

16/05/2012 Instituto de Matemática e Estatística - Universidade de São Paulo 2

GPU Computing CUDA

Aplicações em Finanças

Precificação de Opções

Risco de Mercado Conclusão


GPU Computing CUDA




CPU GPU

Tarefas sequenciais

Cache eficiente

Maior quantidade de memória principal

Controle de fluxo

Número de cores de 1 ordem de grandeza

1, 2 threads por core

Tarefas com paralelismo de dados

Múltiplas ULAs

Maior (capacidade) operações de ponto flutuante por segundo

Alto throughput de memória

Dezenas de multiprocessors

Múltiplas threads por multiprocessor

16/05/2012 4 Instituto de Matemática e Estatística - Universidade de São Paulo


Figura 1: Número de operações de ponto flutuante por segundo


Figura 2: Throughput de memória CPU x GPU


$144K $4 Million 28x Lower Cost

48 GPUs 2000 CPUs 42x Lower Space

$31K / year $1.2 Million / year 38x Lower Power Cost Fonte: NVIDIA Brasil


2 Tesla S1070s 500 CPU Servers

2.8 kWatts 37.5 kWatts

$24 K $250 K

16x Less Space

13x Lower Power

10x Lower Cost

Fonte: NVIDIA Brasil


General-purpose computing on Graphics Processing Units Técnica de uso de GPU para computação de propósito geral

Linguagens/API’s

OpenGL DirectX Cg Brook Brook+ OpenCL CUDA



Compute capability: 2.0

Single Precision Floating Point Performance : 1.03 TFlops

Device copy overlap: Enabled

Kernel timeout : Disabled

Total dedicated memory: 3GB GDDR5

Constant mem: 64KB

Numero de multiprocessadores: 14

Shared mem por mp: 48KB

Registers por mp: 32768

Threads in warp: 32

Max threads per block: 1024

Max thread dimension: (1024, 1024, 64)

Max grid dimension: (65535, 65535, 1)


GPU Computing CUDA





Compute Unified Device Architecture

Arquitetura paralela de propósito geral

Tecnologia proprietária NVIDIA


Arquitetura de Computação Paralela para propósito geral Facilita computação heterogênea (CPU +

GPU)

Suporte a varias linguagens e APIs

CUDA define: Modelo de programação

Modelo de memória

Modelo de execução


Porções paralelas da aplicação são executadas como kernels

CUDA threads

Lighweight

Fast switching

Milhares (potencialmente) executadas ao mesmo tempo


Um kernel executa um grid de blocos de threads

Um bloco é formado por um conjunto

de threads

Cada thread pode ser unicamente

endereçada


Thread

Registradores


Thread

Registradores

Thread

Local Memory


Thread

Registradores

Thread

Local Memory

Bloco

Shared Memory


Thread

Registradores

Thread

Local Memory

Bloco

Shared Memory

Grid

Global Memory


Biblioteca e um compilador para criação de rotinas em GPUs NVIDIA

API de mais alto nível em comparação com: Cg, OpenGL, DirectX

Exige conhecimento de arquitetura para codificação

Amplamente utilizada

Possui grande comunidade e boa documentação

Maioria de artigos publicados em programação em GPGPU utiliza

CUDA C


#include <stdlib.h> #include <stdio.h> __global__ void kernel(int *array) { //do work } int main(void) { int num_elements = 256; int num_bytes = num_elements *

sizeof(int); int *host_array = 0; host_array = (int*)malloc(num_bytes); int *device_array = 0; cudaMalloc((void**)&device_array,

num_bytes);

int block_size = 128; int grid_size = num_elements /

block_size;

kernel<<<grid_size,block_size>>>(device_array);

cudaMemcpy(host_array, device_array,

num_bytes, cudaMemcpyDeviceToHost);

for(int i=0; i < num_elements; ++i) { printf("%d ", host_array[i]); } free(host_array); cudaFree(device_array); }


#include <stdlib.h> #include <stdio.h> __global__ void kernel(int *array) { //do work } // C function int main(void) { int num_elements = 256; int num_bytes = num_elements *


num_bytes);


block_size;







sizeof(int); // ponteiro para host memory int *host_array = 0; // aloca espaço em host memory host_array = (int*)malloc(num_bytes); int *device_array = 0; cudaMalloc((void**)&device_array,

num_bytes);


block_size;







sizeof(int); int *host_array = 0; host_array = (int*)malloc(num_bytes); // Ponteiro para device memory int *device_array = 0; // Aloca espaço em device memory cudaMalloc((void**)&device_array,

num_bytes);


block_size;








num_bytes);

// configuracao de bloco e grid int block_size = 128; int grid_size = num_elements /

block_size;






#include <stdlib.h> #include <stdio.h> // extensao __global __ define kernel __global__ void kernel(int *array) { //do work } int main(void) { int num_elements = 256; int num_bytes = num_elements *


num_bytes);


block_size; // lancamento do kernel








num_bytes);


block_size;


// transfere resultado da GPU para CPU cudaMemcpy(host_array, device_array,






num_bytes);


block_size;




// inspecao do resultado for(int i=0; i < num_elements; ++i) { printf("%d ", host_array[i]); } free(host_array); cudaFree(device_array); }




num_bytes);


block_size;




for(int i=0; i < num_elements; ++i) { printf("%d ", host_array[i]); } // desaloca memoria free(host_array); cudaFree(device_array); }


Definido por extensão __global__

Configurado por sintaxe <<<grid_size, block_size>>>


Todas as threads em um mesmo grid executam o mesmo kernel Necessidade de haver coordenadas únicas para distinção

Coordenadas criadas pelo CUDA Runtime System:

blockIdx índice do bloco

threadIdx índice da thread

gridDim dimensão do grid

blockDim dimensão dos blocos


Kernel é bidimensional

Indexação de bloco

blockIdx.x blockIdx.y

Blocos são tridimensionais

Indexação de thread

threadIdx.x

threadIdx.y

threadIdx.z


GPU Computing CUDA





Opção: Direito negociável de compra de mercadorias, títulos, ações etc., com pagamento em data futura e preços pré determinados

Ativo objeto: ativo ao qual o direito de compra e venda está sendo negociado

Prêmio: Preço da Opção

Spot: Preço à vista do ativo objeto

Strike: Preço de exercício da opção. Valor futuro negociado.


Exemplo: Uma Opção de Compra (Call) de Ouro à R$100 em 24/12 é vendida a R$5. Paga-se um prêmio de R$5 para se ter a opção de comprar Ouro à R$100 na data futura 24/12.

Caso em 24/12 o preço à vista (Spot) do ouro seja maior do que R$100 (in-the-money), podemos lucrar ao exercer a opção de compra e vendê-la em seguida (day-trade).

Caso em 24/12 o preço à vista (Spot) do ouro seja menor do que R$100 (out-of-money), não vale a pena o exercício da opção.


O Modelo de Black & Scholes fornece um valor de prêmio (V) para uma Opção:

S (Spot); X (Strike); T (tempo para vencimento); r (taxa de juros); v (Volatilidade); CND (Distribuição Normal Padrão Acumulada)


Distribuição Normal Padrão Acumulada:


Distribuição Normal Padrão Acumulada:

Aproximação como um polinômio de quinta ordem [Hull]:


Passos para Precificação: Alocar vetores no Host: hOptSpot(N), hOptStrike(N), ...

Alocar vetores no Device: dOptSpot(N), dOptStrike(N), ...




Inicializar vetores com variáveis dos contratos e mercado

Transferir vetores da memória host para device memory






Precificar opção em GPU via Black&Scholes






Precificar opção em GPU via Black&Scholes

Transferir resultado da GPU para Host

Desalocar memória


Fonte: Oneye, 2008

Desempenho CPU vs. GPU Precificação de Opções via Black-Scholes


Muitas vezes, não é possível encontrar uma expressão analítica para precificar um derivativo.

Simulação de Monte Carlo é uma alternativa: 1. Definição do comportamento estocástico para os preços do

instrumento financeiro

2. Geração de números aleatórios para simulação

3. Cálculo dos valores do instrumento

4. Repetir N vezes os passos 2 e 3, com N tendendo ao infinito

5. Determinação da precificação a partir da distribuição dos valores obtidos anteriormente


1. Definição do Processo Estocástico:

Assume-se, geralmente, que o preço do instrumento financeiro segue um movimento Browniano Geométrico

sendo, µ = taxa de rentabilidade esperada para o instrumento σ = desvio padrão da taxa de rentabilidade do instrumento

dW = representa parcela aleatória do movimento


1. Definição do Processo Estocástico:

Assim, chega-se a uma expressão que fornece a variação do preço do instrumento em um δt:

onde, 𝜀𝑡 representa uma variável aleatória que segue uma distribuição normal entre 0 e 1.


2. Para geração dos números aleatórios desejados, podemos utilizar o método de Box-Muller

onde, 𝑥1, 𝑥2 ∈ 𝑁 e 𝑧1, 𝑧2 ∈ 𝑁(0,1)


3. O Prêmio da Opção (𝑐𝑡) pode ser calculado a partir de um valor esperado de seu retorno (Spot – Preço de Exercício)

4. Ao simular aleatoriamente o preço do instrumento 𝑆𝑇, podemos precificar a opção como


Toda a geração de números aleatórios pode ser naturalmente realizada de forma paralela na GPU

As simulações dos preços dos instrumentos são independentes, portanto podem ser realizadas ao mesmo tempo

A capacidade de gerar maior número de simulações resulta em maior precisão no resultado


[Myungho]

Desempenho CPU vs. GPU Método Box-Muller


[Myungho]

Desempenho CPU vs. GPU Simulação de Monte Carlo


GPU Computing CUDA





Possibilidade de ocorrência de perdas resultantes da flutuação nos valores de mercado de posições ativas e passivas detidas pelas instituições financeiras. (JP Morgan)

O risco de mercado inclui os riscos das operações sujeitas a variação cambial,

taxa de juros,

preços das ações e

preços de mercadorias (commodities)


Value-at-Risk representa a perda máxima potencial de uma carteira, em um horizonte de tempo definido, com determinado grau de confiança

Exemplo: Banco anuncia para carteira de sua tesouraria, um VaR de US$ 15 milhões, para o horizonte de tempo de 1 dia e grau de confiança 95%.


Ex.: Supondo uma exposição ao mercado de R$1.000.000, teríamos um risco de perda máxima de R$40.000, em um dia, com uma confiança de 95%.


VaR Stress: teste que visa a validar a qualidade do VaR estimado.

Simulação de caminhos alternativos do comportamento do preço dos instrumentos de uma carteira para avaliar se o resultante valor do portfolio excedeu a perda máxima prevista pelo VaR.


Como já visto, o preço de um instrumento pode ser simulado como:

Em uma arquitetura serial, cada carteira deve ser precificada sequencialmente e os instrumentos são simulados iterativamente.


Em uma GPU podemos simular o comportamento de um portfólio de modo paralelo. Cada thread precificando os instrumentos de simulações diferentes.


Outra abordagem possível seria a paralelização da precificação dos instrumentos. Assim, teríamos uma thread para cada ativo em diferentes simulações de carteira.


[Gregoriou]


GPU Computing CUDA





Computação de propósito geral em GPU é uma realidade.

Novo paradigma de computação. Algoritmos precisam ser repensados.

Problemas em Finanças podem exigir muita capacidade computacional

GPGPU pode viabilizar a solução desses problemas


I. GPUBrasil (http://gpubrasil.com), Maio 2012.

II. CUDA by example, an introduction to General-Purpose GPU Programming, J. Sanders and E. Kandrot, Addison Wesley.

III. Programming Massively Parallel Processors: A Hands-on Approach, D. Kirk, W. Hwu, Morgan Kaufman.

IV. NVIDIA CUDA C Best Practices Guide. NVIDIA, Version 3.2, 20/8/2010.

V. NVIDIA CUDA C Programming Guide. NVIDIA, Version 3.2, 11/9/2010.

VI. NVIDIA's Next Generation CUDA Compute Architecture: Fermi. NVIDIA Whitepaper, Version 1.1.

VII. Optimization principles and application performance evaluation of a multithreaded gpu using cuda. Shane Ryoo, Christopher I. Rodrigues, Sara S. Baghsorkhi, Sam S. Stone, David B. Kirk, and Wen mei W. Hwu. In PPoPP, pages 73-82. ACM, 2008.

VIII. [Gregoriou] The VaR Implementation Handbook. Greg N. Gregoriou.

IX. [Hull] Options, Futures, and Other Derivatives. John C. Hull.

X. [Myungho] Parallel Implementation of a Financial Application on a GPU. Myungho Lee, Jin-hong Jeon, Jongwoo Bae, Hyuk-Soo Jang.

XI. [Solomon] Option Pricing on GPU. Steven Solomon, Ruppa K. Thulasiram and Parimala Thulasiraman.

http://gpubrasil.com

Computação em Finanças em Hardware Gráfico

SEMAC 2012 - UNESP

Thársis T. P. Souza [email protected]

Instituto de Matemática e Estatística - Universidade de São Paulo

Download da Apresentação:

gpubrasil.com

16/05/2012 81

computação em finanças em hardware gráfico

Economy & Finance