hpsdistfit.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "# About this Notebook\n",
    "\n",
    "This Jupyter Notebook can be used to replicate the computational experiments and results presented in the following paper\n",
    "\n",
    "> Paradis, Gregory E. 2019. _A simplified method for estimating stem diameter distributions from horizontal point sample data_. Forestry (submitted).\n",
    "\n",
    "The code in this notebook is implemented using freely-available open-source software libraries, and should be run using a Python 3 kernel. The notebook can be downloaded from [GitHub](https://github.com/gparadis/hpsdistfit).\n",
    "\n",
    "# Background\n",
    "\n",
    "Diameter frequency distributions are a key piece of information describing forest stands, for both practical forestry applications and scientific research on forest ecosystems. A substantial fraction of forest inventory data is collected using horizontal point sampling (HPS) methods. The procedure for deriving diameter distributions from HPS data is clearly described in the literature (e.g., see Ducey and Gove, 2015), but is somewhat complex.\n",
    "\n",
    "Paradis (2019) presents a simplified method for estimating stem diameter distributions from horizontal point sample data, including a computational experiment showing that output from our method is essentially identical to the more complex reference method. We hope our method will make it easier for practitioners and researchers alike to correctly derive diameter distributions from HPS datasets.\n",
    "\n",
    "This notebook contains instructions and code that can be used to replicate the computational experiment and results presented in Paradis (2019), as well as constitute a known-working software implementation of the simplified method presented therein.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Initialization\n",
    "\n",
    "Load required packages, define global variables, and define some helper functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import scipy as sp\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import rc, rcParams\n",
    "import matplotlib\n",
    "import matplotlib.font_manager\n",
    "import math\n",
    "import scipy.version\n",
    "from scipy import integrate\n",
    "from scipy.special import gamma, beta, betaln\n",
    "from scipy import stats \n",
    "#from scipy.ndimage.filters import gaussian_filter1d\n",
    "from scipy.ndimage import gaussian_filter1d\n",
    "from scipy.optimize import curve_fit as _curve_fit\n",
    "import ipy_table as ipt\n",
    "import pysal as ps\n",
    "import geopandas as gpd\n",
    "import shapely\n",
    "from scipy.stats.distributions import t\n",
    "from numpy import zeros, arange\n",
    "from math import sqrt\n",
    "import pickle\n",
    "from functools import partial, wraps\n",
    "import types\n",
    "from lmfit import Model, Parameter, MinimizerException\n",
    "from lmfit.model import ModelResult\n",
    "\n",
    "pd.set_option('display.max_columns', 10)\n",
    "sns.set_context('paper', font_scale=1.0)\n",
    "sns.set_style('white')\n",
    "#rc('text',usetex=True)\n",
    "#rc('font',**{'family':'serif','serif':['Computer Modern']})\n",
    "\n",
    "data_path = './dat/'\n",
    "size_classes = range(10, 62, 2) # 2 cm DBH classes in range [10, 60]\n",
    "treatment_types = [1, 2, 3] # 1: clearcut, 2: selection cut, 3: commercial thin\n",
    "cover_types = ['r', 'm', 'f'] # r: softwood, m: mixedwood, f: hardwood\n",
    "species_group_names = {'auf':'Other Hardwoods',\n",
    "                       'boj':'Yellow Birch',\n",
    "                       'bop':'White Birch',\n",
    "                       'chce':'Oak-Hickory',\n",
    "                       'ers':'Sugar Maple',\n",
    "                       'erx':'Other Maples',\n",
    "                       'peu':'Poplar',\n",
    "                       'pib':'Eastern White Pine',\n",
    "                       'pir':'Red Pine',\n",
    "                       'sepm':'Fir-Spruce-Pine-Larch',\n",
    "                       'topu':'Eastern White Cedar'}\n",
    "cover_type_names = {'r':'Softwood', \n",
    "                    'm':'Mixedwood',\n",
    "                    'f':'Hardwood'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define some helper functions that will be used further down."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We use `scipy.optimize.curve_fit`, which can handle a wide range of curve fitting tasks. By default, `curve_fit` calls `scipy.optimize.leastsq` for unbounded problems, which has an optional `maxfev` argument (related to the number of iterations the algorithm will run before giving up and declaring non-convergence) that we need to set to a big number (`curve_fit` throws too many errors with default values). For bounded problems, `curve_fit` calls `scipy.optimize.least_squares`, which has similar optional argument named `max_nfev`. Depending on whether we set bounds on parameter values or not, we need to call `curve_fit` with different keyword argument names (either `max_nfev` or `maxfev`). Therefore, we have to test for boundedness of problem before every call to `curve_fit` to make sure we pass the correct keyword argument name. Yuck. Perhaps `scipy` package maintainers will patch the interface someday to make this work as expected.  \n",
    "\n",
    "Meanwhile, we can get around all this nonsense by defining a wrapper function for `scipy.optimize.curve_fit` that tests problem boundedness and renames `maxfev` keyword argument to `max_nfev` if the problem is bounded. If called via this wrapper, `curve_fit` now seems to behaves the way it should (i.e. according to the POLA). \n",
    "\n",
    "Note that this problem seems to have been [patched](https://github.com/scipy/scipy/commit/eef17945bf0f89344ea9c1ce8ce2ec33f0e401f8) in the `master` branch on GitHub since the latest release of `scipy` (`0.18.1`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "@wraps(_curve_fit)\n",
    "def curve_fit(*args, **kwargs):\n",
    "    b = kwargs['bounds'] if 'bounds' in kwargs else None \n",
    "    if b and np.any(np.isfinite(b)) and 'max_nfev' not in kwargs:\n",
    "        kwargs['max_nfev'] = kwargs.pop('maxfev', None)\n",
    "    return _curve_fit(*args, **kwargs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define a helper function that standardizes compilation of a bin centers, bin values, bin edges, and bin standard errors from a `pandas.DataFrame` containing our raw PSP inventory data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true,
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "def compile_bin_data(data, bins=None, xminmm=90, xmaxmm=610, xwmm=20, ef=25., alpha=0.05, pid_colname='id_pep', dbh_colname='dhpmm', normed=True, compile_stderr=False):\n",
    "    #display(data)\n",
    "    df = data.reset_index().set_index(pid_colname)\n",
    "    if bins is None:\n",
    "        bins = np.arange(xminmm, xmaxmm+xwmm, xwmm)\n",
    "\n",
    "    bin_vals, bin_edges = np.histogram(df[dbh_colname], bins=bins, range=(xminmm, xmaxmm))\n",
    "    bin_vals = bin_vals * ef # expand to stems/ha\n",
    "    bin_stderrs = []\n",
    "    if compile_stderr:\n",
    "        for i, (xa, xb) in enumerate([(x, x+xwmm) for x in bins[:-1]]):\n",
    "            #print 'processing bin', i\n",
    "            Y = []\n",
    "            for pid in df.index.unique():\n",
    "                #print i, pid, len(df.index.unique())\n",
    "                try:\n",
    "                    _df = df.loc[[pid]].query('%s > %i & %s <= %i' % (dbh_colname, xa, dbh_colname, xb))\n",
    "                except:\n",
    "                    print(df.loc[pid]) \n",
    "                    raise\n",
    "                Y.append(len(_df) * ef)\n",
    "            sigma = sqrt((sum(y**2 for y in Y) - sum(Y)/len(Y))/(len(Y) - 1))\n",
    "            t = distributions.t.ppf(1. - alpha/2., len(Y) - 1) \n",
    "            #print t*sigma\n",
    "            bin_stderrs.append(t * sigma)\n",
    "    else:\n",
    "        bin_stderrs = [0. for i in bin_vals]\n",
    "    bin_stderrs = np.array(bin_stderrs)\n",
    "    bin_centers = (bin_edges[:-1] + (xwmm * 0.5)) * 0.1\n",
    "    if normed: \n",
    "        scale = float(0.1 * xwmm * sum(bin_vals))\n",
    "        bin_vals = bin_vals * pow(scale, -1)\n",
    "        bin_stderrs = bin_stderrs * pow(scale, -1)\n",
    "    return bin_centers, bin_vals, bin_edges * 0.1, bin_stderrs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Note on Inventory Data\n",
    "\n",
    "The computational experiment implemented in this notebook uses permanent sample data collected in Quebec (Canada). Detailed information on the Quebec PSP inventory program under which our test data was collected is available from the [Ministère des forêts, faune, et parcs (MFFP)](http://mffp.gouv.qc.ca/les-forets/inventaire-ecoforestier/), including technical documentation on inventory methods, data standards, and contact information. The full PSP dataset can be downloaded from [Données Québec](ftp://transfert.mffp.gouv.qc.ca/Public/Diffusion/DonneeGratuite/Foret/DONNEES_FOR_ECO_SUD/Placettes_permanentes/PEP_GDB.zip). \n",
    "\n",
    "We preprocessed the full PSP dataset to include only live, merchantable stems from the fourth decennial inventory cycle, from the largest of 8 plot networks, corresponding to mature, undisturbed stands, for which there was valid data in all fields. This notebook loads a pickle file (`dat/misc/tiges_final_full.p`) that contains a serialized `pandas.DataFrame` object created in the preprocessing step. We include filtered dataset here for convenience, and to facilitate reproduction of results presented in Paradis (2019). It is advisable that someone with expert understanding of the statistical limitation of Quebec PSP data be tasked with re-filtering the PSP dataset on a per-project basis, to ensure that the subset of data used best match the needs and goals of each project. \n",
    "\n",
    "The data preprocessing method is described an implemented in a separate notebook (`psp_preprocess.ipynb`). The PSP database we used as input for the processing step is packaged differently thant the freely-available PSP data downloadable using the link above (i.e., several DBF files that implicitly form a relational database, versus a single MDB file in the downloadable dataset). The underlying data is the same, but some work is required at the time of writing this to finish adapting the preprocessing notebook code to use the newer MDB database as input. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Define statistical distributions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The generalized beta family of statistical distributions is useful for modelling stem density distributions. All members of the family can be derived from either the generalized beta distribution of the first kind (GB1) or the generalized beta distribution of the second kind (GB2)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The generalized gamma GG distribution is a special case of both GB1 and GB2 distributions. The GG PDF has the following form\n",
    "\n",
    "$$\n",
    "\\text{GG}(x; a, b, p) = \\frac{ax^{ap-1}e^{-\\left(\\frac{x}{b}\\right)^a}}{b^{ap}\\Gamma(p)}, \\qquad a > 0, b > 0, q > 0\n",
    "$$\n",
    "\n",
    "defined for $x > 0$, where $\\Gamma(p)$ represents the [gamma function](https://en.wikipedia.org/wiki/Gamma_function) (not to be confounded with the gamma, or generalized gamma, distributions), which is given by\n",
    "\n",
    "$$\n",
    "\\Gamma(p) = \\int_0^\\infty x^{p-1}e^{-x} dx.\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The size-biased form of the GG PDF is given by (adapted from Ducey and Gove, 2015)\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "\\text{GG}_{\\text{SB}}(x; a, b, p, \\alpha) &= \\text{GG}(x; a, b, p + \\alpha/a)\n",
    "\\end{aligned}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can define standard and size-biased forms of the PDFs of Weibull and Gamma distributions in terms GG PDFs.\n",
    "\n",
    "The standard forms are given by\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "\\text{W}(x; a, b) &= \\text{GG}(x; a, b, 1) \\\\\n",
    "\\text{GA}(x; b, p) &= \\text{GG}(x; 1, b, p) \\\\\n",
    "\\end{aligned}\n",
    "$$\n",
    "\n",
    "The size-biased forms are given by (adapted from Ducey and Gove, 2015)\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "\\text{W}_{\\text{SB}}(x; a, b, \\alpha) &= \\text{GG}(x; a, b, 1 + \\alpha/a),& \\qquad \\alpha > -a \\\\\n",
    "\\text{GA}_{\\text{SB}}(x; b, p, \\alpha) &= \\text{GG}(x; 1, b, p + \\alpha),& \\qquad \\alpha > -p \\\\\n",
    "\\end{aligned}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We implement standard and size-biased forms of GG PDFs as follows. Note that we add a global scaling parameter $s$ to the implemented functions, to allow the fitting algorithm to compensate for the truncated sample domain."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "code_folding": [],
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def gg_pdf(x, a, b, p, s=1.):\n",
    "    y = s * ((a * pow(x, a*p-1.) * np.exp(-pow(x/b, a))) / (pow(b, a*p) * gamma(p)))\n",
    "    return 0. if (np.any(np.isnan(y)) or np.any(np.isinf(y))) else y\n",
    "\n",
    "def gg_sb_pdf(x, a, b, p, s, alpha):\n",
    "    return gg_pdf(x, a, b, p+alpha/a, s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we implement standard and size-biased forms of the Weibull and Gamma distributions by wrapping `gg_pdf` and `gg_sb_pdf`. For convenience later, store references to these distribution functions in a dictionary `D`, indexed on type and distribution. Note that we also define `sb2` type distributions, which are size-biased forms with the `alpha` parameter fixed at a value of 2 (i.e., we need second-order distibutions to model HPS tally data)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "lim0 = pow(np.nan_to_num(np.inf), -1)\n",
    "\n",
    "D = {'st':{}, 'sb':{}, 'sb2':{}}\n",
    "\n",
    "# standard forms\n",
    "D['st']['gg'] = gg_pdf\n",
    "D['st']['ga'] = lambda x, beta, p, s: gg_pdf(x, 1., beta, p, s)\n",
    "D['st']['w'] = lambda x, a, beta, s: gg_pdf(x, a, beta, 1., s)\n",
    "\n",
    "# size-biased forms\n",
    "D['sb']['gg'] = gg_sb_pdf\n",
    "D['sb']['ga'] = lambda x, beta, p, s, alpha: gg_pdf(x, 1., beta, p + alpha, s)\n",
    "D['sb']['w'] = lambda x, a, beta, s, alpha: gg_pdf(x, a, beta, 1. + alpha/a, s)\n",
    "\n",
    "# size-biased forms with alpha fixed at 2. \n",
    "# [Is there a better way to freeze a parameter and remove it from the signature?]\n",
    "D['sb2']['gg'] = lambda x, a, beta, p, s: D['sb']['gg'](x, a, beta, p, s, 2.)\n",
    "D['sb2']['ga'] = lambda x, beta, p, s: D['sb']['ga'](x, beta, p, s, 2.)\n",
    "D['sb2']['w'] = lambda x, a, beta, s: D['sb']['w'](x, a, beta, s, 2.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To obtain a stand table from HPS data, one must multiply each stem observation by an _expansion factor_ $f_E(x, C_{BA})$, which is related to the DBH $x$ (measured in cm) and the BAF $C_{BA}$ as follows.\n",
    "\n",
    "$$\n",
    "f_E(x, C_{BA}) = \\frac{40000C_{BA}}{\\pi x^2} \n",
    "$$\n",
    "\n",
    "Stand table data can be converted back to HPS tally data by multiplying stand table data by a _compression factor_ $f_C(x; C_{BA})$, which is simply the multiplicative inverse of the expansion function, this is\n",
    "\n",
    "$$\n",
    "f_C(x; C_{BA}) = (f_E(x; C_{BA}))^{-1} = \\frac{\\pi x^2}{40000C_{BA}}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define some helper functions to expand or compress data (we will be bouncing back and forth between tally and stand table space)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true,
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "def expansion_factor(x, baf=2.):\n",
    "    \"\"\"Return stand table expansion factor for given DBH and BAF.\"\"\"\n",
    "    return baf / (math.pi * pow(x * 0.01 * 0.5, 2))\n",
    "\n",
    "def compression_factor(x, expansion_func=expansion_factor):\n",
    "    \"\"\"Return the multiplicative inverse of an expansion function.\"\"\"\n",
    "    return pow(expansion_func(x), -1)\n",
    "\n",
    "def transform_data(xdata, ydata, trans_func, normed=False):\n",
    "    _e = np.vectorize(trans_func)\n",
    "    result = _e(xdata) * ydata\n",
    "    if normed:\n",
    "        return result / sum(result)\n",
    "    else:\n",
    "        return result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, we load some inventory data (pre-processed, see note at top of notebook). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "23233"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pickle.load(open(data_path+'misc/tiges_final_full.p', 'rb'), encoding='latin1')\n",
    "len(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This data was compiled from PEP inventory data, which is collected using a 11.28 m radius fixed-area plot sampling (FAPS) methodology. Thus, the expansion factor for all stems in this dataset is 25.\n",
    "\n",
    "We want to run our distribution-fitting experiment on HPS tally data, so we need to convert our FAPS tally data to pseudo-HPS tally data. We can do this by first expanding the FAPS data (using the constant expansion factor of 25), then compressing the expanded tally data using the reciprocal of the HPS expansion factor.\n",
    "\n",
    "First, we index the FAPS data by cover type and species group."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "df = df.reset_index().set_index(['groupe3', 'type_couv'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "#cover_types = df.index.levels[1].unique()\n",
    "cover_types = ['r', 'm', 'f']\n",
    "species_groups = df.index.levels[0].unique()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define a helper function to compile FAPS inventory data into 2cm wide bins."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "def compile_hist(data, bins=None, xminmm=90, xmaxmm=610, xwmm=20, normed=True):\n",
    "    if bins is None:\n",
    "        bins = np.arange(xminmm, xmaxmm+xwmm, xwmm)\n",
    "    bin_vals, bin_edges = np.histogram(data, bins=bins, range=(xminmm, xmaxmm))\n",
    "    bin_centers = (bin_edges[:-1] + (xwmm * 0.5)) * 0.1\n",
    "    if normed: bin_vals = bin_vals * pow(0.1 * xwmm * sum(bin_vals), -1)\n",
    "    return bin_centers, 1. * bin_vals, bin_edges * 0.1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plot empirical diameter distributions from expanded FAPS data, by species group and cover type. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "run_control": {
     "frozen": true,
     "read_only": true
    }
   },
   "outputs": [],
   "source": [
    "def pairs(a):\n",
    "    return [(v, w) for v, w in zip(a[:-1], a[1:])]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true,
    "run_control": {
     "frozen": true,
     "read_only": true
    }
   },
   "outputs": [],
   "source": [
    "def signchanges(ydata):\n",
    "    signs = np.sign([np.array(v - w for v, w in pairs(ydata))])\n",
    "    return signs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true,
    "run_control": {
     "frozen": true,
     "read_only": true
    }
   },
   "outputs": [],
   "source": [
    "def optimal_bins(df, sg, ct, xwmm=20, max_flipflops=3):\n",
    "    xdata, ydata, _ = compile_hist(df.loc[sg].loc[ct], xwmm=xwmm)\n",
    "    # delete trailing empty bins\n",
    "    while not ydata[-1]: \n",
    "        xdata = np.delete(xdata, -1)\n",
    "        ydata = np.delete(ydata, -1)\n",
    "    # increase bin width until no empty bins\n",
    "    flipflops = 99\n",
    "    xwmm = max(1, xwmm - 1)\n",
    "    while np.count_nonzero(ydata) < len(ydata) or flipflops > max_flipflops:\n",
    "        xwmm += 1\n",
    "        xdata, ydata = compile_hist(df.loc[sg].loc[ct], xwmm=xwmm)\n",
    "    return xdata, ydata, xwmm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define a helper function that plots side-by-side subfigures showing empirical diameter distribution (as histogram, 25 2-cm wide bins subdividing the interval between 10 and 60 cm DBH), result of control method (fit size-biased form distribution to HPS tally data), and result of test method (fit standard form of distribution to expanded HPS data, with points weighted by the reciprocal of corresponding expansion factor in the fitting algorithm). Best-fit distribution from test method is projected onto HPS tally space in the left subfigure, and best-fit distribution from the control method is projected onto expanded HPS space in the right subfigure."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We pick three combinations of species and cover type to use for the computational experiment (three different species, three different cover types, using combinations with large sample sizes)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We cannot use `functools.partial` to freeze some args before passing distribution functions to `curve_fit`, because it just sets arg values (like default values, the args are still in the signature so subject to parameter optimisation by the fitting algorithm). Instead, wrap distribution functions with a `lambda` function to freeze parameters and simplify the signature before fitting."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We define a function to generate the subplots for our paper."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fit_and_plot(ax, fit_func1, fit_func2, bounds, xdata, ydata1, ydata2, bins,\n",
    "                 sigma=None, absolute_sigma=False, w=10, max_nfev=100000, \n",
    "                 xlim=None, ylim=None, alpha1=0.2, alpha2=0.3, \n",
    "                 linecolor='black', expand_data=False, bootstrap=False, use_popt=True):\n",
    "    \"\"\"Assume scipy.optimize leastsq wrapped to rename max_nfev to maxfev.\"\"\"\n",
    "    import warnings\n",
    "    __curve_fit = boots_fit if bootstrap else _curve_fit\n",
    "    m1 = Model(fit_func1)\n",
    "    popt1, pcov1 = __curve_fit(fit_func1, xdata, ydata1, sigma=None, bounds=bounds, max_nfev=max_nfev)\n",
    "    for i, pn in enumerate(m1.param_names):\n",
    "        vary = False if pn == 's' else True\n",
    "        value = popt1[i] if use_popt else 1.\n",
    "        m1.set_param_hint(pn, value=value, min=0., vary=vary)\n",
    "    p1 = m1.make_params()\n",
    "    fit_kws1 = {'sigma':None, 'bounds':bounds, 'max_nfev':max_nfev}\n",
    "    #with warnings.catch_warnings():\n",
    "    #    warnings.simplefilter('ignore')\n",
    "    #    mr1 = m1.fit(ydata1, x=xdata, **fit_kws1)\n",
    "    #mr1 = m1.fit(ydata1, x=xdata)\n",
    "    mr1 = m1.fit(ydata1, x=xdata, **fit_kws1)\n",
    "    m2 = Model(fit_func2)\n",
    "    popt2, pcov2 = __curve_fit(fit_func2, xdata, ydata2, sigma=sigma, absolute_sigma=absolute_sigma, bounds=bounds, max_nfev=max_nfev)\n",
    "    for i, pn in enumerate(m2.param_names):\n",
    "        vary = False if pn == 's' else True\n",
    "        value = popt2[i] if use_popt else 1.\n",
    "        m2.set_param_hint(pn, value=value, min=0., vary=vary)\n",
    "    p2 = m2.make_params()\n",
    "    fit_kws2 = {'sigma':sigma, 'absolute_sigma':absolute_sigma, 'bounds':bounds, 'max_nfev':max_nfev}\n",
    "    #with warnings.catch_warnings():\n",
    "    #    warnings.simplefilter('ignore')\n",
    "    #    mr2 = m2.fit(ydata2, x=xdata, fit_kws=fit_kws2)\n",
    "    mr2 = m2.fit(ydata2, x=xdata, **fit_kws2)\n",
    "    _ydata1 = mr1.best_fit\n",
    "    _ydata1 = _ydata1 / sum(_ydata1)\n",
    "    _ydata1_proj = transform_data(xdata, _ydata1, expansion_factor, normed=True)\n",
    "    _ydata2 = mr2.best_fit\n",
    "    _ydata2 = _ydata2 / sum(_ydata2)\n",
    "    _ydata2_proj = transform_data(xdata, _ydata2, compression_factor, normed=True)\n",
    "    __ydata1 = _ydata1 if not expand_data else _ydata1_proj\n",
    "    __ydata2 = _ydata2_proj if not expand_data else _ydata2\n",
    "    weights = ydata1 / sum(ydata1) if not expand_data else ydata2 / sum(ydata2)\n",
    "    linestyle1, linestyle2 = ('-', '--') if not expand_data else ('--', '-')\n",
    "    label1, label2 = ('Control', 'Test (proj.)') if not expand_data else ('Control (proj.)', 'Test')\n",
    "    ax.plot(xdata, ydata2*2., marker='o', markersize=4, linestyle='', color='k', alpha=0.5, label=r'$\\hat{y}_i$')\n",
    "    ax.plot(xdata, __ydata1, linestyle1, color=linecolor, alpha=alpha2, label=label1)\n",
    "    ax.plot(xdata, __ydata2, linestyle2, color=linecolor, alpha=alpha2, label=label2)\n",
    "    ax.legend(prop={'size':6})\n",
    "    if xlim: plt.xlim(*xlim)\n",
    "    if ylim: plt.ylim(*ylim)\n",
    "    return mr1, mr2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "essencegroupe1 = pd.read_csv(data_path+'misc/essencegroupe1.csv', index_col='groupe1')\n",
    "groupe1groupe2groupe3 = pd.read_csv(data_path+'misc/groupe1groupe2groupe3.csv', index_col='groupe1')\n",
    "groupe1 = sorted(groupe1groupe2groupe3.index.unique())\n",
    "groupe2 = sorted(groupe1groupe2groupe3.groupe2.unique())\n",
    "groupe3 = sorted(groupe1groupe2groupe3.groupe3.unique())\n",
    "\n",
    "species_groups = groupe1groupe2groupe3.reset_index().set_index('groupe3')['groupe1'].to_dict()\n",
    "species_group_names = {'auf':'Other Hardwoods',\n",
    "                       'boj':'Yellow Birch',\n",
    "                       'bop':'Birch',\n",
    "                       'chce':'Oak-Hickory',\n",
    "                       'ers':'Maple',\n",
    "                       'erx':'Other Maples',\n",
    "                       'peu':'Poplar',\n",
    "                       'pib':'White Pine',\n",
    "                       'pir':'Red Pine',\n",
    "                       'sepm':'SPFL', #'Fir-Spruce-Pine-Larch',\n",
    "                       'topu':'Cedar'}\n",
    "cover_type_names = {'r':'Softwood', \n",
    "                    'm':'Mixedwood',\n",
    "                    'f':'Hardwood'}\n",
    "cover_type_names_short = {'r':'S', 'm':'M', 'f':'H'}\n",
    "dist_names_long = {'gg':'GG',\n",
    "                   'ib1':'IB1',\n",
    "                   'ga':'GA',\n",
    "                   'w':'W'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/codespace/.python/current/lib/python3.10/site-packages/lmfit/model.py:1123: UserWarning: The keyword argument sigma does not match any arguments of the model function. It will be ignored.\n",
      "  warnings.warn(f\"The keyword argument {name} does not \" +\n",
      "/home/codespace/.python/current/lib/python3.10/site-packages/lmfit/model.py:1123: UserWarning: The keyword argument bounds does not match any arguments of the model function. It will be ignored.\n",
      "  warnings.warn(f\"The keyword argument {name} does not \" +\n",
      "/home/codespace/.python/current/lib/python3.10/site-packages/lmfit/model.py:1123: UserWarning: The keyword argument absolute_sigma does not match any arguments of the model function. It will be ignored.\n",
      "  warnings.warn(f\"The keyword argument {name} does not \" +\n",
      "/home/codespace/.python/current/lib/python3.10/site-packages/lmfit/model.py:1123: UserWarning: The keyword argument sigma does not match any arguments of the model function. It will be ignored.\n",
      "  warnings.warn(f\"The keyword argument {name} does not \" +\n",
      "/home/codespace/.python/current/lib/python3.10/site-packages/lmfit/model.py:1123: UserWarning: The keyword argument bounds does not match any arguments of the model function. It will be ignored.\n",
      "  warnings.warn(f\"The keyword argument {name} does not \" +\n",
      "/home/codespace/.python/current/lib/python3.10/site-packages/lmfit/model.py:1123: UserWarning: The keyword argument absolute_sigma does not match any arguments of the model function. It will be ignored.\n",
      "  warnings.warn(f\"The keyword argument {name} does not \" +\n",
      "/home/codespace/.python/current/lib/python3.10/site-packages/lmfit/model.py:1123: UserWarning: The keyword argument sigma does not match any arguments of the model function. It will be ignored.\n",
      "  warnings.warn(f\"The keyword argument {name} does not \" +\n",
      "/home/codespace/.python/current/lib/python3.10/site-packages/lmfit/model.py:1123: UserWarning: The keyword argument bounds does not match any arguments of the model function. It will be ignored.\n",
      "  warnings.warn(f\"The keyword argument {name} does not \" +\n",
      "/home/codespace/.python/current/lib/python3.10/site-packages/lmfit/model.py:1123: UserWarning: The keyword argument absolute_sigma does not match any arguments of the model function. It will be ignored.\n",
      "  warnings.warn(f\"The keyword argument {name} does not \" +\n",
      "/home/codespace/.python/current/lib/python3.10/site-packages/lmfit/model.py:1123: UserWarning: The keyword argument sigma does not match any arguments of the model function. It will be ignored.\n",
      "  warnings.warn(f\"The keyword argument {name} does not \" +\n",
      "/home/codespace/.python/current/lib/python3.10/site-packages/lmfit/model.py:1123: UserWarning: The keyword argument bounds does not match any arguments of the model function. It will be ignored.\n",
      "  warnings.warn(f\"The keyword argument {name} does not \" +\n",
      "/home/codespace/.python/current/lib/python3.10/site-packages/lmfit/model.py:1123: UserWarning: The keyword argument absolute_sigma does not match any arguments of the model function. It will be ignored.\n",
      "  warnings.warn(f\"The keyword argument {name} does not \" +\n",
      "/home/codespace/.python/current/lib/python3.10/site-packages/lmfit/model.py:1123: UserWarning: The keyword argument sigma does not match any arguments of the model function. It will be ignored.\n",
      "  warnings.warn(f\"The keyword argument {name} does not \" +\n",
      "/home/codespace/.python/current/lib/python3.10/site-packages/lmfit/model.py:1123: UserWarning: The keyword argument bounds does not match any arguments of the model function. It will be ignored.\n",
      "  warnings.warn(f\"The keyword argument {name} does not \" +\n",
      "/home/codespace/.python/current/lib/python3.10/site-packages/lmfit/model.py:1123: UserWarning: The keyword argument absolute_sigma does not match any arguments of the model function. It will be ignored.\n",
      "  warnings.warn(f\"The keyword argument {name} does not \" +\n",
      "/home/codespace/.python/current/lib/python3.10/site-packages/lmfit/model.py:1123: UserWarning: The keyword argument sigma does not match any arguments of the model function. It will be ignored.\n",
      "  warnings.warn(f\"The keyword argument {name} does not \" +\n",
      "/home/codespace/.python/current/lib/python3.10/site-packages/lmfit/model.py:1123: UserWarning: The keyword argument bounds does not match any arguments of the model function. It will be ignored.\n",
      "  warnings.warn(f\"The keyword argument {name} does not \" +\n",
      "/home/codespace/.python/current/lib/python3.10/site-packages/lmfit/model.py:1123: UserWarning: The keyword argument absolute_sigma does not match any arguments of the model function. It will be ignored.\n",
      "  warnings.warn(f\"The keyword argument {name} does not \" +\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x700 with 6 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import scipy.stats.distributions as distributions\n",
    "bootstrap = False\n",
    "use_sigma = True\n",
    "absolute_sigma = False\n",
    "bounds = (0., np.inf)\n",
    "max_nfev = 10000\n",
    "\n",
    "fig, ax = plt.subplots(3, 2, figsize=(6, 7), sharey=True, sharex=True)\n",
    "distns = [('w', (D['sb2']['w'], D['st']['w'])), \n",
    "          ('ga', (D['sb2']['ga'], D['st']['ga']))]\n",
    "mplots = [('sepm', 'r'), ('bop', 'm'), ('ers', 'f')]\n",
    "compile_stderr = True\n",
    "plot_stderr = True\n",
    "ylim = (0., 0.5)\n",
    "expand_data = True\n",
    "results = {}\n",
    "out_flds = ['species',\n",
    "            'covertype',\n",
    "            'samplesize',\n",
    "            'distribution',\n",
    "            'chisqr1', 'chisqr2']\n",
    "out_data = {fld:[] for fld in out_flds}\n",
    "for i, v in enumerate(mplots):\n",
    "    sg, ct = v\n",
    "    results[v] = {}\n",
    "    for j, (dn, (fit_func1, fit_func2)) in enumerate(distns):\n",
    "        _df = df.loc[sg].loc[ct]\n",
    "        xdata, ydata2, bins, stderrs = compile_bin_data(_df, compile_stderr=compile_stderr)\n",
    "        xdata, ydata2, stderrs = zip(*[(x, y, stderr) for x, y, stderr in zip(xdata, ydata2, stderrs) if y > 0])\n",
    "        xdata = np.array(xdata)\n",
    "        #ydata1 = np.array(ydata1)\n",
    "        ydata2 = np.array(ydata2)\n",
    "        ydata1 = transform_data(xdata, ydata2, compression_factor)\n",
    "        _sigma = expansion_factor(xdata)\n",
    "        _sigma = _sigma / sum(_sigma)\n",
    "        sigma = _sigma if use_sigma else None\n",
    "        r = fit_and_plot(ax=ax[i][j],\n",
    "                         fit_func1=fit_func1, \n",
    "                         fit_func2=fit_func2,\n",
    "                         xdata=xdata, \n",
    "                         ydata1=ydata1, \n",
    "                         ydata2=ydata2, \n",
    "                         bins=bins,\n",
    "                         bounds=bounds,\n",
    "                         sigma=sigma,\n",
    "                         absolute_sigma=absolute_sigma,\n",
    "                         ylim=ylim,\n",
    "                         max_nfev=max_nfev,\n",
    "                         expand_data=expand_data)\n",
    "        mr1, mr2 = r\n",
    "        results[v][dn] = r\n",
    "        sgs = species_group_names[sg]\n",
    "        cts = cover_type_names_short[ct]\n",
    "        dns = dist_names_long[dn]\n",
    "        ax[i][j].set_ylabel('Meta-plot %s, %s' % (sg, ct))\n",
    "        ax[i][0].set_ylabel('Relative Frequency')\n",
    "        ax[i][j].set_xlabel('Meta-plot: %s-%s, Distribution: %s' % (sgs, cts, dns))\n",
    "        sample_size = len(_df)\n",
    "        out_data['species'].append(sgs)\n",
    "        out_data['covertype'].append(cts)\n",
    "        out_data['distribution'].append(dns)\n",
    "        out_data['samplesize'].append(sample_size)\n",
    "        out_data['chisqr1'].append(mr1.chisqr)\n",
    "        out_data['chisqr2'].append(mr2.chisqr)        \n",
    "plt.tight_layout()\n",
    "#plt.savefig(data_path + 'dbhdistfit_method-hpsdata.pdf', format='pdf')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Print out results in $\\LaTeX$ tabular format."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>species</th>\n",
       "      <th>covertype</th>\n",
       "      <th>samplesize</th>\n",
       "      <th>distribution</th>\n",
       "      <th>chisqr1</th>\n",
       "      <th>chisqr2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>SPFL</td>\n",
       "      <td>S</td>\n",
       "      <td>6115</td>\n",
       "      <td>W</td>\n",
       "      <td>4.917945e-09</td>\n",
       "      <td>0.000033</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>SPFL</td>\n",
       "      <td>S</td>\n",
       "      <td>6115</td>\n",
       "      <td>GA</td>\n",
       "      <td>4.492844e-09</td>\n",
       "      <td>0.000028</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Birch</td>\n",
       "      <td>M</td>\n",
       "      <td>1605</td>\n",
       "      <td>W</td>\n",
       "      <td>5.882437e-08</td>\n",
       "      <td>0.000081</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Birch</td>\n",
       "      <td>M</td>\n",
       "      <td>1605</td>\n",
       "      <td>GA</td>\n",
       "      <td>5.696895e-08</td>\n",
       "      <td>0.000122</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Maple</td>\n",
       "      <td>H</td>\n",
       "      <td>1290</td>\n",
       "      <td>W</td>\n",
       "      <td>7.466788e-08</td>\n",
       "      <td>0.000070</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Maple</td>\n",
       "      <td>H</td>\n",
       "      <td>1290</td>\n",
       "      <td>GA</td>\n",
       "      <td>8.409193e-08</td>\n",
       "      <td>0.000108</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  species covertype  samplesize distribution       chisqr1   chisqr2\n",
       "0    SPFL         S        6115            W  4.917945e-09  0.000033\n",
       "1    SPFL         S        6115           GA  4.492844e-09  0.000028\n",
       "2   Birch         M        1605            W  5.882437e-08  0.000081\n",
       "3   Birch         M        1605           GA  5.696895e-08  0.000122\n",
       "4   Maple         H        1290            W  7.466788e-08  0.000070\n",
       "5   Maple         H        1290           GA  8.409193e-08  0.000108"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_out = pd.DataFrame(out_data)[out_flds]\n",
    "df_out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.13"
  },
  "nav_menu": {},
  "toc": {
   "navigate_menu": true,
   "number_sections": true,
   "sideBar": true,
   "threshold": 6,
   "toc_cell": false,
   "toc_section_display": "block",
   "toc_window_display": true
  },
  "toc_position": {
   "height": "900px",
   "left": "0px",
   "right": "1708px",
   "top": "106px",
   "width": "212px"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}