diff --git a/.gitignore b/.gitignore index 346afd4..4e5f94b 100644 --- a/.gitignore +++ b/.gitignore @@ -143,3 +143,4 @@ notebooks/20_catch_errors.ipynb # Custom notebooks/debug* +notebooks/my_hypno.csv \ No newline at end of file diff --git a/docs/changelog.rst b/docs/changelog.rst index c89a363..d3b230b 100644 --- a/docs/changelog.rst +++ b/docs/changelog.rst @@ -29,18 +29,23 @@ which comes with several pre-built functions (aka methods) and attributes. See f hyp.duration # Total duration of the hypnogram, in minutes hyp.sampling_frequency # Sampling frequency of the hypnogram hyp.mapping # Mapping from strings to integers + hyp.proba # Probability of each sleep stage, if specified # Below are some class methods hyp.sleep_statistics() # Calculate the sleep statistics hyp.plot_hypnogram() # Plot the hypnogram hyp.upsample_to_data() # Upsample to data -Please see the documentation of :py:class:`yasa.Hypnogram` for more details. +This brings along critical changes to several YASA function, for example: -.. important:: - The adoption of object-oriented :py:class:`yasa.Hypnogram` usage brings along critical changes to several YASA function, for example: +* :py:class:`yasa.SleepStaging` now returns a :py:class:`yasa.Hypnogram` instead of a :py:class:`numpy.ndarray`. The probability of each sleep stage for each epoch can now be accessed with :py:attr:`yasa.Hypnogram.proba`. +* :py:func:`yasa.simulate_hypnogram` now returns a :py:class:`yasa.Hypnogram` instead of a :py:class:`numpy.ndarray`. +* The suggested approach to plotting hypnograms is through the :py:meth:`yasa.Hypnogram.plot_hypnogram` method. The old function :py:func:`yasa.plot_hypnogram` still exists, but now *requires* a :py:class:`yasa.Hypnogram` instance as input. + +**Other improvements** - * :py:func:`yasa.simulate_hypnogram` now returns a :py:class:`yasa.Hypnogram` instead of a :py:class:`numpy.ndarray`. - * The suggested approach to plotting hypnograms is through the :py:meth:`yasa.Hypnogram.plot_hypnogram` method. The old function :py:func:`yasa.plot_hypnogram` still exists, but now *requires* a :py:class:`yasa.Hypnogram` instance as input. +* Added helpful string representation (__repr__) to :py:class:`yasa.SleepStaging`. +* :py:func:`yasa.simulate_hypnogram` now returns a :py:class:`yasa.Hypnogram` instead of a :py:class:`numpy.ndarray`. +* The suggested approach to plotting hypnograms is through the :py:meth:`yasa.Hypnogram.plot_hypnogram` method. The old function :py:func:`yasa.plot_hypnogram` still exists, but now *requires* a :py:class:`yasa.Hypnogram` instance as input. ---------------------------------------------------------------------------------------- diff --git a/notebooks/14_automatic_sleep_staging.ipynb b/notebooks/14_automatic_sleep_staging.ipynb index 3aad21e..706c138 100644 --- a/notebooks/14_automatic_sleep_staging.ipynb +++ b/notebooks/14_automatic_sleep_staging.ipynb @@ -49,24 +49,29 @@ { "data": { "text/html": [ - "\n", - "\n", "\n", " \n", " \n", + " \n", " \n", " \n", " \n", " \n", " \n", - "\n", + " \n", + " \n", + " \n", " \n", " \n", - "\n", + " \n", + " \n", + " \n", " \n", " \n", " \n", + " \n", " \n", + " \n", " \n", " \n", " \n", @@ -83,28 +88,36 @@ " \n", " \n", " \n", + " \n", " \n", " \n", " \n", " \n", + " \n", + " \n", " \n", " \n", " \n", " \n", + " \n", + " \n", " \n", " \n", " \n", " \n", - "\n", + " \n", + " \n", + " \n", " \n", " \n", " \n", " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", - "
Measurement dateJanuary 15, 2016 14:01:00 GMT
ExperimenterUnknownUnknown
ParticipantUnknownUnknown
Digitized points15 points
Good channels
ECG channelsNot available
Sampling frequency100.00 Hz
Highpass0.00 Hz
Lowpass50.00 Hz
Filenamessub-02_mne_raw.fif
Duration00:48:59 (HH:MM:SS)00:48:60 (HH:MM:SS)
\n" + "" ], "text/plain": [ "" @@ -149,8 +162,66 @@ ], "source": [ "# Let's now load the human-scored hypnogram, where each value represents a 30-sec epoch.\n", - "hypno = np.loadtxt('sub-02_hypno_30s.txt', dtype=str)\n", - "hypno" + "hyp = np.loadtxt('sub-02_hypno_30s.txt', dtype=str)\n", + "hyp" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Epoch\n", + "0 WAKE\n", + "1 WAKE\n", + "2 WAKE\n", + "3 WAKE\n", + "4 WAKE\n", + " ... \n", + "93 WAKE\n", + "94 WAKE\n", + "95 WAKE\n", + "96 WAKE\n", + "97 WAKE\n", + "Name: Stage, Length: 98, dtype: category\n", + "Categories (7, object): ['WAKE', 'N1', 'N2', 'N3', 'REM', 'ART', 'UNS']" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Convert it to a Hypnogram instance, which is the preferred way to manipulate hypnograms since v0.7\n", + "hyp = yasa.Hypnogram(hyp, freq=\"30s\")\n", + "# The hypnogram values can be obtained with\n", + "hyp.hypno" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Let's plot it\n", + "fig, ax = plt.subplots(1, 1, figsize=(7, 3), constrained_layout=True, dpi=80)\n", + "ax = hyp.plot_hypnogram(fill_color=\"gainsboro\", ax=ax)" ] }, { @@ -164,9 +235,20 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# We first need to specify the channel names and, optionally, the age and sex of the participant\n", "# - \"raw\" is the name of the variable containing the polysomnography data loaded with MNE.\n", @@ -174,38 +256,35 @@ "# - \"eog_name\" is the name of the EOG channel (e.g. LOC-M1). This is optional.\n", "# - \"eog_name\" is the name of the EOG channel (e.g. EMG1-EMG3). This is optional.\n", "# - \"metadata\" is a dictionary containing the age and sex of the participant. This is optional.\n", - "sls = yasa.SleepStaging(raw, eeg_name=\"C4\", eog_name=\"EOG1\", emg_name=\"EMG1\", metadata=dict(age=21, male=False))" + "sls = yasa.SleepStaging(raw, eeg_name=\"C4\", eog_name=\"EOG1\", emg_name=\"EMG1\", metadata=dict(age=21, male=False))\n", + "sls" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/Users/raphael/.pyenv/versions/3.8.3/lib/python3.8/site-packages/sklearn/base.py:329: UserWarning: Trying to unpickle estimator LabelEncoder from version 0.24.2 when using version 1.0.2. This might lead to breaking code or invalid results. Use at your own risk. For more info please refer to:\n", - "https://scikit-learn.org/stable/modules/model_persistence.html#security-maintainability-limitations\n", + "/Users/raphael/.pyenv/versions/3.9.6/lib/python3.9/site-packages/sklearn/base.py:329: UserWarning: Trying to unpickle estimator LabelEncoder from version 0.24.2 when using version 1.1.3. This might lead to breaking code or invalid results. Use at your own risk. For more info please refer to:\n", + "https://scikit-learn.org/stable/model_persistence.html#security-maintainability-limitations\n", " warnings.warn(\n" ] }, { "data": { "text/plain": [ - "array(['W', 'W', 'W', 'W', 'W', 'W', 'W', 'W', 'W', 'W', 'W', 'W', 'W',\n", - " 'W', 'W', 'W', 'W', 'W', 'W', 'W', 'W', 'W', 'W', 'W', 'W', 'W',\n", - " 'W', 'W', 'W', 'W', 'W', 'W', 'W', 'W', 'N2', 'N2', 'N2', 'N2',\n", - " 'N2', 'N2', 'N2', 'N2', 'N2', 'N2', 'N2', 'N2', 'N2', 'N2', 'N2',\n", - " 'N2', 'N2', 'N2', 'N2', 'N2', 'N2', 'N2', 'N2', 'N2', 'N2', 'N2',\n", - " 'N2', 'N2', 'N2', 'N3', 'N3', 'N3', 'N3', 'N2', 'N3', 'N3', 'N3',\n", - " 'N3', 'N3', 'N3', 'N3', 'N3', 'N3', 'N3', 'N3', 'N3', 'N3', 'N3',\n", - " 'N3', 'N3', 'N3', 'N3', 'N3', 'N3', 'N3', 'N3', 'W', 'W', 'W', 'W',\n", - " 'W', 'W', 'W', 'W'], dtype=object)" + "\n", + " - Use `.hypno` to get the string values as a pandas.Series\n", + " - Use `.as_int()` to get the integer values as a pandas.Series\n", + " - Use `.plot_hypnogram()` to plot the hypnogram\n", + "See the online documentation for more details." ] }, - "execution_count": 5, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -218,21 +297,122 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Epoch\n", + "0 WAKE\n", + "1 WAKE\n", + "2 WAKE\n", + "3 WAKE\n", + "4 WAKE\n", + " ... \n", + "93 WAKE\n", + "94 WAKE\n", + "95 WAKE\n", + "96 WAKE\n", + "97 WAKE\n", + "Name: Stage, Length: 98, dtype: category\n", + "Categories (7, object): ['WAKE', 'N1', 'N2', 'N3', 'REM', 'ART', 'UNS']" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y_pred.hypno" + ] + }, + { + "cell_type": "code", + "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "The overall agreement is 0.837\n" + "The overall agreement is 83.67%\n" ] } ], "source": [ "# What is the accuracy of the prediction, compared to the human scoring\n", - "accuracy = (hypno == y_pred).sum() / y_pred.size\n", - "print(\"The overall agreement is %.3f\" % accuracy)" + "accuracy = 100 * (hyp.hypno == y_pred.hypno).mean()\n", + "print(f\"The overall agreement is {accuracy:.2f}%\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Plot and sleep statistics**" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the predicted hypnogram\n", + "fig, ax = plt.subplots(1, 1, figsize=(7, 3), constrained_layout=True, dpi=80)\n", + "ax = y_pred.plot_hypnogram(fill_color=\"gainsboro\", ax=ax)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'TIB': 49.0,\n", + " 'SPT': 28.0,\n", + " 'WASO': 0.0,\n", + " 'TST': 28.0,\n", + " 'SE': 57.1429,\n", + " 'SME': 100.0,\n", + " 'SFI': 1.0714,\n", + " 'SOL': 17.0,\n", + " 'SOL_5min': 17.0,\n", + " 'Lat_REM': nan,\n", + " 'WAKE': 21.0,\n", + " 'N1': 0.0,\n", + " 'N2': 15.0,\n", + " 'N3': 13.0,\n", + " 'REM': 0.0,\n", + " '%N1': 0.0,\n", + " '%N2': 53.5714,\n", + " '%N3': 46.4286,\n", + " '%REM': 0.0}" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Calculate the summary sleep statistics of the predicted hypnogram\n", + "y_pred.sleep_statistics()" ] }, { @@ -244,9 +424,17 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 12, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/raphael/GitHub/yasa/yasa/staging.py:475: FutureWarning: The `predict_proba` function is deprecated and will be removed in v0.8. The predicted probabilities can now be accessed with `yasa.Hypnogram.proba` instead, e.g `SleepStaging.predict().proba`\n", + " warnings.warn(\n" + ] + }, { "data": { "text/html": [ @@ -271,11 +459,11 @@ " N1\n", " N2\n", " N3\n", - " R\n", - " W\n", + " REM\n", + " WAKE\n", " \n", " \n", - " epoch\n", + " Epoch\n", " \n", " \n", " \n", @@ -378,8 +566,8 @@ "" ], "text/plain": [ - " N1 N2 N3 R W\n", - "epoch \n", + " N1 N2 N3 REM WAKE\n", + "Epoch \n", "0 0.002202 0.005040 0.000703 1.875966e-18 0.992055\n", "1 0.003362 0.003284 0.001926 8.279263e-05 0.991345\n", "2 0.004078 0.003225 0.000095 7.688612e-04 0.991833\n", @@ -395,31 +583,30 @@ "[98 rows x 5 columns]" ] }, - "execution_count": 7, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# What are the predicted probabilities of each sleep stage at each epoch?\n", - "sls.predict_proba()" + "proba = sls.predict_proba()\n", + "proba" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAApgAAAFBCAYAAADT6N+zAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAB27klEQVR4nO3dd3xk53XY/d+5d3pDx2IBbK9clmVZ9iKqU7aKLTfZclwiW7Ffyy12Ejt2HMd5/bpFcYuSWHGT7ciKLDkSLUuiZBWLIimJnVwu25LL7R0d0+c+7x8zWAyAKXeAGcxczPl+PktiCu48wGDunDnP85wjxhiUUkoppZRqFqvdA1BKKaWUUhuLBphKKaWUUqqpNMBUSimllFJNpQGmUkoppZRqKg0wlVJKKaVUU2mAqZRSSimlmqplAaaI/LmIXBCRw1VuFxH5IxE5KiLPiMiNrRqLUkoppZRaP63MYP4lcF+N298G7Cn9ez/wP1o4FqWUUkoptU5aFmAaY74GTNS4y7uAvzJF3wB6RWRzq8ajlFJKKaXWRzvXYI4BJ8sunypdp5RSSimlPMzX7gG4ISLvpziNTjQauWn/ruE2j0gppZRSlRhA2j2IdhALfH0rrn788ccvGWOG2jCitmpngHka2FJ2ebx03QrGmA8DHwY4dP1u89hHtrZ+dEoptc4MgkMEY/wYY2OMD8exi18j2FYOy8piWRks0gj5po/BIUS+kCBVSJBz/BgEUxqbAbAMAStL0ErjlyQ+SSGkF27tGMXxhnBMiEIhiIONz0pjWenS765Q4XssDAGMCZB3IuRzIbLZMKlcmFQ2SCySZLjnWQSn7uMXiJLJDTCXSzCTiXI5GeX8XIiA7XDX9iPEfCdqfn/O9PHCpWs4NxMhk7PJ5i1SOYtMzqZQgKBtiAYcwj6HSKBA0M7jtw1GwIEr/0dgc2KakdgpQvb5imM3BJjKbeWVyVGOTcRxHAMCxhSDxYVo0RKDCFgCIsXneyplc3nOx/kZizPTFuemoWBgS79h15Bh+0COsZ4Mw7EUPcEkEX+asJ0kaCfxM49FsuP+dlbNPwwHPrbiahE53obRtF07A8z7gQ+IyMeAW4FpY8zZNo5HKdUEOWeQSxfG2TzyVLuH0hYGi4JJkM32kErGSM6GSM4EKOTAKQiFguDki19nUsLcBMxegpkLBabPG0zB/ZutHRDCcYtABAJhIRgRgj1+/JtCRHocEj1pYtEUsUiKcCSJP5AinwuRzEaZzUSZToeZmA9xaT7I2SkfJyd8nJmHc9k8eRdBFICN0Ou3GI7BQMwwEHXoizj0hvMkgnkigTwBMfjtAgGrgE8c/FaBvGOTzRf/ZQp+MjmLvGMRDuSJBLKEAzlCgSxBXxYQ5tJhZpMhpudDTM4FmJr1k8taWIBVcLCMIAXAMUxnfVzO2kwCF50C57J5CsZhwOdjk8/HABb9/gJ9wTzGgVTeZrZgkSpYJAXmcZguFJgqFJh1Fn8PQbH4gV17efdtz9IXfaHi7yPrDPGtYzfwJ4/0cWy+8geAkNzKe6+5mW+/9iWG4keuBLsGYSa1hwdf3sdfPhHhXKbeBwjb1XMEPVhs5UCvjzv3pLh2bIqR+BQnp/r51vE+vvyin/OZlQH3WhyfEI5PCBAs/UtUvF/QgmgAQkEI+w3hAAR98Mtvep4R//NNHZNaX2JMaz45iMjfAvcCg8B54D8CfgBjzP8UEQH+G8Wd5kngR40xj9U7rmYwlWodg6w5m/D8U7fz+T82fM+v5xjf8niTRtYeBZPg3OndRBIpItFJAvZlhNyV2w0+UtlRJi4McualCK8+Lpx7OV8/SBQhtH2QXH8Ux5LiP4GCZeEIZCxIijCLw5xjmCoUSDoOgz6bActHnwjxgiGULSDGMBP0cdGGE7kclwqVg5KoZRO1LSZzeXIbJWPUJn22jx+9KstbDz1JNPgaAKncFh5+4Vr+12NxTmXdZZb9CO8Y8/EdN5xAxOFzz2zn0ycd5p3mBnte9Jf/4hi7I0+0exiNqZ7BfNwYc6gNI2qrlgWYraIBplKtkcpu4Ssf3cG3/cjXVn0MhxB/+m9uZH6imPX5jn9fYMeuR5s1RBzCFJwIiClN9RUnQkWyWKSb9jgGi9Onruezfxi68rMAiC1s2mmzaY9Fetbw6mN5cimX59BSUDk12sNj5Dmfy9X/HtXRtgYDvO+aWdJ5m79+PsKpbHZVx7EAQSho4H/Fn733OPtidXNOnUUDzCU8sclHKdU6DmGOPH4D//QnBlPIct+PhLFIrepY585ctSQg+9T/Z/P2X7yVPVd9c8V9c84gLzy2l0c/Lew8ZLHzhhRDo+cIBc5cWSdmENLZMc6dGOXFR4K88GDl7KAI7L4jwP47M4xuP0c4eHLJWrMCEWZmtnLmaD8vf9OmZ5Nw1R3TDI28is3skmPNp7fzxb/YwrHHcrBsmtgUDOdeznPu5dq/B7Es/P1RrL4o+XiQ6YifJ00pqMyt7nerOs+JTJb/+HiwdGl1wSVw5a9dLco52mjQ6zTAVKqLXZ48wGf/uJ9Lxxen9ApOBMtqPAgyCI98IgYszcx95r8Ib/3A7Ry44RGgmCl96ivb+OYnC5hC8a31yc8UePIzPmCc2MA2DrzeIhA2PPtPhumzC9OF1TN+xsDLD2V5+SEBNhMfGuO6N9skhvIcfdTH0W8uBKYOC2/nT/1jGLGv4eo3+Ln67ln6N53nuYd38rWP5Gs+Vi3+g1v4eszH2VyuLBuVB5dTpkqpopyj4YnX6TOoVJd65At3843/k4NlO5Hz+Qj+wOWGjzc3v4sTT1cOzB74b4a5H7ib6QvC4X/KrnjMJce5XOBbn1jbGrTZiw4PfXQh+1gjMC0YDn8xy+EvBoGtNcflxos9QU6lNUOp1Frlna4sdLShaICpVBeant9TCi5XyuVChAONH/Opr2ymVjD30Ec39ppDfyLM0xpcKtUU+YLbHfKqU+kiB6W60EN/V70razYdrHpbNTlnkMfv7+5pYLN72GVhH6VUPdmCZjBbTUSMiHyw7PIvisivl76+R0SeEJG8iHz3ao6vGUylusz0/F5efLD6hoRMqvH05dFn9jRUv3EjejXmZ3NvL2fPXWr3UJTyvLzTXRnMD78w09Qt8+/fn3Czaz0DvFtEfssYs/zEdQL4EeAXVzsGzWAq1WUe+ruRmren5/0NHc8hyIP/u7uzDb5okCfSacz+q9mxZ5ur7xEEv08/4ytVSTbf3eeUdZKn2CXx55ffYIx5zRjzDMtLaTRAA0yluki97CVAaq6xzMH5ZaWJupHs2UQsHuG1YA/ntu93FTjuum4f4Xtfz8imgXUYoVLektU1mOvlQ8B7RaSn2QfWAFOpLlIvewmQnHJ/YjcID38ivpYhbQjHE0GGdm4FhEkrxLbrrqp5/6GBXl7YvJsLdoST19/B7hsOYIlmbJRaoGsw14cxZgb4K+Bnmn1sDTCV6hJuspcAc1PuT+xzyeqlibqFHfLzRCbN5cHRK9e9OLid3kSs4v0tsTAHbyBf6iNdwOLw8B6GX3dP1e9RqtvkNMBcT38AvA+INvOgGmAq1SW+/vFNru43P+F+s84L36qfEd3o7D2bSPQnOOtbDA5zYpE4eG3F+++84WpO+RMrrn8t2MvMbfewc+/2Vg1VKc/I5DU8WS/GmAng4xSDzKbRZ1CpLjA9t4eXvu4u0zjbwCboidN6CjnZF6Zn+5YV178UGWZ8y9IAfGRkkCOD26seKyl+juy4zvVGIaU2Kg0w190HgcGFCyJys4icAr4H+BMRea7RA+oWRqW6wNf/bgS37Q9nL7rvojNzvrtLE9lBH49n0th9leuKzu+9BuvUeRxj8Nk26auvx5F6b5zCyzuvZet8kjNnLjZ/0Ep5QLftIndZVqipjDGxsq/PA5Gyy48C42s5vgaYSm0Qqdw4X/rrnfSPGfo25YkPZIj2pEgng66zlwDJaQeDD3HRNnHy7NpaOnqdb/cmekf6OWaHK95+1hflmqv3cPTwS2y76Tqe87lb4pTH5uI1h+hLfp3JqdlmDlkpT8joGkzP0wBTqQ1i6tIgLz9UvoknUPrXuIKJ4pPpmvcx+Lu+PNGZgQiRrVtr3ufV0d3sSKc50rdyGr2WWQkQPnQb4a9/jVQ6s5ZhKuU56awGmF6nixyU2iDOvxapfyeXCoX6xyqY7t7xbPltnihkOdlTe/NUUvw8v+t6DI2/YV6wI/Tedhu2padq1V2y3T05siHoWUupDeLkc80rTJzLV57yXXKfXFMrWnhOYPcmejYPMSNussSrz8YcC/ay9bZ1X56lVFulc5rB9DoNMJXaAAw+jj9Rf82kW9lMsP59svWDUK8TS3Bu3UnwqlF80aW/k3MDEezxNa2Bd+35+GZ23HEzg/1Nb7ahVEfK5DQ88Tpdg6nUBpDJDZPLNLajO3jLbjLfOlrxtmw6CHVimUyqeoAplmAc7+8wt+/Yy5fvvpXoy0c4HRd2BUPscoT+6TRP43A5NrxuY3k+Pgo3j7IlO03i/ElOHT1BJtvdRe7VxpVu3udl1Sb6EUGpDWB6crD+ncoEhxJ87C2vx39X5ZaG6fn6nz1Tc5Wnhu2QH9+dVzc0nk4UHErw9Ttu4owvxstX3cLWO2/ljAWfz6X4aMQQ27KJlKz/Z/STgR6e23INmXvfwo7bb2bb9jHCofoZZ6W8JFW/6ZhaIxExIvLBssu/KCK/Xvr6X4vIERF5RkS+JCINF+fVDKZSG8DFEzHA/Y7uwtXbSIqfT77uTr53Pk36yWNLbk/P+eseIznjB1ZmKX19Mb546428/lsvUsh4NMMmwtn7buKVYO+Vq16IjRC9e4BdJ17glRdepTC6PtPj1aTFx/OJUUiMwj7DpnySgeQUTE4wde4iE1reSHlYyqOnjtWSP3/lsWYez/zLXW4WbmeAd4vIbxljlrfYeBI4ZIxJishPAr8LfF8jY9AMplIbwMkjjX1WPLOzGBzNWgHuv+91hPeNLrk9OVP/1DA/VXlTkfTGOBmOkX/DDQ2NqZMEbt3Nl7ftWXH9vPh5btu1bL73dRyL9LdhZNUI531RjiTGOLLtWpI339nuASm1Jhnd5LMe8sCHgZ9ffoMx5ivGmGTp4jdYRdF1DTCV8jiDxbHH3S9Ysvw2T40stjC86IvwhXe9kfCWgSvXJafr70ifuVT59FHoKe4u//z11+JPeG8jUKAvykN3HSJTY/r7WLCXPM3btd9s01YAn92541OqHp0iXzcfAt4rIrVW3b8P+FyjB9YAUymPyxaGycy5nx4P7Bvj4rLOMyeCcb7+PW8mOBgHYHai/nFmLlbexJNLFOtjTviCzL7lZtfj6hSXvu0QL4X72j2MNTEIiXh3l5FS3qabfNaHMWYG+CvgZyrdLiI/CBwCfq/RY2uAqZTHzUwNAcVNKXao/trJmb2VO8+8EO3n8A+8BYC5S/V3gE+drXyfdGyxSPtn9+0nMOyd0jqhm3byxR372j2MpogmNMBU3uboNpH18gcUs5RLThoi8ibgV4B3GmMabiemAaZSHnfpZDFjaI0PYF1Tvx3hi1tGq972aM8wlt/H7KXaGVGDMFWlD/l8dDHATFk+zt13a90xdQJ/IsJD995Mug07w1shENMAU3mb2SCvxU5njJkAPk4xyARARG4A/oRicHlhNcfVAFMpjzv1fDFrme1PcOLaHTXvG9zUw5FE9elfg+DriTBz0anZ2tAxEUyhcgZzOrJ0+v2BrTsJ7azdTtEtXzTUlOMsF9yU4OR338kLkYH6d/YIiTSvdahS7WA0g7mePgiU17v7PSAG/J2IPCUi9zd6QH32lPIwg/DqY8XFSsneBM9s3sqOHUOkj12seP/CVVvrbk6xeiKYSzM4RLCZr3ifvBOv+v2Xw0sDTEcsXnzTrWz7cMPnpxWm3nE7Q4dfJXX4eN372iE/+ddfQ/CRl8hOVf45AAK37uLBuw7x8gYKLgFyQe9tsFKqnGO6J0RxWVaouY9pTKzs6/NApOzym9Z6fM1gKuVhucIgyanidPZkT4xLdpip66tnMc/sHKt7TFNau1dwqmfActnqt10MrQxsvr5pnNB12+s+di2B3gj/tHMXj77+FsSqX8Ik++Yb+eih2/nSv/pOCt9+aMWOdl8sxNx77uZjb37jhgsuAVIBDTCVt+kaTG/TAFMpD5udWWxVeClW/DD6zK4dFcsD2UEfTw3Xn6rOx4vBYz5fPUDJpCvfZvl9TAUqd5V57s611cVM3X0d83aAp3uH8N1euQPRguBIL5+97hoATgQSfOzGW/jKT7wb82034Y+HCR8Y54kffwef3nNtW7rxrIcZX2uWEyi1XpwOLgWm6tuYZ1alusSl08WparGEs6U1dy+H+7n9+m3wtReW3Dewd5SL/vobP3LxCBaQy4agcjdI0vOVg0h/fxRTZQP6M32D7PH7cHKN1x+xQ36+eGAxqPzqHTdx97dexMlV3mh08ttuY8ZaOsbjwR6O33QrW689wGV/kHmp8sNtENNWgKhtky9U/h0p1ekKxkeNpeCqw2kGUykPO/1CcYOPvyfCZf9CVlF46epdK6aRp/fW32EOkCptpMlmqve3Ts5WLockvdXXZiZtP4Edq9zsc8cBLpRN+b4WiuO8sXJGNHzddv5prPoygROB+IYPLqG4PrdHSxUpD3OMZjC9TANMpTzs2OPF9ZfWcA+FspfzMwOjBJe1f3xxvHp5onLzpU06mWT1IKxam0inTkCT2rnZ1RjKiSU8fMPVK67/3A0HVywFsHw233jDrTV3wHeTiBZbVx5W0ElWT9MAUymPyjn9zFwoTn86A4kltyXFz/nrd125HBrt4/m4u40sM6UAMzVX/eQ+N1H5tnyidmmcM6MjNW+vJHDzHo5GeldcX+wUdMvSK99wkMMuf85uoLUwlZcVHA1RvEyfPaU8am52cYNPpj+x4vYntm0jOFS8Pr9/Czlx93KfDhenyFOz1aenqrWJTNfJmD03OIhIY9nFZ265rupt/7hvL6HNxbqegf4Y/3jjwYaOvdFpLUzlZYUuKlPUDiJiROSDZZd/UUR+vfT1T4jIs6UamF8XkQONHl+fPaU86vLZxRaMs4nYitvP+ONkbtwJDzzF6e3upscBJoLFADM5XT3AnD5fOcAs7+JTycVghMBoP5nTl12NJXRgC4/1Dle9PW35OfWWWxn8yOe5+LZbmfBraZ5yWgtTeVmhi9ZgRt/0K48183jz//SbbupqZoB3i8hvGWMuLbvto8aY/wkgIu8E/itwXyNj0AymUh515qXFNZITicqbaw5ftRN/PMSzLsoTXTmWP4jls5mfqp5pnDxTuZXk8i4+leR3uw92X7mjevZywRe27sB+00E+t2O36+N2i6TWwlQelne6J8BskzzwYeDnl99gjJkpuxgFqtQHqU4DTKU8amGDD8D5aOWp6cPxYaZefzXnXZQnWpDHwtcTYW6i8vnEIUBmrnKAOekiwLw07m4dZmjrIA9urr/z3SD81e13UBB9M1puxq5eCUCpTpfXNZjr4UPAe0WkZ/kNIvJTIvIK8LvAzzR6YH32lPKgvEkwcaq4wccO+jgbrhxAFrD4+jX1s4DLWb1RZi5UDjALNdpEXqrQxWe5l4arT3mXu3D3wSU742vTXeOVTNtBfLYG3sqb8roGs+VKmcq/okIAaYz5kDFmF/DvgF9t9NgaYCrlQfPzi1lA/2CCealclxLgkr2KadJ4hJkLlbOUuVzlYFZsi4v++hmzV2IJ/D2112r6ExG+tH1n/XGqOoSE1sJUHlUo6AfHdfIHwPsoToVX8jHgOxo9qAaYSnnQxLmy2YyhFTMba1aIR8gmHUyFVj7ZKn3I/b1RjIud6gbB2jte+/Fv3U/Sqh40K/eiWgtTeVROM5jrwhgzAXycYpAJgIjsKbvLtwMvN3pcDTCV8qAzLy/2mc5XKFG0VtlYMYgsmJXBZDpZOUtp9a3cyV7N1Lba6zCfOrCn5u3KPa2FqbwqV9AQZR19EBgsu/wBEXlORJ4C/jXww40eUD8eKOVBZ19a/DpZoz3jaqWjIcJAvhDF55tacltqrnKHH9PjPpA5tmmYakXVwns282xCi6U3i9bCVF7VTZt8XJYVaipjTKzs6/NApOzyz671+N3z7Cm1gcxdXlwfOd3jPnPoVrK0GzyXC628bbpKF58GpmKf6x3ADlaeAr9wqOF6vqqGvIuNV0p1Is1geps+e0p50NzEYoB5Md78AHOm1M0nl1k5HT4/WTnArNfFp1zWsvHvWtmX3A4FeHD7NtfHUfVpLUzlVbmCVkDwMg0wlfIYg49carGE0Nlo8wPM6VLWK5NaOR0+c6nyzs5knS4+y83vWLkO07p5D5O+lVlTtXpTtv4+lTdlHd1F7mUtDTBF5D4ReVFEjorIL1W4fauIfEVEnhSRZ0Tk21o5HqU2AofFjJS/J8IlX/OLaU+EisdMJ1dOY1erjzkbbSxTdmZsZYD5/LX7GjqGqm/GCmgtTOVJubzmwLysZc+eiNgUK8S/DTgAfH+FZum/CnzcGHMD8B7gv7dqPEptFIXCYkbKN5QgT/ODhwl/ELEt0rMrp8OnzlXr4tNYBvNw/xBiLWYoQuMDfGvAfUtL5ZbQ08AGLKU6RVbrYHpaKz8e3AIcNca8aozJUizU+a5l9zHAQo2VHuBMC8ej1IZQHmA6g82vgQmQER/+ngjJmaXBq8Fi5nyh4vdcCjc2FTvhDxLcMnTl8sytV2G0I09LRFqwTlepVsvqGkxPa2WAOQacLLt8qnRduV8HflBETgGfBX660oFE5P0i8piIPHbx8kyluyjVNfL5xSnxTH/zSxQtsHqjzE8tPUUUTAxTYYZcLOGCv/G1frldo8XH8tk8snvXqsap6gs0uD5WqU6Qzbd7BBubiBRE5CkROSwi/yAivc08frvrYH4/8JfGmA+KyO3AX4vINcaYJXNwxpgPAx8GOHT97soLwJTqErnc4rrI2Z7WBZjEI8xNTC65Kp+vnAnzJSLkrcazDRfGRxgAAjfs5FRAp3FbRcIaYCrvyXRRmaJfkO9/rJnH+6D5Wzd1NVPGmOsBROQjwE8Bv9msMbTy2TsNbCm7PF66rtz7KLYnwhjzCBBiaSV5pdQyucxigDmZaN3Up5OIMHd56ee5XK5yoGL3rm4cL24qTpG/cnDvqr5fuZPTWpjKg7I5XTKzjh5h5SzzmrQywHwU2CMiO0QkQHETz/3L7nMCeCOAiFxFMcC82MIxKeV55QHmhVjrAsxsJMTMxaXrLTOpytPgpnd12cdjoRjhfaM8tKmp5zW1TCqoAabyHt3ksz5Km7LfyMoYbU1aFmAaY/LAB4AHgOcp7hZ/TkR+Q0TeWbrbLwA/LiJPA38L/IgxlVZ4KaUWZFLFlS2W3+ZsqHVTn5lYhLlLDqbsNJGar1wSKZ9Y7fS28MRb7yBntXu1zsamtTCVF6U1g9lq4VKv8XPAJuCLzTx4S8/qxpjPUty8U37dr5V9fQS4s5VjUGqjySYtwOAfiDNjNb8G5oL5aIigAYcINnMAJGcqt3fMxlcf6D7RM7zq71XuzFgBYrZNvlC5AoBSnSijdTBbLWWMuV5EIhSTgT8F/FGzDq7PnlIek54vvmxlqDUlihbMldbtFQqLweP8dOWNPMmobtDpbFoLU3lPOtfuEXQHY0wS+BngF0SkaYlHDTCV8pjUbPFlmx9I1Lnn2kyVuvnk84vr9+YuVw4wG+3io9ZftEotTEuEngb6yCu1XrJ5nSJfL8aYJ4FnKFb3aQpd+KSUx6RmiyfdVF+rA8xi0JjNhomUZuJnLlZeIj3VYBcftf4CscpB5I6r90A+z/QLr67ziJSqLZlt9wjWj8uyQk1ljIktu/yOZh5fM5hKeUxquvj/6RaWKAK47A8glkU2Hbhy3fS5ygHm5Qa7+Kj1ZyrUwgyHgrw2uhtpYTUCpVYroxlMT9MAUymPSU4Xg7xLLW7/l7T8+HvCZJJldTfPVt4kciGgU+SdLl+hFubowQPMi59sWANM1XlSugbT0zTAVMpj5iaKja7OVpnybB7BSkRIzRcDTIcIudTKDKYvFiJt62qbTpcMLM0yD/QneKF3HIDZgC5xUJ0nk9UMppdpgKmUx8xNOPgTYS741yFr2BMhNVvc2JMvVM5y2X2a/fKC6WW1MMPXXEuh9BZw0RdC0Ddz1VmSmsH0NA0wlfIQQ4BC1uAbTJCn8d7fjXLiEeaniqeJam0iWWWbSLW+ZqwAPrv4N7N12yhHw4tdefPYWsZIdZxMTvuueJkGmEp5SMEUs1BOi0sULcjFwsxPFr/OZCpnTAur7uKj1lexFqYlwszuAytuTfSuz9+UUm4VjGDW4YO0ag0NMJXyEMcpBpjZdQowM9EIs5dLXycr7xTPag1Fz4jGY+y4eg/nfCufs0A83oYRKVWbaV7db1VGRH5fRH6u7PIDIvKnZZc/KCL/ei2Poc+cUh6SLxQLUs71rE+AmYyEmL1Y3FSUnA1UvE8qphtEvCLQ18trQ9sr3mZavmlMqcY5+LDItHsYrffwwGNNPd4dl+vV1XwI+F7gD0TEAgaB8jeWO4CfX8sQNIOplIfkc8Us4uQ6TUvPhUPMXigFmFXaRM7FtESRVxwd3sGcVbmffDKoAabqPMboFHmLPAzcXvr6auAwMCsifSISBK4CnljLA2gGUykPyeeKwcHFder9PRMOkcsYHELMTtiAs+I+UxUKeKvOlK4x3TitpYpUByrgp/JHIrUWxpgzIpIXka0Us5WPAGMUg85p4FljzJp6KWkGUykPyWaKp9rJ4Pp0zpkqPU7BiTB7qXIZmwnt4rMhTFhB/D7NOajO4ugmn1Z6mGJwuRBgPlJ2+aG1HlwDTKU8JJf2gQjTvvX5TD8RCCKWRb4QYeZ85ZIhF4I6Rb4xCH19utFHdRbH6IeeFnqIYjB5LcUp8m9QzGDeQTH4XBMNMJXykEzKhy/sJ1llHV2zzYofXyJEPhdiqkKbSDscYM5XefOP8p6olipSHcbRNZit9DDwdmDCGFMwxkwAvRSDTA0wleommaSNHQvDOnVdccTCTkRIJyNXWlSW82kXnw3FjunzqTpLQbeKtNKzFHePf2PZddPGmEtrPbg+c0p5SHrOQqLrvOYxEWHiXOUNIKJdfDaUfESfT9VZCt2SwaxfVqjpjDEFlpYmwhjzI806vmYwlfKQ9JzAOgeYTiLCxeOVp8EL2l5wQ5kP6k5y1Vm6JsDcgDTAVMpDkjNgIsF1fcx8NMSZFypv8MklNCDZSC77dMOW6iwFRwNMr9IAUykPSU5DIby+AWYmGuHMi/mKt6W0+8uGkhQ/sYiWnVKdI68ZTM/SAFMpD0lOGfLrnMFMRUOYQuUM5py2idxwevp0J7nqHJrB9C4NMJXykPlJh2xofQPM+XDlaVN/T4RHx0bXdSyq9UI9WgtTdY68BpiepQGmUh6SnHTIrHOAOVPl8ebfdD2Ttk6nbjQS1Z3kqnPkHQ1TvEqfOaU8wiFIIQ/JdQ4wJyu0ggwOJ/jq3r3rOg61PtIhXVerOodmML1LA0ylPMIxxanqVGB9A8wpXwCxlhZ2n7rnGi76dP3lRjSrpYpUB8lpBtOz9JlTyiMKTjGTOBdY39aMM3YIX3xxHWZo6wDf2L1rXceg1s9lK4Ql69MpSql6cgXNYHqVBphKeUQhX8xczvjXN8DMiYWvZzHAPH/zbs74dSPIRpUXm95efX5VZ8g7+mHHqzTAVMojcgsBZsC//g8eL06bhnZv4rBmLze8uAaYqkNoBtO7NMBUyiPyWT9iW0yvcwYTwClNkR+7dpzXAr3r/vhqffnjGmCqzpAtaAbTqzTAVMojshk/vliIPOv/iT4fjxC8eoyTO3eu+2Or9edoqSLVIbKawfQsX7sHoJRyJ5f2YUXbU3cyEwvz0o5BXo4MtuXx1fpK6k5y1SFyhXaPQK2WBphKeUQmZbctwHxluIe58CZAp6u6wZRfA0zVGTSD6V06Ra6UR2TmbUybAsypeIKX4yNteWy1/qasIMF2bCZTaplMXj/UepUGmEp5RGrOwomsb5H1BUfDgxT0dNFVensT7R6CUuQKet7xKn3mlPKI9JyQb1OAqbpPVEsVqQ6gGUzv0gBTKY9IzQj5de5DrrqXFdMAU7WfBpjepQGmUh6RnDJkNMBU6yQX1o0+qv0yOQ0wvUoDTKU8Yn7KkNYAU62TuWC03UNQiowWWvcsDTCV8oj5SYdUUANMtT7O+yNEw+2pWqDUgrRmMD1LA0ylPMAgJKcNc8H1bxOpulMem837d7d7GKrL6RS5d2mAqZQHGEKYgmE+oAGmWj8nhrbgs7XQtWqfTN60ewhqlTTAVMoDCk5xqnLar1Pkav3MSICte7a1exiqi6VzGqZ4lT5zSnmA44QBmNbuKmqdTY7tbPcQVBdLZds9ArVaGmAq5QH5fAA76Gfe0gBTra+zvihbtm5u9zBUl9I6mN7V0gBTRO4TkRdF5KiI/FKV+3yviBwRkedE5KOtHI9SXpXPB7BjIQx6slXrz2zf1e4hqC6lGUzv8rXqwCJiAx8C3gycAh4VkfuNMUfK7rMH+GXgTmPMpIgMt2o8SnlZLhPAimnJGNUeR8P9jPf3cGliut1DUV0mlWv3CNRqtTKDeQtw1BjzqjEmC3wMeNey+/w48CFjzCSAMeZCC8ejlGdlM36IaICp2kVI7NvT7kGoLpQrgNHVfJ7UymdtDDhZdvlU6bpye4G9IvKQiHxDRO5r4XiU8qxs2oeJ6g5y1T5H4yNEw/o3qNafQUtleVG7Pxb4gD3AvcD3A/9LRHqX30lE3i8ij4nIYxcvz6zvCJXqAJmkjaNdVVQbZUULr6v2MKKbG72olQHmaWBL2eXx0nXlTgH3G2NyxphjwEsUA84ljDEfNsYcMsYcGhpItGzASnWqTNIiH9HskWqvk4NaeF2tP6d120VUC7kKMEXkHSLSaDD6KLBHRHaISAB4D3D/svt8imL2EhEZpDhl/mqDj6PUhpees8iENMBU7TVtBdm6Z2u7h6G6jGP0Q40XuQ0avw94WUR+V0T2u/kGY0we+ADwAPA88HFjzHMi8hsi8s7S3R4ALovIEeArwL8xxlxu7EdQauNLzQhZXf+mOkB+SGtiqvWlGUxvcvWsGWN+UEQSFNdJ/qWIGOAvgL81xszW+L7PAp9ddt2vlX1tgH9d+qeUqiI5K6T6NMBU7TcZjLV7CKrLOMaHlgD2HtfT3saYGeATFMsNbQa+E3hCRH66RWNTSpWkpgwpzWCqDnDJDhH066YLtX40g+lNbtdgvktE/i/wVcAP3GKMeRtwEPiF1g1PKQUwP2WY8wfaPQylMAj9g73tHobqIgVdg+lJbj8WvBv4fWPM18qvNMYkReR9zR+WUqpcctJhNqgBpuoMkb4eOHux3cNQXUIDTG9yO0V+bnlwKSK/A2CM+VLTR6WUusJgkZx2mLE1wFQdIq7l4tT60QDTm9wGmG+ucN3bmjkQpVRlDmHEEmYCuu5NdYb5cLzdQ1BdRANMb6o5RS4iPwn8P8AuEXmm7KY48FArB6aUKnKcEHY4SFp0obvqDBcD0XYPQXWRvKMBphfVe8f6KPA54LeAXyq7ftYYM9GyUSmlrig4Iey4tolUnWNe/AzHIszMJds9FNUFNIPpTfWmyI0x5jXgp4DZsn+ISH9rh6aUAsjng0hUA0zVWXoH+9o9BNUlNIPpTW4ymG8HHgcMS0udGmBni8allCrJ5wKgAabqMIGeHuB0u4ehukDeabRTteoENQNMY8zbS//fsT7DUUotl8v6cbTIuuow+Zhu9FHrQzOY3lRvk8+NtW43xjzR3OEopZbLpX04Ec1gqs4yE9KWkWp95DTA9KR6U+QfrHGbAd7QxLEopSrIpH1kNYOpOswFO0xALBzjtHsoaoPTKXJvqjdF/vr1GohSqrJM0kcurBlM1VnyYrN5IMHFS1PtHora4HJ5DTC9qN4U+RuMMV8WkXdXut0Y8/etGZZSakFm3iKtbSJVB4r192qAqVoupxlMT6o3Rf464MvAOyrcZgANMJVqsfSckNIpctWBrERPyx+jrzdOIV/QmptdLFfQANOL6k2R/8fS/390fYajlFouNSskezSDqTpPJtL6neQDu3cwe+K0BphdLKsBpie5etZEZEBE/khEnhCRx0XkD0VkoNWDU0pBclqYDWmAqTrPpRa3jLREONU3SkirKHS1XEHq30l1HLcfCz4GXAS+C/ju0tf/p1WDUkotSk4bZn0aYKrOM2WHCIdat3xj644xpqwgvhY+hup8msH0JrfP2mZjzH82xhwr/ft/gU2tHJhSqmh+0mE6oAGm6kz9A70tO3Z+fBsAEtQMZjfL5jWD6UVuA8wviMh7RMQq/fte4IFWDkwpVZSaE2Ztf7uHoVRF4b7WbPRJxCK8Ei6uxDJaRaGrZTSD6Un1yhTNstiD/OeAvyndZAFzwC+2cnBKdTuDj4KEKLj+LKjU+nLiiZYcd3jPDi5QzFwV/DpF3s2yWgfTk+rtItdms0q1kUMIK6JvrqpzzYWb3zJSEM4Ojl25nNU1yF1Np8i9qV4dzCtEpA/YA1xZDGOM+VorBqWUKnKcEER1/ZnqXBf8UQTBYJp2zPGtI7xsha9cTvn0Q1Y3S2uA6UmuAkwR+THgZ4Fx4CngNuARtBe5Ui2VL4QwGmCqDpbGx+beGJNTs007prV125LLc5auQe5mmZwGmF7kdmHDzwI3A8dL/clvAKZaNSilVFE+H8DRLj6qw/X09zbtWNFwkFcig0uum7P8WKJBRrfKFNo9ArUabgPMtDEmDSAiQWPMC8C+1g1LKQWQzwbJa5Fp1eF8PZU3+vTEi9Pnjdi8Zwd5sZdcZxAi+kGra2kG05vcBpinRKQX+BTwRRH5NHC8VYNSShXlsn5yWmRadbhcbGWAuWXrZuZvex3RBpd4XBoar3h9JBKueL3a+NIaYHqSqzWYxpjvLH356yLyFaAH+HzLRqWUAiCb9pHRzI3qcJPBxZaRgrDrhgM8N7wLgzAYjzI3n3J1nNHRYV71VW4/GdRMftfK6CYfT2pkF/mNwF0U62I+ZIzJtmxUSimgFGBqBlN1uIt2hKht4/f7GLjlEIfDi2sow/EonLvk6jihbVur3ubX10HXSmm04UmupshF5NeAjwADwCDwFyLyq60cmFIKLp0IktQ2karDGYRt+7Zj3/U6joaXbtCxIxHXx0kGK2cvAayQZjC7VSrX7hGo1XCbwXwvcLBso89vUyxX9P+2aFxKdT2Dj6c+X2D++zXAVJ3vuS3XVLzeCblfOzntr3HfoGYwu5Vu8vEmt5t8zlBWYB0IAqebPxyl1IK55HbmJxxmtQ+z8rBc0F2AaVsWU1b1v/WCX18H3UqnyL2pXi/yP6a45nIaeE5Evli6/GbgW60fnlLd6+SLQ4BhRtvkKQ+b97ub2u7piTFfo6RRTrv5dK10vt0jUKtRb4r8sdL/Hwf+b9n1X23JaJRSVzzzRR9InmnN3CgPm7LdBYbRePX1lwBpn3bz6WYOPiw00vSSmgGmMeYjC1+LSADYW7r4ojFGl90q1SKZwghnX8xhhwMkLdfFHpTqOEnx0xPwk8nWfssIxGoHmPMuA1W1MRnxgdEA00vc7iK/F3gZ+BDw34GXROSe1g1LKe+Ymt3f9GOePV4sNu2Lh6HBTihKdZpEonbwCCB1dpvP6getrmbcV1VUHcLtJp8PAm8xxrzOGHMP8Fbg91s3LKW8YWp2P1//u+GmH/f5h4pvthLRrI3yvnCd7CRALlQ7wMxjE9YNb13LMRpgeo3bANNvjHlx4YIx5iVAF8SorpY3Pfz9bw8we9Fp6nELxHnxweJ0osS0PZ7yvkCsfi3MZKD+33qkwbaTauNwNIPpOW6fscdF5E+Bvyldfi+LG4CU6joG4WufvI7pczlyabef09y5dGEHpmAAKGibSLURhOsHmFN2/eAxHAnDxEwzRqQ8xsFu9xBUg9wGmD8B/BTwM6XLD1Jci6lUVzr52k08/bliljE55WDwIU3a4fjKEz1A8diO9l9WG0C9Wph+n4/ZGjUwF/i0XWTXKhifLkf3mLoBpojYwNPGmP3Af239kJTqbKnsFj71O36KJWGLHBPBlrVnVgx+nv584crlXEjXnCnvS9aphdnbE2PWxXF82i6ya2mA6T115/aMMQXgRRHZug7jUaqjOYT4hz/eTiFrllyfd9z3W65lZn4H6dnFNZ2p3lhTjqtUO836ageG4To1MK/QdpFdS6fIvcftFHkfxU4+3wLmF640xryzJaNSqkM9+eBNnD6ysp5fPhci2ITz34kjQ0AxgxnojfLolpG1H1SpNpu2AkQsi4JTeUNcvRqYC5yABpjdquDY7rclq47gNsD8Dy0dhVIeYPDxtb8srLg+NNZHLjsFTZi9e+YLi3NA6Vt381K4f+0HVarNDEIiEWVyqspEeJ0amAty2ja1axWMZjC9pl4v8hDFDT67gWeBPzNGS+mr7uSYlW+C1q27OLV3nEz6NCTWdvx0bpQLrxZfXv5EmG9evWdtB1Sqg0Rj1QPMbJ0amAsy2ja1a2mA6T31Es4fAQ5RDC7fRrHgumsicp+IvCgiR0Xkl2rc77tExIjIoUaOr9R6KjhLU5SFe/fzz6+/jeODo2SSa3/jO/Pa+JWvczfv4vno0JqPqVSnCNaohTlXZ43mgqSLneZqY8o7GmB6Tb0p8gPGmGsBROTPgG+5PXBp9/mHgDcDp4BHReR+Y8yRZfeLAz8LfLORgSu13gqF4vovsYTMW6/jyzfcyGU7zIhJkppf+8nvyIMhIIsvGuSJa/ehWybVRiI1amFOuQww5yzt79GtNMD0nnoZzCu7GVYxNX4LcNQY86oxJgt8DHhXhfv9Z+B3gHSDx1dqXeXzQSy/zdx33sI/HLqVy3axtt+UP0B6bm1vfHnTw9GHswAUbt7F4Xjz208q1U5OuHItzFAgQFLcvX7S4iPg044u3SivU+SeUy/APCgiM6V/s8B1C1+L1C36NwacLLt8qnTdFSJyI7DFGPOPDY9cqXWWy/m59J57+PSBG0mXJf/T4mM+vbapu1R6EGPADvl57tq9GM1eqg0mXaUWZk+Dpbii2j61K+ULuoXca2p+FDSmdR8ZRMSiWLj9R1zc9/3A+wG2juu6NNUe2VyQz22/quJtyeza3vTy2VKAemgHz/ZsWtOxlOpEs1UCTNc1MBfuHw5V342uNizNYHpPKz8SnAa2lF0eL123IA5cA3xVRF4DbgPur7TRxxjzYWPMIWPMoaGBNW7VVWqVMk71IHI+u7YaRbmsHyvg48jBveRFT6Rq45myKr9GfNHGAsxAWLv5dKNcQc+LXtPKAPNRYI+I7BCRAPAe4P6FG40x08aYQWPMdmPMduAbwDuNMY+1cExKrVq6UP2NbS6ztje9bNqHdeN2nu4br39npTwoJxax6MoPaabG5p9KbO1H3pXyji4b8pqWBZilTUEfAB4Angc+box5TkR+Q0S0A5DynFShegZzJrO2KfJMxs+L1+8hJ7rOSG1c8QrT4ZlgY68d0XaRXSmnazA9p6Xb8YwxnwU+u+y6X6ty33tbORal1ipVI4OZ9oVwCGKRWdWxk4EYTw1tqX9HpTwsVKEW5ry/sQDTaIDZlXSK3Hv0I4FSLs3lqweYmXCQgtPYVF+5eUks2Zmu1EZkR1e+RibtxgLGvF8DzG6U1Slyz9EAUymX5nI1Mpih0NoCzLy+aaqNzyxrCRkNh0hLYx+s0rYWW+9GubyGK16jz5hSLs3lq0/lJcNhcmsoVTRfY32nUhtFNrj0Q1qip7EamABpn7aL7EZZXYPpOfqMKeXSTK56lnEuHCSbWX0Wck4zmKoLLF9vGWqwBibArPYj70oaYHqPPmNKuTRTY4p8JhAgm1791N1sjeyoUhvFlL00OLQjjQeYSfFhW/rW1W2yeV2D6TX6KlXKpel89czJtD9AOrn6ALNWdlSpjSIpAYL+xddJtf7ktQnRiBZb7zYZDTA9RwNMpVxwCJK0q7+pTfoDpOfXEGDW2KGu1EaS6FnMWmZCq9sYF6lQsF1tbBnd5OM5+owp5YJjwswHqgeQactPMrW6LKTBZqag68pUd4jEFgPMWd/qPlgFtV1k18nm2z0C1SgNMJVyoeCEmAvUDgKTq8xCOoSZr3NspTYKf6kWpiBMNFgDc4FP20V2HZ0i9x4NMJVyoZAPMuevHQTOrbJdpOOESGqAqbpFqfd4LBYmz+q6s0hQM5jdJp3TANNrNMBUyoVcPsiMr/Yay7lV1sEsFILM1jm2UhtFPlQMDuOJxmtgXhHUD2TdRjOY3qMBplIu5HIBUlbtjiOz2dVN2+XzQWb9GmCq7pAs1cJcTQ3MBdousvtkcu0egWqUBphKuZBx6mcnZ3JhDI1/ys4Vgsxr+zvVJRY29liR1bdWzXZQN5+eRBRZxeteNSalU+SeowGmUi6kXbRyzARDODT+ppkphFYVmCrlRVNWAEssCuHVB5gpu3MCzERvglhU14S2mk6Re48GmEq5kHbqv4GkwyEKzioCTBfZUdVZNoVtfHr2XBWDkEhESAdX/3c/30EZTH80srb1pMqVlE6Re46eIpVyYd5FK8dkKER+FS0f3QSvqrNsCtsk/Hr6XK1YPMZMjcYF9cyKH0s6I6NlhSMEY6vPxip30tl2j0A1Ss+QSrmQKtR/M5wNBcmtYqNPysX0e6caDHXnKWQopAHmWgQTUSat1W/UMQiRcGds9CmEQthrWE+q3NE1mN6jZ0ilXJhzkZmcDQTJZhrPyiQ9PEW+JVp7Z/1G1R+wSAT09LlaprcfR9b2+wt3SD/ydCCMWVVPddWITM60ewiqQXqGVMqFuXz9bMl0IEAm2fhu8KSLY3eqzeHVFcr2up6ARdyvGZXVuhDuW/MxQpHOCOrmfCEygc4Yy0ZWMIJZZWF+1R4aYCrlwqyLIHDC7ye9igDTTXa0E/kt6A125wk/5rOI6i6fVbvkW/vfvL8D2kUKwqQdYN7fGdnUjc6hO2dMvErPkEq5MJNzsYvcCpDONL67dbbQ/jfK1egP2oSs7sviWQJhW4j5uu9n7yRWqP1BXTQaIo/N9Cp7qqvGGNEA00s0wFTKhamcu4xLMtd4d5LZfPvfKFejL2AR6sIgazhkIxaEu/Bn7yQm0P6gLl7qRpQUP8GANktoNcd054yJV2mAqVQdBotpl1nGuWzjweK0R9dgJgIWgS7MYI6U1p2GbT19tpMTaH8tzPLyRPE1tL5U7jhoEO8leoZUqg6HMCmXvcLnso2vLZteRVDaCRJ+i27c5zIQKgaYIbsLf/gOkvO1/4OZL7oYYEY1wGw5Rzf5eIoGmErV4Tgh5lx2Dpl1sVaznMFi2qNliuJ+C78tXdfRpr9UniioAWZbvRbuZdudtzK+ZaRtvcBNaDHA9Ee1FmarOUbXYHqJPltK1VFwQsy6nI6bzjQWLDqEmXeZHe000dIaxLjPYjLrtHk066enFGD6O6STTLfKY/NibAQOjDC0L8WmS6c4//IxZudT6zaGbKDsA6XWwmw5x9i06bOEWoUuyz0o1bh8Psi0yyBw1oQxDXxuc5wQc/72ryVbjchCgNllBcdjpZStZUGsG9cIdKCLdpjDm/Zw+c43sfvafev2uMmyADO/ht7qyp2C5sQ8pbveGZRahXwuQNJ2F2CmQyEKxv1UWcEJMePzZgYzXJoi7qaC47ZAqOw9TttFdhZHLGaGNq/b401ZiwFmSmthtlxBd5F7ip4dlaojY0K4nZdJhoMUHPcBZj4fZM6jU+QLaxBjXbQIczhsY5VNjfd0WfbWC0754oTWYYd5wOdj3lp87c52wKajjU4DTG/Rs6NSdaQL7gPGuWCInMuamQA5J0Tegy9DvwW+UomiaBfVg9wUWvoGF9MMZsdxxGJkfFPLHyfRs3TX+JQVXPLhQzVfwdEA00v07KhUHWnH/dTXbCBAroGyQxnjzXVb/WUtIiNdlMEcWBZgJrroZ/cSa2io5Y8RiS0NMB2xiMV0J3kr5TWD6Sl6dlSqjlTBfRA4HQiQTbufnkt7tERRb9nUcDd1tBkILj1ldtPP7iWXY/0tf4xAhbJEMa2F2VJ5zWB6igaYqqXyprfdQ6gpbxJ175NsIMCcCATIJN2vqWwkO9pJytcehruoHuTyTT3RLtrg5CXnfVF6Wh3sRVYGmCHNYLaUTpF7iwaYqqXm51q/Fmot5mbr7zidL7gPAlNWgFTG/WL/VAPrOztJvCzQ6qaONsvXXGq7yM41MNbac0+lskRWhaBTNU9OA0xP0bOjaqnLE/2YDq6Me/F0b937zOYbyzIm8+7fZOY9msEsDzC7paONz4Lwsve3bgquvcYZaO06zHSFskROyJtLXryi4GjI4iX6bKmWuuz04zRQF3K9nXo+iKnzMpjLN/amMd9AP/JGsqOdJFpWCzJgdUeQNRyykWW7hENd8rN70dlIX0uPX6ksUSbgzdezV2gG01s0wFQtdU6GyDvxdg+jqssnDIU66zCnc43Vt5troEzRXIPZ0U5RvnPc3yVB1vDy9CWgZTA717QVZGiwtyXHtkSYsleeF5J+zWC2Uq6gLzgv0WdLtdSZQh+ZfKzdw6jq8okC2VztAHg611gQONNAgDnr0TWY5Rt7LOmO3dSDwZUBps8WtBRm5+rZXHsdZiIWwZLGn8B4LEKhwtvnZIWgUzVP3tn455mNRE+NqqXOZHpJ5uvv1G4HhxDJaYd0qnYAPN1AXUuAmQamyBvNjnaK5WsPu6FlYn+w8s+o3Xw6V7p/sObtvTdez86br2v4uNEqO9TT4luXLkLdKlfQKXIv0TOjahmDj1P5GHMdOkWeLxQD3+Rs9YDQ4GdGGgswpzLuA8ypBrOjnaC8i8+CbuhH3lMliK52vWq/U8HeqhnK8fERXgoPcbhvGzv2bGvouLXKES3v8KOaJ6NT5J6iz5ZqmbyT4FIowkyHZjCz2WLmcm6yesbBMWHmG+wVnrSDOLgLHL0YYPZXmCruhn7k1dpCxjWD2bHS4mPz6MospiCk9h64cvnYjmsYHOhxfVwrXP1DZDimAWar6BpMb9FnS7VMNp/goj/EVK4z12CmkxECfVFmLvqq3qfghJhtNMAMhyk49ddWGiymjPemyHsrBFQbveC4z4JQldm5eBcE114W3rRyHebO/Ts47V+cWUmLj9wNNxMMuHutm3D117evQocf1Ry5wsY+z2w0emZULZMsJMiKzeU6m2jaJTkbwtq9mcmz1V8GhUKQGV8xAA37hOFw/ZfMXDBIwUX3H4cQ8z7vrddKVAowN3iQValE0YLYBg+uvW6mZ2DJ5YDPx6kte1fc77wdZdOth1wdM12jHJHUCD7V2mQ1g+kp+myplpktFKecLmY7M8Ccm/IzvXWEiVNO1fvkC0Hm/MUsY1/AYle8foZjNhgk52InueOEmGkwO9oJKm3o2ei7yDdVKFG0ILLBg2uvO+WPL8lMbr3uKqatyjMHL0WG2X3d/rrHnK9RjigX9N6yF6/I5PW15iX6bKmWmcz1AnA+05lT5DOXbM4MDzJ5Tqp2G8o6oSu39QYstkSrT6cvmAoEybpoF+k4IWZt7wWYlTb0bPSWiUMV1p0u6KZe7F7kiMVIqW1kTzzKS4O1N/QcGdnD+Hjt8kbTNcoRJSt0+FHNoVPk3rKx3xVUW03kixnM85lY3W457TB9TjgbjSGJBI6pnGXNOIuZikTAYrjaQrwyk34/2XT9qe+cEyRj1Q9YO02kQkBV6bqNpLdKiSLY+NnbjcA3PAxA33XXkJXar2FHLHJ7qmcxQ4EAKan+up31aYDZKum8vta8pKXv+iJyn4i8KCJHReSXKtz+r0XkiIg8IyJfEpHGakWojnYhU9w9fskfxqHzdlZOnhXOBcMwkCBbZad7qjzA9FnE/VI3oEjaftIuMphZx5tdPyqttwxs8ACzVikibRfZ+S7H+hkZGeSFWO3M5ILjgV4G+iqfE+qVIZq2Aqsq3q7qy2qA6SktexWIiA18CHgbcAD4fhE5sOxuTwKHjDHXAZ8AfrdV41Hr72y2mMG8HAyRL3TeNPnMbIiU5SffnyBTpdh6umyzTswviAi7667DFOZd9C9Pd3CP9lqWF1mHjd8ysVqJIoDgBg+uN4JzvijZqw9ClaUwlfTt2l7x+npliAxCIuHN13any+T0teYlrXxbuAU4aox51RiTBT4GvKv8DsaYrxhjkqWL3wDGWzgetc5OpYsZgFnbT7rDShUViOJEimNK9saqFlufLwswFzJ322L1p7WTufoZ24zxZgYzVCGDG9jAWTx/jRJFC7dX2WCuOsgZX2PnoNN9o1gVnlg3ZYhi8c46320UGV2D6SmtDDDHgJNll0+VrqvmfcDnKt0gIu8XkcdE5LGLl2eaOETVKg4hzl5Z1yikCp1VbD2f76HQXxzfTDzG7FTlNZPJwuJ6qoWp8ZEaO4oXzLnYRZ72YIDpt8BfIZj0W8We5BvRcLh6iSIAESGm6zA3nEkryPjWzSuud1OGKBDz3mvbC9JZfZ15SUdMbInIDwKHgN+rdLsx5sPGmEPGmENDA50VqKjK8oUE58OLwVmntYtMZ6LkeotZholYlNlLlae95/NlAWZpKnQgaNUNpmZcBJhJF7UyO01flc0uIlJzGtnLNrnY2NUb0B7JG5Fs2briOjdliCythdkSGV2D6SmtfEc4DWwpuzxeum4JEXkT8CvAO40xmRaOR62jtJNgzlrMCs7kOuuDQXo+TDJRDDDPRWNMnq184popW0u5sNbOtoStdcoVuQkw5z0YYNYKpDZqP/LBGiWKFmzUn73bvRIdJBxcOrvhpgyRE/Lea9sLMvl2j0A1opUB5qPAHhHZISIB4D3A/eV3EJEbgD+hGFxeaOFY1DqbK/QuuTyZ76wMZnI2yExpsf7ZUJip85WDiNnSFLnfAl9Z2nJHvHaAOZWp/wYz53ivnElPjd08lQqwbwTVsrblKnU3Ut6Xx2Zs99LiJm7KENXq9KNWL5Vt9whUI1p2VjTG5IEPAA8AzwMfN8Y8JyK/ISLvLN3t94AY8Hci8pSI3F/lcMpjZpy+JZcnOmyTz9xEgInSYv08NtPzlTflTGeLbxT9y7JY45HaAeZ0Ply39uesi53mnaZWELlR20Uuf+4r2ag/u4LpTYt7Ty2xmLbq17id11qYLZHK6evMS1pa5dkY81ngs8uu+7Wyr9/UysdX7bNQZH3BhQ7r5jN9weL8rsWgMheNUzBRbJlfcr/JXBjCxS4+5QbqrMubD4ZwCGMzX/U+M/n6tTI7Ta3NLBuxJ/f1/QFXGcyobvLZsE76E2wZ6OXi5Sl6eqIkXZQ6mvKFGiiIpNzK5ky7h6AaoB8HVEtczC5dc3k+3WEB5iWb88HFAC/fHye3bFofYKoUBC6fAo34pGbgMR8MUSjUKci8yjWYw2FrRcC7XqI1MpgbrZuPLXDPiLtMlPYj39h6dhanyaN1amAuyGATCXnvA2SnS+ouck/Rs6JqifPZpRnMc9l4R7WLnJ6PkC9r95bqjZNJLX3zcAgybxenwypNDe9OVC+4PhsMkq8zBT6Va2wazW/BO7ZG+Jd7EuzpaU8P82iNIHKjBVn3joRd74zfaMG1Wupk72YskYbKD8UTnde9zOtSmsH0lI31jqA6xulM75LLE8EQjumMLKbBYjaz9OQ/k4iRnFtaWsQxYeYCxQCz0tRwrZ3kU8EguVztDEYjAeahwSAfuKqHa/sCWIKrnuitUKtrTXgDBVkxv3DjQP21dgsqFZ9XG8e0FWTLttGGyg+FXGY7lXt5RzoqUaFq02dKtcSJzNIp8suBYMe0iyyYOLnE0l3tl+Mx5qaWBoQFJ8SMr5gprDQ1XKs+4qTfTzZTPYA0CJOF+gHmaMTmx/fGectYeEkP9AEX6wIX7Kyz470RtYLIjdQy8S2jYfwN/DwbuZORKjJbtlFooPyQ30XHH9W4DH3177QKGrg2n/5GVdMViHHOXnpynbWDpPOdEWDmcnGyvUvHci4aY/by0kCskA8yWwowK02BJvwW1WZQk5af6cnqGQxDiBm7fobsvrEIQxU6B/U0UBLo7k0hVxtV6il28al+e2CDBJgjYZu9CffZS4CgBpgb3qvhfmbD7sutmbD3qkR4weXMSEuOO+NsqX8n1RANMFXT5QoJLvtWTg8nC51RCzOTiTG/bH3UuUCY6WXdfLJOiLwUg7twhSlQy6q+DtMgXDhfvbi8Y0LMBGoHMZbAYKjySzTqr99NaEFf0ObWobVvOOgN1G66HdwgDbnvG49gNXhmtC1wUc1IeVhebE753TeMSEU643y30ZyY6W/JcY/NjOHQnrXtG5UGmKrpkk4vjqz805rrkH7kqbkQ08vWR+XEZnJu6XUZp6yLT5Voblus+vTzmdPVM5h5J8S8VXvqenvMt6S4ezm36zBDthC2YX9PoFZs6Eq9nesbIYN5oNfPaGR1kaK2i1TlTgd7sCqcB9XaPH++NYH7ickoadOa4LVb6V+/arpZU3mNzEyHdPOZnw5yKVoM/rbFFoOCydTS8aWd4jS/z4JqsdVouHqQePFCEIfKmcOcCUOdSnm1dqkDjEXrBzTjURsRIeITDvSu7dN5vQDKtsDLMZYIvH7z6qc1EwHvB9iqeTLYjGweaPcwNpwnTjS2fMWtY5dCzORbs76zW2mAqZpuskI9SYDJfGdkMGcv+7gQKgaPV/cunqzmg3EKLK4dTZtisNFTY2p4oMoUNoATCZPJDle8LWPqbwCo1+98yEUGc7Ss49CNA2ubJo+7WPfp5j6d6rahYM1WmPVs1FaZavUiw0PtHsKG8+wpC0ea3ynp+XN+Lqc64z1qo9Azomq6iVxPles7Y5PP7FSAi6VewdtifhbKN6Z74+TLOhClSoXQ+2oEHX5LqmYS0wNxZqYqfyLOUjtTZgsM1FnUN+hi0V/5TvexiI/4GrrtuPleLwdZB3rXlhnRdpFquWRv52Ywd+7Z3u4hNCwRixCPx5kubG7qcQ0+XjgL52Y74z1qo9Azomq687neitd3SrvI6XQUU5qeTvjlylrG2Z4Y6cziNPl8oSyDWcOueOWp5wuD/UycqbwOc2H6vZqdcR92nVenm2xb+e5xS+DWodV/8q/VxWeBV9tFhn3iKiNcS602mqo7nQ72YDe6Y2wdRMMhTmw/gM/21pqWwdFh+ob7OTs32NTjpkw/eSOcnNIe8s3UeX/5yvPOZitPM5zPdMYazKlSx56+oIVtCSOlMkCXolFSc4uZxXmneLKpN+07Hqk8lf3qQB9nj1a+LeXUPpHtqbP+EiDms+pu3Flezmgt6zDddKuJeTSLd12pgP1abLRORmrtMthsGqkfDAV8vnVtLTmyaytzlp/RLa0p+dMyA4NYvX0cneht6mGnc8XNPa9e1F3kzaRnRNV0J9OVp8jPZyNtL2Zr8DNV2s0+VgoMB0uZq/PRGPNlxdbnSq0e6wWYQ1XWYZ4MxTlzonKmMllnDeZYnfWXUNxUM1ijvmVf0FpRLDzmt9i7yjaTbjr1eHWaeLW/k3IRzWCqCiKb6q/DHN85zubrDqzDaIpmh0YBsEdH1+0xm+FStI9kNMGzp5pbxP5isheAF897K6Pb6bz5bqA6lsHieK5yBvOyP9L2dpF5J0G6pziGhanx/tLW53PBCLNlAeZ0KcCM1pmrjvqEaIXgIo/NbHCQglmZuZ2r0cXHb9Vff7lgrEr2FIo7yCu5aZWbfUIuAkwvBlk+CzY3ofWmm9+P6j7zifqlb7IjY7zYO0Z/X+s3mfT1xjkRKD7O8diQZ0opxaJhLtgRzgfjfOuY78oyp2Y4PVN8Tzg9JRRasIGoW3njL0t5RsEkOOervIHlUjBIrs3tInO5GHPx4qffhR3gPaXyMlnLZiq5uGZyptRLvG7QJMLOKuswk6MDJNMrd5LPO9U3+exO+F1P1w5X6PKzoFoJpa1RX8XC8bX46nTxWdDocTvBVb1+fE0IDjXAVJXUW4cZCQV5LdRHXmxi117T8vEM7NjKQom0pPgZ3+qNafKh0eJ5NCl+nECcNM1bh/nqpcWgMuV07sYsr9EAUzVV2vSSrVJAfN4OkGlzu8h0KspUqcj6QuHwWFnkNFE2vT+dK550Qi6Cpi1VsoUXhgeYvrRyycB0vvqn5GqbhiqptZO8Whcg26Lhzj71uvgscDON3mnWunt8gbaLVJVkpfY6zM07t1zpGPZSeIjx8U0tHc+l/qU7sO3RsZY+XrNYA4u/w96hAS6lmxcYv3Ru8Zw7XWWTqmqcBpiqqeZNb83bk23u5pOcDXG5VGQ9XlovGLTlSubtUnpxOnuyNEXuZnPLSJWp6mMDA1w6uXK90EyhegZzvIFOMrV2kvfVqHp+dYNBVb0uPgtqBVk3DQbY01N/bel6EoEtNZYZNMJnseaNQmpjqrUOc354aYCX3nsAaeL0b7lNw/2c8y2tbHEyNoS1Dm1eg37/mnatX44ulnyzens4Pt2cougGiyNnF89vl5KdsRl1I9AAUzXVtFP7Rb+adpFTs/uZT29f5YiWmp8OcjYUIewTypfdLewkn7YTOIQwWEw5QSxxNzU8UCUAOxGMcvb0ygBzqkqAGbCht4Gm1tXKAlmyNDO7XE/AYnvcfWDltg1isEYwftNAkO/aGuONo6vvltNsu+K+prW4FBFP1wFVrTPfU3natSce5Xhw6QzHKX+CHfu21zye37e6D0Xx7VtXXDdn+Rlbh93km8aG2X71nlV9bywSWhIYz0d7OdKklpEZ+knlFy+fnane4lc1Rs+GqqkmC7UDzOlC4yeF1w7386n/Or6ky85qzc4FmfYF2Ry2l0z5bioFmDPxGLlCDw5h5vwBEn4LcfHp3m8vljsqlxebM3ODKxakT+UqT5HvSzRWLsdvyZJalwtGI3bd49w66H6afHuNnuvlAlUetC9oMRC0sErT8z+0O9YR6zWv7mtu27kebRepKjgdSFTM3g3t2FJxs8rZrfsqBpE+22b3zQdJveE+xl53Fzv3bncdbFoinOqpHEj612E3eWBwgOMjOwgGGq/YMDi6dB37uWCMJ040p6zTTG7pJqwTk7rJp1k0wFwnzdzx1sku5iuXKFowlWs8wHz2nywuvJLn0S/etNphXTFdagW2aVkwuLCW8XIiRjYTx3FCzPj89NYoA7TcjioZwaneIfLLFo5P5Cpn8XY2kFVcUKkOZ63d5Qu2RX24SZYGbPfj8lVZqnnTQHBJoD4e9fHje+NscVGOqZW2NfnxE/6Vv9CegMX+NfaBV95WXIe5Mos5OVg5sJu0gmy7dt+S60Y3DxF5/Rs43L+dvNi8EhrgyI6D5N74Vnbccaju2s2xLZuYsioHZSfjwy2fJp+N9TIrAbZcs7/h77UHl65hTePjfLqHgqx9NuRSaul71isXO2sZj5dpgLkOHAJMZVc3NeA157K1A8xLDRZbT+fHuPRacf7ikY/lOH/h4KrHBjBR6ia0vGvLQjvI85EIybkIBSdYDDAbmPKsVnD9wqZ+5pd1nrhcZZPP6CrWA1baSb48gK7EZwu3DNb/tH7rYAify7SqJZVLNu2rUDg+5rf4gZ0xru9vbhbRrbGoXXMZwWosb6e5M+7jfXvi3L6GDkpqYwhvWpqFG+hPcNpf/Xx4dGg7sWj4Stby2HW3c8FeOYuTxsfz8TGOXn0b2++6teo6R9/4lqqPNWsFGB1r3eYi27I4Eyi+Nxwd2ko03Fj2sXz95YL4QD9T+bVnXk/PLn0OXjirAWazaIC5DmYL47yc6Y4A81S2t+btl7KN7SI/e3zpCeSTvxklW1hZ9sety6ni4y/vL54oXT4XijI/GybnhMmJ78r1blRrNXisf4DJC4trTx1CzFgrg6qwT1Y1xVppt7jbOprXuJgivrbBaeTl6xBHwjY9VTLBtgX3joTbsjmm0Z/LjfJORncMB/neHTFCvmI7Ul2e2d2W18Ps276t5v3T4qP3ppuIvv71HO7f7moW7IXoCEN330kosPRv22fbvBarfd4MjLVumnx40wC5Ur3NND42X3uV6++NhoMrNiYBSF8fZ5rQMvLYpaVZ0MtJyKPrMJtBT3nr4HRuB0/MdkeAebxKF58F5xrsR/7iw0szP5k5h8//2X4MjX/KdAgx7St+Wl0eBC30kc6IzUw6RrZUp7KR/tIJv1UxiHgtGOPihcVPyY4JMWOvHP++hH9V01R9FR7U7a7vvqDFthrrK3fGfQ0tE4CVnY9uHKgdyEX8wu3Da1tPdcdwkK0u14ku2BFr/rR1xG9hCXzX9ij3bl4MnG0L9ve0J1OrOsOpQM+S7OL5ZeWCKjkaHuC83ViwcyzYR+Tuu0nEFrOd49vHSEnt18fpxHDLdq9Hh5cGgi/0jdMTd/dzDY9tggrjmo0kOHq59vuNGy+fX3kemNdamE2hAeY6eCG1ja/PbcdhY7/BGPwcz9eeAj+XjbpuF1kgygsP5glfvYXwvsVP1698M8sLT9/c8PjyhQSz8SiWQHRZEGRbQm8peziR7SFjSgFmA2kny6q8GcYRi5MziyfYHBEca2WGcTXrL2FlQBf2CS5myK+oVRPzllVM7S7f2e6mr/rNA6FVZzGv6vXzupEQP7grxk/uT3DXpiD1Nr33BS36WrAhpz9g8WN74+yr0HqyGe0olXflxLpSD3NkZJCLduuqKZzxxcjffjeDA8UAzBkbr/s901aQ0bH6bS1XI51YOsWdx2bgGnetMcvrX5Y7H4jzdIUKHY0RDp9eebKYrrPUS7mjAeY6eGx2G0f9PUzna0+JeF2OXmZ8tYPoiUCYgst2kZMTOzAFw+kb9vOP3/lmwrsW1wg98MeGmfnGssKZbIzJaJShUOUd1ptL6x8vpROkneKJK9Jgb+3tVYqkn8iOYCjeljeV31iq1dKsx2/Lkqn88ajtqij6gu0xX8WALOKTVW2CKe9Hvi3mWxHMV7LaLGbQhreORa5sIOoLWtwzEuZnD/TwPTuiVXe/H+wPNPQ7cmskYl/pbb9cI/VN1cYULtXDjG6tH/Ct1YQVYuKmO9m2Y5xXw/XbVQKExhoruu52xuVcqHfFdS/ERxjor1+2bjJWuTJJBptXpvtdJywqydLDbHbl9ReT7a3XvFFogNlieRI8mttMXmyObfCNPklTv/DtpUCQvMtSRa8924sdDvDw1q2c9Ud54LveQmhr8dOsMfDN++tPMZXLJCNcjEYYrfJGv7CG8ny6h5RTzNw12lt7c5XU4fmBATL54hqoTIVySzG/0FOlpqUbY2U/U7UWkdX4LOHmCiWLbh8OUacNe0Xlv7Pr60yPl1tNFvOdW6IVnyO/JexJ+PmBXTF++qoEbxkL01821b+7gW5JzRL1WxVLWanuMZfoxxLhdJVyQc2WFD8v7r2JPO7+7s70bHI9TT4yMsjme+6se7+B/h7mrJWvN0csogdqZzEjoSBnKqy/XCDxAVJm9WvyZ/KVs6NnZtZeEk9pgNlyl/PbmbSLwcpT87vaPJrWmnURYCZ9AdK5+hlMg8UzXzBYN+5m2i4GPyeDcb78ffcRGit+Gn/uS1nydToHLXns2RDnQpGqm3EGSwHIBelhutTRJ9RgxFNtc83R/n5mp4vjTpuVJ6+regOu6m1Ws6nsZ3Kzg3y5a/tWBpjXrLK0Tnm7yJ0NrHNsNIt5oNfPnkT9YDoesDg0GORf7YvzY3vj3DMSqtlis5WaXXdTecvpQA9bto1WLRfUbpNWkF0Hr6obZI6NDXPu4K28EhpgoK92tq93pPq0+0vRYUY2VV/vODw2TKX1l1f09HIxU333e05qj+1yqvJU+PHJznx+vEYDzBZ7Lbfjytdfndqxqs0pXjFVp4vPgpRTf/ohldnC9LkCrx5YGpQfCyV48D33ERzpxRg4e9J90D6bipK0/FWDwIVuNZdjMc6XFo832uUl7JOKG2yOh+NcnugFIFVhirxSGZ9GlAfNlQqv19MftJbUpNzf63c1tV3JwrKCfT3+houpu81iBm14y1ikoWluEWE4bHPXphBWm858OxrciKQ2lpxYTO9yv4O6HQ6P7GHz6+6quglny9bNnLrmFtKl97K+HbWXfhV6a70vCPmrryMarrzWe3n9y+Vmowlem6p8/LO5q/iLp++u+f1nZyvPpr16Xl+nzaABZos9M78YYL7o72fWWdmqq1PljLt1OwsuF3pd3W/GxRT5mWMjBPpjPDK8chr8pUgv3/iBtxIcSvD0P7nfYTmdLT5utf7dC5tTLkQinDkTI+6XVW082VUhq2YQTieL02LLM5iWwOY1rs8rDypX266wfLPPLQ10+VluoV3kwVXUt3SbxXzX1spT451uMGS7Km6vNq5KJXc6zauhfmZvfx07925fcv22HeMcu+omMrjfDX8pXDvxcMqfgDvvYdPQyvebyVjt96BzvjjPV2gZmWaAn/nkAT75RIiCVN+oeGyy8lT48+c0wGwGDTBbyGDx8MxiQFnA4nib1mE6hLgwdy0TaXddFApE+PjvXNtQD/Dz+V5X95vJ1c9gPv/1ALlDe8lZlV/oR6IDHH/HXbz8UJac464W2kSmmJWsVnooYhdLzJwLhZnOhVz3316uWsH1V+eKUzlzztKT2r4eP/41FoJcKPDdF7RWfaydcR9+qxiAN7qOs1zIKgbmW1fZJadeFvNAr5/dq9xx326WwNW9Ok2uOl9S/BzZcZBtd95KOBRkx55tHN17w4r1nBftMJtHKp+DY9Ewl3z1d8tftsOcu/EOduxefL8Mh4KcrROM58Ti5emlj23Ex+88eBdnp2E+A6dSe6t+/8sXKs8czWYMWXQn+VppgNlCKTPC89bST29PJtcvwCwQ5dTsDfz9M+/gx//mO/mhTx3kd55+Bxmn/qLopx+6ia9vHufLn9rvepfemVyvq/tN5WuvwcybBK98I8dz+2tPfz84uoXgUIJTx3bUvN+Ci+kocb9Unfa2rOJUc9ryc7G/x3UtyeUqddYBOMomCkSYKyz9RH2gCW0Eg7ZF1CerDuqguNnn0GCQ24eDa5pCDtjC1X3+hpcXLIj4hduqlE4K+4S3Njg13mn2aLki5SEvxkYo3PMGXth5kEKV94LItspdgoY2uy97lMHm+V3Xs/umaxGETaPDrorLX5Jh8rIYiH72tXv54pHF8+DXjlXfGf/cqerny3mnsRk8tZI30wAeca6wc8Wnva9M7+Bf9FsITksf+/DEHfza/eNcyBQACAUgcvcdfNkXZe+z7+RfHvwIQq7i907N7ufzL29n7qar+dqRl7jx1PWMjT9R9zFPpN2VdqjXLvLyxe0Etw7xVE/tzGRWbJK3HeDJzz3Gjg/Uf9wLmZ66rRg3h23Opwq8kuhjxyrrJPYHimWQHLP0+lf6+0inh5ktLP1EvyXanIBjLOpb8y7lg33BhtdNLhcQuK7CpqFG3DIY4oXpHONRm81hH8Mhm96ARdQvLe+Z3Gpja8gOK9UOM1I7636yZwRLBMcsPelZA40WLBcOD+5kzz0JrFzG1XeYRA+T+c0M2Ud5LXU9v/X5pZnHTzwe5b1X+bDIL7k+R5zLyerHncz00Ne6UqVdQTOYLfRSZmVm7TkGSJrGao01ymDzB1/dfCW49Nk2vXfczhlfDIPw0fitfOu1N1X83gJRPvOpA7x4cB/Px0c5cf11fO5LuyiY2sFjKjfO0aS7T3wX67SLfPXJBLM37Lny6bXWWshH9u/hxDMOmXztsh9ZZ4jJUKzuDuuFzTJng5EVBczdsi0YqxDIHg/HmZobWhJgjkXtpq0lHAnbVXfIu9UfstYcYPpsWXPNx4hf+In9Cd6+JcpNg0G2xHzEA5bng0uAkE+WbKhabihkeTlBq7rQjAQY37pyLeZ0tHdVx3s5PMiRhLv3yZlIgtOzQyQZ4ac/sXLW6/K84Xxu94rrZwu1ExgX5t2V01PVaYDZQo/PbV9xnSMWxwv7Wvq4Z9IHeOFi8WtLhM133sZrwd4rt09bQf449RbOzx5c8b2Pf+M2Htq+l+f6imthXgn28/jevTz1rRurPl46N8Z/f+w9nLXc1Q47X6NdpMHHs1+Cx3cvBudv2BzmvrHKHyWPh+IEb9jJiZdr72R8+NP7mYxGrpQiqmahVqJBiDdYZL3cjgprBA3CmfQoU/nFn+W6JpatGQpZq57Wbza7Hc3FPeTqvspZ65GwzQ/vjvM92zt/I4hS5exl3YKCfj9nfI21Bl6Nc74oz5zt5z88cDuTVTKSj5xYubl2It1b87hnphvvYqaW6ox3ow3IIcCD85XXpTyVrL7ouBk+fXgnAIKw7Y6beTm88pPaC+EBPvTi28mWrcecmD7Apy9fzRNblm4EenLzbh44cxVz6ZUZ2XR+jP/1yPfwt5uvcz2+c7kYpkrh3/nUVgqbNvNKuDjN4beKrQav6w9UbL8H8MoNV/H4Z6oHahcvX8uTn8lxMRylt84W3vId5mvJLFabij+W2sRUYXH6eHsT+2H3B+2GWluq9tleIYPZG7B4z84YAVvYnfDz3RpkKg85FhvC71v8ux7ePIgjrT8f5cXm/pfG+eZr1R/r40/EV+wlODdXO0N5fEIDzLXSd6MWmTbbuWRV/gP9ylTrCq6nzSb+zxPFF/muWw7yfKx6CYnPDe7lE4+/HUOAAnE+8fVbePDAyoXceWwevu46vvxPB5e8SDP5Uf7ya+/ir7be0NAYJ4Khqu0iTx0d5uLBxY1QhwaDBOziurtvH4+s6HMN8NCmzUxMRkhlVwb0BeLc/18SiGVxNhSqW8InVpa1DK+mjU3JUJVM6bPzo0zmi5ne3oB1pf95MwwEKrfAVJ2nN1jclLUg7BN+cFdsyYeavT1+3r2t+qxAwIa3b4lw06DuSlftlxYfW3YsZjGDdWpYNlNsoE4ppAm4nN+55LrjVUoULXhZa2GumQaYLXKyUD2IfLowQIrG2hy69c0zV1MwsPuafRzuqz1tbBD+rP82nnj5jTz85D18et+tJKVyRu2cHeULmw9x+kwxmMwURvibL307f7HzFlc7/cpdCobJV9hJnnMGeObLIb6xbXHcB/sXs30hn1TM6uTEx/wdV/PakZX9fR//0vXMXCgQuHkX2D7q7YEJ2VypUxhaQwYz5peKaxmPBAY5M1P8Ga7rX1v3nuXaVTxcNc4S4ZrS8gi/Bf9iV2xJP/kF+3sDfEeFIPO24SAf2N/Ddf0B7h4Os8oN+0o1VXbz4rrJ+Xjvuj1uIVH/sR49u/T98OjF2hsRXzxvranPudIAc9VezdyNQ/UU+uFU9dI5jlicLLirR9kIBz9//vAAvYkYL4+5K4c0bYf448xb+F/+N3K+Ts2xbwxs5f5nb2E2tYu//ezb+NN9d1YtW1FLyvKRLiu2ni0M88SDd/E/fnIPl0JbueAvrlHcFvMt6R8Nxannezev/L0/tHs3T3zOvyTYnZ7dx0MfzRHeMcw/vOEuRsK++gGdCCOlXb7BNaQDRYSdFdZhHo/EORcs/p7b0Q9bdY5dcR8i8P07YwzW2Jx1oDfAO7YUg8ztcR8/sS/OGzaHr3wAiviF143odJ5qv2PhfiKhIJYIZ4Puqoo0w9H4CLtvuAafXf119Mknlo7n8Kna2YZMHrL0NmN4XUtzwKswzxZ+8vR7+eVNY9wb/VjF+zw0XTt7+HRqD3tjX2nquE7OX8MrEw7jrzvIuSprHCs5HHNfSuITe24i8xnhkzfdSG4Nn0+ShTih/ChPf3Unj3y8gCkUS0icuWZxt99tVTq63DYU4pWZPCfnF8tOnArFmB7Yznz6FLHQqziEuf8PhvAnAjz0nW/goi/MzS53Nm8K21xIF1jDDDkAtw+FeH4qt6xckZC0fARs1rzjW3nbaMTHd2+LMu6idum1/QFGozb9Aavih6QbB4I8cjFDKm8qfLdS66OAxeiurcxenOC4rF94kROLw8O7GHz9KIOvHuG1V0+tuM8L5yymna30WCfIS5SzM/UTCLOFfoL2RCuG3BU0g9kgg80fn/shLlsR/tP5NzLH9hX3yUkvT+RrFzP/0vTKsglr9X+f2c6O3Vs5Gmrd2pcZK8D/vvk20tba1n3982d28j9/YisP/20eUzCE949y8UffxINjxXWUYZ+wvUp9SEvgO7dFWN5o5+WD+zn2TLFc0XOP3sjEKcNr73kDz0eL5ZOGXQZ0g0GLvibsxh4O21U3alzbF1hzAKu8LWBLQ0XXB4J21Qx8wBbePKpF+1T7zQ6PEt+0fusvy12yw7yw5ybG7rmT/r6VGdQnzxdnFucL7pIqky5rO6vK9C2uQU+n7+MT6WKZoVkryH8/9wMr1mlcdHaTq5NBfDy3iYy473JQT9IZ43MvhTiz40DTjtkM8QqbcgAmpkMYA6G9mzn/Y/fxN9/9dr4wvvdKj9vbh0I1A7CY3+LdW5eu43x40yhPfaOXudROvvQnBVLfcTtf3bRYnqLfZdDYH7SbVu5nd8LPmyq88e9L6MYM1VxX9QRWLClRar0dD/QwPTTa1jG8Eh7kwi33sPvg0vfD+58ubgaayKzcFCQV9hKcn2t9maWNTKfIG5BkC//u7Dsp/zv8eHo/78q+nn2BL1257miufutCg3Da2c9OudiUsT184gAj11/Dc9baOqisVdgn7O/xszvuZzRiE/VbvDyd4++Pz1Mom727tGuc2ev28PVNY+RlZTB+bZU6geV2JnzcMxLia+fSQHF65syuq/jfvzqF/+6r+Oj+a5bcv9ImikoSfqvubvNG3DwYYDJb4PFLWaCYgR1dYyFypZazLXjLWISPvTrX7qGoriac9Lc/85fH5vDIHq4OBnnlW08C8K3jNvOMrChRFIuGidx6K4GXX+DUyXNXrj89E4FN6zrsDUU/7rpksPnj8z/MZVmZjfrVM99BjsVPRE8k3fXGfjrbnHqYjoT41NGdHOlZuYt6vezpKW4++LmrenjbeIQ9PX6ipSBtT4+fH9sbXxLg/cOufXx1ZGvF4PJA7+L31nPHcIhdZZtpHtqzGzM2xt/dffuSGmwiS0sQ1RLzi+tg1A0R4U2bI1eKr+9OrL5Pt1K17IjZNbsEKdVtnuvbyo47br7SBezwpT2cnFpcujQ81Efhjns44e/hwlU3EI8uvscfu6QzTWuhAaZLT2fu4+9SxYDQZ8EbR8MMhIq/vmP08H8nvw8Ag8VX62zwWfD3l65lyll7kPnazHWc2H6w4XJBzXLv5hDftTVGf8imWl3dgZDN+/bE2V5hZ/VyhwbdZ2EtgXdtjV6Zij8TiPLx73grc8vWiL5upPaUezmfJU3fgGNb8O5tUQZCFgd69aSlWkNEeHOFrldhn3DvSIj374vz7m0RrukLoDX5Vbd4Pj7K+F2347NtPvNsP6+UShRt2zHGhRvuYLJUs3pGAkRvvuVKMPrSOf2wthb623MhyRb+zdl3AsXNGW8YDRH1WdzYH+Dzp1M8O5nlg1O38vqeh4nYE5wyS9PvEV+xJuLltLPk+udz/bzztX/HLyQe4tsGP4Wf1e1W+9zlO5rekqs/aHHzYJBXZnMcnclXvI/fgu/aFmNnwt2fUdgnfN/2GP98PsU3LmQq3qc3YDEWbuzPMuQT3rMzxp+9NItjihuRFgRs+O7tMbbHGjum2w1BjQjawg/sjGG36YOA6g4jYZsDfX6OTObYEvVx+3CQHTHflfadgyGb/b0BCk6Ei+kCx+ZyPDOZXXF+UqrTXN8fIO63ePB8uuHvfSkyxK67bufhh79J2Jdj93X7eG7zvhWJmdeCvVxz03UcfexpXrlYbF8sVH4PVLWJMa0rayEi9wF/CNjAnxpjfnvZ7UHgr4CbgMvA9xljXqt1zEPX7zaPfWRlX9FmM/jIOz1kCgn+2+X38hX28+3jkRUlRYwxPD2R5XOnU9zlO8OPj3yZHzr5g0AxALt3c5jr+wIg8PXzaR6pEljtzE/zq5s/x7XRLyLkXI2xQJQnLr6Zn5t7J5k6JSGiPuHWoSBjER8nk3lemMpxLlVYch8RuKY3wE2DQUbC1pVPcVMZhycnMjx6KUO+9B7UHyy2tVvtZpgTc8UyQ2dTBU7O56+UV/m28TDXD6xuHemRqSyfOr7YjHZzpLiLO66pGtVl5nMO6YJhwOUHJWMMF9MOh6eyPH4pQ05jTdVh3jga5pbBYnOKM8kCn3xtjtlc4/HL1tw0sdQcRxJjNe5l2PfSExw/doov/qsHCXPB3cH9w3BgZelCEXncGHOo4cF6XMsCTBGxgZeANwOngEeB7zfGHCm7z/8DXGeM+QkReQ/wncaY76t13EoBpsGHwUbIIxSqfGd1OdPHydS1PDmzn9PZXk6mejiZj3M+GCYXDPG6kRDX9wdrTrGeTxX4+LE5BrLTHLcS3DYU5Lah0IpuLifn8vz98Xnmq9Sreyuv8VOb/4GR4LNYVP6UZghwZP71fOjsm7FHtxCxLc6kigHbXNkLTqS4nvHG/iBjUd+KNoLpvOFcusDxuRxRn8WBngCRKru+AbIFw/PTOc4m87xhc7ip6wjTecN0zqEvYK3+uMbwxTNpHr2U4eahIG8YCV3J2iil3Mk7huNzeR6/nKk6e1FPb8DilsEg+3r8hG0hayBTMKQLhlTeMJ93OD6f5/mprAazqiZL4Lu2RVeU9MoWDF84k+SZCXcJmUZFTI7EN7/Gn3/3Iwz7XnL3TRpgLtHKAPN24NeNMW8tXf5lAGPMb5Xd54HSfR4RER9wDhgyNQa199qD5h3/3/8glzVkskIua3AcwDjYIvix8VuGoE/wicNoeIZ9sfNsD59hOHCGeOAMPpkiXdjM0eRB/nnyGv4xu5cLvsVOGL0Bi4P9AXYl/AyH3Pd3TuUNj1/OcG1fgJ4amb103vD500mOTFV/YWzLzvLW/le4ved5dvmfIcJpDBbHnLv4s/PvILBpB/sqbBbJFAzTWYfZnMNoxFexXeFGVnDg+Hy+YhcdpVRj0nnDmWSBo7M5npvK1izk7reKBd+v7gswHFqcAanFMXA5XeD4fJ4XpnOcmNOpSLUo7CsuK9pUrcevMbw0k+fTJ+Zb8kFlPDfDb4/+Ffuj33L3DRpgLtHKAPO7gfuMMT9WuvwvgFuNMR8ou8/h0n1OlS6/UrrPpWrH3XvwRvPW//kAQUsI+YSAJYRswW8JtoBPiv+3RbAtKDiGZKH4iXk2Z5DZeRKzkxyLDJAPBvBZQsAqbuyI+YRtMT+9AWlqj+hKjDG8NFOcpo7YFhFf8ecJWcWfKV0wzOQcZnIO09kCo4Vz9ATy2IldjIV9VTfTKKVUKxgHJrMFTqcKCBCxhWDpnBW0hbBtrbl5QN4xpAqG+ZxhvuAwky2eA7OF4ubKgFU81/ss8FtC3jHkHMg6pvivYEg7hmSudJy8QzJvlnTTEikGwyHbImgV+8IbYzCAA5hl973yNcX3laAtBG0IWhZBuziOgikG46mCw3zeMJ83JPPOlSVFy1kCfUGL/qBFb8Cmx29hAXOl96npnHMlUbAwdkvAloX/S+l3UXz8gC34pTjIdB4yBYdUKWO8EHgt/M78pe/ziZB1DHnHkHEMeYdlXcfWzhLoCRQbV/SVarTO5UrvbVmn6kwewGDI4vt3xIi7WIaVzBtmSz+oufKfIin9zoTic20BjinGBXN5h/nSeKZzDpm8IW+Kv4u8gbwx3OQ7w4HwOaK+PFE7S9SfJSJZAnYWv0nhI4PPJPGRxu8LM7T/P60YX7cGmJ5I84jI+4H3ly5mT75l97F2jketXT6b6fUFglPtHodaG30eN4aN/TwanFIEKSKIIKzbRjuDMcYYikHsAlsEd1mM8gCs/t0rPo/Fh3fxMxuMWfjvYtBdvK72KMyy/xeDOfCVfuHVH9JQqDJlaQn8s7R/jdPXXN/T4DiOk03+RrLCje5Ky2wwrQwwTwNbyi6Pl66rdJ9TpSnyHoqbfZYwxnwY+DCAiDyWmp3uuk8CG42IPJbLpPV59Dh9HjcGfR43Bn0eVSdp5UTro8AeEdkhIgHgPcD9y+5zP/DDpa+/G/hyrfWXSimllFKq87Usg2mMyYvIB4AHKJYp+nNjzHMi8hvAY8aY+4E/A/5aRI4CExSDUKWUUkop5WEtXYNpjPks8Nll1/1a2ddp4HsaPOyHmzA01X76PG4M+jxuDPo8bgz6PKqO0dJC60oppZRSqvtosRullFJKKdVUngowReQ+EXlRRI6KyC+1ezyqPhHZIiJfEZEjIvKciPxs6fp+EfmiiLxc+n9fu8eq6hMRW0SeFJHPlC7vEJFvll6T/6e0oU91MBHpFZFPiMgLIvK8iNyur0fvEZGfL51TD4vI34pISF+PqpN4JsAstZ78EPA24ADw/SJyoL2jUi7kgV8wxhwAbgN+qvS8/RLwJWPMHuBLpcuq8/0s8HzZ5d8Bft8YsxuYBN7XllGpRvwh8HljzH7gIMXnU1+PHiIiY8DPAIeMMddQ3Ej7HvT1qDqIZwJM4BbgqDHmVWNMFvgY8K42j0nVYYw5a4x5ovT1LMU3szGKz91HSnf7CPAdbRmgck1ExoFvB/60dFmANwCfKN1Fn8cOJyI9wD0UK3hgjMkaY6bQ16MX+YBwqYZ0BDiLvh5VB/FSgDkGnCy7fKp0nfIIEdkO3AB8E9hkjDlbuukcsKld41Ku/QHwbyl21AMYAKaMMQsNpPU12fl2ABeBvygtdfhTEYmir0dPMcacBv4LcIJiYDkNPI6+HlUH8VKAqTxMRGLAJ4GfM8bMlN9WKq6v5Qw6mIi8HbhgjHm83WNRa+IDbgT+hzHmBmCeZdPh+nrsfKU1su+i+IFhFIgC97V1UEot46UA003rSdWBRMRPMbj838aYvy9dfV5ENpdu3wxcaNf4lCt3Au8UkdcoLk95A8W1fL2lKTrQ16QXnAJOGWO+Wbr8CYoBp74eveVNwDFjzEVjTA74e4qvUX09qo7hpQDTTetJ1WFK6/T+DHjeGPNfy24qbxP6w8Cn13tsyj1jzC8bY8aNMdspvva+bIx5L/AVim1eQZ/HjmeMOQecFJF9paveCBxBX49ecwK4TUQipXPswvOor0fVMTxVaF1Evo3iOrCF1pO/2d4RqXpE5C7gQeBZFtfu/XuK6zA/DmwFjgPfa4yZaMsgVUNE5F7gF40xbxeRnRQzmv3Ak8APGmMybRyeqkNErqe4USsAvAr8KMVkg74ePURE/hPwfRQrdTwJ/BjFNZf6elQdwVMBplJKKaWU6nxemiJXSimllFIeoAGmUkoppZRqKg0wlVJKKaVUU2mAqZRSSimlmkoDTKWUUkop1VQaYCqlVk1EBkTkqdK/cyJyuvT1nIj89xY95s+JyA+Vvv7PIvJM6TG/ICKjpetFRP5IRI6Wbr+xFWNZbyLyVRE5VOH6a0XkL9swJKWUqshX/y5KKVWZMeYycD2AiPw6MGeM+S+terxSl5J/SbH7DMDvGWP+Q+m2nwF+DfgJ4G3AntK/W4H/Ufr/hmSMeVZExkVkqzHmRLvHo5RSmsFUSjWdiNwrIp8pff3rIvIREXlQRI6LyLtF5HdF5FkR+XyplSgicpOI/LOIPC4iDyy0LlzmDcATxpg8wLK+9lEWe2i/C/grU/QNii30VhxPRL5HRA6LyNMi8rXSdbaI/J6IPFrKfv6rsvv/u9K4nxaR365wvCER+WTpex8VkTvLfgd/LSKPiMjLIvLjpeul9FiHS8f9PheP9T0i8i0ReUlE7i67/h8odllSSqm20wymUmo97AJeDxwAHgG+yxjzb0Xk/wLfLiL/CPwx8C5jzMVSoPWbFLOV5e4EHi+/QkR+E/ghYLr0GFDsaHKy7G6nStedXXa8XwPeaow5LSK9peveB0wbY24WkSDwkIh8AdhPMXC91RiTFJH+Cj/nHwK/b4z5uohsBR4Arirddh1wG8VA+MnSz3w7xQzwQWAQeLQU6F5f47F8xphbSp3N/iPFvtQAjwG/BPxuhXEppdS60gBTKbUePmeMyYnIsxRbvX6+dP2zwHZgH3AN8MVia2VsVgaDAJuB58uvMMb8CvArIvLLwAcoBl1uPQT8pYh8HPj70nVvAa4TkYWezj0Up9rfBPyFMSZZetxKrRTfBBwo/QwACRGJlb7+tDEmBaRE5CvALcBdwN8aYwrAeRH5Z+Bm4HU1HmthnI9T/N0tuACMNvCzK6VUy2iAqZRaDxkAY4wjIjmz2KPWoXgeEuA5Y8ztdY6TAkJVbvvfwGcpBpingS1lt40Dp0vZzm8vjeV6Y8xPiMitpeseF5GbSmP5aWPMA+UHF5G3uvg5LeA2Y0x62ffC4vT9gtX26V3oLV1g6Tk8RPH3o5RSbadrMJVSneBFYEhEbgcQEb+IXF3hfs8DuxcuiMiestveBbxQ+vp+4IdKaxxvozjlfdYY8yulwPL60vfvMsZ80xjza8BFikHpA8BPlq0N3SsiUeCLwI+KSKR0faUp8i8AP102vuvLxyciIREZAO4FHgUeBL6vtO5zCLgH+JbLx1puL3DYxf2UUqrlNIOplGo7Y0y2NCX9RyLSQ/Hc9AfAc8vu+jngr8su/7aI7KOYCT1OcQc5FDOZ3wYcBZLAj1Z56N8rBakCfAl4GniG4tTzE1JMPV4EvsMY8/lSwPiYiGRLj/Hvlx3vZ4APicgzpZ/ha2Vjegb4CsW1lv/ZGHOmtAb19tLjGuDfGmPOAW4ea7nXA/9Y5z5KKbUuZHGmSimlOl8pKPu3xpiX2z0Wt6TFJZxKm5H+GbhrYYe9Ukq1k06RK6W85pcobvZRi7YCv6TBpVKqU2gGUymllFJKNZVmMJVSSimlVFNpgKmUUkoppZpKA0yllFJKKdVUGmAqpZRSSqmm0gBTKaWUUko1lQaYSimllFKqqf5/XbqNEgvRxP4AAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -430,13 +617,13 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "epoch\n", + "Epoch\n", "0 0.992055\n", "1 0.991345\n", "2 0.991833\n", @@ -451,14 +638,14 @@ "Length: 98, dtype: float64" ] }, - "execution_count": 9, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# From the probabilities, we can extract a confidence level (ranging from 0 to 1) for each epoch.\n", - "confidence = sls.predict_proba().max(1)\n", + "confidence = proba.max(1)\n", "confidence" ] }, @@ -471,7 +658,17 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "# The predicted sleep stages can be exported to a CSV file with:\n", + "hyp.hypno.to_csv(\"my_hypno.csv\")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -499,7 +696,7 @@ " Confidence\n", " \n", " \n", - " epoch\n", + " Epoch\n", " \n", " \n", " \n", @@ -507,32 +704,32 @@ " \n", " \n", " 0\n", - " W\n", + " WAKE\n", " 0.992055\n", " \n", " \n", " 1\n", - " W\n", + " WAKE\n", " 0.991345\n", " \n", " \n", " 2\n", - " W\n", + " WAKE\n", " 0.991833\n", " \n", " \n", " 3\n", - " W\n", + " WAKE\n", " 0.995557\n", " \n", " \n", " 4\n", - " W\n", + " WAKE\n", " 0.988994\n", " \n", " \n", " 5\n", - " W\n", + " WAKE\n", " 0.986805\n", " \n", " \n", @@ -541,27 +738,35 @@ ], "text/plain": [ " Stage Confidence\n", - "epoch \n", - "0 W 0.992055\n", - "1 W 0.991345\n", - "2 W 0.991833\n", - "3 W 0.995557\n", - "4 W 0.988994\n", - "5 W 0.986805" + "Epoch \n", + "0 WAKE 0.992055\n", + "1 WAKE 0.991345\n", + "2 WAKE 0.991833\n", + "3 WAKE 0.995557\n", + "4 WAKE 0.988994\n", + "5 WAKE 0.986805" ] }, - "execution_count": 10, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "# Let's first create a dataframe with the predicted stages and confidence\n", - "df_pred = pd.DataFrame({'Stage': y_pred, 'Confidence': confidence})\n", - "df_pred.head(6)\n", - "\n", + "# We can also add the confidence level:\n", + "df_pred = hyp.hypno.to_frame()\n", + "df_pred[\"Confidence\"] = confidence\n", + "df_pred.head(6)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ "# Now export to a CSV file\n", - "# df_pred.to_csv(\"my_hypno.csv\")" + "df_pred.to_csv(\"my_hypno.csv\")" ] }, { @@ -573,33 +778,38 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/Users/raphael/.pyenv/versions/3.8.3/lib/python3.8/site-packages/sklearn/base.py:329: UserWarning: Trying to unpickle estimator LabelEncoder from version 0.24.2 when using version 1.0.2. This might lead to breaking code or invalid results. Use at your own risk. For more info please refer to:\n", - "https://scikit-learn.org/stable/modules/model_persistence.html#security-maintainability-limitations\n", + "/Users/raphael/.pyenv/versions/3.9.6/lib/python3.9/site-packages/sklearn/base.py:329: UserWarning: Trying to unpickle estimator LabelEncoder from version 0.24.2 when using version 1.1.3. This might lead to breaking code or invalid results. Use at your own risk. For more info please refer to:\n", + "https://scikit-learn.org/stable/model_persistence.html#security-maintainability-limitations\n", " warnings.warn(\n" ] }, { "data": { "text/plain": [ - "array(['W', 'W', 'W', 'W', 'W', 'W', 'W', 'W', 'W', 'W', 'W', 'W', 'W',\n", - " 'W', 'W', 'W', 'W', 'W', 'W', 'W', 'W', 'W', 'W', 'W', 'W', 'W',\n", - " 'W', 'W', 'N1', 'N2', 'W', 'W', 'N2', 'N2', 'R', 'N2', 'R', 'R',\n", - " 'N2', 'R', 'R', 'N2', 'R', 'R', 'R', 'R', 'R', 'R', 'R', 'R', 'N2',\n", - " 'N2', 'N2', 'N2', 'N2', 'N2', 'N2', 'N2', 'N2', 'N2', 'N2', 'N2',\n", - " 'N2', 'N2', 'N2', 'N2', 'N2', 'N2', 'N2', 'N2', 'N3', 'N2', 'N2',\n", - " 'N3', 'N2', 'N2', 'N3', 'N2', 'N3', 'N2', 'N2', 'N2', 'N3', 'N3',\n", - " 'N3', 'N2', 'N3', 'N2', 'N3', 'N3', 'W', 'N3', 'W', 'W', 'W', 'W',\n", - " 'W', 'W'], dtype=object)" + "Epoch\n", + "0 WAKE\n", + "1 WAKE\n", + "2 WAKE\n", + "3 WAKE\n", + "4 WAKE\n", + " ... \n", + "93 WAKE\n", + "94 WAKE\n", + "95 WAKE\n", + "96 WAKE\n", + "97 WAKE\n", + "Name: Stage, Length: 98, dtype: category\n", + "Categories (7, object): ['WAKE', 'N1', 'N2', 'N3', 'REM', 'ART', 'UNS']" ] }, - "execution_count": 11, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -607,13 +817,13 @@ "source": [ "# Using just an EEG channel (= no EOG or EMG)\n", "y_pred = yasa.SleepStaging(raw, eeg_name=\"C4\").predict()\n", - "y_pred" + "y_pred.hypno" ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -627,7 +837,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.3" + "version": "3.9.6" } }, "nbformat": 4, diff --git a/yasa/hypno.py b/yasa/hypno.py index d67bf82..c52a8b1 100644 --- a/yasa/hypno.py +++ b/yasa/hypno.py @@ -74,6 +74,10 @@ class Hypnogram: scorer : str An optional string indicating the scorer name. If specified, this will be set as the name of the :py:class:`pandas.Series`, otherwise the name will be set to "Stage". + proba : :py:class:`pandas.DataFrame` + An optional dataframe with the probability of each sleep stage for each epoch in hypnogram. + Each row must sum to 1. This is automatically included if the hypnogram is created with + :py:class:`yasa.SleepStaging`. Examples -------- @@ -215,7 +219,7 @@ class Hypnogram: '%REM': 8.9713} """ - def __init__(self, values, n_stages=5, *, freq="30s", start=None, scorer=None): + def __init__(self, values, n_stages=5, *, freq="30s", start=None, scorer=None, proba=None): assert isinstance( values, (list, np.ndarray, pd.Series) ), "`values` must be a list, numpy.array or pandas.Series" @@ -228,6 +232,9 @@ def __init__(self, values, n_stages=5, *, freq="30s", start=None, scorer=None): assert isinstance( scorer, (type(None), str, int) ), "`scorer` must be either None, or a string or an integer." + assert isinstance( + proba, (pd.DataFrame, type(None)) + ), "`proba` must be either None or a pandas.DataFrame" if n_stages == 2: accepted = ["W", "WAKE", "S", "SLEEP", "ART", "UNS"] mapping = {"WAKE": 0, "SLEEP": 1, "ART": -1, "UNS": -2} @@ -268,6 +275,19 @@ def __init__(self, values, n_stages=5, *, freq="30s", start=None, scorer=None): fake_dt = pd.date_range(start="2022-12-03 00:00:00", freq=freq, periods=hypno.shape[0]) hypno.index.name = "Epoch" timedelta = fake_dt - fake_dt[0] + # Validate proba + if proba is not None: + assert proba.shape[1] > 0, "`proba` must have at least one column." + assert proba.shape[0] == hypno.shape[0], "`proba` must have the same length as `values`" + assert np.allclose(proba.sum(1), 1), "Each row of `proba` must sum to 1." + in_proba_but_not_labels = np.setdiff1d(proba.columns, labels) + # in_labels_but_not_proba = np.setdiff1d(labels, proba.columns) + assert not len(in_proba_but_not_labels), ( + f"Invalid stages in `proba`: {in_proba_but_not_labels}. The accepted stages are: " + f"{labels}." + ) + # Ensure same order as `labels` + proba = proba.reindex(columns=labels).dropna(how="all", axis=1) # Set attributes self._hypno = hypno self._n_epochs = hypno.shape[0] @@ -280,6 +300,7 @@ def __init__(self, values, n_stages=5, *, freq="30s", start=None, scorer=None): self._labels = labels self._mapping = mapping self._scorer = scorer + self._proba = proba def __repr__(self): # TODO v0.8: Keep only the text between < and > @@ -294,15 +315,7 @@ def __repr__(self): ) def __str__(self): - text_scorer = f", scored by {self.scorer}" if self.scorer is not None else "" - return ( - f"\n" - " - Use `.hypno` to get the string values as a pandas.Series\n" - " - Use `.as_int()` to get the integer values as a pandas.Series\n" - " - Use `.plot_hypnogram()` to plot the hypnogram\n" - "See the online documentation for more details." - ) + return self.__repr__() @property def hypno(self): @@ -391,6 +404,14 @@ def scorer(self): """The scorer name.""" return self._scorer + @property + def proba(self): + """ + If specified, a :py:class:`pandas.DataFrame` with the probability of each sleep stage + for each epoch in hypnogram. + """ + return self._proba + # CLASS METHODS BELOW def as_annotations(self): @@ -558,6 +579,7 @@ def consolidate_stages(self, new_n_stages): freq=self.freq, start=self.start, scorer=self.scorer, + proba=None, # TODO: Combine stages probability? ) def copy(self): @@ -568,6 +590,7 @@ def copy(self): freq=self.freq, start=self.start, scorer=self.scorer, + proba=self.proba, ) def find_periods(self, threshold="5min", equal_length=False): @@ -1055,6 +1078,7 @@ def upsample(self, new_freq, **kwargs): freq=new_freq, start=self.start, scorer=self.scorer, + proba=None, # NOTE: Do not upsample probability ) def upsample_to_data(self, data, sf=None, verbose=True): diff --git a/yasa/staging.py b/yasa/staging.py index 9a59ffa..8b42705 100644 --- a/yasa/staging.py +++ b/yasa/staging.py @@ -4,6 +4,7 @@ import glob import joblib import logging +import warnings import numpy as np import pandas as pd import antropy as ant @@ -104,9 +105,9 @@ class SleepStaging: In addition with the predicted sleep stages, YASA can also return the predicted probabilities of each sleep stage at each epoch. This can be used to derive a confidence score at each epoch. - .. important:: The predictions should ALWAYS be double-check by a trained - visual scorer, especially for epochs with low confidence. A full - inspection should be performed in the following cases: + .. important:: The predictions should ALWAYS be double-check by a trained visual scorer, + especially for epochs with low confidence. A full inspection should be performed in the + following cases: * Nap data, because the classifiers were exclusively trained on full-night recordings. * Participants with sleep disorders. @@ -122,13 +123,11 @@ class SleepStaging: If you use YASA's default classifiers, these are the main references for the `National Sleep Research Resource `_: - * Dean, Dennis A., et al. "Scaling up scientific discovery in sleep - medicine: the National Sleep Research Resource." Sleep 39.5 (2016): - 1151-1164. + * Dean, Dennis A., et al. "Scaling up scientific discovery in sleep medicine: the National + Sleep Research Resource." Sleep 39.5 (2016): 1151-1164. - * Zhang, Guo-Qiang, et al. "The National Sleep Research Resource: towards - a sleep data commons." Journal of the American Medical Informatics - Association 25.10 (2018): 1351-1358. + * Zhang, Guo-Qiang, et al. "The National Sleep Research Resource: towards a sleep data + commons." Journal of the American Medical Informatics Association 25.10 (2018): 1351-1358. Examples -------- @@ -143,12 +142,15 @@ class SleepStaging: >>> sls = yasa.SleepStaging(raw, eeg_name="C4-M1", eog_name="LOC-M2", ... emg_name="EMG1-EMG2", ... metadata=dict(age=29, male=True)) + >>> # Print some basic info + >>> sls >>> # Get the predicted sleep stages - >>> hypno = sls.predict() + >>> hyp = sls.predict() + >>> hyp.hypno >>> # Get the predicted probabilities - >>> proba = sls.predict_proba() + >>> hyp.proba >>> # Get the confidence - >>> confidence = proba.max(axis=1) + >>> confidence = hyp.proba.max(axis=1) >>> # Plot the predicted probabilities >>> sls.plot_predict_proba() @@ -159,10 +161,10 @@ class SleepStaging: def __init__(self, raw, eeg_name, *, eog_name=None, emg_name=None, metadata=None): # Type check - assert isinstance(eeg_name, str) - assert isinstance(eog_name, (str, type(None))) - assert isinstance(emg_name, (str, type(None))) - assert isinstance(metadata, (dict, type(None))) + assert isinstance(eeg_name, str), "`eeg_name` must be a string." + assert isinstance(eog_name, (str, type(None))), "`eog_name` must be a string or None." + assert isinstance(emg_name, (str, type(None))), "`emg_name` must be a string or None." + assert isinstance(metadata, (dict, type(None))), "`metadata` must be a string or None." # Validate metadata if isinstance(metadata, dict): @@ -173,7 +175,7 @@ def __init__(self, raw, eeg_name, *, eog_name=None, emg_name=None, metadata=None assert metadata["male"] in [0, 1], "male must be 0 or 1." # Validate Raw instance and load data - assert isinstance(raw, mne.io.BaseRaw), "raw must be a MNE Raw object." + assert isinstance(raw, mne.io.BaseRaw), "`raw` must be a MNE Raw object." sf = raw.info["sfreq"] ch_names = np.array([eeg_name, eog_name, emg_name]) ch_types = np.array(["eeg", "eog", "emg"]) @@ -210,6 +212,22 @@ def __init__(self, raw, eeg_name, *, eog_name=None, emg_name=None, metadata=None self.data = data self.metadata = metadata + def __repr__(self): + n_samples = self.data.shape[-1] + duration = (n_samples / self.sf) / 60 + return ( + f"" + ) + + def __str__(self): + n_samples = self.data.shape[-1] + duration = n_samples / self.sf + return ( + f"" + ) + def fit(self): """Extract features from data. @@ -419,9 +437,13 @@ def predict(self, path_to_model="auto"): Returns ------- - pred : :py:class:`numpy.ndarray` - The predicted sleep stages. + pred : :py:class:`yasa.Hypnogram` + The predicted sleep stages. Since YASA v0.7, the predicted sleep stages are now + returned as a :py:class:`yasa.Hypnogram` instance, which also includes the + probability of each sleep stage for each epoch. """ + from yasa.hypno import Hypnogram + if not hasattr(self, "_features"): self.fit() # Load and validate pre-trained classifier @@ -430,10 +452,15 @@ def predict(self, path_to_model="auto"): X = self._features.copy()[clf.feature_name_] # Predict the sleep stages and probabilities self._predicted = clf.predict(X) - proba = pd.DataFrame(clf.predict_proba(X), columns=clf.classes_) - proba.index.name = "epoch" + # Predict the probabilities + classes = clf.classes_.copy() + classes[classes == "W"] = "WAKE" # Compat for yasa.Hypnogram + classes[classes == "R"] = "REM" + proba = pd.DataFrame(clf.predict_proba(X), columns=classes) + proba.index.name = "Epoch" self._proba = proba - return self._predicted.copy() + # Convert to a `yasa.Hypnogram` instance (including `proba`) + return Hypnogram(values=self._predicted.copy(), freq="30s", n_stages=5, proba=proba.copy()) def predict_proba(self, path_to_model="auto"): """ @@ -454,6 +481,12 @@ def predict_proba(self, path_to_model="auto"): proba : :py:class:`pandas.DataFrame` The predicted probability for each sleep stage for each 30-sec epoch of data. """ + warnings.warn( + "The `predict_proba` function is deprecated and will be removed in v0.8. " + "The predicted probabilities can now be accessed with `yasa.Hypnogram.proba` instead, " + "e.g `SleepStaging.predict().proba`", + FutureWarning, + ) if not hasattr(self, "_proba"): self.predict(path_to_model) return self._proba.copy() @@ -475,19 +508,18 @@ def plot_predict_proba( If True, probabilities of the non-majority classes will be set to 0. """ if proba is None and not hasattr(self, "_features"): - raise ValueError("Must call .predict_proba before this function") + raise ValueError("Must call `.predict` before this function") if proba is None: proba = self._proba.copy() else: - assert isinstance(proba, pd.DataFrame), "proba must be a dataframe" + assert isinstance(proba, pd.DataFrame), "`proba` must be a pandas.DataFrame" if majority_only: cond = proba.apply(lambda x: x == x.max(), axis=1) proba = proba.where(cond, other=0) ax = proba.plot(kind="area", color=palette, figsize=(10, 5), alpha=0.8, stacked=True, lw=0) # Add confidence # confidence = proba.max(1) - # ax.plot(confidence, lw=1, color='k', ls='-', alpha=0.5, - # label='Confidence') + # ax.plot(confidence, lw=1, color='k', ls='-', alpha=0.5, label='Confidence') ax.set_xlim(0, proba.shape[0]) ax.set_ylim(0, 1) ax.set_ylabel("Probability") diff --git a/yasa/tests/test_staging.py b/yasa/tests/test_staging.py index a87edd8..e396431 100644 --- a/yasa/tests/test_staging.py +++ b/yasa/tests/test_staging.py @@ -3,6 +3,7 @@ import unittest import numpy as np import matplotlib.pyplot as plt +from yasa.hypno import Hypnogram from yasa.staging import SleepStaging ############################################################################## @@ -11,7 +12,7 @@ # MNE Raw raw = mne.io.read_raw_fif("notebooks/sub-02_mne_raw.fif", preload=True, verbose=0) -hypno = np.loadtxt("notebooks/sub-02_hypno_30s.txt", dtype=str) +y_true = Hypnogram(np.loadtxt("notebooks/sub-02_hypno_30s.txt", dtype=str)) class TestStaging(unittest.TestCase): @@ -22,12 +23,18 @@ def test_sleep_staging(self): sls = SleepStaging( raw, eeg_name="C4", eog_name="EOG1", emg_name="EMG1", metadata=dict(age=21, male=False) ) + print(sls) + print(str(sls)) sls.get_features() y_pred = sls.predict() + assert isinstance(y_pred, Hypnogram) + assert y_pred.proba is not None proba = sls.predict_proba() - assert y_pred.size == hypno.size + assert y_pred.hypno.size == y_true.hypno.size + assert y_true.duration == y_pred.duration + assert y_true.n_stages == y_pred.n_stages # Check that the accuracy is at least 80% - accuracy = (hypno == y_pred).sum() / y_pred.size + accuracy = (y_true.hypno == y_pred.hypno).mean() assert accuracy > 0.80 # Plot