IRS: Maiores reduções sentem-se nos 6.º, 7.º e 8.º escalões. Veja as simulações

[FredericoRocha]

Tens algum link ou documento que fale como fazer regressão linear em python?

edit: A minha ideia basicamente é tentar fazer o plot de linhas de tendência

[VirtuaGod]

Porque não gosto de ser limitado entre escolhas de linguagens acabei de fazer o que no futuro poderá ser o meu workflow em projectos maiores.

.Tratamento de dados em R (tidyverse + R/finance)
.Apresentação de dados em Python (Visualmente muito mais agradáveis e simples de fazer)

Para passar os dados de um lado para o outro uso os velhinhos ficheiros CSV. Estas linguagens são tão optimizadas na leituras de ficheiros CSV que nem é necessário usar nada high tech como feather ou hdf5.

Em R:

Criação de um dataframe com as 'cotações' de carteiras 4Fundos (defensiva, moderada/pesos iguais e agressiva) assim como um dataframe a matrix de correlação dos fundos que compõe cada carteira.

Crio ficheiros CSV com ambos os dataframes.

Em Python:

Leio ambos os dataframes e apresento os dados, no limite fazendo um pequeno tratamento dos dados para apresentação.

Deem uma vista de olhos se quiserem:

R: https://nbviewer.jupyter.org/github/LuisSousaSilva/Articles-and-studies/blob/master/4Fundos%20%28R%20and%20Python%29/4Fundos%201%20%28R%29.ipynb
Python: https://nbviewer.jupyter.org/github/LuisSousaSilva/Articles-and-studies/blob/master/4Fundos%20%28R%20and%20Python%29/4Fundos%202%20%28Python%29.ipynb

[VirtuaGod]

Descobri recentemente que um fundo que gosto bastante, o MFS Total Return tb existe com hedging cambial.

Portanto é um fundo mas com dois comportamentos, pois poderá ter, ou não hedge cambial. Fiz uma análise de quanto os fundos são diferentes devido ao hedging e fiz uma 'carteira' imaginária com 50% em cada classe. Isto tudo devido à recente valorização do euro e reanálise de carteiras/fundos que sofreram com isso.

MFSTR_A1 = versão sem hedge cambial
MFSTR_AH1 = versão com hedge cambial

No link poderão encontrar o Jupiter Notebook com código python que escrevi para a análise, assim como todos os gráficos e outputs necessários à compreensão da análise:

MFSTR_A1 vs MFSTR_AH1

[VirtuaGod]

Modern Drive An Introduction to Statistical and Data Sciences via R by Chester Ismay and Albert Y. Kim

[VirtuaGod]

Depois de mostrar o gráfico a algumas pessoas apercebi-me que para leigos não é de análise directa.

Inclui mais alguma info nos gráficos para potential explicações no futuro. O gráfico abaixo é "perfeito" do ponto de vista teórico, fazendo a curva da Fronteira eficiente de uma forma que parece saído de um livro de finanças. Há possibilidade de eu fazer um post a ensinar a analisar o "borrão" do outro gráfico.

Adições em relação ao último gráfico:

Linha de Fronteira eficiente a azul, com o objectivo de a mostrar de forma mais clara e perceptível;
Seta a servir de anotação;
Legenda "Rácio de Sharpe" incluída ao lado do colormap para melhor se entender o objectivo das cores;
Colormap viridis em vez de plasma (mas é apenas uma questão de preferência);
Pontos do scatter plot mais pequenos pois parecem-me mais bonitos.

Entretanto já aprendi a colocar isto na net estilo RPubs, por isso quando partilhar o código vão ver os gráficos e outputs etc etc.

P.S. Neste gráfico os valores de retorno e desvio padrão estão 100 vezes mais pequenos, porque ainda não os ajustei para percentagem.

[VirtuaGod]

Por curiosidade, qual é a covariância desse portefólio?

Covariância mesmo não tenho mas tenho Coeficiente de correlação de pearson que penso que chega para analisar o que pretendes. Não sei se era outra coisa que pretendias, mas se for pede que se tiver coloco aqui.

Segue abaixo a matrix de correlação. O código já está em loop para ser simples de adicionar os fundos e datas, correr e esperar pelo output. O output vai desde esta matrix de correlação ao gráfico anterior da fronteira eficiente, passando pela carteira com maior sharpe e com menor desvio padrão (até as posso pintar de outra cor no gráfico se quiser). Estou neste momento a fazer um output extra para fazer a comparação entre a análise in-sample (naturalmente optimizada) para análise out-of-sample (não optimizada) para ver se a carteira continua com risco semelhante e retorno dentro do expectável (o retorno expectável não é bem o retorno histórico mas isso já são conceitos financeiros).

O engraçado é que, contrariamente às minhas expectativas, prefiro esta forma aleatória de ver qual as melhores carteiras do que a versão "perfeita" (usado optimizadores matemáticos). A aleatoriedade torna os portfolios mais realistas em vez de sobreoptimizados.

[VirtuaGod]

Não tenho seguido o tópico pois tenho me dedicado a outros assuntos pessoais. De qualquer forma, gosto de ver que foste brincar com o python. Na verdade, acho q me vou dar melhor com python do que com R.

É questão de preferência. Para mim vai dar mais ou menos ao mesmo. É uma questão de habituação. Mas para mim R ganha pela comunidade. Hadley Wickham + Yihui Xie + Garrett Grolemund em data science (todos trabalham para o RStudio e estão por grau de importância no meu work flow) e toda a comunidade R/Finance acaba por dar peso ao R. Não é a linguagem em si, é mesmo pela comunidade e bibliotecas disponíveis. A empresa que está por detrás do Quantopian está a tentar dar um empurrão a Python Finance mas está a deixar muito a desejar face ao que se faz em R.

A única coisa que ADORO em python são mesmo os gráficos. Matplotlib e todas as bibliotecas feitas com base nele (i.e. seaborn) é LINDO para os meus olhos. A maioria do pessoal prefere o ggplot2 mas eu nem aprecio muito.

Tenho de aprender a chamar o python através do R e o meu workflow fica quase perfeito. A questão é mesmo saber às vezes fazer algo numa linguagem e não saber fazer noutra ou ter preferências por uma biblioteca em R (Tidyverse e a PerformanceAnalytics) e outras em Python (Matplotlib). O uso de um IDE que language agnostic como o Bleaker Notebooks é uma possibilidade também, embora não tenha ainda conseguido colocar aquilo a funcionar correctamente.

Em termos de linguagem, apercebo-me que há enormes vantagens em aprender ambas porque ambas as comunidades têm os seus enviesamentos. Por exemplo o pessoal em python adora For Loops quando a funcionalidade .apply que o pandas tem é muito mais rápida (foi adoptada de R). Por outro lado o pessoal em R não usa append() com muita frequência. Acabo por ser um melhor programador por aprender as duas línguas.

Em Setembro, depois dumas curtas férias, volto aqui e ver com atenção o que posso aprender com python. Mas no fundo, sei que irei dar sempre ao mesmo: Aprender sobre estatística para finanças (e não sobre programação q é o meu forte).

Se calhar recomendo então que estudes mas é finanças. Porque eu já sei o que quero fazer, só não sabia como. Tu estás do lado oposto. Embora caros mas se queres levar isto a sério recomendo:

https://www.amazon.com/Quantitative-Inv ... ntitative#
https://www.amazon.com/Quantitative-Inv ... antitative
https://www.amazon.com/Managing-Investm ... C5KXYPV8X8
https://www.amazon.com/Managing-Investm ... NMMAMEHEEQ

Compra pelo bookdepository ou amazon espanhola.

Podes tb quer saltar para algo mais prático e que te vai explicando os conceitos básicos por detrás do que se vai fazendo. Por 10 euros cada valem bem a pena, embora haja algum overlap no material explicado acabas por aprender técnicas diferentes de fazer a mesma coisa (pesquisa no google por coupons udemy se não estão a 10 euros nesse momento, lembra-te é de ir limpando os cookies do browser).

https://www.udemy.com/python-for-financ ... 4/overview
https://www.udemy.com/python-for-financ ... 4/overview

Sobre visualização de dados (graficos, cores, interacção, etc) recomendo que
leias sobre info vis. É Muitas vezes através destas técnicas q se encontram
(ou se escondem) padroes de correlação! Por exemplo:

-> https://vtechworks.lib.vt.edu/bitstream ... sAllowed=y

-> http://openaccess.city.ac.uk/15205/1/20 ... lytics.pdf

-> http://blog.scottlogic.com/2014/09/26/a ... th-d3.html

Vou dar uma vista de olhos. É um tema que me interessa. Como já viste pelas minhas preferências por matplotlib tenho gostos bastante particulares em termos visuais. O ideal até seria aprender D3.js mas isso já é para pessoas que fazem disto vida, para já estou satisfeito.

[LoneWolf]

Muito bem VG!
Proud of you!

Nao tenho seguido o tópico pois tenho me dedicado a outros assuntos pessoais.
De qlqer forma, gosto de ver que foste brincar com o python. Na verdade, acho
q me vou dar melhor com python do que com R. Em setembro, depois dumas
curtas férias, volto aqui e ver com atençao o que posso aprender com python.
Mas no fundo, sei que irei dar sempre ao mesmo: Aprender sobre estatística
para finanças (e nao sobre programaçao q é o meu forte).

Sobre visualização de dados (graficos, cores, interacção, etc) recomendo que
leias sobre info vis. É Muitas vezes através destas técnicas q se encontram
(ou se escondem) padroes de correlação! Por exemplo:

-> https://vtechworks.lib.vt.edu/bitstream ... sAllowed=y

-> http://openaccess.city.ac.uk/15205/1/20 ... lytics.pdf

-> http://blog.scottlogic.com/2014/09/26/a ... th-d3.html


Cumprimentos,
LW

[Ingenting]

A minha obra prima. Este gráfico é a razão pela qual comecei com programação. O resto foram extras engraçados que fui encontrando pelo caminho, incluindo o site, que tanto jeito me dá. Acabei por gostar mais disto do que estava à espera e estou curioso para saber o que mais aí vem à frente.

O gráfico tem 3 aspectos. O mais simples de compreender é o risco (eixo X) e retorno (eixo Y) mas adicionei agora a cor, que é o rácio de sharpe. Daqui podemos encontrar tudo, desde o fundo com maior sharpe ao fundo com menor desvio padrão. Sabem que me gosto mais de gerir pelo risco, pois é mais estável ao longo do tempo, do que do retorno.

Na parte 3 do código python já vem assim bonito. Uma evolução face ao gráfico azul.

Os fundos são: ['FCI', 'GS_SC', 'MG_OI', 'PimcoGB', 'MFSGE', 'MFSTR']
Com códigos MSid: ['F0GBR04EAN', 'F000000FH0', 'F0000007LD', "F0GBR06T61", 'F0GBR04E6R', 'F0GBR05ZUY']
Testados desde: "2007-12-31"
Até: "2015-12-30"

Por curiosidade o portfolio com menor desvio padrão é: [0.0100774941436, 0.0141581164179, 0.484729067521, 0.43531116483, 0.0348043879285, 0.0209197691586].

Inclui 1% de FCI (Fidelity Consumer Industries), 1.4% de GS_CS (Goldman Sachs Global Small Caps), 3.5% de MFSGE (MFS Global Equity) e 2.1% de MFSTR (MFS Total Return). Ou seja, 5.9% de fundos accionistas e 2.1% de um misto agressivo. Adicionando fundos agressivos mas descorrelacionados com os fundos defensivos fez a carteira como um todo diminuir de risco.

Bónus: Portfolio com max sharpe: [0.0306453255327, 0.00182367708483, 0.496371635424, 0.410084582471, 0.00918309092572, 0.0518916885615]
.

Por curiosidade, qual é a covariância desse portefólio?

[VirtuaGod]

A minha obra prima. Este gráfico é a razão pela qual comecei com programação. O resto foram extras engraçados que fui encontrando pelo caminho, incluindo o site, que tanto jeito me dá. Acabei por gostar mais disto do que estava à espera e estou curioso para saber o que mais aí vem à frente.

O gráfico tem 3 aspectos. O mais simples de compreender é o risco (eixo X) e retorno (eixo Y) mas adicionei agora a cor, que é o rácio de sharpe. Daqui podemos encontrar tudo, desde o fundo com maior sharpe ao fundo com menor desvio padrão. Sabem que me gosto mais de gerir pelo risco, pois é mais estável ao longo do tempo, do que do retorno.

Na parte 3 do código python já vem assim bonito. Uma evolução face ao gráfico azul.

Os fundos são: ['FCI', 'GS_SC', 'MG_OI', 'PimcoGB', 'MFSGE', 'MFSTR']
Com códigos MSid: ['F0GBR04EAN', 'F000000FH0', 'F0000007LD', "F0GBR06T61", 'F0GBR04E6R', 'F0GBR05ZUY']
Testados desde: "2007-12-31"
Até: "2015-12-30"

Por curiosidade o portfolio com menor desvio padrão é: [0.0100774941436, 0.0141581164179, 0.484729067521, 0.43531116483, 0.0348043879285, 0.0209197691586].

Inclui 1% de FCI (Fidelity Consumer Industries), 1.4% de GS_CS (Goldman Sachs Global Small Caps), 3.5% de MFSGE (MFS Global Equity) e 2.1% de MFSTR (MFS Total Return). Ou seja, 5.9% de fundos accionistas e 2.1% de um misto agressivo. Adicionando fundos agressivos mas descorrelacionados com os fundos defensivos fez a carteira como um todo diminuir de risco.

Bónus: Portfolio com max sharpe: [0.0306453255327, 0.00182367708483, 0.496371635424, 0.410084582471, 0.00918309092572, 0.0518916885615]
.

[VirtuaGod]

Já sacaram o novo RStudio? Está todo bonito, principalmente para alguém que usa um tema escuro como eu (monokai).

[VirtuaGod]

quer dizer eurostoxx caput? não há codigo

Nops. Cotações americanas até há grátis, já todas tratadas para introdução neste tipo de software para tratamento estatístico. Aqui népias. Estamos a anos luz deles

assim perdeu algum do interesse para mim mas vou ver os fundos qd tiver tempo anyway

Tive a dar uma olhadela ao site da yahoo e sem API mas tem as cotações necessárias lá. Diz-me aí umas 4 ou 5 acções de teu interesse para eu fazer uma análise sff. No limite depois dou-te mais algum trabalho de casa e cuidado no tratamento dos dados/código mas parece-me que podemos fazer aqui o que desejas, desde que esteja no site da yahoo.

Abr

P.S. Eu ao dizer que poderás ter mais trabalho não é nada do outro mundo nem vais ter de aprender a escrever código, mas ensino-te a confirmar se os dados estão correctos ou terás, por exemplo, de sacar o ficheiro das cotações do site da yahoo em vez de ser automático. Coisas desse género mas nada demais.

[VirtuaGod]

Mais um :-) Este ainda nem está disponível à maioria das pessoas. Fui seleccionado para beta tester Começo a perceber porque em python não é necessário usar muitas bibliotecas. O Pandas faz TUDO É equivalente a 4 ou 5 bibliotecas de topo em R.

P.S. Não é necessariamente bom fazer tudo. A quantidade de funcionalidades muitas vezes confunde a análise da documentação de suporte e instruções de como fazer aquilo que pretendo. Em R as bibliotecas são mais objectivas, cada uma tem a sua funcionalidade e pronto. Tirando a velocidade (python é bem mais rápido que R) ainda não vi nada que me fizesse sair de R. Pelo contrário, aprendi ainda mais a dar valor a algumas bibliotecas e pessoas da comunidade R e R/Finance.

[Artista Romeno]

quer dizer eurostoxx caput? não há codigo

Nops. Cotações americanas até há grátis, já todas tratadas para introdução neste tipo de software para tratamento estatístico. Aqui népias. Estamos a anos luz deles

assim perdeu algum do interesse para mim mas vou ver os fundos qd tiver tempo anyway

[VirtuaGod]

quer dizer eurostoxx caput? não há codigo

Nops. Cotações americanas até há grátis, já todas tratadas para introdução neste tipo de software para tratamento estatístico. Aqui népias. Estamos a anos luz deles

[Artista Romeno]

vou experimentar um dia destes já fiz o download, mas gostava de fazer era com ações também dá?

Acções americanas? O problema é que o yahoo deixou de fornecer a API das cotações. Se for só acções americanas (sem ser ETF) eu adapto o código na boa (até é um bom 'exercício' de 15 minutos). Este scrip/código só funciona com fundos do BEST.

quer dizer eurostoxx caput? não há codigo

[VirtuaGod]

vou experimentar um dia destes já fiz o download, mas gostava de fazer era com ações também dá?

Acções americanas? O problema é que o yahoo deixou de fornecer a API das cotações. Se for só acções americanas (sem ser ETF) eu adapto o código na boa (até é um bom 'exercício' de 15 minutos). Este scrip/código só funciona com fundos do BEST.

[Artista Romeno]

Como criar uma matrix de correlações de fundos em python sem saber programação

Deixo aqui em baixo código suficientemente automatizado que qualquer pessoa esteja mais à vontade com computadores (mesmo não sabendo programação) possa fazer um gráfico de correlação de fundos. Está limitado aos fundos do Best e as cotações são diárias. Atenção que tem de ser um período em que TODOS os fundos já existam senão dá erro. Por exemplo se o fundo mais recente da carteira começa algures em 2012 aconselho a data de 2012-12-31, assim não se enganam.

A única coisa que têm de colocar é o MSid, um nome que queiram dar ao fundo para o identificar na matrix, e uma data de inicio (Begin) e fim (End) da análise.

Instalem a distribuição Anaconda (https://www.continuum.io/downloads), liguem o spyder, coloquem o texto abaixo no editor e carreguem em F5. Já está. Depois comecem a fazer as pequenas alterações desejadas. O que podem/devem mexer está tudo tudo colocado num parágrafo no topo e deverá ser de simples compreensão.

Qualquer dúvida avisem.

Código: Selecionar todos

# -*- coding: utf-8 -*-
# importing libraries
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import time

#### AQUILO QUE PODEM MUDAR COMEÇA AQUI ####

# Apenas têm de colocar o MSid do fundo desejado (no mesmo formato dos que estão presentes)
# e depois colocar um nome para identificarem o fundo na matrix.

Begin = "2007-12-31"
End = "2017-08-04"                           

MSid = ['F000000FH0', 'F0000007LD', 'F0GBR06T61', 'F0GBR067EZ', 'F000000GHB', 'F0GBR04E6R', 'F0GBR06T6D', 'F0GBR06T6F']
Nomes = ['FCI', 'GS_SC', 'MG_OI', 'PimcoGB', 'NordeaSR', 'MG_Conv', 'MFS_GE', 'PimcoHY', 'PimcoIG']

tamanho_dos_graficos = (12, 8.16)

#### AQUILO QUE PODEM MUDAR ACABA AQUI ####

# Conversão de datetime
conv = time.strptime(Begin,"%Y-%m-%d")
start_date = time.strftime("%m/%d/%Y",conv)

# URLs
FCI_url = "https://lt.morningstar.com/api/rest.svc/timeseries_price/okhysb8aoh?id=F0GBR04EAN&currencyId=BAS&idtype=Morningstar&frequency=daily&startDate=" + start_date + "&outputType=CSV"

#### Downloading, formating dataframes and transforming date into datetime ####
# FCI
fundos = pd.read_csv(FCI_url, sep = ";" , index_col = 'date', parse_dates = True)
fundos = fundos.drop('Unnamed: 2', 1)

# Download
for ticker in MSid:
    url = "https://lt.morningstar.com/api/rest.svc/timeseries_price/okhysb8aoh?id=" + str(ticker) + "&currencyId=BAS&idtype=Morningstar&frequency=daily&startDate=" + start_date + "&outputType=CSV"
    fundo = pd.read_csv(url, sep = ";" , index_col = 'date', parse_dates = True)
    fundo =  fundo.drop('Unnamed: 2', 1)
    fundos = fundos.merge(fundo, left_index = True, right_index = True, how='outer')

fundos.columns = Nomes
fundos = fundos.fillna(method='ffill')

#### Returns ####
returns = (fundos / fundos.shift(1)) - 1
         
#### Normalization to 100 ####
# print(fundos.iloc[0])
fundos_norm = (fundos / fundos.iloc[0] * 100)
fundos_norm.plot(figsize = (tamanho_dos_graficos))
plt.show()

#### New Preturns (to include Portfolio returns) ####
Preturns = (fundos / fundos.shift(1)) - 1

#### Correlation (bonus: Seaborn heatmap)####
Pcorr_matrix = Preturns.corr()

# Normal heatmap
fig, ax = plt.subplots()
fig.set_size_inches(tamanho_dos_graficos) # 68%
sns.heatmap(Pcorr_matrix, annot = True, cmap = "coolwarm", linewidths=.2)
# "Blues" is also a good cmap (color palette)

# Triangular heatmap (no repeated values)
# mask = np.zeros_like(Pcorr_matrix)
# mask[np.triu_indices_from(mask)] = True
# with sns.axes_style("white"):
#    sns.heatmap(Pcorr_matrix, annot = True, mask = mask)

P.S. Como bónus têm um gráfico comparativo dos fundos que colocarem na matrix

vou experimentar um dia destes já fiz o download, mas gostava de fazer era com ações também dá?

[VirtuaGod]

Como criar uma matrix de correlações de fundos em python sem saber programação

Deixo aqui em baixo código suficientemente automatizado que qualquer pessoa esteja mais à vontade com computadores (mesmo não sabendo programação) possa fazer um gráfico de correlação de fundos. Está limitado aos fundos do Best e as cotações são diárias. Atenção que tem de ser um período em que TODOS os fundos já existam senão dá erro. Por exemplo se o fundo mais recente da carteira começa algures em 2012 aconselho a data de 2012-12-31, assim não se enganam.

A única coisa que têm de colocar é o MSid, um nome que queiram dar ao fundo para o identificar na matrix, e uma data de inicio (Begin) e fim (End) da análise.

Instalem a distribuição Anaconda (https://www.continuum.io/downloads), liguem o spyder, coloquem o texto abaixo no editor e carreguem em F5. Já está. Depois comecem a fazer as pequenas alterações desejadas. O que podem/devem mexer está tudo tudo colocado num parágrafo no topo e deverá ser de simples compreensão.

Qualquer dúvida avisem.

Código: Selecionar todos

# -*- coding: utf-8 -*-
# importing libraries
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import time

#### AQUILO QUE PODEM MUDAR COMEÇA AQUI ####

# Apenas têm de colocar o MSid do fundo desejado (no mesmo formato dos que estão presentes)
# e depois colocar um nome para identificarem o fundo na matrix.

Begin = "2007-12-31"
End = "2017-08-04"                           

MSid = ['F000000FH0', 'F0GBR04E6R', 'F0GBR06T61', 'F0GBR05PNS']
Nomes = ['GS_SC', 'MFS_GE', 'PimcoGB', 'UBS_Conv']

tamanho_dos_graficos = (8, 6)

#### AQUILO QUE PODEM MUDAR ACABA AQUI ####

Nome = ['FCI']
Nomes = Nome + Nomes

# Conversão de datetime
conv = time.strptime(Begin,"%Y-%m-%d")
start_date = time.strftime("%m/%d/%Y",conv)

# URLs
FCI_url = "https://lt.morningstar.com/api/rest.svc/timeseries_price/okhysb8aoh?id=F0GBR04EAN&currencyId=BAS&idtype=Morningstar&frequency=daily&startDate=" + start_date + "&outputType=CSV"

#### Downloading, formating dataframes and transforming date into datetime ####
# FCI
fundos = pd.read_csv(FCI_url, sep = ";" , index_col = 'date', parse_dates = True)
fundos = fundos.drop('Unnamed: 2', 1)

# Download
for ticker in MSid:
    url = "https://lt.morningstar.com/api/rest.svc/timeseries_price/okhysb8aoh?id=" + str(ticker) + "&currencyId=BAS&idtype=Morningstar&frequency=daily&startDate=" + start_date + "&outputType=CSV"
    fundo = pd.read_csv(url, sep = ";" , index_col = 'date', parse_dates = True)
    fundo =  fundo.drop('Unnamed: 2', 1)
    fundos = fundos.merge(fundo, left_index = True, right_index = True, how='outer')

fundos.columns = Nomes
fundos = fundos.fillna(method='ffill')

#### Returns ####
returns = (fundos / fundos.shift(1)) - 1
         
#### Normalization to 100 ####
# print(fundos.iloc[0])
fundos_norm = (fundos / fundos.iloc[0] * 100)
fundos_norm.plot(figsize = (tamanho_dos_graficos))
plt.show()

#### New Preturns (to include Portfolio returns) ####
Preturns = (fundos / fundos.shift(1)) - 1

#### Correlation (bonus: Seaborn heatmap)####
Pcorr_matrix = Preturns.corr()

# Normal heatmap
fig, ax = plt.subplots()
fig.set_size_inches(tamanho_dos_graficos) # 68%
sns.heatmap(Pcorr_matrix, annot = True, cmap = "coolwarm", linewidths=.2)
# "Blues" is also a good cmap (color palette)

# Triangular heatmap (no repeated values)
# mask = np.zeros_like(Pcorr_matrix)
# mask[np.triu_indices_from(mask)] = True
# with sns.axes_style("white"):
#    sns.heatmap(Pcorr_matrix, annot = True, mask = mask)

P.S. Como bónus têm um gráfico comparativo dos fundos que colocarem na matrix
P.S.2 O primeiro fundo é sempre o Fidelity Consumer Industries MSID = F0GBR04EAN ISIN = LU0114721508. Isto porque os Fidelity são os fundos com mais dias de funcionamento e uso-os para criar o índice temporal. Isto está assim por defeito. Nenhuma alteração na vossa zona de alterações vai mudar isso.

[VirtuaGod]

Python for finance: Parte 2

Não consegui fazer que as coisas fossem perfeitas mas como sei que vou passar para outro projecto e só voltar a este daqui a algum tempo deixo o código para fazerem os gráficos acima.

Correlação entre fundos e curva eficiente. Têm também código para filtrar os portfolios tendo em consideração risco e retorno desejados. No meu código os filtros estão para + de 7% de retorno (anualizado) e menos de 5.5% de risco (desvio padrão). Depois alterem o peso no próprio código que calcula (e desenha) o portfolio para verem como ele se comporta. Daqui a 1 mês já podem voltar a testar no site (espero).

Acabei por descobrir boas carteiras. Parte 3 terá gráficos interactivos em bokeh ou plotly, montecarlo simulation e melhoramentos do código para poder testar as carteiras com mais do que 4 fundos.

Recemente o Portilla lançou um curso novo de python para finanças. Por 10/15 euros parece-me que o vou fazer/estudar já em Agosto: https://www.udemy.com/python-for-financ ... lgorithms/ (queria voltar ao R mas estão sempre a sair coisas interessantes em python )

Aqui está o código mais recente com tudo incluído. Para correm recomendo a distribuição Anaconda (python 3).

Código: Selecionar todos

# -*- coding: utf-8 -*-
# importing libraries
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from datetime import datetime, timedelta

# Setting pandas dataframe display options
pd.set_option('display.width', 1000)
pd.set_option('max_colwidth', 800)

Begin = "2007-04-20"
yesterday = datetime.now() - timedelta(days = 1)
End   = yesterday.strftime('%Y-%m-%d')
# End = "2015-12-31"
                             
# URLs
FCI_url = "https://lt.morningstar.com/api/rest.svc/timeseries_price/okhysb8aoh?id=F0GBR04EAN&currencyId=BAS&idtype=Morningstar&frequency=daily&startDate=04/20/2007&outputType=CSV"
GS_GSC_url  = "https://lt.morningstar.com/api/rest.svc/timeseries_price/okhysb8aoh?id=F000000FH0&currencyId=BAS&idtype=Morningstar&frequency=daily&startDate=04/20/2007&outputType=CSV"
MG_OI_url = "https://lt.morningstar.com/api/rest.svc/timeseries_price/okhysb8aoh?id=F0000007LD&currencyId=BAS&idtype=Morningstar&frequency=daily&startDate=04/20/2007&outputType=CSV"
PimcoGB_url = "https://lt.morningstar.com/api/rest.svc/timeseries_price/okhysb8aoh?id=F0GBR06T61&currencyId=BAS&idtype=Morningstar&frequency=daily&startDate=04/20/2007&outputType=CSV"

#### Downloading, formating dataframes and transforming date into datetime ####
# FCI
FCI = pd.read_csv(FCI_url, sep = ";" , index_col = 'date', parse_dates = True)
FCI = FCI.drop('Unnamed: 2', 1)

#GS_GSC
GS_GSC = pd.read_csv(GS_GSC_url, sep = ";",
                     index_col = 'date', parse_dates = True)
GS_GSC = GS_GSC.drop('Unnamed: 2', 1)

# MG_OI
MG_OI = pd.read_csv(MG_OI_url, sep = ";",
                    index_col = 'date', parse_dates = True)
MG_OI = MG_OI.drop('Unnamed: 2', 1)

# PimcoGB
PimcoGB = pd.read_csv(PimcoGB_url, sep = ";", index_col = 'date',
                       parse_dates = True)
PimcoGB = PimcoGB.drop('Unnamed: 2', 1)

#### Ploting ####
# FCI
# FCI['price'].plot(figsize = (10, 5), title = "FCI")
# plt.show()

# GS_GSC
# GS_GSC['price'].plot(figsize = (10, 5), title = "GS_GSC")
# plt.show()

# MG_OI
# MG_OI['price'].plot(figsize = (10, 5), title = "MG_OI")
# plt.show()

# PimcoGB
# PimcoGB['price'].plot(figsize = (10, 5), title = "PimcoGB")
# plt.show()

#### Merging dataframes ####
Fundos = FCI.merge(GS_GSC, left_index = True,
                   right_index = True, how = 'outer')
Fundos = Fundos.merge(MG_OI, left_index = True,
                      right_index = True, how = 'outer')
Fundos = Fundos.merge(PimcoGB, left_index = True,
                      right_index = True, how = 'outer')

##### Filling "nan" with LOCF (Last Observation Carried Forward) ####
fundos = Fundos.fillna(method = "ffill")

##### Changing column names ####
fundos_names = ["FCI", "GS_GSC", "MG_OI", "PimcoGB"]
fundos.columns = [fundos_names]

#### Returns ####
returns = (fundos / fundos.shift(1)) - 1
         
#### Normalization to 100 ####
# print(fundos.iloc[0])
fundos_norm = (fundos / fundos.iloc[0] * 100)
# fundos_norm.plot(figsize = (10, 6))
# plt.show()

#### weights ####
weights = np.array([0.20,  # FCI
                    0.05,  # GS_GSC
                    0.40,  # MG_OI
                    0.25]) # PIMCO_GB

#### Calculate Portfolio value with linear algebra ####
fundos["Portfolio"] = np.dot(fundos_norm, weights) # weights * quotes
fundos["Portfolio"].plot(figsize = (10, 6), title = "Portfolio")
plt.ylabel('Value for each 100€ invested')
plt.show()

#### New Preturns (to include Portfolio returns) ####
Preturns = (fundos / fundos.shift(1)) - 1

#### Annualized return of portfolio (from "Begin" to "End") ####
a = fundos["Portfolio"].loc[Begin]
b = fundos["Portfolio"].loc[End]

time_delta = pd.to_datetime(End) - pd.to_datetime(Begin)
time_delta = time_delta.days / 365

Annualized_Return = (((b / a) ** (1 / time_delta)) - 1) * 100
print("")
print("The portfolio annualized return is: "
      + str(round(Annualized_Return, 2)) + "%")

#### Standard Deviation as Risk ####
Annualized_SD = Preturns["Portfolio"].std() * 252 ** 0.5 * 100
print("The portfolio annualized standard deviation is: "
      + str(round(Annualized_SD, 2)) + "%")

#### YTD Return ####
c = fundos["Portfolio"].loc["2016-12-30"]
d = ((b / c) - 1) * 100
print("The portfolio YTD return is: "
      + str(round(d, 2)) + "%")

#### Correlation (bonus: Seaborn heatmap)####
Pcorr_matrix = Preturns.corr()
print("")
print(Pcorr_matrix)

# Normal heatmap
sns.heatmap(Pcorr_matrix, annot = True, cmap = "coolwarm", linewidths=.5)
# "Blues" is also a good cmap (color palette)

# Triangular heatmap (no repeated values)
# mask = np.zeros_like(Pcorr_matrix)
# mask[np.triu_indices_from(mask)] = True
# with sns.axes_style("white"):
#    sns.heatmap(Pcorr_matrix, annot = True, mask = mask)

#### Markowitz's Efficient Frontier ####
cov_matrix = returns.cov() * 252
corr_matrix = returns.corr()

num_assets = len(Fundos.columns)
# print(num_assets)

#==============================================================================
# print("")
# print("Average returns:" + str(np.sum(weights * returns.mean()) * 252))
# print("Average variance:" + str(np.dot(weights.T, np.dot(returns.cov() * 252, weights))))
# print("Average SD:" + str(np.sqrt(np.dot(weights.T,np.dot(returns.cov() * 252, weights)))))
#
#==============================================================================
pfolio_returns = []
pfolio_volatilities = []
pfolio_weights = []

for x in range (3000):
    weights = np.random.random(num_assets)
    weights /= np.sum(weights)
    pfolio_weights.append(weights)
    pfolio_returns.append(np.sum(weights * returns.mean()) * 252 * 100)
    pfolio_volatilities.append(np.sqrt(np.dot(weights.T,np.dot(returns.cov() * 252, weights))) * 100)
   
pfolio_returns = np.array(pfolio_returns)
pfolio_volatilities = np.array(pfolio_volatilities)

# Making a dataframe with the values
portfolios = pd.DataFrame({"Return": pfolio_returns,
                           "Volatility": pfolio_volatilities})
# print(portfolios.head())
# print(portfolios.tail())
# Ploting on a graph
portfolios.plot(x = "Volatility", y = "Return", kind = "Scatter", figsize = (10, 6));
plt.xlabel("Expected Volatility")
plt.ylabel("Expected Return")
plt.show()

average_SR = pfolio_returns.mean() / pfolio_volatilities.mean() # Average Sharpe Ratio
print("The average Sharpe Ratio is:" + str(average_SR))

#### Adding Sharpe and weights to portfolios dataframe ####
portfolios["Sharpe"] = portfolios["Return"] / portfolios["Volatility"]
portfolios["Weights"] = pfolio_weights

#### Selecting Portfolios ####
return_target = portfolios['Return'] > 7 # Filter portfolios by return
volatility_target = portfolios['Volatility'] < 5.5 # Filter portfolios by volatility
# select portfolio with highest sharpe
max_sharpe = portfolios['Sharpe'] > (max(portfolios['Sharpe']) - 0.0001)

Portfolios_target = portfolios[return_target & volatility_target]
Portfolio_max_sharpe = portfolios[max_sharpe]
# I recomend using spyder variable explorer to see the dataframes or make the
# console larger
print("")
print("The filtered Portfolios are:")
print(Portfolios_target)
print("")
print("The Portfolio with the highest sharpe is:")
print(Portfolio_max_sharpe)


P.S Adoro matplotlib e seaborn. Um intermédio entre a bibliotecas gráficas do R. A base (simples mas feia) e ggplot2 (bonita mas complexa). Adoraria que o R as tivesse.

[VirtuaGod]

Um cheirinho do que está para vir em breve (em python):

O primeiro gráfico é um heatmap feito em seaborn com as correlações do fundos que compõem a carteira 4 fundos. Cotações diárias desde 2007-04-20.

O Segundo gráfico é matplotlib. Contém 2000 pontos de 2000 combinações diferentes (aleatórias) de pesos dos 4 fundos da carteira. Pode-se perfeitamente visualizar/imaginar a carteira eficiente.

Ainda não coloco aqui porque não está perfeito. A matemática ainda não bate correcto. Mas está muito próxima do que pretendo, e as conclusões deverão ser as mesmas, apenas a volatilidade e o retorno ainda não batem 100% correctos (embora aproximados).

Estive a testar estas carteiras contra a 4Fundos feita em R há cerca de um ano e à 4Fundos EW e dá ela por ela, com uma optimização extrema por parte do python, ainda por cima tem mais info para trabalhar. (a 4Fundos quando foi feita em R só foram usados os dados de 31 de Dezembro de 2009 a 31 de Dezembro de 2015, para ficar com um stress test e um tempo out of sample tornando assim a alocação mais realista e menos "optimizada" com base no passado).

Esta proximidade entre os valores da 4Fundos e a fronteira eficiente actual faz-me pensar que a carteira 4Fundos tem-se mostrado boa e em linha com as expectativas.

[VirtuaGod]

Não pretendo "migrar". Para ser honesto até acho R mais simples (para data science) do que o python, muito devido ao Hadley Wickham (criou um "ecossistema" de biblioteca para tratamento de dados que é brilhante).

Estar a estudar python é mais porque tenho curiosidade (afinal não é o que nos move para áreas que desconhecemos mesmo não sendo estritamente necessárias?) e há muito código online em python que eu gostaria de saber ler correctamente.

Houve temporariamente um adiantamento do python em termos de bibliotecas de machine learning mas o RStudio (empresa) já está a colmatar.

Basicamente qualquer pessoa que faz tratamentos de dados e coisas em linha com finanças quantitativas (e no futuro talvez um pouco de data science) são duas línguas necessárias, com os seus pontos fortes e fracos e acabam mais por se complementar do que serem "rivais".

Para além disso tenho andado a desenvolver um gosto por algoritmia e isso o R não é bom ou pelo menos não encontro onde estudar com R. Enquanto que há imensas coisas para python. R é bom para estatística e ainda tenho de desenvolver essa parte.

P.S. Ainda irei um dia aprender o básico de C++, mais que não seja para os bottlenecks do código (em R ou Python) tipo loops. Ou pode ser que Julia nos próximos anos tenha um desenvolvimento tão grande que eu passe logo para aí.

[FredericoRocha]

Algum motivo em especial para essa "migração" de R para Python?

Abraço

[VirtuaGod]

Já fiz uns 50% do curso e já comecei a "traduzir" o meu código R para python. Embora ainda muito rudimentar, sem loops nem funções complexas e muito copy/paste (como quando comecei com R )

Se alguém percebe de python aqui está o início do código para fazer a carteira 4Fundos:

Código: Selecionar todos

# -*- coding: utf-8 -*-
import pandas as pd
import matplotlib.pyplot as plt

# URLs
FCI_url      = "https://lt.morningstar.com/api/rest.svc/timeseries_price/okhysb8aoh?id=F0GBR04EAN&currencyId=BAS&idtype=Morningstar&frequency=daily&startDate=12/31/2007&outputType=CSV"
GS_GSC_url   = "https://lt.morningstar.com/api/rest.svc/timeseries_price/okhysb8aoh?id=F000000FH0&currencyId=BAS&idtype=Morningstar&frequency=daily&startDate=12/31/2007&outputType=CSV"
MG_OI_url    = "https://lt.morningstar.com/api/rest.svc/timeseries_price/okhysb8aoh?id=F0000007LD&currencyId=BAS&idtype=Morningstar&frequency=daily&startDate=12/31/2007&outputType=CSV"
PIMCO_DB_url = "https://lt.morningstar.com/api/rest.svc/timeseries_price/okhysb8aoh?id=F0GBR06T61&currencyId=BAS&idtype=Morningstar&frequency=daily&startDate=12/31/2007&outputType=CSV"

#### Downloading, formating dataframes and transforming date into datetime ####
# FCI
FCI = pd.read_csv(FCI_url, sep = ";")
FCI = FCI.drop('Unnamed: 2', 1)
FCI['date'] = pd.to_datetime(FCI['date'])
FCI = FCI.set_index(['date'])

#GS_GSC
GS_GSC = pd.read_csv(GS_GSC_url, sep = ";")
GS_GSC = GS_GSC.drop('Unnamed: 2', 1)
GS_GSC['date'] = pd.to_datetime(GS_GSC['date'])
GS_GSC = GS_GSC.set_index(['date'])

# MG_OI
MG_OI = pd.read_csv(MG_OI_url, sep = ";")
MG_OI = MG_OI.drop('Unnamed: 2', 1)
MG_OI['date'] = pd.to_datetime(MG_OI['date'])
MG_OI = MG_OI.set_index(['date'])

# PIMCO_DB
PIMCO_DB = pd.read_csv(PIMCO_DB_url, sep = ";")
PIMCO_DB = PIMCO_DB.drop('Unnamed: 2', 1)
PIMCO_DB['date'] = pd.to_datetime(PIMCO_DB['date'])
PIMCO_DB = PIMCO_DB.set_index(['date'])

#### Ploting ####
#FCI
FCI['price'].plot(figsize = (8, 5), title = "FCI")
plt.show()

# GS_GSC
GS_GSC['price'].plot(figsize = (8, 5), title = "GS_GSC")
plt.show()

# MG_OI
MG_OI['price'].plot(figsize = (8, 5), title = "MG_OI")
plt.show()

# PIMCO_DB
PIMCO_DB['price'].plot(figsize = (8, 5), title = "PIMCO_DB")
plt.show()

#### Merging dataframes ####
Fundos = FCI.merge(GS_GSC, left_index = True, right_index = True, how = 'outer')
Fundos = Fundos.merge(MG_OI, left_index = True, right_index = True, how = 'outer')
Fundos = Fundos.merge(PIMCO_DB, left_index = True, right_index = True, how = 'outer')

##### Filling "nan" with LOCF (Last Observation Carried Forward) ####
fundos = Fundos.fillna(method = "ffill")

##### Changing column names ####
fundos_names = ["FCI", "GS_GSC", "MG_OI", "PIMCO_DB"]
fundos.columns = [fundos_names]

#### Returns ####
returns = (fundos / fundos.shift(1)) - 1
         
#### Normalization to 100 ####
print(fundos.iloc[0])
fundos_norm = (fundos / fundos.iloc[0] * 100)
fundos_norm.plot(figsize = (12, 6))
plt.show()

#### weights ####
weights = np.array([0.25,  # FCI
                    0.25,  # GS_GSC
                    0.25,  # MG_OI
                    0.25]) # PIMCO_GB

#### Calculate Portfolio value with linear algebra ####
fundos["Portfolio"] = np.dot(fundos_norm, weights) # weights * funds values
fundos["Portfolio"].plot(figsize = (12, 6), title = "Portfolio")
plt.show()



E se alguém é curioso pode sempre sacar a distribuição Anaconda (python 3) e usar o Spyder IDE que é super parecido com o RStudio

EDIT: Código actualizado até fazer o gráfico do portfolio com os pesos desejados. Parece-me que faz mais sentido parar aqui. Podemos assim chamar de Parte 1.

[VirtuaGod]

Comprei (hoje) e estou a fazer o Python for Finance: Investment Fundamentals & Data Analytics da 365 Careers no udemy. Custou 10 euros e o curso não só me pareceu hiper interessante como os 12% que já fiz está mesmo user friendly para quem está apenas a aprender a programar. Por 10 euros é difícil melhor.

Entrem na udemy pelo link do R-Bloggers e pesquisem pelo curso. Quem quiser fazer em simultâneo comigo podemos sempre trocar impressões

https://www.r-bloggers.com/online-r-cou ... ember-1st/