{"cells": [{"cell_type": "raw", "id": "3ef6e4ee", "metadata": {"raw_mimetype": "text/restructuredtext"}, "source": ["Customization and Control\n", "#########################\n", "\n", ".. contents::\n", "\n", "\n", "\n", "\n", ".. note::\n", "\n", "    Download the example file here:  `HP3_TE300_SPC630.hdf5 <https://zenodo.org/record/5902313/files/HP3_TE300_SPC630.hdf5>`_\n", "\n", "First, let's run the following code to generate a basic analysis for us to begin working with.\n", "This code is essential the same as that found in the :doc:`tutorial <Tutorial>` ."]}, {"cell_type": "code", "execution_count": 1, "id": "bec4fd47", "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": [" - Optimized (cython) burst search loaded.\n", " - Optimized (cython) photon counting loaded.\n", "--------------------------------------------------------------\n", " You are running FRETBursts (version 0.7.1).\n", "\n", " If you use this software please cite the following paper:\n", "\n", "   FRETBursts: An Open Source Toolkit for Analysis of Freely-Diffusing Single-Molecule FRET\n", "   Ingargiola et al. (2016). http://dx.doi.org/10.1371/journal.pone.0160716 \n", "\n", "--------------------------------------------------------------\n", "# Total photons (after ALEX selection):    11,414,157\n", "#  D  photons in D+A excitation periods:    5,208,392\n", "#  A  photons in D+A excitation periods:    6,205,765\n", "# D+A photons in  D  excitation period:     6,611,308\n", "# D+A photons in  A  excitation period:     4,802,849\n", "\n", " - Calculating BG rates ... get bg th arrays\n", "Channel 0\n", "[DONE]\n", " - Performing burst search (verbose=False) ...[DONE]\n", " - Calculating burst periods ...[DONE]\n", " - Counting D and A ph and calculating FRET ... \n", "   - Applying background correction.\n", "   [DONE Counting D/A]\n"]}, {"data": {"text/plain": ["The model converged after 2 iterations"]}, "metadata": {}, "output_type": "display_data"}, {"data": {"text/plain": ["The model converged after 35 iterations"]}, "metadata": {}, "output_type": "display_data"}, {"data": {"text/plain": ["The model converged after 128 iterations"]}, "metadata": {}, "output_type": "display_data"}, {"data": {"text/plain": ["The model converged after 423 iterations"]}, "metadata": {}, "output_type": "display_data"}, {"data": {"text/plain": ["2"]}, "execution_count": 1, "metadata": {}, "output_type": "execute_result"}], "source": ["import numpy as np\n", "from matplotlib import pyplot as plt\n", "\n", "import fretbursts as frb\n", "import burstH2MM as bhm\n", "\n", "filename = 'HP3_TE300_SPC630.hdf5'\n", "# load the data into the data object frbdata\n", "frbdata = frb.loader.photon_hdf5(filename)\n", "# plot the alternation histogram\n", "# frb.bpl.plot_alternation_hist(frbdata)  # commented to prevent plotting\n", "# if the alternation period is correct, apply data\n", "frb.loader.alex_apply_period(frbdata)\n", "# calcualte the background rate\n", "frbdata.calc_bg(frb.bg.exp_fit, F_bg=1.7)\n", "# plot bg parameters, to verify quality\n", "# frb.dplot(frbdata, frb.hist_bg) # commented to prevent plotting\n", "# now perform burst search\n", "frbdata.burst_search(m=10, F=6)\n", "# make sure to set the appropriate thresholds of ALL size\n", "# parameters to the particulars of your experiment\n", "frbdata_sel = frbdata.select_bursts(frb.select_bursts.size, th1=50)\n", "# frb.alex_jointplot(frbdata_sel) # commented to prevent plotting\n", "# import into burstH2MM\n", "bdata = bhm.BurstData(frbdata_sel)\n", "bdata.models.calc_models()"]}, {"cell_type": "raw", "id": "710bb05b", "metadata": {"raw_mimetype": "text/restructuredtext"}, "source": [".. _custplot:\n", "\n", "\n", "Caclulating Nanotimes with Confidence Threshold\n", "###############################################\n", "\n", "\n", "\n", "By default, when calculating :attr:`H2MM_result.nanohist <burstH2MM.BurstSort.H2MM_result.nanohist>` and :attr:`H2MM_result.dwell_nano_mean <burstH2MM.BurstSort.H2MM_result.dwell_nano_mean>` , all photons are considered. \n", "However, not every photon is necessarily the best way to do this, as we can be more confident of some photon state assignments than others. \n", "This comes by way of the :attr:`H2MM_result.scale <burstH2MM.BurstSort.H2MM_result.scale>`  parameter, which is a measure of the likelihood of the photon being in the state assigned by the *Viterbi* algorithm (it is one of the outputs of the *Viterbi* algorithm itself). \n", "Now, it does not make sense to use this for calculating dwell duration, or even E/S values, as these are very much dependent on taking the whole dwell. \n", "However, for nanotime parameters, some filtration could be useful (although in our tests, it has never made a significant difference, but we still wanted to provide the option).\n", "\n", ".. note::\n", "\n", "    The ``scale`` parameter is a likelihood parameter, therefore it is contained within the interval (0,1).\n", "    Therefore confidence thresholds must also fall within the interval \\[0,1).\n", "    Setting to 0 will result in all photons being considered.\n", "\n", "This can be done in two ways: \n", "1. Using functions, without changing the stored parameter values \n", "2. Using :attr:`H2MM_result.conf_thresh <burstH2MM.BurstSort.H2MM_result.conf_thresh>` , which will change stored parameters :attr:`H2MM_result.nanohist <burstH2MM.BurstSort.H2MM_result.nanohist>` and :attr:`H2MM_result.dwell_nano_mean <burstH2MM.BurstSort.H2MM_result.dwell_nano_mean>` \n", "\n", "For option 1, the appropriately named functions :func:`calc_nanohist() <burstH2MM.BurstSort.calc_nanohist>` and :func:`calc_dwell_nanomean() <burstH2MM.BurstSort.calc_dwell_nanomean>`  exist. \n", "To set a threshold, use the keyword argument ``conf_thresh`` like so:"]}, {"cell_type": "code", "execution_count": 10, "id": "f086c6ac", "metadata": {}, "outputs": [], "source": ["# set irf thresh\n", "bdata.irf_thresh = np.array([2355, 2305, 220])\n", "# recalculate the nanotime histogram excluding photons with a scale value less than 0.3\n", "nanohist = bhm.calc_nanohist(bdata.models[2], conf_thresh=0.3)\n", "# calculate mean nanotimes of DexDem stream with same threshold\n", "dwell_nano_mean_dd = bhm.calc_dwell_nanomean(bdata.models[2], frb.Ph_sel(Dex='Dem'), 2355, conf_thresh=0.3)"]}, {"cell_type": "raw", "id": "8dd0c1b0", "metadata": {"raw_mimetype": "text/restructuredtext"}, "source": [".. note::\n", "\n", "    The second argument of :func:`calc_dwell_nanomean() <burstH2MM.BurstSort.calc_dwell_nanomean>` is the desired photon stream.\n", "    The third argument of :func:`calc_dwell_nanomean() <burstH2MM.BurstSort.calc_dwell_nanomean>` is the threshold for the IRF.\n", "    You could also input ``bdata.models[2].irf_thresh`` and :func:`calc_dwell_nanomean() <burstH2MM.BurstSort.calc_dwell_nanomean>` will automatically choose the right threshold for the given photon stream.\n", "\n", "Using option 2, you will only need to do the following:"]}, {"cell_type": "code", "execution_count": 11, "id": "a226bda9", "metadata": {}, "outputs": [], "source": ["bdata.models[2].conf_thresh = 0.3"]}, {"cell_type": "raw", "id": "867cd58c", "metadata": {"raw_mimetype": "text/restructuredtext"}, "source": ["And the  :attr:`H2MM_result.nanohist <burstH2MM.BurstSort.H2MM_result.nanohist>` and :attr:`H2MM_result.dwell_nano_mean <burstH2MM.BurstSort.H2MM_result.dwell_nano_mean>` attributes of the :class:`H2MM_result <burstH2MM.BurstSort.H2MM_result>` attribute will be updated\n", "\n", ".. note::\n", "\n", "    The :attr:`H2MM_result.conf_thresh <burstH2MM.BurstSort.H2MM_result.conf_thresh>` attribute is specific to each :class:`H2MM_result <burstH2MM.BurstSort.H2MM_result>` , so set each one you are interested in individually.\n", "    This is because the distribution of likelihoods is not comparable for models with different numbers of states.\n", "\n", ".. _custphotstream:\n", "\n", "\n", "Customizing Photon Streams (mp vs sp H\\ :sup:`2`\\ MM)\n", "*****************************************************\n", "\n", "\n", "\n", "You may have noticed that in :doc:`Control plotting functions <PlottingFunctions>` that when arrays are organized by photon stream, they always go in the order D\\ :sub:`ex`\\ D\\ :sub:`em`\\ , D\\ :sub:`ex`\\ A\\ :sub:`em`\\ , A\\ :sub:`ex`\\ A\\ :sub:`em`\\ . \n", "This is the default, but if \n", "\n", "1. The data does not have alternating excitation **or**\n", "2. You have explicitly specified when creating the :class:`BurstData <burstH2MM.BurstSort.BurstData>` object.\n", "\n", "then the photon streams may not follow this pattern.\n", "\n", "To check the order in which photon streams are specified, you can access the :attr:`BurstData.ph_streams <burstH2MM.BurstSort.BurstData.ph_streams>` attribute:"]}, {"cell_type": "code", "execution_count": 12, "id": "db711f0d", "metadata": {}, "outputs": [{"data": {"text/plain": ["(Ph_sel(Dex='Dem', Aex=None),\n", " Ph_sel(Dex='Aem', Aex=None),\n", " Ph_sel(Dex=None, Aex='Aem'))"]}, "execution_count": 12, "metadata": {}, "output_type": "execute_result"}], "source": ["bdata.ph_streams"]}, {"cell_type": "raw", "id": "83647b16", "metadata": {"raw_mimetype": "text/restructuredtext"}, "source": ["This will always return a tuple of the actual order of photon streams for instance in the  :attr:`H2MM_result.nanohist <burstH2MM.BurstSort.H2MM_result.nanohist>` or :attr:`H2MM_result.dwell_ph_counts <burstH2MM.BurstSort.H2MM_result.dwell_ph_counts>` arrays.\n", "\n", "So, what if for some reason you want to create a :class:`BurstData <burstH2MM.BurstSort.BurstData>`  object with a different selection of photon streams? \n", "For instance, if you know your A\\ :sub:`ex`\\ A\\ :sub:`em`\\ stream will introduce undesirable behavior, or just want to compare, you can specify the ``ph_streams`` keyword argument with a list/tuple of the order of streams you want, defined using FRETBurst ``Ph_sel`` objects.\n", "\n", ".. note::\n", "\n", "    burstH2MM is smart, in calculating E and S values, it will do so correctly regardless of the order in which :attr:`BurstData.ph_streams <burstH2MM.BurstSort.BurstData.ph_streams>` is specified, because it automatically identifies which stream is which for the appropriate calculations.\n", "    This also means that if there is no A\\ :sub:`ex`\\ A\\ :sub:`em`\\ stream, then an error will be raised if you attempt to access a stoichiometry based value.\n", "\n", "So let\u2019s demonstrate this, where we will perform H\\ :sup:`2`\\ MM in the original form, using only D\\ :sub:`ex`\\ D\\ :sub:`em`\\ and D\\ :sub:`ex`\\ A\\ :sub:`em`\\ streams:"]}, {"cell_type": "code", "execution_count": 13, "id": "06c62953", "metadata": {}, "outputs": [{"data": {"text/plain": ["The model converged after 3 iterations"]}, "metadata": {}, "output_type": "display_data"}, {"data": {"text/plain": ["The model converged after 40 iterations"]}, "metadata": {}, "output_type": "display_data"}, {"data": {"text/plain": ["The model converged after 510 iterations"]}, "metadata": {}, "output_type": "display_data"}, {"data": {"text/plain": ["Optimization reached maximum number of iterations"]}, "metadata": {}, "output_type": "display_data"}, {"data": {"text/plain": ["[<matplotlib.collections.PathCollection at 0x7fee222ea790>]"]}, "execution_count": 13, "metadata": {}, "output_type": "execute_result"}, {"data": {"image/png": "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\n", "text/plain": ["<Figure size 432x288 with 1 Axes>"]}, "metadata": {}, "output_type": "display_data"}], "source": ["# make 2 stream BurstData\n", "spdata = bhm.BurstData(frbdata_sel, ph_streams=[frb.Ph_sel(Dex='Dem'), frb.Ph_sel(Dex='Aem')])\n", "# run optimization\n", "spdata.models.calc_models()\n", "# plot ICL to choose the best model\n", "bhm.ICL_plot(spdata.models)"]}, {"cell_type": "raw", "id": "2639c96f", "metadata": {"raw_mimetype": "text/restructuredtext"}, "source": ["Great! Now we can look at the dwell FRET histogram: "]}, {"cell_type": "code", "execution_count": 14, "id": "e96c1b24", "metadata": {}, "outputs": [{"data": {"text/plain": ["[<BarContainer object of 20 artists>,\n", " <BarContainer object of 20 artists>,\n", " <BarContainer object of 20 artists>]"]}, "execution_count": 14, "metadata": {}, "output_type": "execute_result"}, {"data": {"image/png": "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\n", "text/plain": ["<Figure size 432x288 with 1 Axes>"]}, "metadata": {}, "output_type": "display_data"}], "source": ["bhm.dwell_E_hist(spdata.models[2])"]}, {"cell_type": "raw", "id": "f99f4248", "metadata": {"raw_mimetype": "text/restructuredtext"}, "source": ["Just be aware, if you try to get a stoichiometry based value (any of them!) you will get an error: "]}, {"cell_type": "code", "execution_count": 15, "id": "dd35f8d8", "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["Parent BurstData must include AexAem stream \n"]}], "source": ["try:\n", "    bhm.dwell_ES_scatter(spdata.models[2])\n", "except Exception as e:\n", "    print(e)"]}, {"cell_type": "raw", "id": "065182e5", "metadata": {"raw_mimetype": "text/restructuredtext"}, "source": [".. _divlochowto:\n", "\n", "\n", "Customizing divisors\n", "********************\n", "\n", "\n", "\n", "There are two methods for defining new divisor schemes.\n", "\n", "1. :meth:`BurstData.auto_div() <burstH2MM.BurstSort.BurstData.auto_div>`  - high level method\n", "2. :meth:`BurstData.new_div() <burstH2MM.BurstSort.BurstData.new_div>` - low level method\n", "\n", ".. note::\n", "\n", "    :meth:`BurstData.auto_div() <burstH2MM.BurstSort.BurstData.auto_div>` acutally calls :meth:`BurstData.new_div() <burstH2MM.BurstSort.BurstData.new_div>` , but simplifies the specification of divisors to the end user.\n", "\n", "So let\u2019s see it in action:"]}, {"cell_type": "code", "execution_count": 16, "id": "c2c5a748", "metadata": {}, "outputs": [], "source": ["name = bdata.auto_div(2)"]}, {"cell_type": "raw", "id": "cbc13ac5", "metadata": {"raw_mimetype": "text/restructuredtext"}, "source": ["So where are the divisors in this system? \n", "In all streams, there are 2 divisors (3 indices per stream), and they equally divide the nanotimes into these indices. \n", "\n", "We can see the nanotimes of these divisors using the :attr:`H2MM_list.divisor_scheme <burstH2MM.BurstSort.H2MM_list.divisor_scheme>`  attribute, and compare where they are relative to the nanotime decays. \n", "We will use the :func:`raw_nanotime_hist() <burstH2MM.Plotting.raw_nanotime_hist>` to plot the nanotime decays, and place vertical lines at the positions of the divisors:"]}, {"cell_type": "code", "execution_count": 17, "id": "5852268e", "metadata": {}, "outputs": [{"data": {"text/plain": ["[[<matplotlib.lines.Line2D at 0x7fee221f8040>,\n", "  <matplotlib.lines.Line2D at 0x7fee22170c40>],\n", " [<matplotlib.lines.Line2D at 0x7fee22170fd0>,\n", "  <matplotlib.lines.Line2D at 0x7fee2217a340>],\n", " [<matplotlib.lines.Line2D at 0x7fee2217a6a0>,\n", "  <matplotlib.lines.Line2D at 0x7fee2217aa00>]]"]}, "execution_count": 17, "metadata": {}, "output_type": "execute_result"}, {"data": {"image/png": "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\n", "text/plain": ["<Figure size 432x288 with 1 Axes>"]}, "metadata": {}, "output_type": "display_data"}], "source": ["fig, ax = plt.subplots()\n", "# plot histogram of nanotimes by stream\n", "bhm.raw_nanotime_hist(bdata, ax=ax)\n", "divs = bdata.div_models[name].divisor_scheme\n", "# plot vertical lines of divs\n", "bhm.axline_divs(bdata.div_models[name], ax=ax)"]}, {"cell_type": "raw", "id": "8e9cd7db", "metadata": {"raw_mimetype": "text/restructuredtext"}, "source": [":meth:`BurstData.auto_div() <burstH2MM.BurstSort.BurstData.auto_div>` offers the option to add one more level of granularity:"]}, {"cell_type": "code", "execution_count": 18, "id": "56ab9202", "metadata": {}, "outputs": [{"data": {"text/plain": ["[[<matplotlib.lines.Line2D at 0x7fee1c1a4a00>,\n", "  <matplotlib.lines.Line2D at 0x7fee1c1664f0>],\n", " [<matplotlib.lines.Line2D at 0x7fee1c166850>],\n", " [<matplotlib.lines.Line2D at 0x7fee1c166bb0>]]"]}, "execution_count": 18, "metadata": {}, "output_type": "execute_result"}, {"data": {"image/png": "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\n", "text/plain": ["<Figure size 432x288 with 1 Axes>"]}, "metadata": {}, "output_type": "display_data"}], "source": ["# make new divisor set\n", "name211 = bdata.auto_div([2,1,1])\n", "# now call same plotting code as before\n", "fig, ax = plt.subplots()\n", "# plot histogram of nanotimes by stream\n", "bhm.raw_nanotime_hist(bdata, ax=ax)\n", "# plot vertical lines of divs\n", "bhm.axline_divs(bdata.div_models[name211], ax=ax)"]}, {"cell_type": "raw", "id": "498ee76b", "metadata": {"raw_mimetype": "text/restructuredtext"}, "source": ["So what will this do? \n", "Now, the number of divisors is specified per stream, meaning the D :sub:`ex`\\ D\\ :sub:`em`\\ stream will have 2 divisors, while the D\\ :sub:`ex`\\ A\\ :sub:`em`\\ and A\\ :sub:`ex`\\ A\\ :sub:`em`\\  streams will have only 1 divisor. \n", "The even distribution of nanotimes between the divisors will however be maintained.\n", "\n", "If you look at the documentation, you will notice that there is a keyword argument ``include_irf_thresh`` . \n", "This adds a divisor to the already existing divisors, which is the threshold set in :attr:`BurstData.irf_thresh <burstH2MM.BurstSort.BurstData.irf_thresh>` . \n", "So, if you call :meth:`BurstData.auto_div() <burstH2MM.BurstSort.BurstData.auto_div>` with ``inlcude_irf_thresh=True`` , there will be one extra divisor than if you had called it with ``inlcude_irf_thresh=False`` (the default).:"]}, {"cell_type": "code", "execution_count": 19, "id": "e4554497", "metadata": {}, "outputs": [{"data": {"text/plain": ["[[<matplotlib.lines.Line2D at 0x7fee1c14c100>,\n", "  <matplotlib.lines.Line2D at 0x7fee1c107790>,\n", "  <matplotlib.lines.Line2D at 0x7fee1c107af0>],\n", " [<matplotlib.lines.Line2D at 0x7fee1c107e50>,\n", "  <matplotlib.lines.Line2D at 0x7fee1c0921f0>,\n", "  <matplotlib.lines.Line2D at 0x7fee1c092550>],\n", " [<matplotlib.lines.Line2D at 0x7fee1c0928b0>,\n", "  <matplotlib.lines.Line2D at 0x7fee1c092c10>,\n", "  <matplotlib.lines.Line2D at 0x7fee1c092f70>]]"]}, "execution_count": 19, "metadata": {}, "output_type": "execute_result"}, {"data": {"image/png": "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\n", "text/plain": ["<Figure size 432x288 with 1 Axes>"]}, "metadata": {}, "output_type": "display_data"}], "source": ["bdata.irf_thresh = np.array([2355, 2305, 220])\n", "nameirf = bdata.auto_div(2, include_irf_thresh=True)\n", "# call same plotting code as before\n", "fig, ax = plt.subplots()\n", "bhm.raw_nanotime_hist(bdata, ax=ax)\n", "# plot vertical lines of divs\n", "bhm.axline_divs(bdata.div_models[nameirf], ax=ax)"]}, {"cell_type": "raw", "id": "d2ffbc39", "metadata": {"raw_mimetype": "text/restructuredtext"}, "source": ["Finally,  :meth:`BurstData.new_div() <burstH2MM.BurstSort.BurstData.new_div>`  offers the greatest granularity, but also requires the most work by the user. \n", "When using :meth:`BurstData.new_div() <burstH2MM.BurstSort.BurstData.new_div>` , you must specify the nanotime divisors themselves.\n", "\n", "The function call looks like this:"]}, {"cell_type": "code", "execution_count": 20, "id": "69e136f1", "metadata": {}, "outputs": [{"data": {"text/plain": ["[[<matplotlib.lines.Line2D at 0x7fee1c079400>],\n", " [<matplotlib.lines.Line2D at 0x7fee1c034be0>],\n", " [<matplotlib.lines.Line2D at 0x7fee1c034f40>]]"]}, "execution_count": 20, "metadata": {}, "output_type": "execute_result"}, {"data": {"image/png": "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\n", "text/plain": ["<Figure size 432x288 with 1 Axes>"]}, "metadata": {}, "output_type": "display_data"}], "source": ["divs = [np.array([2500]), np.array([3000]), np.array([800])]\n", "namecustom = bdata.new_div(divs)\n", "# call same plotting code as before\n", "fig, ax = plt.subplots()\n", "bhm.raw_nanotime_hist(bdata, ax=ax)\n", "divs = bdata.div_models[namecustom].divisor_scheme\n", "# plot vertical lines of divs\n", "bhm.axline_divs(bdata.div_models[namecustom], ax=ax)"]}, {"cell_type": "raw", "id": "04c13c37", "metadata": {"raw_mimetype": "text/restructuredtext"}, "source": ["Customizing optimizations\n", "*************************\n", "\n", "\n", "\n", "As a wrapper around  `H2MM_C <https://h2mmpythonlib.readthedocs.io>`_ , burstH2MM handles a lot of the inner details of working with  `H2MM_C <https://h2mmpythonlib.readthedocs.io>`_ automatically, however, it does allow the user to override these defaults.\n", "\n", ":meth:`H2MM_list.calc_models() <burstH2MM.BurstSort.H2MM_list.calc_models>` automatically optimizes several H\\ :sup:`2`\\ MM models, and the initial H\\ :sup:`2`\\ MM models used in those optmizations are provided in those optimizations. \n", "If you have a look at the documentation, there also exists the :meth:`H2MM_list.optimize() <burstH2MM.BurstSort.H2MM_list.optimize>` method, and its first argument is an ``H2MM_C.h2mm_model`` , this method is the actual method that makes each :class:`H2MM_result <burstH2MM.BurstSort.H2MM_result>` object, and relies on ``H2MM_C.h2mm_model.optimize()`` to optimize the input ``H2MM_C.h2mm_model`` , which is the basis of the :class:`H2MM_result <burstH2MM.BurstSort.H2MM_result>`  object. \n", ":meth:`H2MM_list.calc_models() <burstH2MM.BurstSort.H2MM_list.calc_models>` actually calls :meth:`H2MM_list.optimize() <burstH2MM.BurstSort.H2MM_list.optimize>` for each state model, and uses ``H2MM_C.factory_h2mm_model()`` to make the input models.\n", "\n", "Using :meth:`H2MM_list.optimize() <burstH2MM.BurstSort.H2MM_list.optimize>`\n", "===========================================================================\n", "\n", "\n", "\n", "So, if you want to control the initial models, you can use :meth:`H2MM_list.optimize() <burstH2MM.BurstSort.H2MM_list.optimize>` instead like so:\n", "\n", ".. note::\n", "\n", "    If a given state-model has already been optimized, you must specify the keyword argument ``replace=True`` :\n", "\n", ""]}, {"cell_type": "code", "execution_count": 21, "id": "4f91dd20", "metadata": {}, "outputs": [{"data": {"text/plain": ["The model converged after 34 iterations"]}, "metadata": {}, "output_type": "display_data"}], "source": ["# we need to add H2MM_C to generate the models\n", "import H2MM_C as h2\n", "\n", "# make custom initial model\n", "prior = np.array([0.75, 0.25])\n", "trans = np.array([[1 - 1e-7, 1e-7],\n", "                  [3e-7, 1 - 3e-7]])\n", "obs = np.array([[0.4, 0.1, 0.5],\n", "                [0.2, 0.3, 0.5]])\n", "init = h2.h2mm_model(prior, trans, obs)\n", "\n", "# now we can optimize with the custom model\n", "bdata.models.optimize(init, replace=True)"]}, {"cell_type": "raw", "id": "4ff7ca9f", "metadata": {"raw_mimetype": "text/restructuredtext"}, "source": [":meth:`H2MM_list.optimize() <burstH2MM.BurstSort.H2MM_list.optimize>` also allows passing the same keyword arguments as ``H2MM_C.h2mm_model.optimize()`` , and thus the maxiumum number of iterations and other limits can be controlled in this same way.\n", "\n", "For instance:"]}, {"cell_type": "code", "execution_count": 22, "id": "f77154ff", "metadata": {}, "outputs": [{"data": {"text/plain": ["The model converged after 144 iterations"]}, "metadata": {}, "output_type": "display_data"}], "source": ["prior = np.array([0.5, 0.25, 0.25])\n", "trans = np.array([[1 - 2e-7, 1e-7, 1e-7],\n", "                  [2e-7, 1 - 3e-7, 1e-7],\n", "                  [2e-7, 1e-7, 1 - 3e-7]])\n", "obs = np.array([[0.4, 0.1, 0.5],\n", "                [0.2, 0.3, 0.5],\n", "                [0.1, 0.1, 0.8]])\n", "init = h2.h2mm_model(prior, trans, obs)\n", "bdata.models.optimize(init, max_iter=7200, replace=True)"]}, {"cell_type": "raw", "id": "76a4170c", "metadata": {"raw_mimetype": "text/restructuredtext"}, "source": ["Using :meth:`H2MM_list.calc_models() <burstH2MM.BurstSort.H2MM_list.calc_models>`\n", "=================================================================================\n", "\n", "\n", "\n", ":meth:`H2MM_list.calc_models() <burstH2MM.BurstSort.H2MM_list.calc_models>` functions in essentially the same way.\n", "\n", ".. note::\n", "\n", "    Since we are running this notebook top to bottom, we set the ``replace=True`` keyword argument.\n", "\n", ""]}, {"cell_type": "code", "execution_count": 23, "id": "4b1b270c", "metadata": {}, "outputs": [{"data": {"text/plain": ["The model converged after 1 iterations"]}, "metadata": {}, "output_type": "display_data"}, {"data": {"text/plain": ["The model converged after 36 iterations"]}, "metadata": {}, "output_type": "display_data"}, {"data": {"text/plain": ["The model converged after 128 iterations"]}, "metadata": {}, "output_type": "display_data"}, {"data": {"text/plain": ["The model converged after 414 iterations"]}, "metadata": {}, "output_type": "display_data"}, {"data": {"text/plain": ["2"]}, "execution_count": 23, "metadata": {}, "output_type": "execute_result"}], "source": ["bdata.models.calc_models(max_iter=7200, replace=True)"]}, {"cell_type": "raw", "id": "db01a9e5", "metadata": {"raw_mimetype": "text/restructuredtext"}, "source": ["So now all optimizations will run for a maximum of 7200 iterations instead of the default of 3600. \n", "\n", "You can even specify initial models using :meth:`H2MM_list.calc_models() <burstH2MM.BurstSort.H2MM_list.calc_models>` , using the ``models``  keyword argument. \n", "For this, simply hand models a list of ``H2MM_C.h2mm_model``  objects. \n", ":meth:`H2MM_list.calc_models() <burstH2MM.BurstSort.H2MM_list.calc_models>`  will then use those models as initial models. \n", "However, :meth:`H2MM_list.calc_models() <burstH2MM.BurstSort.H2MM_list.calc_models>` still obeys the other settings provided, eg. it will start optimizing the model with ``min_state`` number of states, and optimize at least to to_state, until ``conv_crit`` or ``max_state``  number of states is reached. \n", ":meth:`H2MM_list.calc_models() <burstH2MM.BurstSort.H2MM_list.calc_models>` will use the model for that number of states given to models, and if such a model does not exist within models, it will fall back on using ``H2MM_C.factory_h2mm_model()`` to generate the function.\n", "\n", ".. note::\n", "\n", "    If you are trying to bound optimizations with ``bounds_func`` and ``bounds`` keyword arguments, be aware that you must use them such that the will work for all optimizations.\n", "    This means that specifying arrays for the ``trans`` / ``obs`` / ``prior`` limits will not work.\n", "    If you wish to set the bounds for each state-model optimization, use :meth:`H2MM_list.optimize() <burstH2MM.BurstSort.H2MM_list.optimize>` instead.\n", "\n", "So let\u2019s see an example:"]}, {"cell_type": "code", "execution_count": 24, "id": "d7efb2ab", "metadata": {}, "outputs": [{"data": {"text/plain": ["The model converged after 31 iterations"]}, "metadata": {}, "output_type": "display_data"}, {"data": {"text/plain": ["The model converged after 141 iterations"]}, "metadata": {}, "output_type": "display_data"}, {"data": {"text/plain": ["2"]}, "execution_count": 24, "metadata": {}, "output_type": "execute_result"}], "source": ["# setup 2 state initial model\n", "prior2 = np.array([0.75, 0.25])\n", "trans2 = np.array([[1 - 1e-7, 1e-7],\n", "                  [3e-7, 1 - 3e-7]])\n", "obs2 = np.array([[0.4, 0.1, 0.5],\n", "                [0.2, 0.3, 0.5]])\n", "init2 = h2.h2mm_model(prior2, trans2, obs2)\n", "\n", "# setup 3 state initial model\n", "prior3 = np.array([0.5, 0.25, 0.25])\n", "trans3 = np.array([[1 - 2e-7, 1e-7, 1e-7],\n", "                  [2e-7, 1 - 3e-7, 1e-7],\n", "                  [2e-7, 1e-7, 1 - 3e-7]])\n", "obs3 = np.array([[0.4, 0.1, 0.5],\n", "                [0.2, 0.3, 0.5],\n", "                [0.1, 0.1, 0.8]])\n", "init3 = h2.h2mm_model(prior3, trans3, obs3)\n", "\n", "# make model list\n", "inits = [init2, init3]\n", "\n", "# run optimization with some initial models\n", "bdata.models.calc_models(models=inits)"]}, {"cell_type": "raw", "id": "9a0b9cb5", "metadata": {"raw_mimetype": "text/restructuredtext"}, "source": ["If not already optimized, this will optimize even the 1 state and 4 state models, using  ``H2MM_C.factory_h2mm_model()``  to create them. \n", "But when it optimizes the 2 state model, it will use ``init2`` , and the 3 state model will use ``init3`` .", "\n", "\n", "Download this documentation as a jupyter notebook here: :download:`Customization.ipynb <notebooks/Customization.ipynb>`"]}], "metadata": {"kernelspec": {"display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3"}, "language_info": {"codemirror_mode": {"name": "ipython", "version": 3}, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.12"}}, "nbformat": 4, "nbformat_minor": 5}