Repository: thodson-usgs/ratingcurve (language: python)

Issue:
Issue with the `plot_residual` function
I am having an issue when trying to plot the residuals of the fit using the `plot_residual` function. 
This issue is easiest to see in the [Model Selection Example](https://thodson-usgs.github.io/ratingcurve/notebooks/model-selection-tutorial.html#residual-analysis).
Here is the code:

```python
from ratingcurve.ratingmodel import PowerLawRating
from ratingcurve import data

df = data.load('green channel')

segments = 2
powerrating = PowerLawRating(q=df['q'],
                             h=df['stage'], 
                             q_sigma=df['q_sigma'],
                             segments=segments,
                             prior={'distribution':'uniform'})

trace = powerrating.fit(method='advi')
powerrating.plot_residuals(trace)
```

This results in an empty set of axes and a `ValueError` of:
`ValueError: operands could not be broadcast together with shapes (36,) (36,10000)`

This appears to be due to how the residuals are calculated in `ratingmodel.py`, with the predicted values including a second dimension of the number samples. Not sure how this should be addressed, but if the idea is to reduce the second dimension by using the sample mean, median, maximum likelihood value, etc., this should be relatively easy to fix.


Discussion / hints:

Fix patch:
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 22e396f..df0d090 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -69,7 +69,7 @@ your fork, to the original upstream repository.
 
 ### Implementing Features
 
-Look through the GitHub [issues](https://github.com/USGS-python/dataretrieval/issues)
+Look through the GitHub [issues](https://github.com/thodson-usgs/ratingcurve/issues)
 for outstanding feature requests. Anything tagged with "enhancement"
 and "please-help" is open to whomever wants to implement it.
 
@@ -84,8 +84,8 @@ Before you submit a pull request, check that it meets these guidelines:
 2. If the pull request adds or modifies functionality, the documentation should
    be updated. To do so, either add or modify a functions docstring which will
    automatically become part of the API documentation
-3. The pull request should work for Python 3.7, 3.8, 3.9, 3.10 - refer to the
-   [python-package.yml file](https://github.com/USGS-python/dataretrieval/blob/master/.github/workflows/python-package.yml)
+3. The pull request should work for Python 3.9, 3.10, 3.11 - refer to the
+   [python-package.yml file](https://github.com/thodson-usgs/ratingcurve/blob/main/.github/workflows/python-package.yml)
    for the latest versions of Python being tested by the continuous integration
    pipelines. This will be checked automatically by the CI pipelines once the
    pull request is opened.
@@ -93,7 +93,7 @@ Before you submit a pull request, check that it meets these guidelines:
 ### Coding Standards and Style
 
 Note that coding standards and style as described below are strong suggestions,
-the `dataretrieval` project does not strictly lint or enforce style guidelines
+the `ratingcurve` project does not strictly lint or enforce style guidelines
 via any automated processes or pipelines.
 
 #### Style
@@ -103,7 +103,6 @@ via any automated processes or pipelines.
   can and should be used internally and in tests
 * Functions for downloading data from a specific web portal must be grouped
   within their own submodule
-  * For example, all NWIS functions are located at `dataretrieval.nwis`
 
 #### Docstrings
 * Docstrings should follow the [numpy standard](https://numpydoc.readthedocs.io/en/v1.5.0/format.html):
@@ -135,7 +134,6 @@ via any automated processes or pipelines.
 
     """
     ```
-  * For more details see https://github.com/sphinx-doc/sphinx/blob/master/doc/ext/example_numpy.py
 
 #### Quotes
 
@@ -183,12 +181,12 @@ clearly describe what it is your proposed changes add or fix.
 ### Adding Examples to the Documentation
 
 A number of examples are provided in the documentation in the form of Jupyter
-notebooks. These example notebooks are all contained within the `demos/`
+notebooks. These example notebooks are all contained within the `docs/notebooks/`
 subdirectory of the repository. If you have an example use of the package you
 would like to add to the documentation as a run and rendered notebook, you
 will need to do the following (in a separate branch of the repository):
 
-1. Add your notebook to the `demos/` subdirectory after clearing all outputs
+1. Add your notebook to the `docs/notebooks/` subdirectory after clearing all outputs
 2. Add a corresponding `.nblink` file to `docs/source/examples/` subdirectory,
    see existing examples for reference, or refer to the [nbsphinx-link](https://nbsphinx-link.readthedocs.io/en/latest/) documentation.
 3. Add the example and some text describing it to one of the `.rst` files in
@@ -212,7 +210,7 @@ refer to [Reporting Bugs](#reporting-bugs).
 ### Feature Requests
 
 To request or propose a new feature, open an issue at
-[https://github.com/USGS-python/dataretrieval/issues](https://github.com/thodson-usgs/ratingcurve/issues).
+[https://github.com/thodson-usgs/ratingcurve/issues](https://github.com/thodson-usgs/ratingcurve/issues).
 
 Please be sure to:
 * Explain in detail how it would work, possibly with pseudo-code or an example
@@ -225,4 +223,4 @@ Please be sure to:
 ---
 
 ## Acknowledgements
-This document was adapted from the cookiecutter project's [CONTRIBUTING file](https://github.com/audreyr/cookiecutter/blob/master/CONTRIBUTING.rst).
+This document was adapted from the cookiecutter project's [CONTRIBUTING file](https://github.com/cookiecutter/cookiecutter/blob/main/CONTRIBUTING.md).
diff --git a/README.md b/README.md
index b9089aa..d27f2d3 100644
--- a/README.md
+++ b/README.md
@@ -10,7 +10,7 @@ Several automated methods currently exist, but each parameterizes the rating cur
 and because of the nature of the problem, those slight differences can greatly affect performance.
 To help the community evaluate different parameterizations,
 we created the `ratingcurve' package, which implements our best parameterization for others to try.
-Furthermore, the implementation uses PyMC, a general purpose library for probabilistic modeling, 
+Furthermore, the implementation uses [PyMC](https://www.pymc.io/welcome.html), a general purpose library for probabilistic modeling, 
 which makes it easier for others to modify the model to test different parameterizations or fitting algorithms.
 If you can improve upon our parameterization, USGS might use your algorithm to generate streamflow timeseries at thousands of locations around the United States.
 The package includes simple demonstrations and test datasets to get you started.
@@ -54,7 +54,7 @@ powerrating.plot(trace)
 
 Once fit, easily generate a rating table that can be imported into other applications.
 ```python
-powerating.table(trace)
+powerrating.table(trace)
 ```
 
 For more, see the [documentation](https://thodson-usgs.github.io/ratingcurve/meta/intro.html).
diff --git a/docs/_config.yml b/docs/_config.yml
index f46e84e..24b2782 100644
--- a/docs/_config.yml
+++ b/docs/_config.yml
@@ -44,6 +44,7 @@ sphinx:
   - 'sphinx.ext.viewcode'
   config:
     add_module_names: True
+    autoclass_content : 'both'
 
 parse:
   myst_enable_extensions:
diff --git a/docs/notebooks/model-selection-tutorial.ipynb b/docs/notebooks/model-selection-tutorial.ipynb
index 6addb1e..f46b5f5 100644
--- a/docs/notebooks/model-selection-tutorial.ipynb
+++ b/docs/notebooks/model-selection-tutorial.ipynb
@@ -29,15 +29,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "## Load the data"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
+    "## Load the data\n",
     "from ratingcurve import data\n",
     "%load_ext autoreload\n",
     "%autoreload 2\n",
@@ -68,7 +60,7 @@
    "outputs": [],
    "source": [
     "%%capture\n",
-    "# OUtput supressed, this will print \"Finished\" after running each of the four models\n",
+    "# Output supressed, this will print \"Finished\" after running each of the four models\n",
     "\n",
     "segments = [1, 2, 3, 4]\n",
     "traces = []\n",
@@ -80,14 +72,14 @@
     "                             prior={'distribution':'uniform'})\n",
     "    \n",
     "    trace = powerrating.fit(n=100_000)\n",
-    "    traces.append(pm.compute_log_likelihood(trace)) # Add arg to compute log likelihood"
+    "    traces.append(pm.compute_log_likelihood(trace, model=powerrating)) # Add arg to compute log likelihood"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "now use `arviz.compare` to format the output"
+    "Now use `arviz.compare` to format the output."
    ]
   },
   {
@@ -126,8 +118,6 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "import matplotlib.pyplot as plt\n",
-    "\n",
     "segments = 2\n",
     "powerrating = PowerLawRating(q=df['q'],\n",
     "                             h=df['stage'], \n",
@@ -144,6 +134,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
+    "import matplotlib.pyplot as plt\n",
+    "\n",
     "fig, ax = plt.subplots(1, 2, figsize=(7,7), sharey=True)\n",
     "\n",
     "powerrating.plot(trace, ax[0])\n",
@@ -167,9 +159,9 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
+   "display_name": "ratingcurve",
    "language": "python",
-   "name": "python3"
+   "name": "ratingcurve"
   },
   "language_info": {
    "codemirror_mode": {
@@ -181,7 +173,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.15"
+   "version": "3.11.4"
   }
  },
  "nbformat": 4,
diff --git a/docs/notebooks/segmented-power-law-tutorial.ipynb b/docs/notebooks/segmented-power-law-tutorial.ipynb
index 06e1c4d..dd39279 100644
--- a/docs/notebooks/segmented-power-law-tutorial.ipynb
+++ b/docs/notebooks/segmented-power-law-tutorial.ipynb
@@ -14,7 +14,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {
     "id": "d23da995-0d8c-4df5-bceb-f9ea29c5034d"
    },
@@ -29,7 +29,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {
     "id": "806409d6-616f-4ecf-a2a7-e5e42744c686"
    },
@@ -55,92 +55,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {
     "id": "9a75a0ac-877b-4b19-8b33-236b1a629875"
    },
-   "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>datetime</th>\n",
-       "      <th>stage</th>\n",
-       "      <th>q</th>\n",
-       "      <th>q_sigma</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>0</th>\n",
-       "      <td>2020-05-21 14:13:41 [UTC-07:00]</td>\n",
-       "      <td>7.04</td>\n",
-       "      <td>12199.342</td>\n",
-       "      <td>199.172931</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>1</th>\n",
-       "      <td>2020-04-16 14:55:31 [UTC-07:00]</td>\n",
-       "      <td>4.43</td>\n",
-       "      <td>4921.953</td>\n",
-       "      <td>95.425619</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2</th>\n",
-       "      <td>2020-03-04 13:54:10 [UTC-07:00]</td>\n",
-       "      <td>2.99</td>\n",
-       "      <td>2331.665</td>\n",
-       "      <td>61.860500</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>3</th>\n",
-       "      <td>2020-03-04 13:16:51 [UTC-07:00]</td>\n",
-       "      <td>2.94</td>\n",
-       "      <td>2289.220</td>\n",
-       "      <td>47.886745</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>4</th>\n",
-       "      <td>2020-01-23 11:04:32 [UTC-07:00]</td>\n",
-       "      <td>2.96</td>\n",
-       "      <td>2408.210</td>\n",
-       "      <td>99.522964</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "</div>"
-      ],
-      "text/plain": [
-       "                          datetime  stage          q     q_sigma\n",
-       "0  2020-05-21 14:13:41 [UTC-07:00]   7.04  12199.342  199.172931\n",
-       "1  2020-04-16 14:55:31 [UTC-07:00]   4.43   4921.953   95.425619\n",
-       "2  2020-03-04 13:54:10 [UTC-07:00]   2.99   2331.665   61.860500\n",
-       "3  2020-03-04 13:16:51 [UTC-07:00]   2.94   2289.220   47.886745\n",
-       "4  2020-01-23 11:04:32 [UTC-07:00]   2.96   2408.210   99.522964"
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "from ratingcurve import data\n",
     "df = data.load('green channel')\n",
@@ -151,35 +70,14 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "and plotting the observations"
+    "and plotting the observations."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Text(0, 0.5, 'Stage (ft)')"
-      ]
-     },
-     "execution_count": 6,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "ax = df.plot.scatter(x='q', y='stage', marker='o')\n",
     "ax.set_xlabel(\"Discharge (cfs)\")\n",
@@ -199,7 +97,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": null,
    "metadata": {
     "id": "c26b75e4-d127-43e3-adec-2ee57a5aba7e"
    },
@@ -225,61 +123,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "\n",
-       "<style>\n",
-       "    /* Turns off some styling */\n",
-       "    progress {\n",
-       "        /* gets rid of default border in Firefox and Opera. */\n",
-       "        border: none;\n",
-       "        /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
-       "        background-size: auto;\n",
-       "    }\n",
-       "    progress:not([value]), progress:not([value])::-webkit-progress-bar {\n",
-       "        background: repeating-linear-gradient(45deg, #7e7e7e, #7e7e7e 10px, #5c5c5c 10px, #5c5c5c 20px);\n",
-       "    }\n",
-       "    .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
-       "        background: #F44336;\n",
-       "    }\n",
-       "</style>\n"
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "\n",
-       "    <div>\n",
-       "      <progress value='200000' class='' max='200000' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
-       "      100.00% [200000/200000 00:21&lt;00:00 Average Loss = -44.318]\n",
-       "    </div>\n",
-       "    "
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Finished [100%]: Average Loss = -44.314\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "trace = powerrating.fit()"
    ]
@@ -293,20 +139,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 500x500 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "powerrating.plot(trace)"
    ]
@@ -320,92 +155,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/mnt/c/Users/thodson/OneDrive - DOI/Desktop/Projects/software-release/ratingcurve/ratingcurve/ratingmodel.py:318: RuntimeWarning: invalid value encountered in log\n",
-      "  b1 = np.where(h_tile <= hs, clips, np.log(h_tile-h0))\n"
-     ]
-    },
-    {
-     "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>stage</th>\n",
-       "      <th>discharge</th>\n",
-       "      <th>sigma</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>0</th>\n",
-       "      <td>2.20</td>\n",
-       "      <td>1365.65</td>\n",
-       "      <td>1.0154</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>1</th>\n",
-       "      <td>2.21</td>\n",
-       "      <td>1378.06</td>\n",
-       "      <td>1.0154</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2</th>\n",
-       "      <td>2.22</td>\n",
-       "      <td>1390.47</td>\n",
-       "      <td>1.0153</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>3</th>\n",
-       "      <td>2.23</td>\n",
-       "      <td>1402.89</td>\n",
-       "      <td>1.0153</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>4</th>\n",
-       "      <td>2.24</td>\n",
-       "      <td>1415.32</td>\n",
-       "      <td>1.0152</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "</div>"
-      ],
-      "text/plain": [
-       "   stage  discharge   sigma\n",
-       "0   2.20    1365.65  1.0154\n",
-       "1   2.21    1378.06  1.0154\n",
-       "2   2.22    1390.47  1.0153\n",
-       "3   2.23    1402.89  1.0153\n",
-       "4   2.24    1415.32  1.0152"
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "table = powerrating.table(trace)\n",
     "table.head()"
@@ -421,7 +173,7 @@
     "What happens if we choose the wrong number of segments? \n",
     "Increase the number of segments by one and rerun the model.\n",
     "In fact, we can use this to select the correct number of segments,\n",
-    "which is demonstrated in the [model evaluation notebook](https://github.com/thodson-usgs/ratingcurve/blob/main/docs/notebooks/model-selection-tutorial.ipynb) "
+    "which is demonstrated in the [model evaluation notebook](https://github.com/thodson-usgs/ratingcurve/blob/main/docs/notebooks/model-selection-tutorial.ipynb)."
    ]
   },
   {
@@ -431,24 +183,16 @@
    },
    "source": [
     "## Simulated Example\n",
-    "This example uses a simulated rating curve, which allows you to test how\n",
+    "This example uses a simulated rating curve, which allows you to test how changing the number of segments affects the rating curve.\n",
     "\n",
     "First, load the '3-segment simulated' tutorial dataset."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "The simulated rating contains 763 observations\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "sim_df = data.load('3-segment simulated')\n",
     "print('The simulated rating contains {} observations'.format(len(sim_df)))"
@@ -459,42 +203,21 @@
    "metadata": {},
    "source": [
     "This rating contains observations of every 0.01 inch. increment in stage, which is much more than we'd have for a natural rating.\n",
-    "Try sampling to `n=15` or `n=30` and see how that affects the model fit."
+    "Try sampling to `n_sample=15` or `n_sample=30` and see how that affects the model fit."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": null,
    "metadata": {
     "id": "bc06f4ff-7855-42db-bc15-2726dc99da7b",
     "outputId": "f4413937-f75c-4043-f1c7-236d3544d611"
    },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Text(0, 0.5, 'Stage (ft)')"
-      ]
-     },
-     "execution_count": 11,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "# subsample the simulated rating curve\n",
-    "n = 30\n",
-    "df = sim_df.sample(n, random_state=12345)\n",
+    "n_sample = 30\n",
+    "df = sim_df.sample(n_sample, random_state=12345)\n",
     "\n",
     "ax = sim_df.plot(x='q', y='stage', color='grey', ls='-', legend=False)\n",
     "df.plot.scatter(x='q', y='stage', marker='o', color='blue', ax=ax)\n",
@@ -563,7 +286,7 @@
     "powerrating.plot(trace, ax=ax)\n",
     "\n",
     "# plot the original data for comparison\n",
-    "ax = sim_df.plot(x='q', y='stage', color='red', ls=':', legend=False)"
+    "sim_df.plot(x='q', y='stage', color='red', ls=':', legend=False, ax=ax)"
    ]
   },
   {
@@ -583,9 +306,9 @@
     "The most common issue is a poor initialization of the breakpoints.\n",
     "A fix is under development, but for now, try\n",
     "1. reinitializing the model `PowerLawRating()`;\n",
-    "1. increasing the number of iterations `n`;\n",
+    "1. increasing the number of iterations for the fitting algorithm `fit(n=300_000)`;\n",
     "1. a prior on the breakpoints, example, try `prior={'distribution':'normal', 'mu':[5, 9.5, 10.5], 'sigma':[1, 1, 0.2]})`, which implies we know the true breakpoint within +-0.5 ft; or\n",
-    "1. fitting the model with NUTS `fit(method='nuts')`.\n"
+    "1. fitting the model with NUTS `fit(method='nuts')`."
    ]
   },
   {
@@ -615,7 +338,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.15"
+   "version": "3.11.4"
   }
  },
  "nbformat": 4,
diff --git a/docs/notebooks/spline-tutorial.ipynb b/docs/notebooks/spline-tutorial.ipynb
index d387f98..8948540 100644
--- a/docs/notebooks/spline-tutorial.ipynb
+++ b/docs/notebooks/spline-tutorial.ipynb
@@ -84,8 +84,8 @@
     "sim_df = data.load('3-segment simulated')\n",
     "\n",
     "# subsample the simulated rating curve\n",
-    "n = 30\n",
-    "df = sim_df.sample(n, random_state=12345)\n",
+    "n_sample = 30\n",
+    "df = sim_df.sample(n_sample, random_state=12345)\n",
     "\n",
     "ax = sim_df.plot(x='q', y='stage', color='gray', ls='-', legend=False)\n",
     "df.plot.scatter(x='q', y='stage', marker='o', color='blue', ax=ax)\n",
@@ -121,9 +121,9 @@
     "### Excercise \n",
     "Splines can give unexpectedly poor results.\n",
     "Experiment with the following:\n",
-    "1. Try  `sim_df.sample(n=30, random_state=771)`  \n",
+    "1. Try changing the random state: `sim_df.sample(n=30, random_state=771)`  \n",
     "1. Rerun with `n=200`. The fit has improved, but the uncertainty is unreasonably high.\n",
-    "2. Rerun with `df=30` in `SplineRating()`, and observe how the uncertainty changes. "
+    "2. Rerun with more degrees of freedon (`df=30`) in `SplineRating()`, and observe how the uncertainty changes. "
    ]
   },
   {
@@ -153,7 +153,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.15"
+   "version": "3.11.4"
   }
  },
  "nbformat": 4,
diff --git a/ratingcurve/plot.py b/ratingcurve/plot.py
index 387f06d..67749f8 100644
--- a/ratingcurve/plot.py
+++ b/ratingcurve/plot.py
@@ -123,6 +123,7 @@ def plot_residuals(self, trace: InferenceData=None, ax=None) -> None:
 
         # approximate percentage error
         residuals = self.residuals(trace) * 100
+        residuals = residuals.mean(axis=1)
         ax.errorbar(y=self.h_obs, x=residuals, xerr=q_sigma*2*100, fmt="o",
                     lw=NARROW_LINE,
                     markersize=4,
diff --git a/ratingcurve/ratingmodel.py b/ratingcurve/ratingmodel.py
index b48ac87..8f7e228 100644
--- a/ratingcurve/ratingmodel.py
+++ b/ratingcurve/ratingmodel.py
@@ -2,6 +2,7 @@
 from __future__ import annotations
 from typing import TYPE_CHECKING
 
+import math
 import numpy as np
 import pymc as pm
 import arviz as az
@@ -86,7 +87,13 @@ def residuals(self, trace: InferenceData) -> ArrayLike:
           Log residuals of rating model
         """
         q_pred = self.predict(trace, self.h_obs).discharge
-        return np.array(np.log(self.q_obs) - np.log(q_pred))
+
+        if self.q_obs.ndim == 1:
+            q_obs = self.q_obs.values.reshape((-1,1))
+        else:
+            q_obs = self.q_obs
+
+        return np.array(np.log(q_obs) - np.log(q_pred))
     
     def predict(self, trace: InferenceData, h: ArrayLike) -> RatingData:
         """Predicts values of new data with a trained rating model
@@ -478,7 +485,7 @@ def stage_range(minimum: float, maximum: float, step: float = 0.01):
     h_min, h_max : float
         Minimum and maximum stage (h) observations.
     """
-    start = minimum - (minimum % step)
-    stop = maximum + (maximum % step)
+    start = minimum - math.remainder(minimum, step)
+    stop = maximum + (step - math.remainder(maximum, step))
 
     return np.arange(start, stop, step)


Test patch:
diff --git a/ratingcurve/tests/test_ratingmodel.py b/ratingcurve/tests/test_ratingmodel.py
index 117dde4..fc297a1 100644
--- a/ratingcurve/tests/test_ratingmodel.py
+++ b/ratingcurve/tests/test_ratingmodel.py
@@ -1,14 +1,21 @@
 import pytest
-
 import numpy as np
 
 from ..ratingmodel import stage_range
 
-from ..ratingmodel import Rating, PowerLawRating, SplineRating
+@pytest.mark.parametrize('minimum', [0, 10, 1e3])
+@pytest.mark.parametrize('maximum', [0, 1e2, 1e4])
+@pytest.mark.parametrize('step', [0.01, 1, 50, 1e3])
+def test_stage_range(minimum, maximum, step):
+    
+    if minimum >= maximum:
+        pytest.xfail("minimum must be less than maximum")
+    if step > (maximum - minimum):
+         pytest.xfail("step must be smaller than minimum/maximum difference")
 
-# TODO specify these with pytest parametrize
-def test_stage_range():
-    assert np.allclose(stage_range(0, 1, 2), np.array([0])) # Nonsense
-    assert np.allclose(stage_range(0.01, 1.01, 0.1), np.array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.]))
-    assert np.allclose(stage_range(0.01, 1.01, 0.2), np.array([0. , 0.2, 0.4, 0.6, 0.8, 1.]))
-    
\ No newline at end of file
+    print(maximum, step)
+    stg_rng = stage_range(minimum, maximum, step)
+    assert stg_rng[0] <= minimum
+    assert (stg_rng[-1] >= maximum) or (np.allclose(stg_rng[-1], maximum))
+    assert np.allclose(stg_rng[1] - stg_rng[0], step)
+    assert len(stg_rng) <= (maximum - minimum)/step + 2
\ No newline at end of file
diff --git a/ratingcurve/tests/test_transform.py b/ratingcurve/tests/test_transform.py
index ec75908..4a8fe34 100644
--- a/ratingcurve/tests/test_transform.py
+++ b/ratingcurve/tests/test_transform.py
@@ -3,39 +3,54 @@
 
 from ..transform import *
 
-class TestTransform:
-    def test_transform(self):
-        x = np.array([1, 2, 3, 4, 5])
-        t = Transform(x)
-        assert np.allclose(t.transform(x), x)
-        assert np.allclose(t.untransform(t.transform(x)), x)
-
-
-class TestZTransform:
-    def test_transform(self):
-        x = np.array([1, 2, 3, 4, 5])
-        z = ZTransform(x)
-        assert np.allclose(z.transform(x), np.array([-1.41421356, -0.70710678, 0., 0.70710678, 1.41421356]))
-        assert np.allclose(z.untransform(z.transform(x)), x)
-
-
-class TestLogZTransform:
-    def test_transform(self):
-        x = np.array([1, 2, 3, 4, 5])
-        lz = LogZTransform(x)
-        assert np.allclose(lz.transform(x), np.array([-1.68450008, -0.46506562,  0.24825781,  0.75436884,  1.14693905]))
-        assert np.allclose(lz.untransform(lz.transform(x)), x)
-
-
-class TestUnitTransform:
-    def test_transform(self):
-        x = np.array([1, 2, 3, 4, 5])
-        u = UnitTransform(x)
-        assert np.allclose(u.transform(x), np.array([0.2, 0.4, 0.6, 0.8, 1.]))
-        assert np.allclose(u.untransform(u.transform(x)), x)
-
-
-def test_compute_knots():
-    assert np.allclose(compute_knots(0, 1, 2), np.array([0, 1]))
-    assert np.allclose(compute_knots(0, 1, 3), np.array([0, 0.5, 1]))
-    assert np.allclose(compute_knots(0, 1, 11), np.array([0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1]))
\ No newline at end of file
+@pytest.mark.parametrize('length', [2, 5, 10, 100, 1000, 10_000])
+@pytest.mark.parametrize('range', [0.1, 1, 5, 10, 1e2, 1e4])
+def test_transform(length, range):
+    x = np.random.rand(length) * range
+    t = Transform(x)
+    assert np.allclose(t.transform(x), x)
+    assert np.allclose(t.untransform(t.transform(x)), x)
+
+
+@pytest.mark.parametrize('length', [2, 5, 10, 100, 1000, 10_000])
+@pytest.mark.parametrize('range', [0.1, 1, 5, 10, 1e2, 1e4])
+def test_ztransform(length, range):
+    x = np.random.rand(length) * range
+    zt = ZTransform(x)
+    assert np.allclose(zt.transform(x), (x - np.mean(x))/ np.std(x))
+    assert np.allclose(zt.untransform(zt.transform(x)), x)
+
+
+@pytest.mark.parametrize('length', [2, 5, 10, 100, 1000, 10_000])
+@pytest.mark.parametrize('range', [0.1, 1, 5, 10, 1e2, 1e4])
+def test_logztransform(length, range):
+    x = np.random.rand(length) * range
+
+    if (x == 0).any():
+        pytest.xfail("Drew an exact zero which is not implemented")
+
+    lzt = LogZTransform(x)
+    assert np.allclose(lzt.transform(x), (np.log(x) - np.mean(np.log(x)))/ np.std(np.log(x)))
+    assert np.allclose(lzt.untransform(lzt.transform(x)), x)
+
+
+@pytest.mark.parametrize('length', [2, 5, 10, 100, 1000, 10_000])
+@pytest.mark.parametrize('range', [0.1, 1, 5, 10, 1e2, 1e4])
+def test_unittransform(length, range):
+    x = np.random.rand(length) * range
+    ut = UnitTransform(x)
+    assert np.allclose(ut.transform(x), x / np.max(x))
+    assert np.allclose(ut.untransform(ut.transform(x)), x)
+
+
+@pytest.mark.parametrize('minimum', [0, 10, 1e3])
+@pytest.mark.parametrize('maximum', [0, 1e2, 1e4])
+@pytest.mark.parametrize('n', [1, 5, 10, 50, 1000])
+def test_compute_knots(minimum, maximum, n):
+    if minimum >= maximum:
+        pytest.xfail("minimum must be less than maximum")
+ 
+    knots = compute_knots(minimum, maximum, n)
+    assert knots[0] == minimum
+    assert knots[-1] <= maximum
+    assert len(knots) == n
\ No newline at end of file