Portfolio Analysis

I recently completed a project called Portfolio Pilot, a tool designed to help users build and analyze their investment portfolios. This tool allows you to allocate percentages to ETFs, visualize performance over time, compare against benchmarks, and much more.

https://portfoliopilot.danieleligato.com/

1. Defining the Purpose

The main goal of Portfolio Pilot is to let users:

Build custom portfolios using ETFs.

Simulate historical performance.

Compare portfolio performance against a benchmark.

Visualize key metrics like CAGR, volatility, and Sharpe ratio.

Provide an intuitive, web-based interface using Dash.

2. Project Structure

The tool was developed in Python using the Dash framework, with Plotly for visualizations and Pandas for data manipulation. The core components include:

Data Loading: Read ETF data from CSV files.

Portfolio Building: Allow users to allocate percentages to ETFs.

Performance Simulation: Normalize and calculate portfolio returns.

Visualizations: Line charts, bar charts, and rolling returns.

Let’s break down each of these components.

3. Building the Dash App Layout

The app’s layout was designed using Dash and Bootstrap for responsiveness. Here’s how I set up the main interface:


import dash_bootstrap_components as dbc
from dash import dcc, html

# Function to create the app layout
def create_layout(asset_list, initial_table_data):
    return html.Div([
        # Header Section
        dbc.Container([
            dbc.Row(
                dbc.Col(
                    html.Img(src="/assets/Logo.png", style={
                        'maxHeight': '100px', 'margin': 'auto', 'display': 'block'
                    }), width=12
                )
            )
        ], fluid=True),

        # Main Content Section
        dbc.Container([
            dbc.Row([
                # Dropdown for selecting ETFs
                dbc.Col([
                    dcc.Dropdown(
                        id='etf-dropdown',
                        options=[{'label': etf, 'value': etf} for etf in asset_list],
                        placeholder="Select an ETF"
                    )
                ], md=6),

                # Slider for allocation percentages
                dbc.Col([
                    dcc.Slider(
                        id='percentage-slider', min=1, max=100, step=1, value=100,
                        marks={i: f'{i}%' for i in range(0, 101, 10)}
                    )
                ], md=6)
            ]),

            # Portfolio Table
            dbc.Row([
                dbc.Col(
                    dash.dash_table.DataTable(
                        id='portfolio-table',
                        columns=[
                            {"name": "ETF", "id": "ETF"},
                            {"name": "Percent", "id": "Percentuale", 'type': 'numeric'}
                        ],
                        data=initial_table_data.to_dict('records'),
                        editable=True, row_deletable=True
                    ), width=12
                )
            ])
        ])
    ])

This layout provides:

A dropdown for selecting ETFs.

A slider to allocate percentages.

A table to review and edit allocations.

4. Loading ETF Data

ETF data is loaded from CSV files. I used Pandas to process and clean the data.


import pandas as pd

def load_asset_list(file_path):
    try:
        data = pd.read_csv(file_path)
        asset_list = data['Fund'].apply(lambda x: x.split('.csv')[0]).tolist()
        return asset_list
    except FileNotFoundError:
        print(f"Error: File {file_path} not found.")
        return []

# Example usage
asset_list = load_asset_list("assets.csv")

5. Simulating Portfolio Performance

Once users allocate percentages to ETFs, Portfolio Pilot calculates the portfolio’s historical performance by combining normalized ETF returns. Here’s the core logic:


def simulate_portfolio(table_data, etf_data):
    df = pd.DataFrame(table_data)
    normalized_data = etf_data / etf_data.iloc[0] * 100
    weighted_returns = normalized_data * df['Percentuale'].values / 100
    portfolio = weighted_returns.sum(axis=1)
    return portfolio

This function:

Normalizes ETF data to start at 100.

Scales returns by user-defined percentages.

Aggregates the results to calculate portfolio performance.

6. Visualizing Performance

The app’s visualizations include line charts for performance and bar charts for metrics like CAGR and volatility.


import plotly.graph_objects as go

def plot_performance(portfolio, benchmark):
    fig = go.Figure()
    fig.add_trace(go.Scatter(x=portfolio.index, y=portfolio, mode='lines', name='Portfolio'))
    if benchmark is not None:
        fig.add_trace(go.Scatter(x=benchmark.index, y=benchmark, mode='lines', name='Benchmark'))
    return fig

The user can instantly see how their portfolio stacks up against a chosen benchmark.

7. Calculating Metrics

Metrics like CAGR, volatility, and Sharpe ratio give users deeper insights into portfolio performance. These metrics are calculated as follows:


def calculate_metrics(portfolio):
    cagr = ((portfolio[-1] / portfolio[0]) ** (1 / len(portfolio)) - 1) * 100
    volatility = portfolio.pct_change().std() * (12 ** 0.5) * 100
    sharpe_ratio = cagr / volatility if volatility > 0 else 0
    return {'CAGR': cagr, 'Volatility': volatility, 'Sharpe Ratio': sharpe_ratio}

# Example usage
metrics = calculate_metrics(portfolio)
print(metrics)

These metrics are displayed in bar charts, making it easy for users to compare portfolios.

8. Challenges and Future Plans

Challenges:

Data Handling: Managing large datasets efficiently.

Accuracy: Ensuring calculations are robust and error-free.

Future Plans:

Add support for additional asset types.

Integrate Monte Carlo simulations for risk analysis.

Include predictive analytics for future performance estimation.