ExemPy-Parameters-OptimizingC.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "84c8ae95",
   "metadata": {},
   "source": [
    "# Optimizing exemplar sensitivity in ExemPy\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "99065652",
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "from ExemPy import *\n",
    "from ExemPy.utils import *\n",
    "from ExemPy.viz import *\n",
    "from ExemPy.GCM import *\n",
    "%aimport ExemPy, ExemPy.utils, ExemPy.viz, ExemPy.GCM\n",
    "%autoreload 1\n",
    "import math\n",
    "import random\n",
    "import matplotlib.pyplot as plt\n",
    "#%matplotlib inline\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from pandas import DataFrame\n",
    "from scipy.optimize import minimize\n",
    "import seaborn as sns\n",
    "sns.set(style='ticks', context='paper')\n",
    "colors=[\"#e3c934\",\"#68c4bf\",\"#c51000\",\"#287271\"]\n",
    "sns.set_palette(colors)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8721875",
   "metadata": {},
   "source": [
    "## Read in data, set initial parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "319642dc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>type</th>\n",
       "      <th>gender</th>\n",
       "      <th>speaker</th>\n",
       "      <th>vowel</th>\n",
       "      <th>repetition</th>\n",
       "      <th>F0</th>\n",
       "      <th>F1</th>\n",
       "      <th>F2</th>\n",
       "      <th>F3</th>\n",
       "      <th>z0</th>\n",
       "      <th>z1</th>\n",
       "      <th>z2</th>\n",
       "      <th>z3</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>451</th>\n",
       "      <td>m</td>\n",
       "      <td>m</td>\n",
       "      <td>23</td>\n",
       "      <td>PALM</td>\n",
       "      <td>2</td>\n",
       "      <td>120</td>\n",
       "      <td>690</td>\n",
       "      <td>960</td>\n",
       "      <td>2520</td>\n",
       "      <td>1.016731</td>\n",
       "      <td>6.450717</td>\n",
       "      <td>8.284247</td>\n",
       "      <td>14.550625</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>583</th>\n",
       "      <td>m</td>\n",
       "      <td>m</td>\n",
       "      <td>30</td>\n",
       "      <td>KIT</td>\n",
       "      <td>2</td>\n",
       "      <td>155</td>\n",
       "      <td>360</td>\n",
       "      <td>2010</td>\n",
       "      <td>2400</td>\n",
       "      <td>1.434799</td>\n",
       "      <td>3.630172</td>\n",
       "      <td>13.043829</td>\n",
       "      <td>14.227798</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>414</th>\n",
       "      <td>m</td>\n",
       "      <td>m</td>\n",
       "      <td>21</td>\n",
       "      <td>FOOT</td>\n",
       "      <td>1</td>\n",
       "      <td>142</td>\n",
       "      <td>430</td>\n",
       "      <td>1130</td>\n",
       "      <td>2440</td>\n",
       "      <td>1.281142</td>\n",
       "      <td>4.293556</td>\n",
       "      <td>9.274304</td>\n",
       "      <td>14.337364</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1341</th>\n",
       "      <td>c</td>\n",
       "      <td>f</td>\n",
       "      <td>68</td>\n",
       "      <td>FLEECE</td>\n",
       "      <td>2</td>\n",
       "      <td>262</td>\n",
       "      <td>340</td>\n",
       "      <td>3100</td>\n",
       "      <td>3400</td>\n",
       "      <td>2.631215</td>\n",
       "      <td>3.433217</td>\n",
       "      <td>15.895099</td>\n",
       "      <td>16.476343</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1262</th>\n",
       "      <td>c</td>\n",
       "      <td>m</td>\n",
       "      <td>64</td>\n",
       "      <td>KIT</td>\n",
       "      <td>1</td>\n",
       "      <td>290</td>\n",
       "      <td>580</td>\n",
       "      <td>2760</td>\n",
       "      <td>3400</td>\n",
       "      <td>2.925511</td>\n",
       "      <td>5.591969</td>\n",
       "      <td>15.147034</td>\n",
       "      <td>16.476343</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     type gender  speaker   vowel  repetition   F0   F1    F2    F3        z0  \\\n",
       "451     m      m       23    PALM           2  120  690   960  2520  1.016731   \n",
       "583     m      m       30     KIT           2  155  360  2010  2400  1.434799   \n",
       "414     m      m       21    FOOT           1  142  430  1130  2440  1.281142   \n",
       "1341    c      f       68  FLEECE           2  262  340  3100  3400  2.631215   \n",
       "1262    c      m       64     KIT           1  290  580  2760  3400  2.925511   \n",
       "\n",
       "            z1         z2         z3  \n",
       "451   6.450717   8.284247  14.550625  \n",
       "583   3.630172  13.043829  14.227798  \n",
       "414   4.293556   9.274304  14.337364  \n",
       "1341  3.433217  15.895099  16.476343  \n",
       "1262  5.591969  15.147034  16.476343  "
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pb52 = pd.read_csv('pb52_data//pb52.csv')\n",
    "pb52 = HzToBark(pb52, [\"F0\", \"F1\", \"F2\", \"F3\"])\n",
    "pb52.sample(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1b2777c",
   "metadata": {},
   "source": [
    "## Specify arguments for optimization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "b24e50cc",
   "metadata": {},
   "outputs": [],
   "source": [
    "dimsvals={'z0' : 1,\n",
    "          'z1' : .761,\n",
    "          'z2' : .681,\n",
    "          'z3' : .407}\n",
    "dimslist = list(dimsvals.keys())\n",
    "\n",
    "catslist = ['type', 'vowel']           # man, woman, or child; lexical set notation\n",
    "\n",
    "cval = 25\n",
    "\n",
    "exemplars = pb52.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "9c19d5ae",
   "metadata": {},
   "outputs": [],
   "source": [
    "fitdims = dimslist[1:]      # Fit all dimensions except item 0\n",
    "anchordim = dimslist[0]     # Set item 0 to 1\n",
    "\n",
    "name = 'pboptimization-3'                # name of output spreadsheet\n",
    "n = 2                        # number of times that random x is generated\n",
    "t = 0.1                     # Tolerance value -- lower = more evals\n",
    "\n",
    "test = exemplars.sample(50)\n",
    "cloud = exemplars\n",
    "cats = [\"vowel\"]\n",
    "\n",
    "cmax = 50\n",
    "cmin = 0\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c484dacd",
   "metadata": {},
   "source": [
    "## Define error functions\n",
    "- In future versions, this function will be pre-defined in the library\n",
    "- For now, there is some value in being able to tweak the function, and to see how it works!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "4e3e798f-8d15-4f7d-8cdb-b3ee28dab4f6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def calcerror_dims(x, test, exemplars, catslist, fitdims, cval, anchordim = None):\n",
    "    '''\n",
    "    Categorizes a data set and returns the proportion of stimuli/test rows\n",
    "    that were categorized inaccurately. A lower value means a lower amount of\n",
    "    error. Designed to be used with parameter fitting functions to assign\n",
    "    values to attention weighting for the dimensions.\n",
    "    \n",
    "    Required paratemers:\n",
    "    \n",
    "    x = Array. Initial guesses for parameters\n",
    "    \n",
    "    test = DataFrame. Stimuli to be categorized\n",
    "    \n",
    "    exemplars = DataFrame. Exemplar cloud to use for categorization\n",
    "    \n",
    "    catslist = List of strings. Each string should correspond to a category that\n",
    "        should be assigned to the test\n",
    "    \n",
    "    fitdims = List of strings. Each string should correspond to a dimension\n",
    "        for which parameters should be fit.\n",
    "        \n",
    "    Optional parameters:\n",
    "    \n",
    "    anchordim = String. Dimension for parameter which will not be fit, but will\n",
    "        instead be hard-coded as 1. This helps constrain the set of possible\n",
    "        solutions\n",
    "    \n",
    "    \n",
    "    '''\n",
    "    dimsvals = {fitdims[i]: x[i] for i in range(len(fitdims))}\n",
    "    if anchordim != None:\n",
    "        dimsvals.update({anchordim:1})\n",
    "    \n",
    "    choices = multicat(test, cloud, catslist, dimsvals, cval)\n",
    "    accuracy = checkaccuracy(choices, catslist)\n",
    "    category = catslist[0]\n",
    "    err = accuracy[category+\"Acc\"].value_counts(normalize=True)['n']\n",
    "    return err"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "6a0b5c52",
   "metadata": {},
   "outputs": [],
   "source": [
    "def calcerror_both(x, test, exemplars, catslist, fitdims, anchordim = None):\n",
    "    '''\n",
    "    Categorizes a data set and returns the proportion of stimuli/test rows\n",
    "    that were categorized inaccurately. A lower value means a lower amount of\n",
    "    error. Designed to be used with parameter fitting functions to assign\n",
    "    values to attention weighting for the dimensions.\n",
    "    \n",
    "    Required paratemers:\n",
    "    \n",
    "    x = Array. Initial guesses for parameters\n",
    "    \n",
    "    test = DataFrame. Stimuli to be categorized\n",
    "    \n",
    "    exemplars = DataFrame. Exemplar cloud to use for categorization\n",
    "    \n",
    "    catslist = List of strings. Each string should correspond to a category that\n",
    "        should be assigned to the test\n",
    "    \n",
    "    fitdims = List of strings. Each string should correspond to a dimension\n",
    "        for which parameters should be fit.\n",
    "        \n",
    "    Optional parameters:\n",
    "    \n",
    "    anchordim = String. Dimension for parameter which will not be fit, but will\n",
    "        instead be hard-coded as 1. This helps constrain the set of possible\n",
    "        solutions\n",
    "    \n",
    "    \n",
    "    '''  \n",
    "    cval = x[0]\n",
    "    dimsvals = {fitdims[i]: x[i] for i in range(len(fitdims))}\n",
    "    if anchordim != None:\n",
    "        dimsvals.update({anchordim:1})\n",
    "    \n",
    "    choices = multicat(test, cloud, catslist, dimsvals, cval)\n",
    "    accuracy = checkaccuracy(choices, catslist)\n",
    "    category = catslist[0]\n",
    "    err = accuracy[category+\"Acc\"].value_counts(normalize=True)['n']\n",
    "    return err"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "832a80d6-e66b-4d82-848d-20b3ced9dc0e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def calcerror_c(x, test, exemplars, dimsvals, catslist):\n",
    "    '''\n",
    "    Categorizes a data set and returns the proportion of stimuli/test rows\n",
    "    that were categorized inaccurately. A lower value means a lower amount of\n",
    "    error. Designed to be used with parameter fitting functions to assign\n",
    "    values to attention weighting for the dimensions.\n",
    "    \n",
    "    Required paratemers:\n",
    "    \n",
    "    x = Array. Initial guesses for c\n",
    "    \n",
    "    test = DataFrame. Stimuli to be categorized\n",
    "    \n",
    "    exemplars = DataFrame. Exemplar cloud to use for categorization\n",
    "    \n",
    "    catslist = List of strings. Each string should correspond to a category that\n",
    "        should be assigned to the test\n",
    "\n",
    "    \n",
    "    \n",
    "    '''\n",
    "    cval = x[0]\n",
    "    choices = multicat(test, cloud, catslist, dimsvals, cval)\n",
    "    accuracy = checkaccuracy(choices, catslist)\n",
    "    category = catslist[0]\n",
    "    err = accuracy[category+\"Acc\"].value_counts(normalize=True)['n']\n",
    "    return err"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46db8b5a",
   "metadata": {},
   "source": [
    "## Optimize!\n",
    "You may want to come back later for the results: \n",
    "- Results will be saved to a spreadsheet. (\\[NAME\\].csv)\n",
    "- Settings will be saved to a text file. (\\[NAME\\]\\_info.txt)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a323fa8-4155-4be8-b7be-e678559ec190",
   "metadata": {},
   "source": [
    "### Attention weights only"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "33e0fd38",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----- Parameters -----\n",
      "Anchored (1):   z0\n",
      "Optimized:      c value, ['z1', 'z2', 'z3']\n",
      "\n",
      "Categorizing for:  ['vowel']\n",
      "\n",
      "Trials:  2\n",
      "\n",
      "----- 1  -----\n",
      "Initial guess:     [0.13 2.32 0.8 ]\n",
      "Optimized:         [ 2.979  1.205 -2.106]\n",
      " \n",
      "Number evals:  83\n",
      "Error:         0.06\n",
      "\n",
      "----- 2  -----\n",
      "Initial guess:     [2.96 1.1  1.85]\n",
      "Optimized:         [1.411 1.413 2.232]\n",
      " \n",
      "Number evals:  36\n",
      "Error:         0.1\n",
      "\n"
     ]
    }
   ],
   "source": [
    "resultslist=[['start','fit','error','evals']] # initialize a list for results\n",
    "\n",
    "\n",
    "print(\"----- Parameters -----\")\n",
    "if anchordim != None: \n",
    "    print(\"Anchored (1):  \", anchordim)\n",
    "    \n",
    "print(\"Optimized:     \", fitdims)\n",
    "print(\"\")\n",
    "print(\"Categorizing for: \", cats)\n",
    "print(\"\")\n",
    "print(\"Trials: \", n)\n",
    "print(\"\")\n",
    "\n",
    "for i in range(0,n): \n",
    "    dimsguess=np.divide(random.sample(range(0,300),len(fitdims)),100)\n",
    "        # Get a random sample of numbers between 0 and 300,\n",
    "           # divide by 100 to get floats between 0 and 3  \n",
    "    xguess = dimsguess\n",
    "    start = xguess\n",
    "    \n",
    "    print (\"-----\", (i+1) ,\" -----\")\n",
    "    print(\"Initial guess:    \", start)\n",
    "\n",
    "    \n",
    "    result = minimize(calcerror_dims,\n",
    "                  xguess,  # the initial guess array\n",
    "                  args=(test, cloud, cats, fitdims, cval, anchordim), # arguments for the error function\n",
    "                  method='Powell',  \n",
    "                  tol = t)  # a 'tolerance' value, smaller means more function evaluation, but potentially better fit\n",
    "    start = xguess\n",
    "    fit = np.round(result.x,3)\n",
    "    error = result.fun\n",
    "    evals = result.nfev\n",
    "    row = [start,fit,error,evals]\n",
    "    resultslist.append(row)\n",
    "    \n",
    "\n",
    "    print(\"Optimized:        \", fit)\n",
    "    print(\" \")\n",
    "    print(\"Number evals: \", evals)\n",
    "    print(\"Error:        \", error)\n",
    "    print(\"\")\n",
    "results=pd.DataFrame(resultslist)\n",
    "results.columns = results.iloc[0]\n",
    "results=results[1:]\n",
    "\n",
    "settings = {\"fitdims\": fitdims, \"anchordim\": anchordim, \"cats\": cats, \"trials\":n, \"tol\": t }\n",
    "\n",
    "# write results to csv\n",
    "### good for if you want to leave it running while you do something else!\n",
    "results.to_csv(name+\".csv\")     \n",
    "with open((name+\"_info.txt\"),\"w\") as file:\n",
    "    file.write(str(settings))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc60fb6d-3d0d-4df2-b0e1-295956c8bc05",
   "metadata": {},
   "source": [
    "### Both attention weights and c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "59d68555",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----- Parameters -----\n",
      "Anchored (1):   z0\n",
      "Optimized:      c value, ['z1', 'z2', 'z3']\n",
      "\n",
      "Categorizing for:  ['vowel']\n",
      "\n",
      "Trials:  2\n",
      "\n",
      "----- 1  -----\n",
      "Initial guess:     [49.    0.46  0.9   2.47]\n",
      "Optimized:         [52.483  1.943 -2.15   5.953]\n",
      " \n",
      "Number evals:  68\n",
      "Error:         0.08\n",
      "\n",
      "----- 2  -----\n",
      "Initial guess:     [34.    0.51  0.66  2.34]\n",
      "Optimized:         [34.382  1.684 -1.885  4.34 ]\n",
      " \n",
      "Number evals:  43\n",
      "Error:         0.08\n",
      "\n"
     ]
    }
   ],
   "source": [
    "resultslist=[['start','fit','error','evals']] # initialize a list for restults\n",
    "\n",
    "\n",
    "print(\"----- Parameters -----\")\n",
    "if anchordim != None: \n",
    "    print(\"Anchored (1):  \", anchordim)\n",
    "    \n",
    "print(\"Optimized:     \", \"c value,\", fitdims)\n",
    "print(\"\")\n",
    "print(\"Categorizing for: \", cats)\n",
    "print(\"\")\n",
    "print(\"Trials: \", n)\n",
    "print(\"\")\n",
    "\n",
    "for i in range(0,n): \n",
    "    cguess = random.sample(range(0, 50),1)\n",
    "    dimsguess=np.divide(random.sample(range(0,300),len(fitdims)),100)\n",
    "        # Get a random sample of numbers between 0 and 300,\n",
    "           # divide by 100 to get floats between 0 and 3  \n",
    "    xguess = np.concatenate((cguess, dimsguess))\n",
    "    start = xguess\n",
    "    \n",
    "    print (\"-----\", (i+1) ,\" -----\")\n",
    "    print(\"Initial guess:    \", start)\n",
    "\n",
    "    \n",
    "    result = minimize(calcerror_both,\n",
    "                  xguess,  # the initial guess array\n",
    "                  args=(test, cloud, cats, fitdims, anchordim), # arguments for the error function\n",
    "                  method='Powell',  \n",
    "                  tol = t)  # a 'tolerance' value, smaller means more function evaluation, but potentially better fit\n",
    "    start = xguess\n",
    "    fit = np.round(result.x,3)\n",
    "    error = result.fun\n",
    "    evals = result.nfev\n",
    "    row = [start,fit,error,evals]\n",
    "    resultslist.append(row)\n",
    "    \n",
    "\n",
    "    print(\"Optimized:        \", fit)\n",
    "    print(\" \")\n",
    "    print(\"Number evals: \", evals)\n",
    "    print(\"Error:        \", error)\n",
    "    print(\"\")\n",
    "results=pd.DataFrame(resultslist)\n",
    "results.columns = results.iloc[0]\n",
    "results=results[1:]\n",
    "\n",
    "settings = {\"fitdims\": fitdims, \"anchordim\": anchordim, \"cats\": cats, \"trials\":n, \"tol\": t }\n",
    "\n",
    "# write results to csv\n",
    "### good for if you want to leave it running while you do something else!\n",
    "results.to_csv(name+\".csv\")     \n",
    "with open((name+\"_info.txt\"),\"w\") as file:\n",
    "    file.write(str(settings))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7cd2fbf-63be-43ab-a2bf-54c826742407",
   "metadata": {},
   "source": [
    "### c only"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "f97219f1-4193-4a5b-a6f8-aeb6da1bbb83",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----- Parameters -----\n",
      "Optimized:      c value\n",
      "\n",
      "Categorizing for:  ['vowel']\n",
      "\n",
      "Trials:  2\n",
      "\n",
      "----- 1  -----\n",
      "Initial guess:     [18.82]\n",
      "Optimized:         [19.82]\n",
      " \n",
      "Number evals:  5\n",
      "Error:         0.12\n",
      "\n",
      "----- 2  -----\n",
      "Initial guess:     [35.72]\n",
      "Optimized:         [36.72]\n",
      " \n",
      "Number evals:  5\n",
      "Error:         0.1\n",
      "\n"
     ]
    }
   ],
   "source": [
    "resultslist=[['start','fit','error','evals']] # initialize a list for restults\n",
    "\n",
    "\n",
    "print(\"----- Parameters -----\")\n",
    "    \n",
    "print(\"Optimized:     \", \"c value\")\n",
    "print(\"\")\n",
    "print(\"Categorizing for: \", cats)\n",
    "print(\"\")\n",
    "print(\"Trials: \", n)\n",
    "print(\"\")\n",
    "\n",
    "for i in range(0,n):\n",
    "    cguess = np.divide(random.sample(range(cmin, (cmax*100)),1),100)\n",
    "    xguess = cguess\n",
    "    start = xguess\n",
    "    \n",
    "    print (\"-----\", (i+1) ,\" -----\")\n",
    "    print(\"Initial guess:    \", start)\n",
    "\n",
    "    \n",
    "    result = minimize(calcerror_c,\n",
    "                  xguess,  # the initial guess array\n",
    "                  args=(test, cloud, dimsvals, cats), # arguments for the error function\n",
    "                  method='Powell',  \n",
    "                  tol = t)  # a 'tolerance' value, smaller means more function evaluation, but potentially better fit\n",
    "\n",
    "    fit = np.round(result.x,3)\n",
    "    error = result.fun\n",
    "    evals = result.nfev\n",
    "    row = [start,fit,error,evals]\n",
    "    resultslist.append(row)\n",
    "    \n",
    "\n",
    "    print(\"Optimized:        \", fit)\n",
    "    print(\" \")\n",
    "    print(\"Number evals: \", evals)\n",
    "    print(\"Error:        \", error)\n",
    "    print(\"\")\n",
    "results=pd.DataFrame(resultslist)\n",
    "results.columns = results.iloc[0]\n",
    "results=results[1:]\n",
    "\n",
    "settings = {\"dims\": dimslist, \"cats\": cats, \"trials\":n, \"tol\": t, \"cmin\": cmin, \"cmax\": cmax }\n",
    "\n",
    "# write results to csv\n",
    "### good for if you want to leave it running while you do something else!\n",
    "results.to_csv(name+\".csv\")     \n",
    "with open((name+\"_info.txt\"),\"w\") as file:\n",
    "    file.write(str(settings))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ed1889f3-776f-41d2-8214-8452e2d8848e",
   "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}