DEV Community: Pier Paolo Ippolito

The Startup Fork in the Road: VC Funding vs. The Bootstrapper's Journey

Pier Paolo Ippolito — Thu, 29 May 2025 07:30:00 +0000

So, you've got a killer idea, the spark of entrepreneurial fire in your belly, and you're ready to build. But before you dive headfirst into the exhilarating world of startups, there's a fundamental question every founder must answer: How will you fuel your vision? Broadly, two paths diverge: seeking Venture Capital (VC) funding or embracing the often grittier, yet incredibly rewarding, path of bootstrapping. This isn't just a financial decision; it's a choice that shapes your company's culture, your control, and your growth trajectory.

Let's break down these two distinct approaches before we explore how one of these philosophies inspired me and Alked to create Linkaout, a map-based app designed to connect Londoners with local events, with a particular focus on how we approached development and launch as bootstrappers.

The VC Route: Rocket Fuel and High Stakes

Venture Capital funding is often portrayed as the glamorous path to startup stardom. It involves selling a portion of your company (equity) to investors in exchange for significant capital.

The Upsides of VC Funding:

Accelerated Growth: Access to substantial funds can mean scaling rapidly – hiring a large team, launching aggressive marketing campaigns, and capturing market share quickly.
Expertise and Network: VCs often bring more than just money. They can provide invaluable mentorship, industry connections, and strategic guidance.
Validation and Credibility: Securing VC funding can be seen as a stamp of approval, potentially attracting further investment, top talent, and customer trust.
Reduced Personal Financial Risk: The financial burden is shared with investors, lessening the direct hit on your personal savings.

The Downsides of VC Funding:

Loss of Control and Ownership: Giving away equity means giving away a degree of control. Founders may find their decision-making power diluted and be beholden to investor expectations.
Intense Pressure for Rapid Returns: VCs are looking for significant returns on their investment, often within a 5-10 year timeframe. This can create immense pressure to prioritize hyper-growth, sometimes at the expense of sustainable profitability or the founder's original vision.
Focus on Growth over Profitability (Initially): The mantra is often "grow big, fast," with profitability sometimes taking a backseat in the early stages.
Exit Strategy Focus: Most VCs invest with an exit in mind, such as an acquisition or an Initial Public Offering (IPO). This might not align with every founder's long-term goals.

The Bootstrapper's Creed: Building Brick by Brick

Bootstrapping, on the other hand, is the art of building a company from the ground up with little to no external funding. It relies on personal savings, revenue generated by the business itself, and a relentless focus on lean operations.

The Upsides of Bootstrapping:

Full Ownership and Control: You retain 100% ownership of your company and make all the decisions. Your vision remains undiluted.
Focus on Profitability and Sustainability: Since you're relying on your own revenue to grow, profitability becomes a key focus from day one, often leading to more resilient and sustainable business models.
Freedom and Flexibility: You have the autonomy to pivot, adapt, and grow at your own pace without external investor pressure.
Customer-Centricity: Bootstrappers are often laser-focused on their customers, as paying users are the lifeblood of their growth.
Fosters Creativity and Resourcefulness: Limited resources force you to be innovative and find cost-effective solutions.

The Downsides of Bootstrapping:

Slower Growth: Growth is typically more organic and can be slower compared to VC-backed competitors with deep pockets.
Personal Financial Risk: You're often investing your own money, making the financial stakes very personal.
Limited Resources: Scaling can be challenging without significant capital for marketing, hiring, or large-scale development.
Building Credibility Can Take Longer: Without the halo effect of VC backing, establishing credibility and attracting talent can require more persistent effort.

The "Why" and "How" of Linkaout: A Bootstrapping Tale

This brings us to Linkaout.

Why?

The idea was born from the bootstrapping philosophy, popularised by figures like Pieter Levels—known for his mantra of building and launching products quickly to get real feedback from users. This "Indie Hacker" or "Maker" ethos champions rapid iteration and a direct line to the customer. Living in London, we often found it difficult to discover local events without switching between multiple platforms. That’s why we created Linkaout—a map-based app that helps you easily discover what’s happening around you, in the most intuitive way possible (Figure 1). The core motivation was to solve a personal pain point, a common starting place for many bootstrapped ventures, and to do so by building something people would genuinely use and, ideally, pay for, ensuring sustainability from the outset.

Figure 1: Linkaout Web Interface (Image by Author).

How? The Lean Development and Launch Process

In true bootstrapping fashion, the approach was lean and agile. We built on tools we were familiar with—or had heard good things about—and quickly got to work. There was no lengthy fundraising process or a large, pre-hired team. Our first version included a simple map that let users create events in London, along with a login system, profile pages to view created events, and other basic features to immediately showcase the app’s potential.

This wasn't about perfecting every detail before launch. It was about identifying the core problem and building the absolute minimum required to see if the solution resonated with users. This led us to embrace a lean tech stack and strategically leverage free-tier services to keep costs to a minimum while maximizing development speed and flexibility.

Here's a closer look at the 'how' for a bootstrapped app like Linkaout:

1. Choosing a Lean and Cost-Effective Tech Stack:

Bootstrappers need technology that is powerful, easy to use, and ideally offers a generous free tier to defer costs until revenue is generated. For Linkaout, or similar bootstrapped projects, a stack like the following is highly effective:

Supabase (Backend: Database, Authentication, Storage, Realtime): As an open-source Firebase alternative, Supabase provides a powerful PostgreSQL database with built-in features like authentication, file storage, and real-time subscriptions. Its free tier is remarkably generous, offering sufficient database storage (e.g., 500MB), file storage (e.g., 1GB), and bandwidth for initial development and gaining early users. This eliminates the need for a dedicated backend team or managing complex server infrastructure from day one. Setting up user accounts, storing event data, and handling user uploads can all be done within Supabase's free limits for a considerable time. The unlimited API requests in the free tier are a significant advantage for apps expecting variable usage.
NextJS (Web Frontend): A React framework that enables server-side rendering and static site generation. This is excellent for building fast, SEO-friendly web applications. For a bootstrapped team, NextJS streamlines front-end development, providing a solid structure and performance optimizations out-of-the-box. You can build your web presence, marketing site, or even parts of your application interface efficiently. Its flexibility allows for building everything from a simple landing page to a more complex web application.
Netlify (Web Hosting & Serverless Functions): Netlify offers a fantastic platform for hosting static websites and serverless functions directly from your Git repository. Their free tier provides ample bandwidth (e.g., 100GB/month), build minutes (e.g., 300 minutes/month), and serverless function invocations (e.g., 125,000/month). This is more than enough to host a performant web application or landing page for a bootstrapped product and handle initial API calls via functions without incurring hosting costs. The seamless integration with Git makes the deployment process incredibly simple and fast.
FlutterFlow (Cross-Platform Mobile App Development): This is a low-code platform specifically designed for building native mobile applications (iOS and Android) using Google's Flutter framework, and also supports web app development. FlutterFlow dramatically accelerates the UI build process with drag-and-drop components and integrates easily with backends like Supabase. For bootstrappers, this means building a high-quality, cross-platform mobile app can be done significantly faster and often without deep native mobile development expertise, saving considerable time and money. While FlutterFlow has paid tiers for advanced features and code export, their free tier allows for building and testing, providing a clear path to see if the platform meets your needs before committing financially. The ability to export code later also provides a safety net if more custom development is needed down the line.

By combining tools like these, a bootstrapped team can build a robust, scalable application with authentication, a database, file storage, a web presence, and native mobile apps, all while staying within free-tier limits during the crucial early stages of development and validation. The focus is on speed, functionality, and minimizing burn rate. This lean stack minimizes complexity and allows a small team (or even a solo founder) to manage the entire development process, potentially leveraging AI tools like Cursor for code generation and assistance, or Lovable for user feedback analysis to further streamline the process.

Linkaout architecture design for the whole application is shown below in Figure 2:

Figure 2: Linkaout Architecture (Image by Author).

What's remarkable is just how low the initial financial outlay can be. For Linkaout, the core development and initial launch costs were incredibly modest, primarily consisting of:

Figure 3: Linkaout Development Costs (Image by Author).

This demonstrates that the barrier to entry for launching a functional, cross-platform product is significantly lower than many might assume, thanks to the power of modern, developer-friendly tools and generous free tiers.

2. The "MVP of an MVP" Approach:

Instead of aiming for a feature-rich application, the goal is to build the absolute minimum required to test the core value proposition. For Linkaout, this meant a map, the ability to create events, and user profiles. This stripped-down approach ensures you don't waste time building features nobody wants. It forces clarity on what is truly essential for the first version that users will interact with. This initial version should be functional enough to gather genuine user feedback on the core concept.

3. Rapid Iteration and User Feedback:

With a lean stack and an MVP, the focus shifts to getting the product in front of real users as quickly as possible. As soon as we had a working MVP—an MVP of an MVP, you could say—we launched it across the web, the App Store, and Google Play. This aligns perfectly with the bootstrapping principle of getting your product in front of real users as quickly as possible to gather crucial feedback.

Launching to Gain Traction: Getting Your Product Seen

The initial launch isn't the end; it's the beginning of a conversation with your market. For bootstrapped apps, gaining initial visibility without a massive marketing budget is key. This involves strategically leveraging platforms and communities where your target users spend time.

Here are some common approaches for launching a bootstrapped product:

Product Hunt: A popular platform for discovering new products. A well-executed launch can provide a significant surge of early adopters and valuable feedback from a tech-savvy community. Strategies include building anticipation with a "Coming Soon" page, engaging with the community beforehand, crafting a compelling product page with visuals and a demo, planning for launch day engagement, and following up with supporters.
App Stores (Apple App Store, Google Play Store): For mobile apps, launching on the major app stores is essential. Focus on clear descriptions, compelling screenshots, and optimizing for relevant keywords to improve discoverability. Encourage early users to leave reviews.
Online Communities and Forums: Identify online communities, forums, and social media groups relevant to your product's niche. Share your product in a non-spammy way, focusing on how it solves a specific problem for that community. Be prepared to engage and answer questions.
Content Marketing: Create valuable content (blog posts, tutorials, videos) related to your product's domain. This can attract organic traffic and establish your expertise, driving users to your product.
Direct Outreach: Reach out to potential early adopters directly, whether through personal networks, targeted emails (if you have a relevant list), or introductions.

The key for bootstrappers is to choose launch channels that align with their target audience and leverage them effectively with limited resources. The goal is to get the product in front of real users to gather feedback and begin building traction.

Improving the Product

After the launch, we began iterating, adding small but meaningful features based on real user feedback gathered from initial usage and various launch efforts. This iterative process, driven by direct user input rather than boardroom directives, is a hallmark of a bootstrapped company that must stay closely attuned to its customers' needs to survive and thrive. Every feature added, every bug fixed, is a direct response to what the market is telling you, ensuring that limited resources are always focused on delivering maximum value.

This level of agility gives bootstrapped products a distinct advantage over large corporations and well-known apps, where new ideas often get stuck in endless meetings and approval loops. By staying lean and responsive, you can move faster, adapt quicker, and deliver what users want, before the competition even has time to react.

Conclusion: Choosing the Path Less Traveled and Planning for the Future

The choice between VC funding and bootstrapping is a deeply personal one, with significant implications for a startup's journey. While VC can provide rapid acceleration, bootstrapping offers control, sustainability, and a direct connection with your users. For Linkaout, the bootstrapping path, empowered by a lean tech stack and strategic launch platforms, allowed us to quickly turn an idea into a working product, gather real-world feedback, and begin the process of building a sustainable business, brick by brick. It's a path that demands resourcefulness and resilience, but offers the profound reward of building something truly yours, guided by the needs of the people you aim to serve.

For those embarking on the entrepreneurial journey, especially if you're starting solo, resources like YC Startup School can be invaluable. Beyond providing foundational knowledge, they offer platforms, such as co-founder matching, that can help connect you with potential partners who share your vision and complementary skills.

Furthermore, the bootstrapping journey doesn't mean you're locked into running the business forever. Unlike the often high-stakes exit demands of VC, bootstrappers have more flexibility in how they eventually move on. Options can include selling the business on platforms specifically designed for smaller, profitable online businesses like BuyMyMicroStartup, or pursuing Entrepreneurship Through Acquisition (ETA), where an individual or small group acquires a controlling stake in a mature, profitable small business with the intent of running it. These avenues provide alternative exit opportunities that align with the sustainable, profitable nature of many bootstrapped ventures.

This article was co-written with Alked Ejupi.

Plotly Dash for Financial Data Analysis

Pier Paolo Ippolito — Tue, 23 Jan 2024 17:30:00 +0000

Being able to access and react as fast as possible to changes in data plays a crucial role in the financial world. How can we do this in the most reliable and interactive way possible? One common approach to do this, is to leverage Financial APIs and create real time dashboards to share with the relevant stakeholders.

As part of this article, we are going to accomplish this using Financial Modeling Prep as our free API of choice and Plotly Dash for dash boarding. If you are interested in learning more about the fundamentals of Dash and alternative dash boarding tools, you can find more information in my previous article.

The main objective at the end of this tutorial is going to create a fully fledged dashboard to help us asses how different companies are performing. In oder to do so, we are going to create 3 main sections:

Comparing Stocks performance & forecasting
Portfolio Building Simulations
Analysing companies financial statements

You can find here a video demonstration of our end product:

Figure 1: Plotly Dashboard for Financial Data Analysis (Image by Author).

All the code used as part of this article (and more!) is available on my Github profile.

Demonstration

Setup

First of all we need to make sure have all the dependencies installed on our machine. In this case, we are going to use libraries such as Dash, Plotly, Datetime, Pmdarima, etc...

import dash
from dash import dcc, html, Dash, Input, Output, State, ctx
import plotly.graph_objs as go
import pandas as pd
import requests
from datetime import datetime, timedelta
import dash_bootstrap_components as dbc
from pmdarima import auto_arima
import numpy as np
from sklearn.metrics import mean_absolute_error
from itertools import count

Now you need to make sure to create an API key for Financial Modeling Prep, this can be easily done by creating an account on their website. With their free plan, we can then get up to 250 calls per day. Once the API is setup, we can then proceed to initialise the Dash app and over useful variables (e.g. unique id generator and start/end dates for date picker widget).

api_key = 'YOUR_API_KEY'
# Initialize Dash app with Bootstrap for better styling
app = Dash(__name__, external_stylesheets=[dbc.themes.BOOTSTRAP])

# Define default start and end dates for the date picker
default_end_date = datetime.now()
default_start_date = default_end_date - timedelta(days=180)
# Counter for generating unique IDs
unique_id_generator = count(start=0)

At this point we can now go to the Financial Modeling Prep API documentation and look for the different endpoints we are interested to use in order to build the application. In this case, I decided to create 3 helper functions to fetch data from their API:

fetch_stock_list: get a list of all the stocks available from the API to pre-populate dropdowns on the application when users have to select stocks.
fetch_data: get historical stock data for selected data ranges.
fetch_financial_data: get data from financial reports of publicly listed companies (e.g. income statements, balance sheets, cash flow statements).

def fetch_stock_list():
    url = f'https://financialmodelingprep.com/api/v3/stock/list?apikey={api_key}'
    response = requests.get(url)
    if response.status_code == 200:
        data = response.json()
        stocks = [{'label': stock['symbol'], 'value': stock['symbol']} for stock in data]
        return stocks
    else:
        return []

# Function to fetch and process data
def fetch_data(stock, start_date, end_date):
    formatted_start_date = pd.to_datetime(start_date).strftime('%Y-%m-%d')
    formatted_end_date = pd.to_datetime(end_date).strftime('%Y-%m-%d')
    url = f'https://financialmodelingprep.com/api/v3/historical-price-full/{stock}?from={formatted_start_date}&to={formatted_end_date}&apikey={api_key}'
    response = requests.get(url)
    if response.status_code != 200:
        return pd.DataFrame()  # Return an empty DataFrame in case of an error
    data = response.json()
    df = pd.DataFrame(data['historical'])
    df['date'] = pd.to_datetime(df['date'])
    return df


def fetch_financial_data(company, report_type):
    url = f'https://financialmodelingprep.com/api/v3/{report_type}/{company}?apikey={api_key}'
    response = requests.get(url)
    if response.status_code == 200:
        return response.json()
    else:
        return {}


# Fetch the list of stocks when initializing the app
stock_options = fetch_stock_list()

Finally, we are now ready to define the layout for the application for each of the 3 different sections.

# Define app layout
app.layout = dbc.Container([
    html.H1('Financial Analysis Companion'),
    html.H3('Compare Stocks Performance and Forecasting'),
    dbc.Row([
        dbc.Col([
            dcc.Dropdown(
                id='stock-selector',
                options=stock_options,  # Set the options to the list of stocks
                value=[],  # Default value can be empty or some default stocks
                multi=True,
                placeholder="Select a stock"
            )
        ], width=6),
        dbc.Col([
            dcc.DatePickerRange(
                id='date-picker',
                start_date=default_start_date,
                end_date=default_end_date
            )
        ], width=6)
    ]),
    dbc.Row([
        dbc.Col([
            html.Button('Forecast', id='forecast-button', n_clicks=0),
        ], width=12)
    ]),
    dbc.Row([
        dbc.Col([
            dcc.Graph(id='stock-graph'),
            dcc.Loading(
                id="loading-1",
                type="default",
                children=html.Div(id="loading-output-1")
            )
        ])
    ]),
    html.H3('Build Your Portfolio'),
    dbc.Row([
        dbc.Col([
            dcc.Dropdown(
                id='stock-input',
                options=stock_options,  # Set the options to the list of stocks
                value='',
                placeholder="Select a stock"
            ),
        ], width=6),
        dbc.Col([
            dcc.Input(id='weight-input', type='number', placeholder='Enter stock weight'),
        ], width=6)
    ]),
    html.Button('Add to Portfolio', id='add-stock-button', n_clicks=0),
    html.Div(id='portfolio-list', children=[]),
    html.Div(id='portfolio-message', children=''),
    dcc.Graph(id='portfolio-performance'),
    html.H3('Company Financials'),
    dcc.Dropdown(
            id='company-selector',
            options=stock_options,  # Set the options to the list of stocks
            value='',
            placeholder="Select a stock"
        ),
    dcc.Dropdown(
        id='report-type-selector',
        options=[
            {'label': 'Income Statement', 'value': 'income-statement'},
            {'label': 'Balance Sheet', 'value': 'balance-sheet-statement'},
            {'label': 'Cash Flow Statement', 'value': 'cash-flow-statement'}
        ],
        value='income-statement',
        placeholder="Select a report type"
    ),
    dcc.Graph(id='financial-report-graph')
], fluid=True)

Comparing Stocks performance & forecasting

For this section, we want to ensure to be able to display the stock data from the Financial Modeling Prep and add a button the user can use in order to create a forecasting analysis. In order to perform the forecast we will use a classical ARIMA model. In order to create the model we then need to:

Split up the data into training and test sets (split_data).
Training the model on the training data (perform_forecast), evaluate its performance on the test set (evaluate_model) and predict the stock price for the upcoming month. In this example, we are going to use the Mean Absolute Error (MAE) as our key metric.

# Function to split data into training and test sets
def split_data(df, test_size=30):
    df = df.sort_values(by='date')
    train = df[:-test_size]
    test = df[-test_size:]
    return train, test

# Function to perform forecasting and return predictions
def perform_forecast(train, test, future_periods=30):
    model = auto_arima(train['close'], seasonal=False, error_action='ignore', suppress_warnings=True)
    model.fit(train['close'])

    # Predict on training data
    train_pred = model.predict_in_sample()

    # Forecast future data
    future_forecast = model.predict(n_periods=len(test) + future_periods)

    # Generating future dates
    last_date = train['date'].iloc[-1]
    future_dates = pd.date_range(start=last_date, periods=len(test) + future_periods + 1, closed='right')

    return train_pred, future_forecast, future_dates

# Function to evaluate model performance
def evaluate_model(test, predictions):
    mae = mean_absolute_error(test['close'], predictions[:len(test)])
    return mae

At this point, we are now ready to combine our helper functions together and create the resulting graph and widgets:

# Callback to update graph with forecasting
@app.callback(
    Output('stock-graph', 'figure'),
    [Input('stock-selector', 'value'),
     Input('date-picker', 'start_date'),
     Input('date-picker', 'end_date'),
     Input('forecast-button', 'n_clicks')],
    prevent_initial_call=True
)
def update_graph_with_forecast(selected_stocks, start_date, end_date, n_clicks):
    triggered_id = ctx.triggered_id if not ctx.triggered_id is None else ''

    traces = []
    layout = {
        'title': 'Stock Data and Forecast',
        'xaxis': {'title': 'Date'},
        'yaxis': {'title': 'Price'},
        'annotations': []
    }

    base_y_position = 1.05  # Starting y position for the first MAE annotation
    y_step = 0.05  # Vertical spacing between annotations

    for index, stock in enumerate(selected_stocks):
        df = fetch_data(stock, start_date, end_date)
        if df.empty:
            continue

        historical_trace = go.Scatter(x=df['date'], y=df['close'], mode='lines', name=f'{stock} - Historical')
        traces.append(historical_trace)

        if triggered_id == 'forecast-button':
            train, test = split_data(df)
            train_pred, future_forecast, future_dates = perform_forecast(train, test)
            mae = evaluate_model(test, future_forecast)

            forecast_trace = go.Scatter(x=future_dates, y=future_forecast, mode='lines', name=f'{stock} - Forecast', line={'dash': 'dot'})
            traces.append(forecast_trace)

            # Calculate the y position for the current annotation
            y_position = base_y_position - (index * y_step)

            layout['annotations'].append(
                dict(
                    xref='paper', yref='paper', x=0.5, y=y_position,
                    xanchor='center', yanchor='bottom',
                    text=f'{stock} MAE: {mae:.2f}',
                    showarrow=False,
                    font=dict(color="blue", size=12)
                )
            )

    figure = {'data': traces, 'layout': layout}
    return figure

With the current setup, users are allowed to add as many stock as they wish on the graph for comparison, but adding too many stocks can end up overcrowding too much the chart. In this case, we can then define an helper function to allow for maximum 2 stocks to be selected at the same time and reject any additional selection:

@app.callback(
    Output('stock-selector', 'value'),
    [Input('stock-selector', 'value')]
)
def limit_stock_selection(selected_stocks):
    max_stocks = 2
    if len(selected_stocks) > max_stocks:
        selected_stocks = selected_stocks[:max_stocks]  # Keep only the first two selected stocks
    return selected_stocks

Figure 2: Comparing Stocks Section (Image by Author).

Portfolio Building Simulations

In order to simulate the process of building a portfolio there are different key characteristics we need to keep in mind such as:

We need to make sure data from the different companies added to the portfolio is aligned, covering the same time range (align_data)
A guiding metric should be set up to evaluate if, based on past performance, investing in a certain combination of companies can result or not in good returns on the invested capital and how high it would be the associated risk (calculate_portfolio_volatility).

def align_data(historical_data):
    # Check if historical_data is empty or contains empty DataFrames
    if not historical_data or any(df.empty for df in historical_data.values()):
        return {}

    start_dates = [df.index.min() for df in historical_data.values()]
    end_dates = [df.index.max() for df in historical_data.values()]
    max_start = max(start_dates)
    min_end = min(end_dates)

    # Truncate each DataFrame to this common date range
    aligned_data = {symbol: df[(df.index >= max_start) & (df.index <= min_end)] for symbol, df in historical_data.items()}
    return aligned_data



def calculate_portfolio_volatility(portfolio_return, weights):
    # Calculate the covariance matrix of the returns
    covariance_matrix = portfolio_return.cov()

    # Calculate portfolio variance
    portfolio_variance = np.dot(weights, np.dot(covariance_matrix, weights))

    # Calculate portfolio standard deviation (volatility)
    portfolio_volatility = np.sqrt(portfolio_variance)

    # Annualize the volatility
    annualized_volatility = portfolio_volatility * np.sqrt(252)

    return annualized_volatility

Additionally building a portfolio is usually an highly iterative process and we therefore need to make it as easy as possible for users to add companies, inspect the simulation results and if needed remove companies to start the process again.

# Function to generate a portfolio item with a delete button
def generate_portfolio_item(symbol, weight, unique_id):
    return html.Div([
        html.Span(f'{symbol.upper()}: {weight}%'),
        html.Button('Delete', id={'type': 'delete-stock-button', 'index': unique_id}, n_clicks=0)
    ], id={'type': 'portfolio-item', 'index': unique_id})

# Callback for adding and deleting stocks
@app.callback(
    Output('portfolio-list', 'children'),
    [Input('add-stock-button', 'n_clicks'),
     Input({'type': 'delete-stock-button', 'index': dash.dependencies.ALL}, 'n_clicks')],
    [State('stock-input', 'value'),
     State('weight-input', 'value'),
     State('portfolio-list', 'children')]
)
def update_portfolio(add_n_clicks, delete_n_clicks, stock_symbol, weight, portfolio_children):
    triggered_id = ctx.triggered[0]['prop_id']

    if 'add-stock-button' in triggered_id:
        if add_n_clicks > 0 and stock_symbol and weight:
            # Correctly extract weights from portfolio_children
            current_total_weight = sum([float(child['props']['children'][0]['props']['children'].split(': ')[1].strip('%')) for child in portfolio_children])

            new_total_weight = current_total_weight + float(weight)

            if new_total_weight <= 100:
                unique_id = next(unique_id_generator)
                new_element = generate_portfolio_item(stock_symbol, weight, unique_id)
                portfolio_children.append(new_element)
            else:
                return portfolio_children, 'Total portfolio weight cannot exceed 100%'

    # Check if any delete button was clicked
    elif 'delete-stock-button' in triggered_id:
        # Extract the delete button index
        delete_index = int(triggered_id.split('{"index":')[1][0])
        # Remove the item with the matching unique ID
        portfolio_children = [child for child in portfolio_children if child['props']['id']['index'] != delete_index]

    return portfolio_children

Finally, we can now just create a callback function to combine all our utils together and display the results.

@app.callback(
    Output('portfolio-performance', 'figure'),
    [Input('portfolio-list', 'children')]
)
def display_portfolio_performance(portfolio_children):
    if not portfolio_children:
        return go.Figure()  # Return an empty figure if no children

    symbols = []
    weights = []
    for child in portfolio_children:
        # child is a dictionary representing a Dash component
        portfolio_item = child['props']['children'][0]['props']['children']  # Getting the text content
        symbol, weight = portfolio_item.split(': ')
        weight = float(weight.strip('%')) / 100
        symbols.append(symbol)
        weights.append(weight)

    historical_data = {symbol: fetch_data(symbol, default_start_date, default_end_date) for symbol in symbols}
    historical_data = align_data(historical_data)

    portfolio_return = pd.DataFrame()
    for symbol in symbols:
        df = historical_data[symbol]
        df[f'{symbol}_return'] = df['close'].pct_change()
        portfolio_return = pd.concat([portfolio_return, df[f'{symbol}_return']], axis=1)

    # Normalize weights to sum to 1
    weights = np.array(weights) / sum(weights)
    portfolio_return['portfolio_return'] = portfolio_return.dot(weights)
    portfolio_cumulative_return = (1 + portfolio_return['portfolio_return']).cumprod() - 1

    # Calculate annualized volatility
    annualized_volatility = calculate_portfolio_volatility(portfolio_return.iloc[:, :-1], weights)

    fig = go.Figure()
    fig.add_trace(go.Scatter(x=portfolio_cumulative_return.index, y=portfolio_cumulative_return, mode='lines', name='Portfolio Cumulative Return'))
    fig.update_layout(title=f'Portfolio Performance (Annualized Volatility: {annualized_volatility:.2%})', xaxis_title='Date', yaxis_title='Cumulative Returns')

    return fig

Figure 3: Building Portfolio Section (Image by Author).

Analysing companies financial statements

Another important part of the process to understand if a company is performing well or not is to look at some of the key metrics on their financial statements. Three of most important financial statements are:

Income Statement: providing us metrics such as revenue, net income, gross profit, etc...
Balance Sheet: showing a company assets and liabilities, etc...
Cash Flow: estimating a company free cash flow, capital expenditure, etc...

@app.callback(
    Output('financial-report-graph', 'figure'),
    [Input('company-selector', 'value'),
     Input('report-type-selector', 'value')]
)
def update_financial_report_graph(company, report_type):
    financial_data = fetch_financial_data(company, report_type)

    if not financial_data:
        return go.Figure()

    # Convert the data to a pandas DataFrame
    df = pd.DataFrame(financial_data)
    df['date'] = pd.to_datetime(df['date'])
    df.sort_values(by='date', inplace=True)

    # Initialize figure
    fig = go.Figure()

    # Depending on the report type, plot different metrics
    if report_type == 'income-statement':
        fig.add_trace(go.Scatter(x=df['date'], y=df['revenue'], mode='lines', name='Revenue'))
        fig.add_trace(go.Scatter(x=df['date'], y=df['netIncome'], mode='lines', name='Net Income'))
        fig.add_trace(go.Scatter(x=df['date'], y=df['grossProfit'], mode='lines', name='Gross Profit'))
    elif report_type == 'balance-sheet-statement':
        fig.add_trace(go.Scatter(x=df['date'], y=df['totalAssets'], mode='lines', name='Total Assets'))
        fig.add_trace(go.Scatter(x=df['date'], y=df['totalLiabilities'], mode='lines', name='Total Liabilities'))
        fig.add_trace(go.Scatter(x=df['date'], y=df['totalStockholdersEquity'], mode='lines', name='Total Stockholders’ Equity'))
    elif report_type == 'cash-flow-statement':
        fig.add_trace(go.Scatter(x=df['date'], y=df['netCashProvidedByOperatingActivities'], mode='lines', name='Net Cash from Operating Activities'))
        fig.add_trace(go.Scatter(x=df['date'], y=df['capitalExpenditure'], mode='lines', name='Capital Expenditure'))
        fig.add_trace(go.Scatter(x=df['date'], y=df['freeCashFlow'], mode='lines', name='Free Cash Flow'))

    # Update layout
    fig.update_layout(
        title=f'{company.upper()} Financials - {report_type.replace("-", " ").title()}',
        xaxis_title='Date',
        yaxis_title='Amount (USD)',
        hovermode='closest'
    )

    return fig

Figure 4: Company Financials Section (Image by Author).

Running the application

Now that we have all the components in place, we are finally ready launch the application!

# Run the app
if __name__ == '__main__':
    app.run_server(debug=True)

If you are using Jupyer Lab/Notebook and have the Dash extension installed, you should be able to visualise the dashboard directly in your notebook, otherwise you should now be able to inspect the results at this URL: http://127.0.0.1:8050/

Conclusion

As part of this tutorial we explored how to create a financial dashboard using Plotly and Financial Modeling Prep. At the moment, our application is able to run just locally, but if you are interested in sharing it with your friends/colleagues many alternatives for deployment exist such as Heroku, AWS, Azure, GCP. For the context of this tutorial, we just scratched the surface of what tools like Financial Modeling Prep and Dash are able to achieve, therefore you are highly encouraged to explore their documentations in order to build on!

Introduction to NannyML: Model Evaluation without labels

Pier Paolo Ippolito — Fri, 15 Dec 2023 15:04:59 +0000

Introduction

Developing Machine Learning models is nowadays becoming easier and easier thanks to the different tools created by cloud providers (e.g. Amazon Sagemaker, Azure ML) and data platforms (e.g. Dataiku, DataRobot, DataBricks, etc…). Although, correctly monitoring and evaluating ML models once deployed still remains a big problem for some applications in which it can be costly (or impossible!) to gather new labels within a reasonable timeframe.

In order to try to solve this issue, NannyML was created. NannyML is an open-source Python library designed in order to make it easy to monitor drift in the distributions of our model input variables and estimate our model performance (even without labels!) thanks to the Confidence-Based Performance Estimation algorithm they developed. But first of all, why do models need to be monitored and why their performance might vary over time?

ML Models Monitoring/Evaluation

Unlike traditional software projects, which are rule-based and deterministic, ML projects are inherently probabilistic and therefore require some level of maintenance (monitoring) in the same way code quality is ensured in software development through testing.

Model Monitoring and Evaluation are an area of research falling into the MLOps subspace (Figure 1). MLOps (Machine Learning -> Operations) is a set of processes designed to transform experimental Machine Learning models into productionized services ready to make decisions in the real world. Additional information about MLOps and some of its key design patterns is available in my previous article.

Figure 1: Hidden Technical Debt in Machine Learning Systems [1]. Reposted with permission.

Some of the key reasons why we need to have a system in place to monitor and frequently re-evaluate ML models are changes in:

Data Drift: can take place when the distribution of the input features is different from the one in production (Figure 2). This change could take place suddenly due to changes in the real world or incrementally over time. Due to the nature of this shift, Data Drift does not necessarily always lead to a decrease in the performance of our model and if detected in its early stages could be taken as an opportunity to improve our model pipeline to make it more robust to these form of changes (e.g. re-training to find a better decision boundary, handle differently missing values, changes in schema, etc…).

Figure 2: Data Drift without model degradation (Image by Author).

Target Drift: In the case of Target Drift, our label variable might suffer a change in its distribution and addition/removal of some of its classification categories (Figure 3).

Figure 3: New categories added to our label (Image by Author).

Concept Drift: This type of drift can take place when the underlying relationship between features and labels changes (Figure 4). Making therefore the patterns learned by our model during training time no longer valid (causing an overall degradation in performance).

Figure 4: Concept Drift altering model decision boundary (Image by Author).

In order to try to measure drift, it is first necessary to identify a windowing approach (e.g. fixed or sliding) to select the points used for the comparison and then choose a metric to quantify the drift.

For univariate analysis, the Kolmogorov-Smirnov (KS) test can be used when working with continuous variables and the Pearson’s Chi-squared test for categorical data. In the case of multivariate analysis, we can instead first use a dimensionality reduction techniques (e.g. Principal Component Analysis, Autoencoders, etc…) to work in a lower dimensionality space and then apply a two-sample test (e.g. KS Test with Bonferroni Correction).

Once having in place a system able to identify drift it can then be important to evaluate how this can impact our model performance. In some circumstances, actual labels could be made available relatively soon and we should be able to assess performance in the same way we did for training a model, but in most cases, labels might be available just months or years after a prediction has been made (e.g. long term insurance contracts). In these circumstances, approximate signals could be fabricated as a proxy to evaluate our model, or performance estimation algorithms such as the Confidence-Based Performance Estimation algorithm developed by NannyML could be used.

Demonstration

In this article, I will walk you through a practical example in order to get started using NannyML. All the code used throughout this demonstration (and more!) is available on my GitHub and Kaggle accounts. For this example, we are going to use the Kaggle Home Equity (HMEQ) dataset [2] in order to predict if a customer is going to default or not on their loan.

First of all, we need to make sure to install NannyML.

!pip install nannyml

We are now ready to import all the necessary dependencies and visualize our dataset (Figure 5). If you are interested in learning more about what each column means, you can find additional information here.

import numpy as np
import pandas as pd
import random
import datetime as dt
import matplotlib.pyplot as plt
from imblearn.under_sampling import RandomUnderSampler
from imblearn.over_sampling import RandomOverSampler
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import recall_score
import nannyml as nml

df = pd.read_csv("/kaggle/input/hmeq-data/hmeq.csv")
df.head()

Figure 5: HMEQ Dataset (Image by Author).

Before proceeding with our analysis we need first to make sure that all categorical variables are converted into a numeric format (e.g. using One Hot Encoding), any missing value is removed, and the distribution between the two classes is as close as possible (e.g. using Oversampling and Undersampling). Once ensured that, we are then ready to split the dataset into training, test, and production sets and train a Random Forest Classifier.

df = pd.get_dummies(df).dropna()

over = RandomOverSampler(sampling_strategy=0.8)
df = pd.concat(over.fit_resample(df[df.columns[1:]], df["BAD"]), axis=1)
under = RandomUnderSampler(sampling_strategy=0.9)
df = pd.concat(under.fit_resample(df[df.columns[:-1]], df["BAD"]), axis=1)

X_train, X_rest, y_train, y_rest = train_test_split(df[df.columns[:-1]], 
                                                    df["BAD"],
                                                    stratify=df["BAD"], 
                                                    test_size=0.5)
X_test, X_prod, y_test, y_prod = train_test_split(X_rest, 
                                                  y_rest,
                                                  stratify=y_rest, 
                                                  test_size=0.2)

clf = RandomForestClassifier(random_state=0)
clf.fit(X_train, y_train)

At this point, we just need to check the performance of the trained model and prepare the dataset to be used by NannyML.

Considering predicting loan defaults is a quite class imbalanced problem in nature, the recall has been chosen as our metric of choice (rather than for example accuracy).

In order to prepare the dataset to be used with NannyML, the following columns have been added:

Partition: to divide the dataset into reference and analysis periods.
BAD: our target column indicating if someone has defaulted or not their loan.
Time: to make our dataset time-dependent and monitor the model performance against this dimension.
Identifier: a unique identifier for each row.
Y_Pred_Proba: a column with the prediction probabilities made by our model of if someone is going to default on their loan or not.
Y_Pred: a column with the binary predictions made by the model with a custom threshold of 75% probability.

Finally, some custom noise is added to the YOJ, MORTDUE, and CLAGE variables in order to add some arbitrary drift to the variables.

X_test['partition'], X_test['BAD'] = 'reference', y_test.values  
X_prod['partition'], X_prod['BAD'] = 'analysis', y_prod.values
X_prod['YOJ'] = X_prod['YOJ'] * (random.uniform(0, 12) + 0.4)
X_prod['MORTDUE'] = X_prod['MORTDUE'] * random.uniform(0, 5)
X_prod['CLAGE'] = X_prod['CLAGE'] * 0.1
nanny_ml_df = pd.concat([X_test, X_prod])
nanny_ml_df['Time'] = [dt.datetime(2020,1,1) + dt.timedelta(hours=x+5) 
                       for x in range(len(nanny_ml_df))]
nanny_ml_df['identifier'] = nanny_ml_df.index
nanny_ml_df['y_pred_proba'] = (
  clf.predict_proba(nanny_ml_df[nanny_ml_df.columns[:-4]])[:,1])
nanny_ml_df['y_pred'] = nanny_ml_df['y_pred_proba'].map(lambda p: int(p >= 0.75))

reference = nanny_ml_df[nanny_ml_df['partition']=='reference'].copy()
analysis = nanny_ml_df[nanny_ml_df['partition']=='analysis'].copy()

for partition_name, partition_data in nanny_ml_df.groupby('partition', sort=False):
    print(partition_name, recall_score(partition_data['BAD'], partition_data['y_pred']))

reference 0.984390243902439
analysis 0.26848249027237353

We are now finally ready to start using NannyML capabilities. First of all, a metadata variable is created to specify what kind of ML problem we are trying to solve and the columns to exclude and prioritize. Then, as shown in Figure 6, the Confidence-Based Performance Estimation (CBPE) algorithm is trained and used to make performance estimations on the analysis partition.

metadata = nml.extract_metadata(reference, 
                                exclude_columns=['identifier', 'y_pred_proba', 
                                                 'y_pred', 'BAD'], 
                                model_type='classification_binary')
metadata.target_column_name = 'BAD'
metadata.timestamp_column_name = 'Time'

cbpe = nml.CBPE(model_metadata=metadata, chunk_period='W', metrics=['recall'])
cbpe.fit(reference_data=reference)
est_perf = cbpe.estimate(pd.concat([reference, analysis]))

fig = est_perf.plot(kind='performance', metric='recall')
fig.show()

Figure 6: Confidence-Based Performance Estimation Algorithm in action (Image by Author).

Considering that in this specific case, we have the labels available we can then try to compare what recall the CBPE algorithm predicted against the actual recall of the model. As we can see from Figure 7, in this case, the algorithm was able to a good extent to foresee our model degradation throughout time.

Figure 7: Actual Recall vs Estimated (Image by Author).

Now that we have validated our model is degrading over time, we can then try to take a step back and see what features might be causing this problem and are generating alerts in our monitoring system. As shown in Figure 8, YOJ, CLAGE, and MORTDUE seem to be the main causes.

univariate_calculator = (
  nml.UnivariateStatisticalDriftCalculator(model_metadata=metadata)
     .fit(reference_data=reference))
univariate_results = univariate_calculator.calculate(data=analysis)
nml.Ranker.by('alert_count').rank(univariate_results, metadata)

Figure 8: Number of alerts estimation (Image by Author).

Taking MORTDUE (the amount due on an existing customer mortgage) as an example, we can then go on and plot how the distribution of this feature varied against time.

Figure 9: MORTDUE Feature distribution over time (Image by Author).

Finally, taking this analysis a step further we could then look at how the reconstruction error varied against time in the case of multivariate drift (Figure 10).


rcerror_calculator = (nml.DataReconstructionDriftCalculator(model_metadata=metadata)
                         .fit(reference_data=reference))
rcerror_results = rcerror_calculator.calculate(data=pd.concat([reference, analysis], 
                                                              ignore_index=True))
fig = rcerror_results.plot()
fig.show()

Figure 10: Multivariate Drift visualization (Image by Author).

Bibliography

[1] Hidden Technical Debt in Machine Learning Systems, D. Sculley et. al. Part of Advances in Neural Information Processing Systems 28 (NIPS 2015). Accessed at: https://papers.nips.cc/paper/2015/hash/86df7dcfd896fcaf2674f757a2463eba-Abstract.html

[2] HMEQ_Data, Predict clients who default on their loan. CC0: Public Domain. Accessed at: https://www.kaggle.com/datasets/ajay1735/hmeq-data

Contacts

If you want to keep updated with my latest articles and projects follow me on Medium and subscribe to my mailing list. These are some of my contacts details:

Financial Data Analysis

Pier Paolo Ippolito — Thu, 07 Dec 2023 17:00:00 +0000

Financial Background

Financial Data Analysis is one of the most common active fields in Data Science and Machine Learning.

Two of the most traded types of assets in finance are Equities (Stocks) and Bonds (Figure 1):

Stocks: companies move from being private to public through Initial Public Offering (IPO) in order to raise money. At this point, a company can be traded on the market and investors can invest in their shares and became stockholders (in hope to earn dividends).
Bonds: are instead debt securities typically issued by governments or corporations. When buying a Bond, we are not acquiring ownership of a company but lending instead money which will then be paid back to us at a fixed rate of interest.

Figure 1: Stocks vs Bonds [1]

Additionally, other common types of assets in finance are Commodities and Derivatives.

In this article, we will focus on introducing different techniques used in order to analyse time-series stock market prices.

Basics of Time Series Data

A time series is a series of ordered data points which are subject to a serial dependence (eg. datapoints generated at different times can be dependent on each other). Most time series can be decomposed into 4 main components:

Level: represents how the time series would look like if it was a simple straight line.
Noise: resulting from measurement errors embedded in the recorded data.
Trend: determines the overall behaviour of the time series (eg. linearly increasing/decreasing).
Seasonality: represents any cyclical behaviour which might compose our data (eg. for a particular stock, prices might always be higher during the summer compared to the rest of the year).

Additionally, time series can fall into two main categories: stationary and non-stationary. A time series can be considered to be stationary if its main statistical properties (eg. mean, autocorrelation, variance) do not vary over time (otherwise, is non-stationary). Stationary time series are much easier to model compared to their non-stationary counterparts.

Lastly, another important property to take into account when analysing time series is autocorrelation. In fact, if a time series is autocorrelated, it can show a linear relationship with some of its lagged values (likely leading to overfitting during modelling).

Demonstration

I will now walk you through a simple example to get you started with Financial Data Analysis. First of all, we need to import all the necessary dependencies.

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from pandas.plotting import autocorrelation_plot
from statsmodels.tsa.seasonal import seasonal_decompose
from yahoofinancials import YahooFinancials

We can now load historical financial data of Microsoft for the last two years using Yahoo Finance records (Figure 2).

df = YahooFinancials('MSFT').get_historical_price_data(start_date='2017-01-01', 
                                                       end_date='2019-12-31', 
                                                       time_interval='daily')
df = pd.DataFrame(df['MSFT']['prices'])
df['Date'] = df['formatted_date']
df = df.drop(['date','formatted_date'], axis=1)
df = df.set_index('Date')
df.head()

Figure 2: Microsoft Stocks Dataset

Once loaded the data, we can then give a look at the close price distribution over time (Figure 3).

df['close'].plot();
plt.xlabel("Date", fontsize=18);
plt.ylabel("Price", fontsize=18);
plt.title('Microsoft Close Prices', fontsize=18);

Figure 3: Microsoft Close Prices

In order to decompose our time series into its fundamental 4 components, we can then make use of Statsmodel seasonal_decompose functionality (Figure 4).

seasonal_decompose(df['close'], model='additive', freq=20).plot();

Figure 4: Stock Prices Series Decomposition

Finally, we can examine if our time series has any autocorrelation and how it’s overall score varies against different lagged versions (of the time series against itself). As we can see in Figure 5, when comparing our time series with a version of itself just a few data points back in time, there is a strong autocorrelation between the two, which then starts linearly decreasing when increasing the lagging factor.

autocorrelation_plot(df['close']);
plt.xlabel("Lag", fontsize=18);
plt.ylabel("Autocorrelation", fontsize=18);
plt.title('Microsoft Close Prices Autocorrelation', fontsize=18);

Figure 5: Microsoft Close prices autocorrelation

Stocks Prediction

Three of the main techniques used in order to predict stock market prices are:

Auto-Regressive Integrated Moving Average (ARIMA): ARIMA is a combination of Auto-Regressive and Moving Average models and assumes that future prices are a linear combination of past input data. One of the main advantages of ARIMA is that it can work also with non-stationary time series (which reflects better the true nature of stock data).
Long Short Term Memory (LSTM) Network: LSTM is a type of Recurrent Neural Network (RNN). RNNs were initially developed to make up for the inability of traditional neural networks to work with time series. This is because traditional neural networks, in contrast with RNN, lack of a memory mechanism to remember its past input values (all the inputs are fed in at once and information moves only in one direction; forward). RNNs are able to overcome these shortfalls keeping the information in a loop, therefore enabling the network to make decisions using not only the current input but also the previous ones (input are added sequentially, one input is added after the previous one has been computed). Therefore, to some extent, an RNN can be considered as a collection of artificial neural networks passing each output from the previous one.
Convolutional Neural Network (CNN): CNN’s are a class of neural networks typically used for image recognition/classification in Computer Vision but can be also used for time series analysis. This can be done by converting the time series in a grayscale image like format.

Modern Portfolio Theory

No Financial Advice Disclaimer: none of the content and photos in the following coding demonstration should be considered as financial advice. This content was created for informational purposes only and only reflects personal opinions on the subject.

Modern Portfolio Theory is an investment theory developed in order to optimize a portfolio (collection of the different stocks owned by an investor) overall return.

Investors tend in fact to contribute to different stocks at the same time in order to minimize their risk to occur in losses. For example, if we invest in different stocks, in case one starts performing poorly its losses can be outweighed by the profits obtained thanks to the other stocks in our portfolio. One important point to take into account when deciding which set of stocks to invest in is the correlation between each of them (eg. if all the chosen stocks are positively correlated each other, in case of a fall in price each of them will be negatively affected). This strategy is commonly known as Portfolio Diversification.

Generally, more risky stocks (which are most likely to perform poorly) tend to provide a greater return in case of positive outcome compared to less risky stocks. Therefore investors are faced with an optimization problem: increasing their potential revenue while keeping their risk as low as possible.

In this fictitious example created simply for demonstration purposes, we are now going to use Monte Carlo Sampling in order to simulate a large number of possible portfolio combination scenarios in order to find out which combinations can help us maximizing a portfolio return (Efficient Frontier).

Two main measures are typically considered in order to calculate the goodness of a combination of stocks:

Standard Deviation: measures the volatility (risk) associated with our portfolio (the lower the better).
Sharpe ratio: the Sharpe ratio is a measure used in order to express risk-adjusted return (which incorporates in a single value the investment return with it’s associated risk). The greater the Sharpe ratio, the better our portfolio can be considered (Figure 6). One of the main problems associated with the use of the Sharpe ratio is that it assumes the returns follow a normal distribution (which doesn’t always hold true). Therefore other techniques such as the Treynor Ratio and Jensen’s Alpha are commonly used as well.

Figure 6: Sharpe Ratio Formula [2]

Every type of portfolio which falls between these two metrics can finally be considered as efficient (representing one of the best possible solutions available to us).

Demonstration

In this section, we are now going to explore how to apply Modern Portfolio Theory on a real dataset for educational purposes. For this fictitious example, we are just going to consider the adjusted closing price of 3 stocks: Apple, Microsoft, Facebook (Figure 7) over a limited amount of time. For more accurate results, many other companies and features other than adjusted closing price, should be considered.

Adjusted closing price amends a stock’s closing price to accurately reflect that stock’s value after accounting for any corporate actions.

— Investopedia [3]

df = YahooFinancials(['AAPL', 'MSFT', 'FB']).get_historical_price_data(start_date='2017-01-01', 
                                                                       end_date='2019-12-31', 
                                                                       time_interval='daily')
df = pd.DataFrame({'Date' :pd.DataFrame(df['AAPL']['prices'])['formatted_date'],
                   'AAPL' :pd.DataFrame(df['AAPL']['prices'])['adjclose'],
                   'MSFT' :pd.DataFrame(df['MSFT']['prices'])['adjclose'],
                   'FB' :pd.DataFrame(df['FB']['prices'])['adjclose']})
df = df.set_index('Date')
df.head()

Figure 7: Example Portfolio Dataset

Once loaded the data, we can then give a look at how the different stocks compare each other (Figure 8).

df['AAPL'].plot();
df['MSFT'].plot();
df['FB'].plot();
plt.legend(['AAPL', 'MSFT', 'FB'])
plt.xlabel("Date", fontsize=18);
plt.ylabel("Price", fontsize=18);
plt.title('Portfolio Stock Prices over time', fontsize=18);

Figure 8: Stocks Adjusted closing prices

Finally, we can create our simulation. We first start by converting our Adjusted closing prices into daily returns and then calculate their mean and associated covariance. For this example, we will assume a risk-free rate of 0.025 and 10000 simulation iterations. During each iteration, new weights (each representing the predominance a stock in our portfolio) summing up to one are randomly created and the portfolio annual return (assuming 252 trading days), standard deviation and Sharpe Ratio are calculated. Finally, the portfolios giving us the minimum risk and the maximum Sharpe Ratio and identified (Figure 9) and everything is plotted (Figure 10).

def portfolio_return_sim(df, daily_mean_returns, daily_cov_matrix, rf_rate, 
                         itern, working_days=252):
    number_of_stocks = df.shape[1]
    sim_res = np.zeros((3, itern))
    list_weights = []
    for i in range(itern):
        random_weights = np.random.random(number_of_stocks)
        normalized_weights = random_weights/np.sum(random_weights)
        list_weights.append([np.round(i, 3) for i in normalized_weights])
        port_annual_return = np.sum(daily_mean_returns*normalized_weights) * working_days)
        port_annual_std = np.sqrt(np.dot(normalized_weights.T, 
                                         np.dot(daily_cov_matrix, 
                                         normalized_weights))) * np.sqrt(working_days)
        sim_res[0,i], sim_res[1,i] = port_annual_std, port_annual_return
        sim_res[2,i] = (port_annual_return - rf_rate) / port_annual_std

    min_risk, max_sharpe = np.argmin(sim_res[0]), np.argmax(sim_res[2])
    plt.scatter(sim_res[0,:], sim_res[1,:], c=sim_res[2,:], cmap='cividis', marker='.')
    plt.colorbar(orientation='vertical')
    plt.scatter(sim_res[0, min_risk], sim_res[1, min_risk], 
                marker='x', color='r', s=300, label='Minimum Risk')
    plt.scatter(sim_res[0, max_sharpe], sim_res[1, max_sharpe], 
                marker='x', color='b', s=300, label='Maximum Sharpe Ratio')
    plt.legend(labelspacing=0.7)
    plt.title('Monte Carlo Simulated Portfolio Optimization', fontsize=18)
    plt.xlabel('Annual Risk (variation)', fontsize=18)
    plt.ylabel('Annual Return', fontsize=18)
    plt.savefig("5.png", format='png', dpi=1200, bbox_inches='tight')
    plt.show()

    df2 = pd.DataFrame([list_weights[min_risk], list_weights[max_sharpe]], 
                       columns=df.columns, index=["Minimum Volatility Portfolio", 
                                                  "Maximum Sharpe Portfolio"])
    return df2

daily_returns = df.pct_change()
df2 = portfolio_return_sim(df, daily_returns.mean(), daily_returns.cov(), 
                           0.025, 10000)
df2.head()

As we can see in Figure 9, for this particular combination of stocks, assigning more than half the weight of our portfolio in Microsoft stocks, would then give us both reduced risk and a good return on the investment. As already mentioned before, this example portfolio has been created only for explaination purposes, took into consideration only data from a limited amount of time (2017–2019) and didn’t take into account of any other public company (which could potentially have led to better results). In a real life production enviroment, all these different considerantions (and many more!) would have defenitively been taken into account.

Figure 9: Set of optimized portfolios

Figure 10: Portfolio Optimization

Choosing any portfolio in the arc between the Minimum Risk and the Maximum Sharpe Ratio would then lead to an efficient solution (because this type of portfolios would give us the lowest risk possible in order to achieve our targeted return).

In case you are interested in learning more about Modern Portfolio Theory, “Modern Portfolio Theory and Investment Analysis” by Elton, Gruber et. al. is a great place where to start [4].

Bibliography

[1] How Stocks and Bonds Differ and Why It Matters, The Balance. Accessed at: https://www.thebalance.com/the-difference-between-stocks-and-bonds-417069

[2] The Sharpe ratio explained, IG. Chris Beauchamp. Accessed at: https://www.ig.com/au/trading-strategies/the-sharpe-ratio-explained-190117

[3] Adjusted Closing Price, Investopedia. AKHILESH GANTI. Accessed at: https://www.investopedia.com/terms/a/
adjusted_closing_price.asp

[4] Modern Portfolio Theory and Investment Analysis, WILEY. Elton, Gruber et. al. Accessed at: https://www.wiley.com/en-us/Modern+Portfolio+Theory+and+Investment
+Analysis%2C+9th+Edition-p-9781118469941

Contacts

If you want to keep updated with my latest articles and projects follow me on Medium and subscribe to my mailing list. These are some of my contacts details:

Introduction To Bitcoin And The Blockchain

Pier Paolo Ippolito — Wed, 22 Nov 2023 18:43:47 +0000

Introduction

The Bitcoin blockchain is a decentralised and democratic model. Miners (users who try to contribute to the blockchain through a Proof of Work) are given the power to expand the blockchain adding new blocks (updating the “ledger”) and the different transactions are then formally accepted if they archive the consensus of the majority of users. This process is performed automatically within the protocol by considering the record of blocks in the blockchain which required the greatest computational power to be constructed as the one represented by the majority of the users. Therefore, this protocol is governed by its own users and the winning miners have the power to write a part of the code in order to add new blocks to the blockchain.

The overall Blockchain workflow is exemplified in Figure 1.

Figure 1: Blockchain Workflow (Image Source)

The maximum number of Bitcoins is 21 million, although the actual quantity will most likely be a bit lower than this taking into account that Bitcoins are represented with a limited number of decimals (8). This number can be calculated by considering that: every new block added on the blockchain originally introduced 50 new Bitcoins into the system, this amount is then halved every 210000 added blocks and a maximum of 33 halving events can take place (due to the limited decimal representation).

The last Bitcoin will be mined when the block reward will go below one Satoshi (which should happen within the 33rd halving period).

With the Bitcoin rewards assigned to miners halving every four years, the block transaction fees will most likely become the main form of income for the miners in the future. Therefore, in order to incentivize miners to work for the community, the transactions fees might vary in line with the supply/demand relationship of the network. In fact, if miners would be no more stimulated to maintain updated the blockchain, it would be not anymore possible to keep updated the blockchain without a central point of authority. Transaction fees might, therefore, be considered in their function as taxes necessary in order to ensure the correct functioning of the system.

Upcoming Challenges

Animosity

The Bitcoin protocol is not considered to be completely anonymous but pseudo-anonymous. In fact, although being designed to be secure, some techniques have been ideated throughout the years in order to undermine its safety. Two reasons why the Bitcoin protocol can be considered to be secure are [1]:

On a protocol level, addresses and transactions are not connected to users identities.
Bitcoin transaction data propagates through a random subset of the network nodes.

Instead, some examples of approaches which can be used in order to undermine the safety of transactions are:

An attacker might be able to retrieve enough information (so that to infer where a transaction was originated) by connecting multiple nodes to the bitcoin network.
All Bitcoin transactions are visible on the network, therefore, it can be possible to cluster together Bitcoin addresses connected to same users (deanonymizing the system).

Some possible approaches which can be used in order to prevent privacy breaches when using the Bitcoin protocol are to hide the used IP (Internet Protocol) address or change the IP address used for each transaction.

Double Spending Attack

Double spending is a type of attack which aims to erase a transaction from the blockchain by building a competing fork able to achieve wide consensus where the performed transaction is not recorded (therefore allowing the user to spend money on a good, receive the good and keep the initial amount of money spent).

Figure 2: Double Spending Attack (Image Source)

When forks are created in the blockchain, the network successively achieves consensus by accepting the chain of blocks with most Proof of Work (amount of processing power consumed to create this chain of blocks). Usually, the chain with most Proof of Work is also the chain containing the greatest number of blocks. Consensus mechanisms such as Proof of Work incentives miners to act truthfully (trying to deceive the network would most likely lead to a loss for them). One possible way miners might manage to make the system vulnerable is by controlling at least 51% of the total network processing power (making double-spending feasible). Another problematic of Proof of Work as a consensus mechanism is it’s moderate velocity to reach consensus (although this can lead to an increase in security).

Limited block size and Scalability

Increasing block size would allow for more transactions to be contained in a block and would potentially give less importance to transaction fees (more lower transaction fees could be processed faster). Additionally, using a larger block size would make the blocks move at a slower rate through the network (increasing the likelihood and length of forks and therefore of attacks on the blockchain). On the other hand, decreasing the block size would give more importance to transaction fees and would allow for fewer transactions to be processed at the time.

Another possible approach to process more transactions faster in the Bitcoin protocol, could be to reduce the block generation interval. Although, also this approach would then lead to an increase in the number of forks in the network and consequently a decrease in security. Bitcoin scalability is additionally heavily dependent on factors such as: storage requirements, network bandwidth and size.

Execution Speed

One of the main problems of the Proof of Work consensus algorithms is its limited execution speed. SegWit2x and Lighting Network (LN) are two examples of techniques proposed in order to speed up transactions executions in the Bitcoin protocol (making this system more easily scalable). SegWit2x was designed in order to increase the allowable block size from 1 MB to 2 MB by creating a hard fork in the system. This approach has currently been rejected by the majority of the users since it might cause the risk of dividing the whole network into two concurrent branches. The use of SegWit (an earlier version of SegWit2x which uses instead a soft fork and is backwards-compatible) allowed successively the creation of Lightning network.

SegWit allows for a faster transaction execution speed by restructuring the block data so that signatures are not stored in conjunction with the transaction data. Both SegWit and Lighting Network are used in order process transactions faster, but Lightning Network is a second-layer protocol and therefore is not embedded in the blockchain itself but is built on the top of the network [2].

Bibliography

[1] Is Bitcoin Anonymous? A Complete Beginners Guide Bitcoin Magazine. Accessed at: https://bitcoinmagazine.com/articles/is-bitcoin-anonymous-a-complete-beginner-sguide-1447875283, February 2020.

[2] A Beginners Guide to Segregated Witness (SegWit) Binance Academy. Accessed at: https://www.binance.vision/blockchain/a-beginners-guide-to-segretated-witness-segwit, February 2020.

Contacts

If you want to keep updated with my latest articles and projects follow me on Medium and subscribe to my mailing list. These are some of my contacts details:

Fine-tuning LLMs with LoRA: A Gentle Introduction

Pier Paolo Ippolito — Tue, 22 Aug 2023 08:54:41 +0000

Four million dollars. That's how much it cost to train GPT-3. Luckily, a new training technique called LoRA makes it possible to train LLMs for a very small fraction of the cost.

In this article, we're going to experiment with LoRA and fine-tune Llama Alpaca using commercial hardware.

What is the difference between the LLaMA LLM and Alpaca?

First, we'll quickly review some LLM genealogy. Llama is a large language model released by Meta. It's Meta's response to OpenAI's GPT4, and is widely-considered to outperform GPT3.5.

Following the success of Llama, a research lab at Stanford released a new model called Alpaca, which was fine-tuned from the initial Llama model.

Alpaca is cheap to train, and performs on-par with OpenAI’s text-davinci-003. The initial Alpaca model was trained on 8 80GB A100s, and took 3 hours.

How was the LLaMA Alpaca LLM fine-tuned?

Fine-tuning involves taking an existing pre-trained model and training a small subset of parameters on new data. In order to fine-tune Llama, the Stanford Researchers used Open AI's text-davinci-003 to generate 52K instructions. The instructions were passed into the model using Huggingface training library.

Models with billions of parameters are extremely expensive to fine-tune. Earlier this year, Microsoft introduced a new technique called LoRA, or Low-Rank Adaptation.

LoRA uses 10,000 fewer training parameters than GPT-3 and 3x less GPU memory, yet performs equal or better than GPT-3. Importantly, LoRA models introduce no additional latency per request, making it a contender for production-grade use-cases.

LoRA can be used on pre-trained models, by freezing the weights of the model and adding specific training layers to each transformer block in the model.

After the model is fine-tuned on the new dataset, the product of the matrices between the new model and the original model are combined, which allows the fine-tuned model to remain the same size as the original.

How to setup a training script to fine-tune LLaMA Alpaca

In this article, I'll be using the following resources:

Llama 2 Alpaca LoRA repo for the fine-tuning code
Huggingface for the dataset used for fine-tuning
beam.cloud for cloud GPUs and tooling to train and deploy the models

We're going to train an instruction-following LLM on 52k rows of data generated by GPT-4.

I'm using the Instruction Tuning with GPT-4 dataset, which is hosted on Huggingface.

High-level Goal

Implement the code in Llama LoRA repo in a script we can run locally
Pass in the fine-tuning dataset to the model
Setup a cloud GPU to run the fine-tuning process
(Optional) Deploy an inference API to make predictions with the fine-tuned model

Training Script

The first thing we'll do is setup the compute environment to run Llama 2.

We'll run the training process on cloud GPUs from beam.cloud. The training script is run on a 24Gi A10G GPU:

📝 Please Note
For the sake of clarity, the full training code from this example has been abbreviated.

from math import ceil
from beam import App, Runtime, Image, Volume
from datasets import load_dataset

# Setup compute environment
app = App(
    "fine-tune-llama",
    runtime=Runtime(
        cpu=4,
        memory="32Gi",
        gpu="A10G",
        image=Image(
            python_version="python3.10",
            python_packages="requirements.txt",
        ),
    ),
    # Mount Volumes for fine-tuned models and cached model weights
    volumes=[
        Volume(name="checkpoints", path="./checkpoints"),
        Volume(name="pretrained-models", path="./pretrained-models"),
    ],
)


# Training entry point
@app.run()
def train_model():
    # Trained models will be saved to this path
    beam_volume_path = "./checkpoints"

    # Load vicgalle/alpaca-gpt4 dataset hosted on Huggingface:
    dataset = load_dataset("vicgalle/alpaca-gpt4")

    # Adjust the training loop based on the size of the dataset
    samples = len(dataset["train"])
    val_set_size = ceil(0.1 * samples)

    train(
        base_model=base_model,
        val_set_size=val_set_size,
        data=dataset,
        output_dir=beam_volume_path,
    )

In order to run this on Beam, we use the beam run command:

beam run app.py:train_model

When we run this command, the training function will run on Beam's cloud, and we'll see the progress of the training process streamed to our terminal:

Deploying an Inference API

When the model is trained, we can deploy an API to run inference on our fine-tuned model.

Let's create a new function for inference. If you look closely, you'll notice that we're using a different decorator this time: rest_api instead of run.

This will allow us to deploy the function as a REST API.

@app.rest_api()
def run_inference(**inputs):
    # Inputs passed to the API
    input = inputs["input"]

    # Grab the latest checkpoint
    checkpoint = get_newest_checkpoint()

    # Initialize models with latest fine-tuned checkpoint
    models = load_models(checkpoint=checkpoint)

    model = models["model"]
    tokenizer = models["tokenizer"]
    prompter = models["prompter"]

    # Generate text response
    response = call_model(
        input=input, model=model, tokenizer=tokenizer, prompter=prompter
    )
    return response

We can deploy this as a REST API by running this command:

beam deploy app.py:run_inference

If we navigate to the URL printed in the shell, we'll be able to copy the full cURL request to call the REST API.

I modified the request slightly with a payload for the model:

-d '{"input": "what are the five steps to become a published author?"}'

And here's the response from the fine-tuned model:

1. Create your manuscript with consistent writing sessions.


Revise and polish your work for clarity and accuracy.
Study your target audience and market trends.
Choose between traditional or self-publishing based on your goals.
Pursue traditional publishing with a compelling proposal.

Conclusion

Fine-tuning is a powerful technique for developing LLMs that perform relevant inference on your own dataset. With the addition of LoRA, anyone with access to a basic GPU can produce their own powerful and accurate LLMs.

The cloud GPU landscape is evolving too, and vendors like Beam, Banana, and Replicate offer pay-per-use GPUs that make it extremely affordable to fine-tune your own version of Alpaca.

Moreover, this post only scratches the surface of what's possible from a model optimization standpoint. In order to optimize your fine-tuned Llama model in production, techniques like GPTQ and 4-bit quantization can be used to achieve superior inference speed without any drop in performance.

Contacts

If you want to keep updated with my latest articles and projects follow me on Medium and subscribe to my mailing list. These are some of my contacts details: