exercise08_ridge_regression.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "489c7bcd-d5b9-4a10-beb9-e58120f4758b",
   "metadata": {},
   "source": [
    "Sascha Spors,\n",
    "Professorship Signal Theory and Digital Signal Processing,\n",
    "Institute of Communications Engineering (INT),\n",
    "Faculty of Computer Science and Electrical Engineering (IEF),\n",
    "University of Rostock,\n",
    "Germany\n",
    "\n",
    "# Data Driven Audio Signal Processing - A Tutorial with Computational Examples\n",
    "\n",
    "Winter Semester 2023/24 (Master Course #24512)\n",
    "\n",
    "- lecture: https://github.com/spatialaudio/data-driven-audio-signal-processing-lecture\n",
    "- tutorial: https://github.com/spatialaudio/data-driven-audio-signal-processing-exercise\n",
    "\n",
    "Feel free to contact lecturer frank.schultz@uni-rostock.de"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "201797c2-3cc5-4cce-b1b9-684286f3b759",
   "metadata": {},
   "source": [
    "# Exercise 8: Ridge Regression \n",
    "\n",
    "## Objectives\n",
    "\n",
    "TBD\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f0e5fd45",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import os\n",
    "import shutil\n",
    "from scipy.io import wavfile\n",
    "from numpy.linalg import cond, matrix_rank\n",
    "from scipy.linalg import inv, lstsq, pinv, svd, diagsvd, norm\n",
    "from sklearn.linear_model import LinearRegression, Ridge"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8c7c76a4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# some 'global' variables that should be appear here at top for convenience\n",
    "flag_channel = \"Mono\"  # 'Left', 'Right' or 'Mono'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72e22fb2",
   "metadata": {},
   "source": [
    "## Data Preparation\n",
    "\n",
    "This notebook gains most fun, if we have multi-track audio to work with, ideally on our own computer. Maybe we even have some own recorded multi-tracked music ;-)\n",
    "\n",
    "We can get some nice multi-track audio material from [https://www.cambridge-mt.com/ms/mtk/](https://www.cambridge-mt.com/ms/mtk/) .\n",
    "\n",
    "This data base supports Mike Senior's 2nd edition of the book \"[The Mixing Secrets For The Small Studio](https://cambridge-mt.com/ms/main/)\".\n",
    "\n",
    "The data base is provided for educational purpose and we will use it precisely this way...learning linear regression and regularization.\n",
    "\n",
    "So, if we need some multi-track material, we can download one of the zip files. Below we use 4 examples that worked out very illustratively.\n",
    "\n",
    "To create a matrix where the columns represent the multi-tracked files (either the left channel, or the right channel or summed to a mono channel) we need equal length *.wav files to work with the code below (I was too lazy to program this nicely).\n",
    "\n",
    "A reasonable work flow is to use a digital audio workstation (DAW) software, such as [Reaper](https://www.reaper.fm/purchase.php) (please support these guys, non-commercial license is very cheap).\n",
    "\n",
    "In Reaper we would do:\n",
    "- grabbing all multi-track files from a certain zip into an empty project\n",
    "- making them as separate tracks\n",
    "- choose an appropriate time selection\n",
    "- do some simple level mixing according to actual taste\n",
    "- selecting all tracks\n",
    "- open the `render to file` dialog\n",
    "    - choose Source: `Selected tracks (stems)`\n",
    "    - choose Bounds: `Time selection`\n",
    "    - Directory: create a `multi-track` folder as subfolder where the raw wav files are stored\n",
    "    - File name: `multi-track`\n",
    "    - make sure that original sampling rate is used\n",
    "    - Format: `Wav`\n",
    "    - WAV bit depth: `32 Bit FP` (uses more storage, but then we don't need to pay attention to numbers larger/smaller than 1 if some mixing was performed)\n",
    "    - click `Dry Run (no output`)\n",
    "    - check if this simulated rendering comes with the expected channels into the expected number of files with naming convention `multi_track-xxx.wav`\n",
    "    - we are ready to render by clicking `Render xxx files``\n",
    "- maybe it's a good idea to save this Reaper project for further reference "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76282c50",
   "metadata": {},
   "source": [
    "## Data Generation\n",
    "\n",
    "Instead of setting up multi-track audio described above, we can create some data to play with, in order to make this notebook self-contained and running out of the box."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "342eab4c",
   "metadata": {},
   "outputs": [],
   "source": [
    "if True:\n",
    "    path_gen = \"svd_multitrack_audio/test_data2/\"\n",
    "    # clear/del path and re-create new to start fresh\n",
    "    try:  # for left_singular_vectors/\n",
    "        shutil.rmtree(path_gen)\n",
    "    except OSError as e:\n",
    "        print(\"Error: %s : %s\" % (path_gen, e.strerror))\n",
    "    os.makedirs(path_gen)\n",
    "    path_multi = \"multi_track\"\n",
    "    os.mkdir(path_gen + path_multi)\n",
    "\n",
    "    fs = 48000\n",
    "    N = 48\n",
    "    k = np.arange(N * 1000)\n",
    "    dOm = 2 * np.pi / N\n",
    "\n",
    "    for track in range(16):\n",
    "        x = np.sin(dOm * (track + 1) * k)\n",
    "        x *= 10 ** (\n",
    "            -(3 * track) / 20\n",
    "        )  # dB weighting to have different amplitudes\n",
    "        x = np.tile(x, (2, 1)).T\n",
    "        tmp = \"%0*d\" % (3, track + 1)  # multitrack number with leading zeros\n",
    "        wavfile.write(\n",
    "            path_gen + path_multi + \"/\" + path_multi + \"-\" + tmp + \".wav\",\n",
    "            fs,\n",
    "            x.astype(np.float32),\n",
    "        )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "781e056b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# choose one of the nice multitrack projects:\n",
    "\n",
    "path = \"svd_multitrack_audio/cfx_Mathematician_Full/\"\n",
    "# c:fx, 'Mathematician', https://soundcloud.com/c-fx\n",
    "# multitrack for educational use only:\n",
    "# https://mtkdata.cambridgemusictechnology.co.uk/MTK005/cfx_Mathematician.zip\n",
    "\n",
    "path = \"svd_multitrack_audio/MaurizioPagnuttiSextet_AllTheGinIsGone/\"\n",
    "# Maurizio Pagnutti Sextet, 'All The Gin Is Gone', https://www.artesuono.it/album.aspx?id=76&p=0\n",
    "# for educational use only:\n",
    "# https://multitracks.cambridge-mt.com/MaurizioPagnuttiSextet_AllTheGinIsGone.zip\n",
    "\n",
    "path = \"svd_multitrack_audio/cryonicPAX_Excessive/\"\n",
    "# cryonicPAX, 'Excessive'\n",
    "# multitrack for educational use only:\n",
    "# https://mtkdata.cambridgemusictechnology.co.uk/MTK015/cryonicPAX_Excessive.zip\n",
    "\n",
    "path = \"svd_multitrack_audio/Fin_Echoes/\"\n",
    "# FIN, 'Echoes'\n",
    "# multitrack for educational use only:\n",
    "# https://multitracks.cambridge-mt.com/Fin_Echoes.zip\n",
    "\n",
    "path = \"svd_multitrack_audio/test_data2/\"\n",
    "# we use the audio that is generated above in order to make this notebook\n",
    "# self-contained"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3db1b3b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# read in multitrack wavs and store in a matrix X\n",
    "# set up path name\n",
    "pathr = path + \"multi_track/\"\n",
    "files = sorted(os.listdir(pathr))\n",
    "print(files)\n",
    "flag_conc = True\n",
    "\n",
    "for i in files:\n",
    "    # consider only .wav (this excludes .wav.reapeaks files from Reaper)\n",
    "    if i[-4:] == \".wav\":\n",
    "        # consider only multi_track-\n",
    "        if i[0:12] == \"multi_track-\":\n",
    "            # so we read in all stuff with name 'multi_track-xxxxxxxx.wav'\n",
    "            # if we set up the folder multi_track properly, we only find\n",
    "            # multi_track-001.wav, multi_track-002.wav, multi_track-003.wav, ...\n",
    "            fs, tmp = wavfile.read(pathr + i)  # get raw data from file\n",
    "            # we assume that the files are stereo\n",
    "            if flag_channel == \"Mono\":\n",
    "                # make mono and make it (xxx, 1) dimension\n",
    "                x = np.expand_dims((tmp[:, 0] + tmp[:, 1]) / 2, 1)\n",
    "            elif flag_channel == \"Left\":\n",
    "                # take left channel and make it (xxx, 1) dimension\n",
    "                x = np.expand_dims(tmp[:, 0], 1)\n",
    "            elif flag_channel == \"Right\":\n",
    "                # take right channel and make it (xxx, 1) dimension\n",
    "                x = np.expand_dims(tmp[:, 1], 1)\n",
    "            else:\n",
    "                print(\"!!! unknown flag_channel !!!\")\n",
    "                break\n",
    "            # if we got here, we can print some log data\n",
    "            print(i, fs, \"Hz\", x.shape, x.dtype)\n",
    "            # non-elegant way to stack all stems (single channel tracks) into matrix\n",
    "            if flag_conc:  # very first x into non-exisiting X\n",
    "                X, flag_conc = x, False\n",
    "            else:  # X is already existing and axis=0 is assumed to be const\n",
    "                # for all concatenated x,\n",
    "                # so multi_track-001.wav, multi_track-002.wav, multi_track-003.wav, ...\n",
    "                # must have exactly same length\n",
    "                X = np.concatenate((X, x), axis=1)\n",
    "# we could ignore the warning  Chunk (non-data) not understood, skipping it.\n",
    "\n",
    "print(\"\\nmulti-track matrix X\", X.shape, X.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bf67e07f",
   "metadata": {},
   "outputs": [],
   "source": [
    "path_tmp = \"ols_ridge_multitrack_audio/\"\n",
    "try:\n",
    "    shutil.rmtree(path_tmp)\n",
    "except OSError as e:\n",
    "    print(\"Error: %s : %s\" % (path_tmp, e.strerror))\n",
    "os.mkdir(path_tmp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6688df98",
   "metadata": {},
   "outputs": [],
   "source": [
    "no_samples = X.shape[0]\n",
    "no_channels = X.shape[1]\n",
    "print(\"no_samples:\", no_samples, \"\\nno_channels:\", no_channels)\n",
    "\n",
    "# X[:,2] *= 10**(+6/20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2477f688",
   "metadata": {},
   "outputs": [],
   "source": [
    "# this is beta for the standard problem y = X beta\n",
    "mix_weights = np.ones([no_channels, 1])  # unity gain for all channels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "07840341",
   "metadata": {},
   "outputs": [],
   "source": [
    "# this is y for the standard problem y = X beta\n",
    "mix = X @ mix_weights  # mix lives in in column space of X\n",
    "# so we expect that least squares solution yields exactly mix_weights\n",
    "mix_weights_solved, res, rnk, s = lstsq(X, mix)\n",
    "np.allclose(mix_weights_solved, mix_weights)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5c20181c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# get some very basic audio features\n",
    "def crest(x):  # works only for single dim array\n",
    "    sq_mean = 1 / np.size(x) * np.sum(x**2)\n",
    "    sq_abs_peak = np.max(x**2)\n",
    "    cf = 10 * np.log10(sq_abs_peak / sq_mean)  # crest factor in dB\n",
    "    std = np.std(x)\n",
    "    mean = np.mean(x)\n",
    "    peak = np.max(np.abs(x))\n",
    "    return sq_mean, sq_abs_peak, cf, std, mean, peak"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c766bb47",
   "metadata": {},
   "outputs": [],
   "source": [
    "sq_mean_mix, sq_abs_peak_mix, cf_mix, std_mix, mean_mix, peak_mix = crest(mix)\n",
    "print(\"features for mix\")\n",
    "print(f\"{'sq_mean_mix:'} {sq_mean_mix:+4.3e}\")\n",
    "print(f\"{'sq_abs_peak_mix:'} {sq_abs_peak_mix:+4.3e}\")\n",
    "print(f\"{'cf_mix:'} {cf_mix:+4.2f} {'dB'}\")\n",
    "print(f\"{'std_mix:'} {std_mix:+4.3e}\")\n",
    "print(f\"{'mean_mix:'} {mean_mix:+4.3e}\")\n",
    "print(f\"{'peak_mix:'} {peak_mix:+4.3e}\")\n",
    "\n",
    "# create noise with stdev that matches an specific SNR between mix and noise:\n",
    "\n",
    "# this yields +280 dB SNR\n",
    "# mean, stdev = 0, std_mix  / 1e14\n",
    "\n",
    "# mean, stdev = 0, std_mix  / 1e7  # this yields +140 dB SNR\n",
    "# mean, stdev = 0, std_mix  / 100  # this yields +40 dB SNR\n",
    "# mean, stdev = 0, std_mix  / 10  # this yields +20 dB SNR\n",
    "# mean, stdev = 0, std_mix  / 2  # this yields +6 dB SNR\n",
    "# mean, stdev = 0, std_mix  / 1  # this yields +0 dB SNR\n",
    "\n",
    "# this yields -6 dB SNR (noise louder than music)\n",
    "mean, stdev = 0, std_mix * 2\n",
    "\n",
    "# this yields -12 dB SNR (noise louder than music)\n",
    "# mean, stdev = 0, std_mix * 4\n",
    "\n",
    "rng = np.random.default_rng(1)\n",
    "noise = rng.normal(mean, stdev, [no_samples, 1])\n",
    "(\n",
    "    sq_mean_noise,\n",
    "    sq_abs_peak_noise,\n",
    "    cf_noise,\n",
    "    std_noise,\n",
    "    mean_noise,\n",
    "    peak_noise,\n",
    ") = crest(noise)\n",
    "print(\"\\nfeatures for noise\")\n",
    "print(f\"{'sq_mean_noise:'} {sq_mean_noise:+4.3e}\")\n",
    "print(f\"{'sq_abs_peak_noise:'} {sq_abs_peak_noise:+4.3e}\")\n",
    "print(f\"{'cf_noise:'} {cf_noise:+4.2f} {'dB'}\")\n",
    "print(f\"{'std_noise:'} {std_noise:+4.3e}\")\n",
    "print(f\"{'mean_noise:'} {mean_noise:+4.3e}\")\n",
    "print(f\"{'peak_noise:'} {peak_noise:+4.3e}\")\n",
    "\n",
    "SNR = 10 * np.log10(sq_mean_mix / sq_mean_noise)\n",
    "print(f\"\\n{'SNR'} {SNR:4.2f} {'dB'}\")\n",
    "\n",
    "# standard problem X beta = y\n",
    "# here: beta-> mix_weights, y-> mixdown\n",
    "\n",
    "# now add noise to the mix that was created above\n",
    "# mix_with_noise potentially also lives in left nullspace of X\n",
    "mix_with_noise = np.squeeze(mix) + np.squeeze(noise)\n",
    "\n",
    "max_peak = np.max(np.abs(np.array([mix_with_noise[:, None], mix])))\n",
    "\n",
    "wavfile.write(\n",
    "    path_tmp + \"mix_with_noise_SNR_\" + str(int(SNR)) + \"dB.wav\",\n",
    "    fs,\n",
    "    mix_with_noise / max_peak * 10 ** (-1 / 20),\n",
    ")\n",
    "wavfile.write(\n",
    "    path_tmp + \"mix_without_noise_SNR_\" + str(int(SNR)) + \"dB.wav\",\n",
    "    fs,\n",
    "    np.squeeze(mix) / max_peak * 10 ** (-1 / 20),\n",
    ")\n",
    "\n",
    "# LS solution using lstsq():\n",
    "mix_weights_solved, res, rnk, s = lstsq(X, mix_with_noise)\n",
    "print(\n",
    "    \"mix_weights_solved == mix_weights:\",\n",
    "    np.allclose(mix_weights_solved, mix_weights),\n",
    ")\n",
    "\n",
    "channel_idx = np.arange(no_channels) + 1\n",
    "\n",
    "plt.figure(figsize=(10, 3))\n",
    "plt.plot(\n",
    "    channel_idx, 20 * np.log10(mix_weights), \"C0o-\", label=\"exact mix weights\"\n",
    ")\n",
    "plt.plot(\n",
    "    channel_idx,\n",
    "    20 * np.log10(mix_weights_solved),\n",
    "    \"C1o:\",\n",
    "    label=\"LS mix weights for mix+noise\",\n",
    ")\n",
    "plt.xticks(channel_idx)\n",
    "plt.xlabel(\"channel\")\n",
    "plt.ylabel(\"dB\")\n",
    "plt.title(f\"{'SNR ='} {SNR:4.2f} {'dB'}\")\n",
    "plt.legend()\n",
    "plt.grid(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "afe85887",
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_ridge_regression_via_svd(X, lmb=0):\n",
    "    # textbook implementation for a tall/thin, full column rank matrix X\n",
    "    # we should not use this for real practical applications\n",
    "    # as this might be numerically non-robust\n",
    "    [U, s, Vh] = svd(X, full_matrices=False)  # economy SVD\n",
    "    V = Vh.conj().T\n",
    "    S = diagsvd(s, U.shape[1], V.shape[0])\n",
    "    Sli_ridge = inv(S.conj().T @ S + lmb * np.eye(X.shape[1])) @ S.conj().T\n",
    "    Xli_ridge = (\n",
    "        V @ Sli_ridge @ U.conj().T\n",
    "    )  # for lmb=0 return is the left inverse\n",
    "    return Xli_ridge"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33fe57dd",
   "metadata": {},
   "source": [
    "we might want to check the `solver` options for the ridge regression implementation\n",
    "https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.Ridge.html\n",
    "\n",
    "We are going to use it below and compar it to our own implementation\n",
    "`my_ridge_regression_via_svd(X, lmb = 0)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "14759839",
   "metadata": {},
   "outputs": [],
   "source": [
    "ridge_coeff = 10  # 0.5\n",
    "\n",
    "mw1 = my_ridge_regression_via_svd(X, lmb=ridge_coeff) @ mix_with_noise\n",
    "\n",
    "# set up a Ridge model\n",
    "model_ridge_regression = Ridge(\n",
    "    alpha=ridge_coeff,\n",
    "    fit_intercept=False,  # model has no intercept, but only audio channels\n",
    "    solver=\"svd\",\n",
    ")\n",
    "# train / fit with the mix_with_noise data and X as feature matrix\n",
    "model_ridge_regression.fit(X, mix_with_noise)\n",
    "# read coefficients\n",
    "mw2 = model_ridge_regression.coef_\n",
    "\n",
    "print(\"my_ridge_regression_via_svd()==Ridge?\", np.allclose(mw1, mw2))\n",
    "\n",
    "channel_idx = np.arange(no_channels) + 1\n",
    "\n",
    "plt.figure(figsize=(9, 6))\n",
    "\n",
    "plt.subplot(2, 1, 1)\n",
    "plt.plot(\n",
    "    channel_idx, 20 * np.log10(mix_weights), \"C0o-\", label=\"exact mix weights\"\n",
    ")\n",
    "plt.plot(\n",
    "    channel_idx,\n",
    "    20 * np.log10(mix_weights_solved),\n",
    "    \"C3o-\",\n",
    "    label=\"LS mix weights for mix+noise\",\n",
    ")\n",
    "plt.plot(channel_idx, 20 * np.log10(mix_weights_solved), \"C3o\")\n",
    "plt.plot(\n",
    "    channel_idx,\n",
    "    20 * np.log10(mw2),\n",
    "    \"C1d-\",\n",
    "    lw=2,\n",
    "    label=\"my ridge LS mix weights for mix+noise, coeff=\" + str(ridge_coeff),\n",
    ")\n",
    "plt.plot(\n",
    "    channel_idx,\n",
    "    20 * np.log10(mw2),\n",
    "    \"C2+-\",\n",
    "    label=\"scipy ridge LS mix weights for mix+noise, coeff=\" + str(ridge_coeff),\n",
    ")\n",
    "plt.xticks(channel_idx)\n",
    "plt.xlabel(\"audio channel\")\n",
    "plt.ylabel(\"channel level / dB\")\n",
    "plt.title(\"SNR = \" + str(SNR) + \" dB\")\n",
    "plt.legend()\n",
    "plt.grid(True)\n",
    "\n",
    "plt.subplot(2, 1, 2)\n",
    "plt.plot(channel_idx, mix_weights, \"C0o-\", label=\"exact mix weights\")\n",
    "plt.plot(\n",
    "    channel_idx,\n",
    "    mix_weights_solved,\n",
    "    \"C3o-\",\n",
    "    label=\"LS mix weights for mix+noise\",\n",
    ")\n",
    "plt.plot(\n",
    "    channel_idx,\n",
    "    mw1,\n",
    "    \"C1d-\",\n",
    "    lw=2,\n",
    "    label=\"my ridge LS mix weights for mix+noise, coeff=\" + str(ridge_coeff),\n",
    ")\n",
    "plt.plot(\n",
    "    channel_idx,\n",
    "    mw2,\n",
    "    \"C2+-\",\n",
    "    label=\"scipy ridge LS mix weights for mix+noise, coeff=\" + str(ridge_coeff),\n",
    ")\n",
    "plt.xticks(channel_idx)\n",
    "plt.xlabel(\"audio channel\")\n",
    "plt.ylabel(\"linear gain = linear mixing weight\")\n",
    "plt.legend()\n",
    "plt.grid(True)\n",
    "\n",
    "plt.tight_layout()\n",
    "\n",
    "print(\"||mix_weights||_2^2 =\", norm(mix_weights, 2) ** 2)\n",
    "print(\"||LS mix_weights||_2^2 =\", norm(mix_weights_solved, 2) ** 2)\n",
    "print(\"||ridge LS mix_weights||_2^2 =\", norm(mw2, 2) ** 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b96bff94-6ef3-40e3-8273-2aa218d2edb7",
   "metadata": {},
   "source": [
    "## Copyright\n",
    "\n",
    "- the notebooks are provided as [Open Educational Resources](https://en.wikipedia.org/wiki/Open_educational_resources)\n",
    "- the text is licensed under [Creative Commons Attribution 4.0](https://creativecommons.org/licenses/by/4.0/)\n",
    "- the code of the IPython examples is licensed under the [MIT license](https://opensource.org/licenses/MIT)\n",
    "- feel free to use the notebooks for your own purposes\n",
    "- please attribute the work as follows: *Frank Schultz, Data Driven Audio Signal Processing - A Tutorial Featuring Computational Examples, University of Rostock* ideally with relevant file(s), github URL https://github.com/spatialaudio/data-driven-audio-signal-processing-exercise, commit number and/or version tag, year."
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "1743232f157dd0954c61aae30535e75a2972519a625c7e796bafe0cd9a07bf7e"
  },
  "kernelspec": {
   "display_name": "myddasp",
   "language": "python",
   "name": "myddasp"
  },
  "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}