Zorg dat het werkt, maak het goed, maak het snel - Kent Beck

De bedoeling van deze tutorial is om financiële professionals die nieuw zijn in Python niet alleen een introductie te geven van hoe een nuttig programma eruit zou kunnen zien, maar ook een introductie in het iteratieve proces dat je kunt gebruiken om het te ontwikkelen. Het bestaat daarom uit twee delen:

1. Eerst ontwikkel ik een werkend prototype met behulp van een rechttoe rechtaan aanpak die volgens mij gemakkelijk te volgen is en niet helemaal anders is dan het proces dat je zou kunnen gebruiken om dit project te starten als je helemaal opnieuw zou beginnen.
2. Nadat ik het werkende prototype heb ontwikkeld, loop ik door het proces van refactoring - de structuur van code veranderen zonder de functionaliteit ervan te veranderen. Misschien wil je voor dat deel blijven - het is een elegantere oplossing dan de eerste, en als bonus is het ongeveer 75x sneller in termen van uitvoeringstijd.

1. Een werkend prototype ontwikkelen

De Jupyter-notebook instellen

De Jupyter-notebook is een geweldig hulpmiddel om interactief met Python te werken. Het is een interactieve Python-interpreter met cellen die code, Markdown-tekst, afbeeldingen of andere gegevens kunnen bevatten. Voor deze tutorial heb ik het Python Quant Platform gebruikt, maar ik kan Colaboratory van Google ook aanraden, dat gratis is en in de cloud draait. Eenmaal daar selecteert u eenvoudig "Nieuw Python 3 Notebook" in het menu "Bestand" en u bent klaar om te gaan.

Als we dat hebben gedaan, is de volgende stap het importeren van de pakketten van derden die we nodig hebben voor gegevensmanipulatie en visualisaties, en het programma vertellen dat we grafieken inline in onze notebook willen zien, in plaats van in afzonderlijke vensters:

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
%matplotlib inline

Een opmerking voordat we onze eerste variabelen gaan benoemen. Zoals ik al heb benadrukt, is leesbaarheid een van de sterke punten van Python. Taalontwerp ondersteunt dat in grote mate, maar iedereen die code schrijft, is verantwoordelijk voor het leesbaar en begrijpelijk maken, niet alleen voor anderen, maar ook voor zichzelf. Zoals de wet van Eagleson stelt:"Elke eigen code waar je zes of meer maanden niet naar hebt gekeken, had net zo goed door iemand anders kunnen zijn geschreven."

Een goede vuistregel is om de onderdelen van je programma zo te noemen dat je zo min mogelijk aparte opmerkingen nodig hebt waarin wordt uitgelegd wat je programma doet.

Laten we met dat in gedachten verder gaan.

De financiële overzichten maken

Er zijn veel manieren waarop we met bestaande spreadsheetgegevens in Python kunnen werken. We kunnen bijvoorbeeld een blad in een Pandas DataFrame lezen met één regel code met behulp van de read_excel opdracht. Als u een nauwere integratie en realtime koppeling tussen uw spreadsheet en Python-code wilt, zijn er zowel gratis als commerciële opties beschikbaar om die functionaliteit te bieden.

Omdat het model hier heel eenvoudig is en om ons te concentreren op de Python-concepten, zullen we het helemaal opnieuw maken in ons script. Aan het einde van het eerste deel zal ik laten zien hoe u kunt exporteren wat we hebben gemaakt naar een spreadsheet.

Als eerste stap naar het maken van een Python-weergave van de jaarrekening hebben we een geschikte datastructuur nodig. Er zijn er veel om uit te kiezen, sommige ingebouwd in Python, andere uit verschillende bibliotheken, of we kunnen er zelf een maken. Laten we voor nu een serie uit de Pandas-bibliotheek gebruiken om de functionaliteit ervan te bekijken:

years = ['2018A', '2019B', '2020P', '2021P', '2022P', '2023P']
sales = pd.Series(index=years)
sales['2018A'] = 31.0  
sales

Deze ingang en de bijbehorende uitgang worden hieronder weergegeven:

Met de eerste drie regels hebben we een datastructuur gecreëerd met een index bestaande uit jaren (elk gemarkeerd om aan te geven of het Actual, Budget of Projected is), een startwaarde (in miljoenen euro's, zoals in het originele DCF-model), en lege (NaN, "Not a Number") cellen voor de projecties. De vierde regel drukt een representatie van de gegevens af - in het algemeen geeft het typen van de naam van een variabele of andere objecten in de interactieve interpreter u er meestal een zinnige voorstelling van.

Vervolgens declareren we een variabele om de verwachte jaarlijkse omzetgroei weer te geven. In dit stadium is het een puntschatting, hetzelfde cijfer als in ons oorspronkelijke DCF-model. We willen eerst dezelfde invoer gebruiken en bevestigen dat onze Python-versie hetzelfde presteert en hetzelfde resultaat geeft als de Excel-versie, voordat we puntschattingen gaan vervangen door kansverdelingen. Met behulp van deze variabele creëren we een lus die de verkoop in elk jaar van de projecties berekent op basis van het voorgaande jaar en de groeisnelheid:

growth_rate = 0.1
for year in range(1, 6):
    sales[year] = sales[year - 1] * (1 + growth_rate)
    
sales

We hebben nu geprojecteerde verkopen in plaats van NaN:

Op dezelfde manier doorlopen we de jaarrekening, declareren we variabelen wanneer we ze nodig hebben en voeren we de nodige berekeningen uit om uiteindelijk tot vrije kasstroom te komen. Als we daar eenmaal zijn, kunnen we controleren of wat we hebben overeenkomt met wat de Excel-versie van het DCF-model zegt.

ebitda_margin = 0.14
depr_percent = 0.032
ebitda = sales * ebitda_margin
depreciation = sales * depr_percent
ebit = ebitda - depreciation
nwc_percent = 0.24
nwc = sales * nwc_percent
change_in_nwc = nwc.shift(1) - nwc 
capex_percent = depr_percent
capex = -(sales * capex_percent)
tax_rate = 0.25
tax_payment = -ebit * tax_rate
tax_payment = tax_payment.apply(lambda x: min(x, 0))
free_cash_flow = ebit + depreciation + tax_payment + capex + change_in_nwc
free_cash_flow

Dit geeft ons de vrije kasstromen:

De ene regel erboven die in dit stadium misschien een opmerking nodig heeft, is de tweede tax_payment referentie. Hier passen we een kleine functie toe om ervoor te zorgen dat in scenario's waarin de winst voor belasting negatief wordt, we dan geen positieve belastingbetaling hebben. Dit laat zien hoe effectief u aangepaste functies kunt toepassen op alle cellen in een Pandas Series of DataFrame. De feitelijk toegepaste functie is natuurlijk een vereenvoudiging. Een realistischer model voor een grotere waarderingsoefening zou een afzonderlijk belastingmodel hebben dat de daadwerkelijk betaalde contante belastingen berekent op basis van een aantal bedrijfsspecifieke factoren.

De DCF-waardering uitvoeren

Nu we zijn aangekomen bij de geprojecteerde kasstromen, kunnen we nu een eenvoudige eindwaarde berekenen en alle kasstromen terug naar het heden verdisconteren om het DCF-resultaat te krijgen. De volgende code introduceert indexering en slicing, waarmee we toegang hebben tot een of meer elementen in een gegevensstructuur, zoals het Pandas Series-object.

We hebben toegang tot elementen door vierkante haken direct achter de naam van de structuur te schrijven. Eenvoudig indexeren benadert elementen op hun positie, beginnend met nul, wat betekent dat free_cash_flow[1] zou ons het tweede element geven. [-1] is een afkorting voor toegang tot het laatste element (de cashflow van het afgelopen jaar wordt gebruikt om de eindwaarde te berekenen), en het gebruik van een dubbele punt geeft ons een segment, wat betekent dat [1:] geeft ons alle elementen behalve de eerste, omdat we het historische jaar 2018A niet willen opnemen in onze DCF-waardering.

cost_of_capital = 0.12
terminal_growth = 0.02
terminal_value = ((free_cash_flow[-1] * (1 + terminal_growth)) / 
                 (cost_of_capital - terminal_growth))
discount_factors = [(1 / (1 + cost_of_capital)) ** i for i in range (1,6)]
dcf_value = (sum(free_cash_flow[1:] * discount_factors) +
            terminal_value * discount_factors[-1])
dcf_value

Daarmee is het eerste deel van ons prototype afgesloten - we hebben nu een werkend DCF-model, zij het een zeer rudimentair model, in Python.

De gegevens exporteren

Voordat we verder gaan met de daadwerkelijke Monte Carlo-simulatie, is dit misschien een goed moment om de exportmogelijkheden te noemen die beschikbaar zijn in het Pandas-pakket. Als je een Pandas DataFrame-object hebt, kun je dat met één regel naar een Excel-bestand schrijven met de to_excel methode. Er is een vergelijkbare functionaliteit om te exporteren naar meer dan een dozijn andere formaten en bestemmingen.

output = pd.DataFrame([sales, ebit, free_cash_flow],
                     index=['Sales', 'EBIT', 'Free Cash Flow']).round(1)
output.to_excel('Python DCF Model Output.xlsx')
output

Waarschijnlijkheidsverdelingen maken voor onze Monte Carlo-simulatie

Nu zijn we klaar om de volgende uitdaging aan te gaan:een deel van de puntschattingsinvoer vervangen door kansverdelingen. Hoewel de stappen tot nu toe misschien wat omslachtig leken vergeleken met het bouwen van hetzelfde model in Excel, zullen de volgende regels je een idee geven van hoe krachtig Python kan zijn.

Onze eerste stap is om te beslissen hoeveel iteraties we in de simulatie willen uitvoeren. Door 1.000 als uitgangspunt te gebruiken, wordt een balans gevonden tussen het verkrijgen van voldoende datapunten om zinvolle outputplots te krijgen, versus het voltooien van de simulatie binnen een redelijk tijdsbestek. Vervolgens genereren we de werkelijke verdelingen. Voor de eenvoud heb ik hier drie normale distributies gegenereerd, maar de NumPy-bibliotheek heeft een groot aantal distributies om uit te kiezen, en er zijn ook andere plaatsen om te kijken, waaronder de standaardbibliotheek van Python. Nadat we hebben besloten welke verdeling we moeten gebruiken, moeten we de parameters specificeren die nodig zijn om hun vorm te beschrijven, zoals gemiddelde en standaarddeviatie, en het aantal gewenste uitkomsten.

iterations = 1000
sales_growth_dist = np.random.normal(loc=0.1, scale=0.01, size=iterations)
ebitda_margin_dist = np.random.normal(loc=0.14, scale=0.02, size=iterations)
nwc_percent_dist = np.random.normal(loc=0.24, scale=0.01, size=iterations)
plt.hist(sales_growth_dist, bins=20)
plt.show()

Hier zou je kunnen stellen dat EBITDA geen afzonderlijke willekeurige variabele moet zijn die onafhankelijk is van de verkoop, maar in plaats daarvan tot op zekere hoogte gecorreleerd moet zijn met de verkoop. Ik ben het hiermee eens en voeg eraan toe dat het moet worden gedreven door een gedegen begrip van de dynamiek van de kostenstructuur (variabele, semi-variabele en vaste kosten) en de belangrijkste kostenfactoren (waarvan sommige hun eigen kansverdelingen kunnen hebben, zoals bijvoorbeeld de prijzen van inputgrondstoffen), maar die complexiteiten laat ik hier voor de ruimte en duidelijkheid buiten beschouwing.

Hoe minder gegevens u hebt om uw keuze van distributie en parameters te bepalen, hoe meer u zult moeten vertrouwen op de uitkomst van uw verschillende due diligence-werkstromen, gecombineerd met ervaring, om een ​​consensus te vormen over de reeksen van waarschijnlijke scenario's. In dit voorbeeld, met kasstroomprojecties, zal er een grote subjectieve component zijn, waardoor het visualiseren van de kansverdelingen belangrijk wordt. Hier kunnen we een basisvisualisatie krijgen, die de distributie van de verkoopgroei laat zien, met slechts twee korte regels code. Op deze manier kunnen we snel elke distributie naar eyeball bekijken die het beste de collectieve visie van het team weerspiegelt.

Nu hebben we alle bouwstenen die we nodig hebben om de simulatie uit te voeren, maar ze hebben geen handig formaat om de simulatie uit te voeren. Hier is dezelfde code waarmee we tot nu toe hebben gewerkt, maar allemaal verzameld in één cel en voor het gemak herschikt in een functie:

def run_mcs():
    
    # Create probability distributions
    sales_growth_dist = np.random.normal(loc=0.1, scale=0.01, size=iterations)
    ebitda_margin_dist = np.random.normal(loc=0.14, scale=0.02, size=iterations)
    nwc_percent_dist = np.random.normal(loc=0.24, scale=0.01, size=iterations)
    
    # Calculate DCF value for each set of random inputs
    output_distribution = []
    for i in range(iterations):
        for year in range(1, 6):
            sales[year] = sales[year - 1] * (1 + sales_growth_dist[0])
        ebitda = sales * ebitda_margin_dist[i]
        depreciation = (sales * depr_percent)
        ebit = ebitda - depreciation
        nwc = sales * nwc_percent_dist[i]
        change_in_nwc = nwc.shift(1) - nwc 
        capex = -(sales * capex_percent)
        tax_payment = -ebit * tax_rate
        tax_payment = tax_payment.apply(lambda x: min(x, 0))
        free_cash_flow = ebit + depreciation + tax_payment + capex + change_in_nwc
        
        # DCF valuation
        terminal_value = (free_cash_flow[-1] * 1.02) / (cost_of_capital - 0.02)
        free_cash_flow[-1] += terminal_value
        discount_factors = [(1 / (1 + cost_of_capital)) ** i for i in range (1,6)]
        dcf_value = sum(free_cash_flow[1:] * discount_factors )
        output_distribution.append(dcf_value)
    
    return output_distribution

We kunnen nu de hele simulatie uitvoeren en de outputverdeling plotten, wat de contante waarde van de cashflow van dit bedrijf in elk van de 1000 iteraties zal zijn, met de volgende code. De %time commando is geen Python-code, maar een notebook-steno die de tijd meet om iets uit te voeren (u zou in plaats daarvan de Python-functie uit de standaardbibliotheek kunnen gebruiken). Het hangt af van de computer waarop u het uitvoert, maar deze versie heeft 1-2 seconden nodig om de 1000 herhalingen uit te voeren en het resultaat te visualiseren.

%time plt.hist(run_mcs(), bins=20, color='r')
plt.show()

2. Het prototype verfijnen

# Key inputs from DCF model
years = 5
starting_sales = 31.0
capex_percent = depr_percent = 0.032
sales_growth = 0.1
ebitda_margin = 0.14
nwc_percent = 0.24
tax_rate = 0.25
# DCF assumptions
r = 0.12
g = 0.02
# For MCS model
iterations = 1000
sales_std_dev = 0.01
ebitda_std_dev = 0.02
nwc_std_dev = 0.01

def run_mcs():
    
    # Generate probability distributions
    sales_growth_dist = np.random.normal(loc=sales_growth, 
                                         scale=sales_std_dev, 
                                         size=(years, iterations))
    ebitda_margin_dist = np.random.normal(loc=ebitda_margin, 
                                          scale=ebitda_std_dev, 
                                          size=(years, iterations))
    nwc_percent_dist = np.random.normal(loc=nwc_percent, 
                                        scale=nwc_std_dev, 
                                        size=(years, iterations))
    
    # Calculate free cash flow
    sales_growth_dist += 1
    for i in range(1, len(sales_growth_dist)):
        sales_growth_dist[i] *= sales_growth_dist[i-1]
    sales = sales_growth_dist * starting_sales
    ebitda = sales * ebitda_margin_dist
    ebit = ebitda - (sales * depr_percent)
    tax = -(ebit * tax_rate)
    np.clip(tax, a_min=None, a_max=0)
    nwc = nwc_percent_dist * sales
    starting_nwc = starting_sales * nwc_percent
    prev_year_nwc = np.roll(nwc, 1, axis=0)
    prev_year_nwc[0] = starting_nwc
    delta_nwc = prev_year_nwc - nwc
    capex = -(sales * capex_percent)
    free_cash_flow = ebitda + tax + delta_nwc + capex
    # Discount cash flows to get DCF value
    terminal_value = free_cash_flow[-1] * (1 + g) / (r - g)
    discount_rates = [(1 / (1 + r)) ** i for i in range (1,6)]
    dcf_value = sum((free_cash_flow.T * discount_rates).T) 
    dcf_value += terminal_value * discount_rates[-1]
        
    return dcf_value

%time plt.hist(run_mcs(), bins=20, density=True, color="r")
plt.show()