Portfolio Management.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0dd26ab6",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "!pip install hvplot\n",
    "import numpy as np\n",
    "import hvplot.pandas\n",
    "import hvplot.dask\n",
    "\n",
    "import ipywidgets as ipw\n",
    "import hvplot.xarray\n",
    "import panel as pn\n",
    "import panel.widgets as pnw\n",
    "import xarray as xr\n",
    "\n",
    "# hvplot.extension('matplotlib')\n",
    "!pip install statsmodels\n",
    "import statsmodels.api as sm\n",
    "import statsmodels.formula.api as smf\n",
    "from statsmodels.formula.api import ols\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "# matplotlib.use('TkAgg')\n",
    "# from matplotlib.widgets import Cursor, Button\n",
    "# from mpl_toolkits.axes_grid1 import host_subplot\n",
    "!pip install seaborn\n",
    "import seaborn as sns\n",
    "\n",
    "%matplotlib inline\n",
    "import pandas_datareader as pdr\n",
    "from statsmodels.tsa.api import acf, graphics, pacf\n",
    "from statsmodels.tsa.ar_model import AutoReg, ar_select_order\n",
    "\n",
    "!pip install fredapi\n",
    "# https://pypi.org/project/fredapi/\n",
    "!pip install wbgapi\n",
    "# https://pypi.org/project/wbgapi/\n",
    "from fredapi import Fred\n",
    "fred = Fred(api_key='62a3bc99b6ec805d8540f407fa1f239f')\n",
    "\n",
    "import time\n",
    "from pathlib import Path\n",
    "import pandas as pd\n",
    "import sklearn\n",
    "import json\n",
    "import requests\n",
    "import urllib3\n",
    "from urllib3.util.retry import Retry\n",
    "from requests.adapters import HTTPAdapter\n",
    "import urllib.parse\n",
    "import os\n",
    "\n",
    "urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)  # Disable SSL warnings\n",
    "\n",
    "# region Description : User Data\n",
    "host = '71.247.198.112'\n",
    "path = \"analytics/accounts/v3/models/\" # replace filepath with EncodeURIComponent filepath CLIENT%3A%2FTest.ACCT\n",
    "fds_username = 'COLUMBIA_STU'\n",
    "fds_api_key = 'OzmyQBe9tet8LuyEZABIrqUOXYzzb8ehkddiIST3'\n",
    "\n",
    "import wbgapi as wb\n",
    "import datetime\n",
    "import io\n",
    "import urllib\n",
    "import pprint\n",
    "\n",
    "import operator as op\n",
    "import pandas as pd\n",
    "import requests\n",
    "import param\n",
    "import panel as pn\n",
    "import hvplot.pandas\n",
    "import holoviews as hv\n",
    "from holoviews.element.tiles import EsriImagery\n",
    "from holoviews.selection import link_selections\n",
    "\n",
    "%matplotlib notebook\n",
    "from matplotlib.widgets import SpanSelector\n",
    "from IPython.display import display\n",
    "import plotly\n",
    "!pip install plotly --upgrade\n",
    "import plotly.express as px\n",
    "import plotly.graph_objects as go\n",
    "from plotly.subplots import make_subplots\n",
    "!pip install arch\n",
    "from sklearn.decomposition import PCA\n",
    "from sklearn.linear_model import Lasso\n",
    "\n",
    "!pip install yfinance\n",
    "import yfinance as yf\n",
    "from scipy.stats import linregress\n",
    "import scipy.optimize as spop\n",
    "!pip install pandas_datareader\n",
    "import pandas_datareader as pdr\n",
    "\n",
    "!pip install fundamentalanalysis\n",
    "import fundamentalanalysis as fa\n",
    "api_key = \"c2cec35b227b1e453e4b5ee12f90d063\"\n",
    "\n",
    "plt.style.use('fivethirtyeight') #setting matplotlib style\n",
    "!pip install empyrial\n",
    "!pip install Riskfolio-Lib\n",
    "\n",
    "!pip install TA_Lib-0.4.24-cp39-cp39-win_amd64.whl\n",
    "import talib as t\n",
    "!pip install ta\n",
    "from ta.trend import ADXIndicator\n",
    "\n",
    "!pip install statsmodels --user  \n",
    "!pip install tensorboardX --user\n",
    "!pip install pandas==0.24.2 --user\n",
    "!pip install plotly\n",
    "!pip install bs4 --user\n",
    "!pip install plotly --user\n",
    "!pip install -U auquan_toolbox --user\n",
    "import statsmodels\n",
    "!pip install backtester\n",
    "import backtester\n",
    "from statsmodels.tsa.stattools import coint, adfuller\n",
    "\n",
    "!pip install factor_analyzer\n",
    "from factor_analyzer import FactorAnalyzer\n",
    "\n",
    "!pip install simfin\n",
    "import simfin as sf\n",
    "sf.set_api_key('6b73716b-c3c4-452a-937f-c57cef49e940')\n",
    "sf.set_data_dir(r'C:\\Users\\paduc\\Google Drive\\ws2607@columbia.edu 2022-07-27 16 26\\Research & Analysis\\Python\\simfin')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "40d538d7",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "34bab983",
   "metadata": {},
   "outputs": [],
   "source": [
    "startdate = '2012-01-01'\n",
    "enddate = '2023-08-31'\n",
    "\n",
    "tickers = ['JPM', 'V', 'MA', 'BAC', 'WFC', 'SPGI', 'GS', 'MS', 'BLK', 'AXP', 'SCHW', 'MMC', 'C', 'CB', 'PGR', 'CME', 'PYPL', 'ICE', 'AON', 'USB', 'MCO', 'PNC', 'AJG', 'AIG', 'MSCI', 'COF', 'TFC', 'MET', 'TRV', 'AMP', 'PRU', 'FIS', 'BK', 'GPN', 'ALL', 'ACGL', 'DFS', 'TROW', 'STT', 'MTB', 'HIG', 'WTW', 'RJF', 'RF', 'FITB', 'FLT', 'PFG', 'HBAN', 'CINF', 'NDAQ', 'NTRS', 'BRO', 'FDS', 'CBOE', 'CFG', 'SYF', 'RE', 'WRB', 'JKHY', 'L', 'KEY', 'GL', 'MKTX', 'BEN', 'IVZ', 'AIZ', 'CMA', 'ZION', 'XLF'\n",
    "]\n",
    "ticker = 'GS'\n",
    "\n",
    "df_stocks = yf.download(\n",
    "        tickers = tickers, \n",
    "        start=startdate, end=enddate,\n",
    "\n",
    "        # valid intervals: 1m,2m,5m,15m,30m,60m,90m,1h,1d,5d,1wk,1mo,3mo\n",
    "        # (optional, default is '1d')\n",
    "        interval = \"1d\",\n",
    "        ignore_tz = True,\n",
    "        # group by ticker (to access via data['SPY'])\n",
    "        # (optional, default is 'column')\n",
    "        group_by = 'column',\n",
    "        # adjust all OHLC automatically\n",
    "        # (optional, default is False)\n",
    "        auto_adjust = True,\n",
    "        # attempt repair of missing data or currency mixups e.g. $/cents\n",
    "        repair = True,\n",
    "        # download pre/post regular market hours data\n",
    "        # (optional, default is False)\n",
    "        prepost = True,\n",
    "        # use threads for mass downloading? (True/False/Integer)\n",
    "        # (optional, default is True)\n",
    "        threads = True,\n",
    "        # proxy URL scheme use use when downloading?\n",
    "        # (optional, default is None)\n",
    "        proxy = None\n",
    "    )\n",
    "df_stocks.index.name = None\n",
    "df_stocks_001 = df_stocks.Close\n",
    "df_stocks_001 = df_stocks_001[tickers]\n",
    "# df_stocks_001.columns = ['SM', 'JYP', 'YG', 'Hybe']\n",
    "\n",
    "# Normalize the prices\n",
    "normalized_prices = df_stocks_001 / df_stocks_001.iloc[0]*100\n",
    "\n",
    "daily_returns = df_stocks_001.pct_change().dropna()\n",
    "norm_cum_g = df_stocks_001 / df_stocks_001.iloc[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51398f71",
   "metadata": {},
   "source": [
    "### Annualized Statistics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6695b7ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "import seaborn as sns; sns.set()\n",
    "semana = 365\n",
    "\n",
    "stats = pd.DataFrame()\n",
    "stats[\"Annualized Returns(%)\"] =daily_returns.mean() * semana *100\n",
    "stats[\"Annualized Volatility(%)\"] = daily_returns.std() * np.sqrt(semana)*100\n",
    "stats[\"Sharpe Ratio\"] = stats[\"Annualized Returns(%)\"] /stats[\"Annualized Volatility(%)\"]\n",
    "print(\"Assets Classes Annualized Statistics — full observation period\")\n",
    "stats.style.bar(color=[\"red\",\"green\"], align=\"zero\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4feddef4",
   "metadata": {},
   "source": [
    "### Daily Return Distributions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "097f494f",
   "metadata": {},
   "outputs": [],
   "source": [
    "mean_return = np.mean(daily_returns)\n",
    "\n",
    "fig = go.Figure()\n",
    "fig.add_trace(go.Histogram(x=daily_returns[ticker], nbinsx=200))\n",
    "\n",
    "# Add a vertical line to mark the mean on the plot\n",
    "fig.add_shape(\n",
    "    type=\"line\",\n",
    "    x0=mean_return[ticker],\n",
    "    x1=mean_return[ticker],\n",
    "    y0=0, y1=1.0,\n",
    "    line=dict(color='red', width=2, dash='dash'),\n",
    "    name=\"Mean\"\n",
    ")\n",
    "\n",
    "fig.update_layout(title=\"Daily Returns\", xaxis_title=\"Returns\", yaxis_title=\"Frequency\",\n",
    "                  width=800, height=500,\n",
    "                  template='plotly_white',\n",
    "                  paper_bgcolor='white'\n",
    "                 )\n",
    "fig.show()\n",
    "\n",
    "print(daily_returns[ticker].describe())\n",
    "print(\"Skewness: \", daily_returns[ticker].skew())\n",
    "print(\"Kurtosis: \", daily_returns[ticker].kurtosis())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4c7458e4",
   "metadata": {},
   "outputs": [],
   "source": [
    "daily_returns.corr()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "81a42120",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "3b9f24cc",
   "metadata": {},
   "source": [
    "### Rolling Volatility"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2fa61ae5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Rolling volatility, the trading days is set to 252 days\n",
    "TRADING_DAYS = 252\n",
    "returns = np.log(df_stocks_001/df_stocks_001.shift(1))\n",
    "returns.fillna(0, inplace=True)\n",
    "volatility = returns.rolling(window=120).std()*np.sqrt(TRADING_DAYS)\n",
    "\n",
    "\n",
    "fig = px.line(volatility[ticker]*100,\n",
    "#     y= ['Naver'],\n",
    "              width=900, height=600,\n",
    "              title='Annualized rolling volatility')\n",
    "# fig.add_trace(\n",
    "#     go.Scatter(x= df_stocks_001.index, y=df_stocks_001.Kakao, name=\"Kakao\", yaxis=\"y2\", line_color='ForestGreen'))\n",
    "\n",
    "# Create axis objects\n",
    "fig.update_layout(\n",
    "#     xaxis=dict(\n",
    "#         domain=[0.3, 0.7]\n",
    "#     ),\n",
    "#     yaxis=dict(\n",
    "#         title=\"yaxis title\",\n",
    "#         titlefont=dict(color=\"#1f77b4\"),\n",
    "#         tickfont=dict(color=\"#1f77b4\")\n",
    "#     ),\n",
    "    yaxis2=dict(range = [0, 0.5],\n",
    "        title=\"\",\n",
    "        titlefont=dict(color=\"#ff7f0e\"),\n",
    "        tickfont=dict(color=\"#ff7f0e\"),\n",
    "        anchor=\"x\", overlaying=\"y\", side=\"right\", position=0.5\n",
    "    )\n",
    ")\n",
    "\n",
    "fig.update_layout(xaxis_title='Date',\n",
    "                  yaxis_title='Volatility',\n",
    "                  showlegend=True,\n",
    "                  legend_orientation='h',\n",
    "                  hovermode='x',\n",
    "                  template='plotly_white',\n",
    "                  paper_bgcolor='white',\n",
    "#                   plot_bgcolor='darkslategray',\n",
    "                  legend_title_text='')\n",
    "\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56312982",
   "metadata": {},
   "source": [
    "### Rolling Beta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b6ef113a",
   "metadata": {},
   "outputs": [],
   "source": [
    "market_ticker = 'XLF'\n",
    "\n",
    "def calculate_rolling_beta(daily_returns):\n",
    "    rolling_beta = daily_returns[ticker].rolling(window=120).cov(daily_returns[market_ticker]) / daily_returns[market_ticker].rolling(window=120).var()\n",
    "    return rolling_beta\n",
    "\n",
    "daily_returns['rolling_beta'] = calculate_rolling_beta(daily_returns[[ticker, market_ticker]])\n",
    "\n",
    "fig = px.line(daily_returns['rolling_beta'],\n",
    "              x=daily_returns.index, y='rolling_beta',\n",
    "              width=900, height=600,\n",
    "              title='Rolling Beta')\n",
    "\n",
    "fig.update_layout(xaxis_title='Date',\n",
    "                  yaxis_title='Rolling Beta',\n",
    "                  showlegend=True,\n",
    "                  template='plotly_white',\n",
    "                  paper_bgcolor='white',\n",
    "                  legend_title_text='')\n",
    "\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1aa6663d",
   "metadata": {},
   "source": [
    "### Daily Simple Returns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "52ed49c1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Visualizing Daily Simple Returns:\n",
    "\n",
    "fig = go.Figure()\n",
    "\n",
    "for i in daily_returns.columns.values:\n",
    "    # Add traces for each column (stock)\n",
    "    fig.add_trace(go.Scatter(x=daily_returns.index, y=daily_returns[i], mode='lines', name=i, line=dict(width=2)))\n",
    "\n",
    "# Set the title and axis labels\n",
    "fig.update_layout(title='Volatility in Daily Simple Returns', xaxis_title='Date', yaxis_title='Daily Simple Returns',\n",
    "                  width=900, height=500,\n",
    "                  template='plotly_white',\n",
    "                  paper_bgcolor='white',\n",
    "                  showlegend=True,\n",
    "                  legend=dict(orientation='h', x=0, y=1)\n",
    "                 )\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22cadb26",
   "metadata": {},
   "source": [
    "### Risk Box Plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "990c7f3b",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = go.Figure()\n",
    "\n",
    "# Add a box trace for each column (stock)\n",
    "for column in daily_returns.columns:\n",
    "    fig.add_trace(go.Box(y=daily_returns[column], name=column))\n",
    "\n",
    "# Update the layout and title\n",
    "fig.update_layout(title=\"Risk Box Plot\", xaxis_title=\"Stocks\", yaxis_title=\"Daily Returns\",\n",
    "                  width=800, height=400,\n",
    "                  template='plotly_white',\n",
    "                  paper_bgcolor='white',\n",
    "                  showlegend=False,\n",
    "                  boxmode='group'  # To display boxes side by side\n",
    "                 )\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ddd12fd",
   "metadata": {},
   "source": [
    "## Asset Prices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "249454f4",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = px.line(df_stocks_001,\n",
    "              width=900, height=600,\n",
    "              title='Stock Prices')\n",
    "\n",
    "fig.update_layout(xaxis_title='',\n",
    "                  yaxis_title='',\n",
    "                  yaxis_tickformat=\".2f\",\n",
    "                  showlegend=True,\n",
    "                  legend_orientation='h',\n",
    "                  hovermode='x',\n",
    "                  template='plotly_white',\n",
    "                  paper_bgcolor='white',\n",
    "#                   plot_bgcolor='darkslategray',\n",
    "                  legend_title_text='')\n",
    "\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e8212103",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "9caed18c",
   "metadata": {},
   "source": [
    "## Expected returns and sample covariance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "46bb4fa3",
   "metadata": {},
   "outputs": [],
   "source": [
    "from pypfopt import expected_returns, risk_models, efficient_frontier, plotting\n",
    "from pypfopt.expected_returns import mean_historical_return\n",
    "from pypfopt.risk_models import CovarianceShrinkage\n",
    "\n",
    "# Calculate expected returns and sample covariance\n",
    "mu = expected_returns.mean_historical_return(df_stocks_001, returns_data=False, \n",
    "                                             compounding=True, frequency=252, log_returns=False)\n",
    "S = risk_models.sample_cov(df_stocks_001)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "286643bc",
   "metadata": {},
   "outputs": [],
   "source": [
    "asset_tickers = tickers \n",
    "data = yf.download(asset_tickers, start='2022-01-01', end='2023-08-20')['Adj Close']\n",
    "\n",
    "# Generate mock forecasting variables\n",
    "for asset_ticker in asset_tickers:\n",
    "    data[f'{asset_ticker}_ForecastingVariable1'] = np.random.randn(len(data))\n",
    "    data[f'{asset_ticker}_ForecastingVariable2'] = np.random.randn(len(data))\n",
    "\n",
    "# Drop rows with NaN values\n",
    "data.dropna(inplace=True)\n",
    "\n",
    "# Calculate rolling windows parameters\n",
    "window_size = 60  # Adjust as needed\n",
    "training_horizon = 12  # Adjust as needed\n",
    "\n",
    "# Create a DataFrame to store forecasts\n",
    "forecast_data = pd.DataFrame(columns=['Date', 'AssetClass', 'Forecast'])\n",
    "\n",
    "# Iterate over each asset class\n",
    "for asset_ticker in asset_tickers:\n",
    "    # Iterate over rolling windows\n",
    "    for i in range(len(data) - window_size - training_horizon):\n",
    "        # Define training and testing data\n",
    "        train_data = data.iloc[i:i + window_size]\n",
    "        test_data = data.iloc[i + window_size:i + window_size + training_horizon]\n",
    "\n",
    "        # Prepare X and y for training\n",
    "        X_train = train_data[[f'{asset_ticker}_ForecastingVariable1', f'{asset_ticker}_ForecastingVariable2']]\n",
    "        y_train = train_data[asset_ticker]\n",
    "\n",
    "        # Train Lasso model\n",
    "        model = Lasso(alpha=0.01)  # Adjust regularization parameter as needed\n",
    "        model.fit(X_train, y_train)\n",
    "\n",
    "        # Prepare X for forecasting\n",
    "        X_forecast = test_data[[f'{asset_ticker}_ForecastingVariable1', f'{asset_ticker}_ForecastingVariable2']]\n",
    "\n",
    "        # Forecast next 12-month return\n",
    "        forecast = model.predict(X_forecast)\n",
    "\n",
    "        # Append forecast to the DataFrame\n",
    "        forecast_data = forecast_data.append({'Date': test_data.index[-1], 'AssetClass': asset_ticker, 'Forecast': forecast[-1]}, ignore_index=True)\n",
    "\n",
    "# Visualize the forecasts using Plotly\n",
    "fig = go.Figure()\n",
    "for asset_ticker in asset_tickers:\n",
    "    asset_forecast = forecast_data[forecast_data['AssetClass'] == asset_ticker]\n",
    "    fig.add_trace(go.Scatter(x=asset_forecast['Date'], y=asset_forecast['Forecast'], mode='lines', name=asset_ticker))\n",
    "\n",
    "# Customize layout\n",
    "fig.update_layout(title='Model Expected Return Forecast',\n",
    "                  xaxis_title='Date',\n",
    "                  yaxis_title='Forecasted Return')\n",
    "\n",
    "# Show the chart\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7875bf2c",
   "metadata": {},
   "source": [
    "## Efficient Frontier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4db776ad",
   "metadata": {},
   "outputs": [],
   "source": [
    "from pypfopt.efficient_frontier import EfficientFrontier\n",
    "from pypfopt.plotting import plot_efficient_frontier\n",
    "\n",
    "ef = EfficientFrontier(mu, S, weight_bounds=(-1, 0.5))\n",
    "# ef.add_constraint(lambda w: w[0] >= 0.2)\n",
    "# ef.add_constraint(lambda w: w[2] <= -0.15)\n",
    "# ef.add_constraint(lambda w: w[3] + w[1] <= 0.90)\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "ef_max_sharpe = ef.deepcopy()\n",
    "plotting.plot_efficient_frontier(ef, ax=ax, show_assets=False)\n",
    "\n",
    "# Find the tangency portfolio\n",
    "ef_max_sharpe.max_sharpe()\n",
    "ret_tangent, std_tangent, _ = ef_max_sharpe.portfolio_performance()\n",
    "ax.scatter(std_tangent, ret_tangent, marker=\"*\", s=100, c=\"r\", label=\"Max Sharpe\")\n",
    "\n",
    "# Generate random portfolios\n",
    "n_samples = 10000\n",
    "w = np.random.dirichlet(np.ones(ef.n_assets), n_samples)\n",
    "rets = w.dot(ef.expected_returns)\n",
    "stds = np.sqrt(np.diag(w @ ef.cov_matrix @ w.T))\n",
    "sharpes = rets / stds\n",
    "ax.scatter(stds, rets, marker=\".\", c=sharpes, cmap=\"viridis_r\")\n",
    "\n",
    "# Output\n",
    "ax.set_title(\"Efficient Frontier with random portfolios\")\n",
    "ax.legend()\n",
    "plt.tight_layout()\n",
    "plt.savefig(\"ef_scatter.png\", dpi=200)\n",
    "plt.show()\n",
    "\n",
    "cleaned_weights = ef.clean_weights()\n",
    "print(cleaned_weights)\n",
    "ef.portfolio_performance(verbose=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6d379bc",
   "metadata": {},
   "source": [
    "## Mean-Variance Optimization include short position"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f85b8658",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Optimize for maximal Sharpe ratio\n",
    "ef = EfficientFrontier(mu, S, weight_bounds=(-1, 0.5))\n",
    "# ef.efficient_return(target_return=0.2, market_neutral=True)\n",
    "raw_weights = ef.max_sharpe()\n",
    "cleaned_weights = ef.clean_weights()\n",
    "print(cleaned_weights)\n",
    "ef.portfolio_performance(verbose=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "40bdfaa6",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import cvxpy as cp\n",
    "\n",
    "# Sample data: Expected returns and covariance matrix\n",
    "expected_returns = np.array(mu)\n",
    "cov_matrix = np.array(S)\n",
    "\n",
    "# Number of assets\n",
    "n_assets = len(expected_returns)\n",
    "\n",
    "# Create optimization variables\n",
    "weights = cp.Variable(n_assets)\n",
    "\n",
    "# Define the optimization problem\n",
    "mean_return = expected_returns @ weights\n",
    "risk = cp.quad_form(weights, cov_matrix)\n",
    "portfolio_variance = cp.quad_form(weights, cov_matrix)\n",
    "portfolio_volatility = cp.sqrt(portfolio_variance)\n",
    "sharpe_ratio = (mean_return) / portfolio_volatility\n",
    "\n",
    "# Specify the target return\n",
    "target_return = 0.10\n",
    "\n",
    "# Set up the optimization problem with custom constraints for each asset\n",
    "objective = cp.Maximize(mean_return)  #sharpe_ratio, mean_return\n",
    "constraints = [cp.sum(weights) == 1, mean_return >= target_return]\n",
    "\n",
    "# Custom constraints for each asset\n",
    "constraints += [weights[0] >= -0.5, weights[0] <= 0.5]\n",
    "constraints += [weights[1] >= -0.5, weights[1] <= 0.5]\n",
    "constraints += [weights[2] >= -0.5, weights[2] <= 0.5]\n",
    "\n",
    "problem = cp.Problem(objective, constraints)\n",
    "\n",
    "# Solve the problem\n",
    "problem.solve()\n",
    "\n",
    "# Get the optimal portfolio weights\n",
    "optimal_weights = weights.value\n",
    "\n",
    "# Print the results\n",
    "print(\"Optimal Portfolio Weights:\")\n",
    "print(optimal_weights)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "87817751",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from scipy.optimize import minimize\n",
    "\n",
    "# Sample data: Expected returns and covariance matrix\n",
    "expected_returns = np.array(mu)\n",
    "cov_matrix = np.array(S)\n",
    "\n",
    "# Risk-free rate\n",
    "rf = 0.05\n",
    "\n",
    "# Define the objective function for the negative Sharpe ratio\n",
    "def negative_sharpe_ratio(weights):\n",
    "    portfolio_return = np.sum(expected_returns * weights)\n",
    "    portfolio_volatility = np.sqrt(np.dot(weights.T, np.dot(cov_matrix, weights)))\n",
    "    sharpe_ratio = (portfolio_return - rf) / portfolio_volatility\n",
    "    return -sharpe_ratio\n",
    "\n",
    "# Set the bounds for the weights\n",
    "bounds = [(-1, 0.5) for _ in range(len(expected_returns))]\n",
    "\n",
    "# Set the equality constraint for the sum of weights to be 1\n",
    "constraints = {'type': 'eq', 'fun': lambda x: np.sum(x) - 1}\n",
    "\n",
    "# Initial guess for the weights\n",
    "x0 = np.ones(len(expected_returns)) / len(expected_returns)\n",
    "\n",
    "# Minimize the negative Sharpe ratio to maximize the Sharpe ratio\n",
    "result = minimize(negative_sharpe_ratio, x0, method='SLSQP', bounds=bounds, constraints=constraints)\n",
    "\n",
    "# Get the optimal portfolio weights for maximum Sharpe ratio\n",
    "optimal_weights_sharpe_ratio = np.round(result.x, 5)\n",
    "\n",
    "# Print the results\n",
    "print(\"Optimal Portfolio Weights for Maximum Sharpe Ratio:\")\n",
    "print(optimal_weights_sharpe_ratio)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cddac2ab",
   "metadata": {},
   "source": [
    "## Optimization long only"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9c9ddcc9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# \"EF\": Global Efficient Frontier \n",
    "\n",
    "from empyrial import empyrial, Engine\n",
    "portfolio = Engine(\n",
    "      start_date = '2023-01-01', \n",
    "    end_date= '2023-08-21',\n",
    "      portfolio = tickers,\n",
    "    benchmark = [\"SPY\"],\n",
    "      optimizer = \"EF\"\n",
    "    ,min_weights = 0.01\n",
    "    ,max_weights = 0.2\n",
    "#       ,rebalance = \"monthly\"\n",
    ")\n",
    "empyrial(portfolio, rf=0.05, confidence_value=0.95)\n",
    "portfolio.weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4cfa855f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# \"MEANVAR\": Mean-Variance \n",
    "\n",
    "from empyrial import empyrial, Engine\n",
    "portfolio = Engine(\n",
    "      start_date = startdate, \n",
    "    end_date= enddate,\n",
    "      portfolio = tickers,\n",
    "    benchmark = [\"SPY\"],\n",
    "      optimizer = \"MEANVAR\",\n",
    "    max_vol = 0.25\n",
    "    ,min_weights = 0.01\n",
    "    ,max_weights = 0.2\n",
    "#     ,diversification = 1.8\n",
    "#       ,rebalance = \"monthly\"\n",
    ")\n",
    "empyrial(portfolio, rf=0.05, confidence_value=0.95)\n",
    "portfolio.weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a6eb1778",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# \"HRP\": Hierarchical Risk Parity\n",
    "\n",
    "from empyrial import empyrial, Engine\n",
    "portfolio = Engine(\n",
    "      start_date = startdate, \n",
    "    end_date= enddate,\n",
    "      portfolio = tickers,\n",
    "    benchmark = [\"SPY\"],\n",
    "      optimizer = \"HRP\"\n",
    "    ,min_weights = 0.01\n",
    "    ,max_weights = 0.2\n",
    "#     ,diversification = 1.8\n",
    "      ,rebalance = \"monthly\"\n",
    ")\n",
    "empyrial(portfolio, rf=0.05, confidence_value=0.95)\n",
    "portfolio.weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fecfd71a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# \"MINVAR\": Minimum-Variance \n",
    "\n",
    "from empyrial import empyrial, Engine\n",
    "portfolio = Engine(\n",
    "      start_date = startdate, \n",
    "    end_date= enddate,\n",
    "      portfolio = tickers,\n",
    "    benchmark = [\"SPY\"],\n",
    "      optimizer = \"MINVAR\"\n",
    "    ,min_weights = 0.01\n",
    "    ,max_weights = 0.2\n",
    "#     ,diversification = 1.8\n",
    "#       ,rebalance = \"monthly\"\n",
    ")\n",
    "empyrial(portfolio, rf=0.05, confidence_value=0.95)\n",
    "portfolio.weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "50358d18",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "ce16ed44",
   "metadata": {},
   "source": [
    "## Risk Manager"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3e60ffd1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3 Risk managers are available:\n",
    "# Max Drawdown: {\"Max Drawdown\" : -0.3} \n",
    "# Take Profit: {\"Take Profit\" : 0.4} \n",
    "# Stop Loss: {\"Stop Loss\" : -0.2} \n",
    "\n",
    "from empyrial import empyrial, Engine\n",
    "portfolio = Engine(\n",
    "      start_date = startdate, \n",
    "    end_date= enddate,\n",
    "      portfolio = tickers,\n",
    "    benchmark = [\"SPY\"],\n",
    "      optimizer = \"EF\"\n",
    "    ,min_weights = -1\n",
    "    ,max_weights = 0.5\n",
    "#       ,rebalance = \"monthly\"\n",
    "      ,risk_manager = {\"Max Drawdown\" : -0.2} #Stop the investment when the drawdown becomes superior to -20%\n",
    ")\n",
    "\n",
    "empyrial(portfolio, rf=0.05, confidence_value=0.95)\n",
    "portfolio.weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e9d15560",
   "metadata": {},
   "outputs": [],
   "source": [
    "from empyrial import empyrial, Engine\n",
    "portfolio = Engine(\n",
    "      start_date = startdate, \n",
    "    end_date= enddate,\n",
    "      portfolio = tickers,\n",
    "    benchmark = [\"SPY\"],\n",
    "      optimizer = \"EF\"\n",
    "    ,min_weights = -1\n",
    "    ,max_weights = 0.5\n",
    "#       ,rebalance = \"monthly\"\n",
    "      ,risk_manager = {\"Take Profit\" : 0.4}\n",
    ")\n",
    "\n",
    "empyrial(portfolio, rf=0.05, confidence_value=0.95)\n",
    "portfolio.weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "82fe6dfd",
   "metadata": {},
   "outputs": [],
   "source": [
    "from empyrial import empyrial, Engine\n",
    "portfolio = Engine(\n",
    "      start_date = startdate, \n",
    "    end_date= enddate,\n",
    "      portfolio = tickers,\n",
    "    benchmark = [\"SPY\"],\n",
    "      optimizer = \"EF\"\n",
    "    ,min_weights = -1\n",
    "    ,max_weights = 0.5\n",
    "#       ,rebalance = \"monthly\"\n",
    "      ,risk_manager = {\"Stop Loss\" : -0.2}\n",
    ")\n",
    "\n",
    "empyrial(portfolio, rf=0.05, confidence_value=0.95)\n",
    "portfolio.weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d4aa2605",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "41539292",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1b726678",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "f57cce7b",
   "metadata": {},
   "source": [
    "# Factor Models"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eba7a327",
   "metadata": {},
   "source": [
    "## Macroeconomic factor model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4e0b250e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define the stock symbol and the date range for data retrieval\n",
    "stock_symbol = ticker\n",
    "start_date = startdate\n",
    "end_date = enddate\n",
    "\n",
    "data = yf.download(stock_symbol, start=start_date, end=end_date)['Adj Close'].pct_change().dropna()\n",
    "\n",
    "# Fetch macroeconomic data from FRED\n",
    "gdp_growth = fred.get_series('GDP', start_date, end_date).pct_change().dropna()\n",
    "inflation = fred.get_series('CPIAUCSL', start_date, end_date).pct_change().dropna()\n",
    "unemployment = fred.get_series('UNRATE', start_date, end_date).dropna()\n",
    "\n",
    "# Combine the data into a DataFrame\n",
    "data = pd.concat([data, gdp_growth, inflation, unemployment], axis=1)\n",
    "data.columns = [ticker, 'GDP_Growth', 'Inflation', 'Unemployment']\n",
    "\n",
    "# Calculate excess returns by subtracting risk-free rate (use T-bill rate as an example)\n",
    "risk_free_rate = 0.02\n",
    "data['Excess_Return'] = data[ticker] - risk_free_rate\n",
    "\n",
    "data = data.dropna()\n",
    "\n",
    "# Define the independent variables (macroeconomic factors)\n",
    "X = data[['GDP_Growth', 'Inflation', 'Unemployment']]\n",
    "X = sm.add_constant(X)\n",
    "\n",
    "# Define the dependent variable (excess S&P 500 return)\n",
    "y = data['Excess_Return']\n",
    "\n",
    "# Fit the regression model\n",
    "model = sm.OLS(y, X).fit()\n",
    "\n",
    "# Print the regression results\n",
    "print(model.summary())\n",
    "\n",
    "import plotly.express as px\n",
    "import plotly.graph_objects as go\n",
    "import fredapi\n",
    "\n",
    "fig = px.scatter_matrix(data, dimensions=['GDP_Growth', 'Inflation', 'Unemployment', 'Excess_Return'],\n",
    "                        color='Excess_Return', title='Scatter Matrix of Macroeconomic Factors and Excess ' + ticker + ' Return')\n",
    "fig.update_traces(diagonal_visible=False)\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d28b42e4",
   "metadata": {},
   "source": [
    "## Fundamental factor model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "70dd4545",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fetch fundamental data using the .info attribute\n",
    "fundamental_data = yf.Ticker(stock_symbol).info\n",
    "\n",
    "# Extract specific fundamental factors that you need\n",
    "fundamental_factors = {\n",
    "    'EPS_Growth': fundamental_data.get('trailingEps') / fundamental_data.get('forwardEps') - 1,\n",
    "    'Book_Value': fundamental_data.get('bookValue'),\n",
    "    'Dividend_Yield': fundamental_data.get('trailingAnnualDividendYield') * 100,  # Convert to percentage\n",
    "}\n",
    "\n",
    "# Create a DataFrame for the fundamental factors\n",
    "fundamental_df = pd.DataFrame.from_dict(fundamental_factors, orient='index', columns=['Value'])\n",
    "\n",
    "# Print the DataFrame\n",
    "print(fundamental_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cf81839a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load data: Replace with your own data source\n",
    "# We'll generate some example data for demonstration purposes\n",
    "data = pd.DataFrame({\n",
    "    'Date': pd.date_range(start='2020-01-01', periods=100),\n",
    "    'Asset_Return': np.random.normal(0.005, 0.02, 100),  # Simulated asset returns\n",
    "    'EPS_Growth': np.random.normal(0.003, 0.01, 100),    # Simulated EPS growth\n",
    "    'Book_Value': np.random.normal(50, 10, 100),         # Simulated book value per share\n",
    "    'Dividend_Yield': np.random.normal(0.02, 0.005, 100)  # Simulated dividend yield\n",
    "})\n",
    "\n",
    "# Define the independent variables (fundamental factors)\n",
    "X = data[['EPS_Growth', 'Book_Value', 'Dividend_Yield']]\n",
    "\n",
    "# Add a constant term to the independent variables\n",
    "X = sm.add_constant(X)\n",
    "\n",
    "# Define the dependent variable (asset returns)\n",
    "y = data['Asset_Return']\n",
    "\n",
    "# Fit the regression model\n",
    "model = sm.OLS(y, X).fit()\n",
    "\n",
    "# Print the regression results\n",
    "print(model.summary())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ec5dec1",
   "metadata": {},
   "source": [
    "## Statistical factor model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a7545a6a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# statistical factor model, statistical methods are applied to historical\n",
    "# returns of a group of securities to extract factors that can explain the\n",
    "# observed returns of securities in the group. In statistical factor models, the\n",
    "# factors are actually portfolios of the securities in the group under study and\n",
    "# are therefore defined by portfolio weights. Two major types of factor models\n",
    "# are factor analysis models and principal components models. In factor\n",
    "# analysis models, the factors are the portfolios of securities that best explain\n",
    "# (reproduce) historical return covariances. In principal components models,\n",
    "# the factors are portfolios of securities that best explain (reproduce) the\n",
    "# historical return variances."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2addda4e",
   "metadata": {},
   "source": [
    "### Factor analysis models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4ab6c152",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate the covariance matrix\n",
    "cov_matrix = daily_returns.cov()\n",
    "\n",
    "# Perform factor analysis using PCA\n",
    "num_factors = 3  # Number of factors to extract\n",
    "fa = FactorAnalyzer(n_factors= num_factors, rotation=None)\n",
    "fa.fit(cov_matrix)\n",
    "\n",
    "# Get factor loadings\n",
    "factor_loadings = fa.loadings_\n",
    "\n",
    "# Print factor loadings\n",
    "print(\"Factor Loadings:\")\n",
    "print(factor_loadings)\n",
    "\n",
    "# Calculate the explained variance ratio\n",
    "explained_variance = fa.get_factor_variance()\n",
    "\n",
    "# Print explained variance ratio\n",
    "print(\"\\nExplained Variance Ratio:\")\n",
    "print(explained_variance)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e560bd4",
   "metadata": {},
   "source": [
    "### Principal components models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6bbbf1f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate the covariance matrix\n",
    "cov_matrix = daily_returns.cov()\n",
    "\n",
    "# Perform PCA\n",
    "pca = PCA(n_components=len(daily_returns.columns))\n",
    "pca.fit(cov_matrix)\n",
    "\n",
    "# Get principal components (factors)\n",
    "principal_components = pca.components_\n",
    "\n",
    "# Print principal components\n",
    "print(\"Principal Components (Factors):\")\n",
    "print(principal_components)\n",
    "\n",
    "# Calculate the explained variance ratio\n",
    "explained_variance_ratio = pca.explained_variance_ratio_\n",
    "\n",
    "# Print explained variance ratio\n",
    "print(\"\\nExplained Variance Ratio:\")\n",
    "print(explained_variance_ratio)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "07b03142",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "aaa7fe18",
   "metadata": {},
   "source": [
    "## Fama-French multi-factor"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e6bf332",
   "metadata": {},
   "source": [
    "### 3-factor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1afece41",
   "metadata": {},
   "outputs": [],
   "source": [
    "ff_3factors = pd.read_csv(r'C:\\Users\\paduc\\Google Drive\\ws2607@columbia.edu 2022-07-27 16 26\\Research & Analysis\\Python\\8. Data\\F-F_Research_Data_Factors_daily_CSV/F-F_Research_Data_Factors_daily.csv', skiprows=0)\n",
    "ff_3factors['Date'] = pd.to_datetime(ff_3factors['Date'])\n",
    "ff_3factors.set_index('Date', inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b7b35871",
   "metadata": {},
   "outputs": [],
   "source": [
    "stock_data = yf.download(ticker, start=startdate, end=enddate)\n",
    "\n",
    "# Merge Fama-French factors and stock data\n",
    "merged_data = pd.merge(stock_data, ff_3factors/100, left_index=True, right_index=True)\n",
    "\n",
    "# Calculate excess returns\n",
    "merged_data['Excess_Return'] = merged_data['Adj Close'].pct_change() - merged_data['RF'] / 100\n",
    "merged_data = merged_data.dropna()\n",
    "\n",
    "# Define the independent variables (market excess return, SMB, HML)\n",
    "X = merged_data[['Mkt-RF', 'SMB', 'HML']]\n",
    "\n",
    "# Add a constant term to the independent variables\n",
    "X = sm.add_constant(X)\n",
    "\n",
    "# Define the dependent variable (stock excess return)\n",
    "y = merged_data['Excess_Return']\n",
    "\n",
    "# Fit the regression model\n",
    "model = sm.OLS(y, X).fit()\n",
    "\n",
    "# Print the regression results\n",
    "print(model.summary())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "971b30d8",
   "metadata": {},
   "source": [
    "### 5-factor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c107ac0c",
   "metadata": {},
   "outputs": [],
   "source": [
    "ff_5factors = pd.read_csv(r'C:\\Users\\paduc\\Google Drive\\ws2607@columbia.edu 2022-07-27 16 26\\Research & Analysis\\Python\\8. Data\\F-F_Research_Data_5_Factors_2x3_daily_CSV (2)/F-F_Research_Data_5_Factors_2x3_daily.csv', skiprows=0)\n",
    "ff_5factors['Date'] = pd.to_datetime(ff_5factors['Date'])\n",
    "ff_5factors.set_index('Date', inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f4eb1859",
   "metadata": {},
   "outputs": [],
   "source": [
    "stock_data = yf.download(ticker, start=startdate, end=enddate)\n",
    "\n",
    "# Merge Fama-French factors and stock data\n",
    "merged_data = pd.merge(stock_data, ff_5factors/100, left_index=True, right_index=True)\n",
    "\n",
    "# Calculate excess returns\n",
    "merged_data['Excess_Return'] = merged_data['Adj Close'].pct_change() - merged_data['RF'] / 100\n",
    "merged_data = merged_data.dropna()\n",
    "\n",
    "# Define the independent variables (market excess return, SMB, HML)\n",
    "X = merged_data[['Mkt-RF', 'SMB', 'HML', 'RMW', 'CMA']]\n",
    "\n",
    "# Add a constant term to the independent variables\n",
    "X = sm.add_constant(X)\n",
    "\n",
    "# Define the dependent variable (stock excess return)\n",
    "y = merged_data['Excess_Return']\n",
    "\n",
    "# Fit the regression model\n",
    "model = sm.OLS(y, X).fit()\n",
    "\n",
    "# Print the regression results\n",
    "print(model.summary())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e9937689",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = px.scatter_matrix(merged_data, dimensions=['Excess_Return', 'Mkt-RF', 'SMB', 'HML', 'RMW', 'CMA'],\n",
    "                        color='Excess_Return', title='Scatter Matrix of Fama-French Factors and Excess ' + ticker + ' Return')\n",
    "fig.update_traces(diagonal_visible=False)\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3a3c3329",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}