Financial Risk - Calculating Value At Risk (VaR) with R.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Intro"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This module is based on a Pluralsight course, Understanding and Applying Financial Risk Modeling Techniques (https://app.pluralsight.com/library/courses/financial-risk-modeling-techniques/table-of-contents), with this part Implementing Financial Risk Models in Python.\n",
    "\n",
    "The code itself is nearly verbatim, but again, this is mostly for my own development, working through the peculiarities of Value at Risk (VaR) in both R and Python.\n",
    "\n",
    "The general outline of this process is as follows:\n",
    "\n",
    "- Load and clean Data\n",
    "- Calculate returns\n",
    "- Calculate historical variance\n",
    "- Calculate systemic, idiosyncratic, and total variance\n",
    "- Develop a range of stress variants, e.g. scenario-based possibilities\n",
    "- Calculate VaR, as the worst case loss in a period for a particular probability\n",
    "\n",
    "Note, The data required for this is in my Public Google Drive folder: https://drive.google.com/folderview?id=0B5Mi6_CV6da5aFc2Q0g3cHowVms&usp=sharing."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load and Clean Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (162119822.py, line 6)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  Cell \u001b[1;32mIn[2], line 6\u001b[1;36m\u001b[0m\n\u001b[1;33m    portfolios.dirty[, c(\"AsOfDate\")] <- as.Date(portfolios.dirty[, c(\"AsOfDate\")], \"%m/%d/%Y\")\u001b[0m\n\u001b[1;37m                     ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# load data\n",
    "filePath <- \"Portfolios.csv\"\n",
    "portfolios.dirty <- read.table(filePath, header = TRUE, sep = \",\", stringsAsFactors = FALSE)\n",
    "\n",
    "# convert date: http://www.statmethods.net/input/dates.html\n",
    "portfolios.dirty[, c(\"AsOfDate\")] <- as.Date(portfolios.dirty[, c(\"AsOfDate\")], \"%m/%d/%Y\")\n",
    "\n",
    "# sort by date: # http://www.statmethods.net/management/sorting.html\n",
    "portfolios.sorted <- portfolios.dirty[order(portfolios.dirty$AsOfDate, decreasing = TRUE),]\n",
    "head(portfolios.sorted)\n",
    "\n",
    "# remove nulls\n",
    "# NA in this module\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Estimating Historical Risk"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Calculating Returns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (3569025213.py, line 11)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  Cell \u001b[1;32mIn[1], line 11\u001b[1;36m\u001b[0m\n\u001b[1;33m    stockNames = names(returns)[-which(names(returns) %in% c('AsOfDate', 'FVX', 'SP500'))]\u001b[0m\n\u001b[1;37m                                                       ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# copy data frame, preserving original\n",
    "returns <- portfolios.sorted\n",
    "\n",
    "# calculate returns as difference between rows\n",
    "returns[-nrow(returns), -1] <- returns[-nrow(returns), -1] / returns[-1, -1] - 1\n",
    "\n",
    "# removes last row, since it is not a calcualted return\n",
    "returns <- returns[-nrow(returns),]\n",
    "\n",
    "# create a data frame of stock names, not the date and not the factors to use as a filter\n",
    "stockNames = names(returns)[-which(names(returns) %in% c('AsOfDate', 'FVX', 'SP500'))]\n",
    "\n",
    "# create a data frame of only stocks\n",
    "stockReturns <- returns[stockNames]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Historical Risk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "\n",
    "# create a data frame of weights, but make it equal weighted\n",
    "# it is therefore 1 for each item, divided by the number of names\n",
    "# in effect, 1 divided by 10\n",
    "weights <- data.frame(rep(1, times = length(stockNames)) / length(stockNames))\n",
    "\n",
    "# rename the row names, then rename the column header\n",
    "row.names(weights) <- stockNames\n",
    "names(weights) <- \"Weights\"\n",
    "\n",
    "# cacluate portfolio variance\n",
    "# Var(p) = W * COV(Y) * W_transposed\n",
    "# matrix multiplication is done via %*%\n",
    "# first is transpose of weights\n",
    "# second is the covariance of the returns\n",
    "# third is the matrix of weights\n",
    "(historicalReturnRisk <- t(weights) %*% cov(stockReturns) %*% as.matrix(weights))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Building Factor Models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "\n",
    "# calculate lm (regression) for FVX, SP500, and the stock value\n",
    "# loops for each stock to create\n",
    "# create data frame\n",
    "modelCoeffs <- data.frame()\n",
    "for (stockName in stockNames) {\n",
    "    stockReturn <- as.matrix(returns[stockName])\n",
    "    sp500 <- as.matrix(returns[\"SP500\"])\n",
    "    fvx <- as.matrix(returns[\"FVX\"])\n",
    "    model <- lm(stockReturn ~ sp500 + fvx)\n",
    "    modelCoeffs <- rbind(modelCoeffs, cbind(coef(model)[1], coef(model)[2], coef(model)[3], sd(resid(model))))\n",
    "}\n",
    "\n",
    "# cleanup data frame\n",
    "row.names(modelCoeffs) <- stockNames\n",
    "names(modelCoeffs) <- c(\"Alpha\",\"B_SP500\",\"B_FVX\",\"ResidualVol\")\n",
    "modelCoeffs\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Idiosyncratic and Systemic Risk"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Besides historical risk, one can decompose risk into systemic (beta) and idiosyncratic risk (alpha), the latte rbeing specific to the stock itself:\n",
    "\n",
    "TotalVaR(P) = SystemicVaR(P) + IdisyncraticVaR(P)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "\n",
    "# systemicVariance(P) = weights * betas * covariance(factor returns) * betas_transposed * weight_transposed\n",
    "# create matrix of factors\n",
    "factorNames <- c(\"SP500\",\"FVX\")\n",
    "factorReturns <- returns[factorNames]\n",
    "\n",
    "# internal covariance matrix\n",
    "reconstructedCov <- as.matrix(modelCoeffs[c(\"B_SP500\", \"B_FVX\")]) %*% as.matrix(cov(factorReturns)) %*% t(modelCoeffs[c(\"B_SP500\", \"B_FVX\")])\n",
    "\n",
    "# external covariance matrix\n",
    "systemicVariance <- t(weights) %*% reconstructedCov %*% as.matrix(weights)\n",
    "\n",
    "\n",
    "# idosyncraticVariance(P) = weights * var(residuals) * weight_transposed\n",
    "idosyncraticVariance <- sum((weights ^ 2) * (modelCoeffs$ResidualVol ^ 2))\n",
    "\n",
    "\n",
    "# totalVariance = systemicVariance + idiosyncraticVariance\n",
    "(factorBasedVariance = systemicVariance + idosyncraticVariance)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Scenario-based Stress Testing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "\n",
    "# create a range of scenarios, stepping from min to max through the factors, FVX and S&P500\n",
    "fvxScenarios <- seq(min(returns[\"FVX\"]), max(returns[\"FVX\"]), by = .05)\n",
    "sp500Scenarios <- seq(min(returns[\"SP500\"]), max(returns[\"SP500\"]), by = .02)\n",
    "\n",
    "# build scenarios from fvxScenarios by sp500Scenarios\n",
    "scenarios <- data.frame()\n",
    "for (fvxValue in fvxScenarios) {\n",
    "    for (sp500value in sp500Scenarios) {\n",
    "        scenario <- cbind(fvxValue, sp500value)\n",
    "        scenarioPredictedReturns <- data.frame()\n",
    "        for (stockName in stockNames) {\n",
    "            alpha = subset(modelCoeffs, row.names(modelCoeffs) %in% c(stockName)) [\"Alpha\"]\n",
    "            beta_sp = subset(modelCoeffs, row.names(modelCoeffs) %in% c(stockName))[\"B_SP500\"]\n",
    "            beta_fvx = subset(modelCoeffs, row.names(modelCoeffs) %in% c(stockName))[\"B_FVX\"]\n",
    "            scenarioPredictedReturn = alpha + (beta_sp * sp500value) + (beta_fvx * fvxValue)\n",
    "            scenarioPredictedReturns = rbind(scenarioPredictedReturns, scenarioPredictedReturn)\n",
    "        }\n",
    "        scenario <- (cbind(scenario, t(scenarioPredictedReturns)))\n",
    "        scenarios <- rbind(scenarios, scenario)\n",
    "    }\n",
    "}\n",
    "\n",
    "# totalVariance(P) = weights * cov(scenarios) * weight_transposed\n",
    "(scenarioTotalVariance <- t(weights) %*% cov(as.matrix(scenarios[stockNames]))  %*% as.matrix(weights))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Quantifying the Worst Case"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "\n",
    "# VaR = P x Z_alpha x stdDev\n",
    "calculateVaR <- function(risk, confidenceLevel, principal = 1, numMonths = 1) {\n",
    "    vol <- sqrt(risk)\n",
    "    data.frame(VaR = abs(principal * qnorm(1-confidenceLevel, 0, 1) * vol * sqrt(numMonths))[1])\n",
    "}\n",
    "\n",
    "# Worst Case: VaR based on scenario-based stress testing\n",
    "calculateVaR(scenarioTotalVariance, 0.99)\n",
    "\n",
    "# Allternaitve Risk Measure:  VaR based on factors\n",
    "calculateVaR(factorBasedVariance, 0.99)\n",
    "\n",
    "# Allternaitve Risk Measure:  VaR based on history\n",
    "calculateVaR(historicalReturnRisk, 0.99)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Plotting VaR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "library(PerformanceAnalytics)\n",
    "\n",
    "returnsForChart <- returns\n",
    "\n",
    "row.names(returnsForChart) <- c(returnsForChart$AsOfDate)\n",
    "\n",
    "chart.VaRSensitivity(returnsForChart[, 2:11, drop=TRUE],\n",
    "\t\tmethods=c(\"HistoricalVaR\", \"ModifiedVaR\", \"GaussianVaR\"),\n",
    "\t\tcolorset=bluefocus, lwd=2)\n",
    "\n",
    "chart.RelativePerformance(returnsForChart[, 2:11], returnsForChart[, 13], main = \"Relative Performace vs. Benchmark\",\n",
    "    colorset = c(1:8), xaxis = TRUE, ylog = FALSE, legend.loc = \"topleft\", cex.legend = 0.8)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}