Как правильно и легко рассчитать прибыль на инвестиции или калькулятор ROI на Python

Суть проблемы

Пусть у вас есть вложения активов в некую стратегию (даже если buy and hold), и вы хотите рассчитать (return on investment).

Если вы не производили никаких выводов или депозитов, тогда легко рассчитать прибыль
по формуле:

где — текущая стоимость наших активов, а — исходная стоимость активов.

Однако если в период инвестиций вы делали операции по счету, то их, конечно, нужно учитывать, и тогда простой формулы здесь недостаточно. Одним из способов расчета доходности на ивестиции является расчет перефоманса цены акции «виртуального» паевого фонда (ПИФ). Думаю, что он многим знаком, а если нет, то покажется тоже интуитивным и простым после последующего описания и примеров (надеюсь).

Немного формул

При первом депозите надо создать «виртуальный» паевой фонд, начальное количество акций (паёв) в котором равно депонированным активам (в акциях) с ценой за акцию

Любой депозит или вывод средств в момент времени эквивалентен покупке или продаже акций по цене . Далее меняем состояние ПИФа при изменении счета по следующему алгоритму:

1. Пустьактивов было добавлено к фонду в момент времени , где
   при депозите и при выводе.

2. В ПИФ состоял из акций с ценой

3. После выполнения транзакции, в момент времени новое количество акций составит а цена акции останется той же:

Таким образом, для каждого момента времени имеем:

1. стоимость активов

2. количество виртуальных акций

3. цену одной акции

В итоге, можно рассчитать доходность от начального момента времени
по формуле:

Более того, также можно легко рассчитать по этой формуле на любой период времени , в чем и заключается суть данного метода.

Пример

Допустим мы положили 100$ в стратегию. Сразу отметим, что в этот момент времени «покупаем» 100 акций за 1$. Далее стратегия за какое-то время заработала 20% и наш баланс теперь стал 120$, а следовательно изменилась и цена акции, она стала 120$ / 100 = 1.2$ (количество акций не изменилось, потому что никаких новых вложений или выводов не было).

Пусть в этот же момент времени мы решили положить ещё 210$, чтобы увеличить абсолютный доход. Депозит эквивалентен увелечению акций на 210$ / 1.2$ = 175. Таким образом, цена акции осталась (120 + 210)$ / (100 + 175) = 1.2$, а стоимость активов изменилась. Спустя время стратегия заработала ещё 10% от нового баланса, то есть стоимость активов стала равна 363$, следовательно стоимость акции стала равна 363$ / 275 = 1,32$.

Посчитаем доходность с начального момента до момента депозита: (1.2 / 1 — 1) * 100 = 20%
Посчитаем доходность от момента депозита: (1.32 / 1.2 — 1) * 100 = 10%
Посчитаем общую доходность на ивестиции: (1.32 / 1 — 1) * 100 = 32%

Наконец-то про код

Здесь мы будем манипулировать тремя простыми сущностями.

1. транзакция (Transaction)

2. ивестор (Investor)

3. ПИФ (ROICalculator)

Транзакция является структурой с двумя полями, где funding — это вывод или депозит с соответсвующим знаком (X из формул)

class Transaction:     '''     Transaction model.      timestamp: datetime.datetime - transaction timestamp     funding: float - deposit or withdrawal     {         deposit: +X in asset [U]         withdrawal: -X in asset [U]     }     '''     def __init__(self, timestamp: datetime, funding: float):         self.timestamp = timestamp         self.funding = funding 

Далее, модель инвестора — самая важная в рамках использования. Для расчетов нам важно иметь:

1. начальный депозит

2. дату первых инвестиций

3. список транзакций

Cамое главное — переопределить метод доступа к балансу по временной метке. Best practice здесь запрос к БД или pandas.DataFrame

Transactions = List[Transaction]  class Investor(ABC):     '''     Investor model.      1. Attributes     investment_timestamp: datetime.datetime - investment timestamp (deposit timestamp)     deposit: float - deposit amount in asset [U]     transactions: Transactions - list of transactions with fundings and timestamp      2. get_nav_by_timestamp - investor's net asset value      '''      def __init__(self, investment_timestamp: datetime, deposit: float, transactions: Transactions, *args, **kwargs):         self.investment_timestamp = investment_timestamp         self.deposit = deposit          # sort transactions by timestamp         # from first transaction to last         #         # EXCEPT DEPOSIT TRANSACTION         #         self.transactions = sorted(             transactions, key=lambda x: x.timestamp, reverse=False)      @abstractmethod     def get_nav_by_timestamp(self, timestamp: datetime) -> float:         '''returns NAV'''         raise NotImplementedError

И последнее — сам ROICalculator. В целом, он полностью повторяет алгоритм, описанный выше, сохраняя состояние ПИФа в атрибуты объекта, что позволяет достаточно быстро рассчитывать share price на любой момент времени даже на больших данных с большим количеством движений по счету (проверял на боевых данных).

class ROICalculator:     '''     ROICalculator.      1. Create virtual pif __init_pif      {         init shares = deposit quantity of asset[U]         share price = 1     }      2. System go through 3 conditions while getting funding     {         Let funding X[U] was added to virtual pif at T;          T - transaction timestamp,         T0 = T - eps - timestamp before transaction         T1 = T + eps - timestamp after transaction          pif consisted of N SHARES with share price P_0[U] = NAV_T0[U] / N.          Add X[U] to virtual pif: M = N + X[U] / P_0[U],         where M - new shares amount          Update share price P[U] = NAV_T1[U] / M      }     '''      def __init__(self, investor: Investor, eps_hours=1):         # eps is used while getting nav_before         # and nav_after transaction         self.investor = investor         self.eps_hours = eps_hours         self.__init_pif()      def __init_pif(self):         self.shares = self.investor.deposit         self.share_price = 1      def __calculate_shares(self, funding: float):         self.shares += funding / self.share_price      def __calculate_share_price(self, nav: float):         self.share_price = nav / self.shares      def __calculate_shares_by_timestamp(self, timestamp: datetime):          # create virtual pif each time calculating shares         self.__init_pif()          for transaction in self.investor.transactions:             if transaction.timestamp > timestamp:                 break              # 1 condition: before transaction             # T0             timestamp_before_transtaction = transaction.timestamp - \                 timedelta(hours=self.eps_hours)              if timestamp_before_transtaction < self.investor.investment_timestamp:                 nav_before = self.investor.deposit              # NAV_T0             try:                 nav_before = self.investor.get_nav_by_timestamp(                     timestamp_before_transtaction)             except Exception as e:                 print(e)              # P0 = NAV_T0 / N             self.__calculate_share_price(nav_before)              # 2 condition: add funding to virtual pif             # shares = M             self.__calculate_shares(transaction.funding)              # T1             timestamp_after_transtaction = transaction.timestamp + \                 timedelta(hours=self.eps_hours)              # NAV_T             try:                 nav_after = self.investor.get_nav_by_timestamp(                     timestamp_after_transtaction)             except Exception as e:                 print(e)              # update share price             # P[U] = NAV_T1[U] / M             self.__calculate_share_price(nav_after)      def __calculate_share_price_by_timestamp(self, timestamp: datetime):         # update shares N in self.shares         self.__calculate_shares_by_timestamp(timestamp)          # get NAV from data         nav = self.investor.get_nav_by_timestamp(timestamp)          # update share_price in self.share_price         self.__calculate_share_price(nav)      def get_share_price_perfomance(self, t0: datetime, t: datetime) -> float:         '''         t  - end_timestamp         t0 - start_timestamp, t > t0          t = datetime.utcnow(), t0 = investment_timestamp to get ROI         '''         self.__calculate_share_price_by_timestamp(t)         # fix share_price at t         k = self.share_price          self.__calculate_share_price_by_timestamp(t0)         # fix share_price at t0         k0 = self.share_price          return k / k0 - 1 

Как можно использовать

Допустим, вы положили средства в лендинговую стратегию с доходом около 0.05% в день на инвестированные средства. Это означает, что наш P&L на стоимость активов будет рассчитываться как:

Это нужно для правильного определения доступа к балансам по временной метке.

Пусть 2020/1/1 было депонировано 100$, а 2020/4/1, было депонировано ещё 200$, тогда, с учетом описанной выше формулы получаем такую модель инвестора:

class ExampleInvestor(Investor):     '''      Simple lending (static) strategy with 0.05% profit daily     on investments without reinvestment      '''      def __init__(self, investment_timestamp, deposit, transactions):         super().__init__(investment_timestamp, deposit, transactions)      def lending_assets(self, timestamp):         # before transaction         if timestamp <= datetime(2020, 4, 1):             return 100         # after transaction         else:             return 300      def get_nav_by_timestamp(self, timestamp):         '''          NAV = investments + PnL         daily PnL = 0.0005 * investments =>         total PnL = 0.0005 * sum(invesmetns_i * period_i)          '''         if timestamp < datetime(2020, 4, 1):             pnl = 0.0005 * \                 self.lending_assets(timestamp) * \                 (timestamp - self.investment_timestamp).days             return self.lending_assets(timestamp) + pnl          elif timestamp > datetime(2020, 4, 1):             # redefine investments_i and daily PnL             transaction_timestamp = datetime(2020, 4, 1)             acc_pnl_before_transaction = 0.0005 * self.lending_assets(                 transaction_timestamp) * (transaction_timestamp - self.investment_timestamp).days             pnl =  0.0005 * self.lending_assets(timestamp) * (timestamp - transaction_timestamp).days +\                 acc_pnl_before_transaction              return self.lending_assets(timestamp) + pnl

Определим модель инвестора:

transaction = Transaction(datetime(2020, 4, 1), funding=200) investor = ExampleInvestor(investment_timestamp=datetime(2020, 1, 1),                            deposit=100, transactions=[transaction])

Создадим модель ПИФа:

pif = ROICalculator(investor)

И теперь при помощи метода get_share_price_perfomance можем получить ROI на любой период времени. В качестве примера посчитаем 1D%, MTD% и YTD% до и после депозита и получим:

1D return on 2020-03-31 = 0.05 % MTD return on 2020-03-31 = 1.51 % YTD return on 2020-03-31 = 4.50 %  1D return on 2020-04-30 = 0.05 % MTD return on 2020-04-30 = 1.44 % YTD return on 2020-04-30 = 6.01 %

Делюсь кодом в надежде на то, что это кому-нибудь ещё пригодится и пару часов моих выходных не прошли впустую. Лично у меня получилось очень удачно совместить эту небольшую модель с API бирж, а также используя известную питоновскую ORM — sqlalchemy для доступа к балансам.