{ "cells": [ { "cell_type": "markdown", "metadata": { "collapsed": true, "deletable": true, "editable": true }, "source": [ "# Replicates Figs 4, D, and E. And, Tables A and B." ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "### Importing useful functions" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "###### \n", "import numpy as np\n", "from matplotlib import pyplot as plt\n", "from matplotlib import rc\n", "from matplotlib.pylab import *\n", "import pickle\n", "from scipy.integrate import odeint\n", "from scipy.optimize import curve_fit\n", "from copy import copy\n", "\n", "global resol, thresh" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "thresh=0 #mV\n", "resol=0.01#ms (min resolution of integration)\n" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "collapsed": false, "deletable": true, "editable": true }, "outputs": [], "source": [ "######Importing useful functions\n", "exec(open(\"./functions/f_stimulations_simulations.py\").read())\n", "exec(open(\"./functions/f_plots.py\").read())\n", "exec(open(\"./functions/f_saving_plots.py\").read())\n", "exec(open(\"./functions/f_post_simulation_analysis.py\").read())\n" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "collapsed": false, "deletable": true, "editable": true }, "outputs": [], "source": [ "####### This part is needed just to give a neuron structure to the generation of sim_exp (the specific model is completely irrelevant)\n", "#Model to Analyze\n", "s_model_abrev=\"MTM_W_sPNaS_sICD\"\n", "s_model=\"neuron_\"+s_model_abrev\n", "exec(open(\"./cfg/m_\"+s_model_abrev+\".py\").read())\n", "d_Pars=eval(\"Pars_\"+s_model_abrev)\n", "# #######Importing model to be used########\n", "identifier = getattr(sys.modules[__name__], s_model)\n", "# ############ Creating neuron\n", "d_Pars_copy=copy(d_Pars)\n", "neuron=identifier(d_Pars_copy)" ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "collapsed": false, "deletable": true, "editable": true }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "2.7187500000000004\n", "3 nA spike train recovery Copy\n", "0.309375\n", "Test of Na channel inactivation Copy\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "### Figure properties\n", "matplotlib.rcParams['lines.linewidth']=0.065\n", "fig_wide=matplotlib.rcParams[\"figure.figsize\"][0]\n", "fig_height=matplotlib.rcParams[\"figure.figsize\"][1]\n", "\n", "###################SpikeAmplitudeDecay_#####################################################\n", "########################################################################\n", "################ 1 example Figure with 40Hz depolarizations & 1 example Figure with hyperpolarizations ####################\n", "##########################################################################\n", "#########################################################################\n", "dir_exps='./Data/Recordings/SpikeAmplitude/'\n", "i_s_cell='SpikeAmplitudeExps0_modern'\n", "\n", "import matplotlib.cm as cm\n", "import pandas as pd\n", "import numpy as np\n", "import seaborn as sns\n", "from scipy import stats\n", "from sklearn.metrics import mean_squared_error\n", "\n", "\n", "######################## Loading cell Dictionary ##############################\n", "cell=str(i_s_cell)\n", "f=open(dir_exps+cell+'.pk1', 'rb')\n", "d_Cell=pickle.load(f, encoding='latin1')\n", "f.close()\n", "\n", "for s_descpt in d_Cell.keys():\n", " if d_Cell[s_descpt]!={}:\n", " if len(d_Cell[s_descpt]['s_vars'])==3:\n", " c_s=0\n", " for s_var in d_Cell[s_descpt]['s_vars']:\n", " if 'Time' in s_var:\n", " v_t=d_Cell[s_descpt]['a_vars'][:,c_s]*1000#s To ms\n", " if 'Voltage' in s_var or 'Vm' in s_var:\n", " v_V=d_Cell[s_descpt]['a_vars'][:,c_s]*1000#to mV\n", " if 'Current' in s_var or 'Im' in s_var:\n", " v_Iapp=d_Cell[s_descpt]['a_vars'][:,c_s]*1e9-0.3\n", " c_s+=1\n", " neuron.noisy_current=v_Iapp\n", " sim_exp=organizing_experimentalData(neuron,v_t,v_V)\n", " sp_ampl,sp_V_max,sp_V_min=extract_spike_ampl(sim_exp.a_Results.V, sim_exp.fr[2])\n", " sim=sim_exp\n", " sp_ampl,sp_V_max,sp_V_min=extract_spike_ampl(sim_exp.a_Results.V, sim_exp.fr[2])\n", " if 'inactivation' in s_descpt:\n", " f0=fancy_fig_4_stimulation(sim,title=s_descpt[0:s_descpt.index('Copy')],add_scale=[0.2,'0.2nA'])\n", " print(max(sim.c_neuron.noisy_current))\n", " md_dir={\n", " 'Title':'Experimental trace'+i_s_cell+ ' Small hyperpolarizing pulses',\n", " 'Author':\"Susana Contreras 27/07/2018\",\n", " 'Subject':'Spike amplitude ',\n", " 'Keywords':\"Na dynamic concentration, Na-K-Pump, dependent excitability, adaptation\"\n", " }\n", " fig_file_title='SpikeAmplitudeDecay_'+i_s_cell+'_hyperPol_pulses_vthesis'\n", " print(s_descpt)\n", " else:\n", " f0=fancy_fig_4_stimulation(sim,title='40Hz pulses',add_scale=[1,'1nA'])\n", " print(max(sim.c_neuron.noisy_current))\n", " md_dir={\n", " 'Title':'Experimental trace'+i_s_cell+ ' 40Hz Depolarizing pulses',\n", " 'Author':\"Susana Contreras 27/07/2018\",\n", " 'Subject':'Spike amplitude ',\n", " 'Keywords':\"Na dynamic concentration, Na-K-Pump, dependent excitability, adaptation\"\n", " }\n", " fig_file_title='SpikeAmplitudeDecay_'+i_s_cell+'_40Hz_DepolPulses'\n", " print(s_descpt)\n", " " ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "collapsed": false, "deletable": true, "editable": true }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Fast tau= 355.17241302531386\n", "Slow tau= 22304.006095828543\n", "Ratio Fast slow= 0.32429144086586464\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Fast tau= 1060.3178940175176\n", "Slow tau= 14165.290120479722\n", "Ratio Fast slow= 1.0006006006078538e-07\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Fast tau= 366.388687170984\n", "Slow tau= 17257.730719812\n", "Ratio Fast slow= 0.14188607537156525\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Fast tau= 83.94246294497044\n", "Slow tau= 11541.945823468299\n", "Ratio Fast slow= 0.2518113207194139\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Fast tau= 178.0745099120584\n", "Slow tau= 10683.859493985956\n", "Ratio Fast slow= 0.4252686278564513\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Fast tau= 496.3726647858268\n", "Slow tau= 12667.613136489836\n", "Ratio Fast slow= 0.16879794968355982\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Fast tau= 3688.3982064675256\n", "Slow tau= 94258.65363997004\n", "Ratio Fast slow= 0.23743033747915035\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Trying improvement!\n", "Trying improvement!\n", "Trying improvement!\n", "Trying improvement!\n", "Fast tau= 78.68609092697507\n", "Slow tau= 55268.610329635434\n", "Ratio Fast slow= 0.11064021606642215\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Fast tau= 251.52669272555067\n", "Slow tau= 30154.40298425932\n", "Ratio Fast slow= 0.3953145235744133\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Fast tau= 160.06995409384103\n", "Slow tau= 10802.475606521784\n", "Ratio Fast slow= 0.4797095255371057\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Fast tau= 3663.2065728787925\n", "Slow tau= 37290.8584656668\n", "Ratio Fast slow= 0.21612802333265235\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Fast tau= 256.4206195646063\n", "Slow tau= 14626.904229391988\n", "Ratio Fast slow= 0.2481044820523987\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Fast tau= 469.6783513858691\n", "Slow tau= 17181.99806037583\n", "Ratio Fast slow= 0.18378517565679697\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Fast tau= 221.50908005719796\n", "Slow tau= 15898.562210698303\n", "Ratio Fast slow= 0.16710582139818694\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Fast tau= 2371.165752395139\n", "Slow tau= 5085.075793951244\n", "Ratio Fast slow= 7.292344673741984e-08\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Fast tau= 476.9660836299085\n", "Slow tau= 18907.683758193227\n", "Ratio Fast slow= 0.26001390825723564\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Fast tau= 126.84663360675769\n", "Slow tau= 9616.42528481818\n", "Ratio Fast slow= 0.3433636796077955\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Trying improvement!\n", "Trying improvement!\n", "Trying improvement!\n", "Trying improvement!\n", "Fast tau= 78.5002973797842\n", "Slow tau= 63768.619672510875\n", "Ratio Fast slow= 0.29879187906397514\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Fast tau= 209.93566741863847\n", "Slow tau= 34280.71357980866\n", "Ratio Fast slow= 0.23168054254100431\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "A171218M Failed because: max() arg is an empty sequence\n", "Trying improvement!\n", "Trying improvement!\n", "Trying improvement!\n", "Trying improvement!\n", "Fast tau= 0.018101049867034296\n", "Slow tau= 23140.879624613895\n", "Ratio Fast slow= 0.05879761478977413\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Fast tau= 182.92374343982337\n", "Slow tau= 11775.39819043236\n", "Ratio Fast slow= 0.3915618657997295\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Fast tau= 2163.3709102665152\n", "Slow tau= 37898.91740780164\n", "Ratio Fast slow= 0.3275353116969177\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Trying improvement!\n", "Trying improvement!\n", "Trying improvement!\n", "Trying improvement!\n", "Fast tau= 72.13243022501443\n", "Slow tau= 174162852286363.72\n", "Ratio Fast slow= 3058.2192720499256\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Trying improvement!\n", "Trying improvement!\n", "Trying improvement!\n", "Trying improvement!\n", "Fast tau= 172.3277768734306\n", "Slow tau= 6146.3503519660535\n", "Ratio Fast slow= 0.45426659161756383\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Trying improvement!\n", "Trying improvement!\n", "Trying improvement!\n", "Trying improvement!\n", "Fast tau= 444.90075177568053\n", "Slow tau= 34229.19303880455\n", "Ratio Fast slow= 0.3585924313623662\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Trying improvement!\n", "Trying improvement!\n", "Trying improvement!\n", "Trying improvement!\n", "Fast tau= 2.7027021893685247e-06\n", "Slow tau= 296387341648.86\n", "Ratio Fast slow= 42572.431637987764\n", "Fast tau= 61.49429215718686\n", "Slow tau= 18578.103808234046\n", "Ratio Fast slow= 0.11444319326341226\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Fast tau= 178.44820750868968\n", "Slow tau= 25065.15162345536\n", "Ratio Fast slow= 0.25860588817844155\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Trying improvement!\n", "Trying improvement!\n", "Trying improvement!\n", "Trying improvement!\n", "Fast tau= 0.08907695573686099\n", "Slow tau= 83578.40661053239\n", "Ratio Fast slow= 0.9988310912971493\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Fast tau= 1150.7421551215486\n", "Slow tau= 19530.418840644095\n", "Ratio Fast slow= 0.13878127450752914\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Fast tau= 141.9871092123704\n", "Slow tau= 15524.996943103211\n", "Ratio Fast slow= 0.26186914206114914\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Fast tau= 231.2472896823294\n", "Slow tau= 11609.726701047352\n", "Ratio Fast slow= 0.39593915338619706\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Fast tau= 334.6830595598295\n", "Slow tau= 10772.479246251\n", "Ratio Fast slow= 0.6175069943871558\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Fast tau= 3054.8023823187827\n", "Slow tau= 44290.86434479258\n", "Ratio Fast slow= 0.44515342634822364\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Fast tau= 234.1791020616161\n", "Slow tau= 20907.499787891633\n", "Ratio Fast slow= 0.22817136783656314\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Fast tau= 97.99434224844609\n", "Slow tau= 11540.13801798011\n", "Ratio Fast slow= 0.2577801773629288\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Trying improvement!\n", "Trying improvement!\n", "Trying improvement!\n", "Trying improvement!\n", "Fast tau= 0.027348184860427845\n", "Slow tau= 58744.965182936765\n", "Ratio Fast slow= 0.8850296280839014\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Trying improvement!\n", "Trying improvement!\n", "Trying improvement!\n", "Trying improvement!\n", "Fast tau= 141.0693371455914\n", "Slow tau= 26134.191032117385\n", "Ratio Fast slow= 0.25496998443776353\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Fast tau= 864.0876022171589\n", "Slow tau= 19930.95903534917\n", "Ratio Fast slow= 0.16944349022709132\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "A171219D Failed because: doub_expon_fun_2() missing 5 required positional arguments: 'tau1', 'tau2', 'a', 'b', and 'c'\n", "Fast tau= 151.40663491966754\n", "Slow tau= 13963.556624917219\n", "Ratio Fast slow= 0.16525581101797193\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Fast tau= 273.85373267406925\n", "Slow tau= 19299.439350376964\n", "Ratio Fast slow= 0.4772089934159511\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Fast tau= 190.23268760490464\n", "Slow tau= 20388.679439919673\n", "Ratio Fast slow= 0.4691186201371811\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Fast tau= 100.65407959585214\n", "Slow tau= 12144.062794043744\n", "Ratio Fast slow= 0.1484135307322459\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Fast tau= 257.1657722565231\n", "Slow tau= 22003.858733761117\n", "Ratio Fast slow= 0.34344663108867735\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Fast tau= 1916.6558824652705\n", "Slow tau= 14219.433976332806\n", "Ratio Fast slow= 0.45310917665310174\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Fast tau= 214.35603100780648\n", "Slow tau= 13726.038257978427\n", "Ratio Fast slow= 0.37319871267679716\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "A171212E Failed because: Optimal parameters not found: Number of calls to function has reached maxfev = 1200.\n", "Trying improvement!\n", "Trying improvement!\n", "Trying improvement!\n", "Trying improvement!\n", "Fast tau= 0.015255348552196346\n", "Slow tau= 42742.07096531062\n", "Ratio Fast slow= 0.12684067341022318\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Trying improvement!\n", "Trying improvement!\n", "Fast tau= 15155.396151874203\n", "Slow tau= 662.6940350254025\n", "Ratio Fast slow= 6.457184816778418\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Fast tau= 680.9741531598639\n", "Slow tau= 9540.79892317879\n", "Ratio Fast slow= 0.3194199453189148\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Fast tau= 186.9432368535297\n", "Slow tau= 18832.75740327516\n", "Ratio Fast slow= 0.28705085188513735\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "A171220F Failed because: max() arg is an empty sequence\n", "Fast tau= 79.155509382785\n", "Slow tau= 11339.071798466952\n", "Ratio Fast slow= 0.20995116388190743\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Fast tau= 342.87045592263706\n", "Slow tau= 23012.306182991764\n", "Ratio Fast slow= 0.29820770959583703\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Fast tau= 99.28018199251234\n", "Slow tau= 25166.124843653135\n", "Ratio Fast slow= 0.32154413562917705\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Trying improvement!\n", "Trying improvement!\n", "Trying improvement!\n", "Trying improvement!\n", "Fast tau= 90.71111727767128\n", "Slow tau= 9577.203887158696\n", "Ratio Fast slow= 0.34831826741895705\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:130: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Fast tau= 409.41911256984764\n", "Slow tau= 13616.337574825855\n", "Ratio Fast slow= 0.28465907671891943\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Fast tau= 266.9112411762768\n", "Slow tau= 14969.28468727315\n", "Ratio Fast slow= 0.4303919171946258\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Fast tau= 147.2908109626872\n", "Slow tau= 4312.108482240693\n", "Ratio Fast slow= 0.6862719767321637\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Fast tau= 292.37422095380333\n", "Slow tau= 18717.267708626146\n", "Ratio Fast slow= 0.29105831542187655\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Fast tau= 1907.009189620777\n", "Slow tau= 233813.26499614198\n", "Ratio Fast slow= 0.20010404894882536\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Fast tau= 203.80865255938707\n", "Slow tau= 24169.87441775654\n", "Ratio Fast slow= 0.645622652334997\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Fast tau= 207.0073283341247\n", "Slow tau= 20825.732937033055\n", "Ratio Fast slow= 0.3266583771016809\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Fast tau= 339.4230612050146\n", "Slow tau= 16882.345245497057\n", "Ratio Fast slow= 0.31246484634685484\n" ] } ], "source": [ "########################################################################\n", "########################################################################\n", "################ Stats for all groups 40Hz pulses ####################\n", "##########################################################################\n", "#########################################################################\n", "dir_exps='./Data/Recordings/SpikeAmplitude/'\n", "\n", "import matplotlib.cm as cm\n", "import pandas as pd\n", "import numpy as np\n", "import seaborn as sns\n", "from scipy import stats\n", "from sklearn.metrics import mean_squared_error\n", "######################## Loading cell Dictionary ###############################\n", "dt_pool=['40Hz_Group_1','40Hz_Group_2']\n", "arr_fit=[]\n", "for i_s_cell in dt_pool:\n", " cell=str(i_s_cell)\n", " f=open(dir_exps+cell+'.pk1', 'rb')\n", " d_Cell=pickle.load(f, encoding='latin1')\n", " for i_which_cell in range(len(d_Cell.keys())):\n", " s_Cell=list(d_Cell.keys())[i_which_cell]\n", " if s_Cell!='s_name':\n", " for s_iExp in d_Cell[s_Cell].keys():\n", " i_Exp=d_Cell[s_Cell][s_iExp]\n", " c_s=0\n", " for s_var in i_Exp['s_vars']:\n", " if 'Time' in s_var or '(s))' in s_var:\n", " v_t=i_Exp['a_vars'][:,c_s]*1000#s To ms\n", " if 'Voltage' in s_var or 'Vm' in s_var:\n", " v_V=i_Exp['a_vars'][:,c_s]*1000#to mV\n", " if 'Current' in s_var or 'Im' in s_var:\n", " v_Iapp=i_Exp['a_vars'][:,c_s]*10e9-0.3\n", " c_s+=1\n", " neuron.noisy_current=v_Iapp\n", " sim_exp=organizing_experimentalData(neuron,v_t,v_V)\n", " sim=sim_exp\n", " sp_ampl,sp_V_max,sp_V_min=extract_spike_ampl(sim_exp.a_Results.V, sim_exp.fr[2][0:-1])\n", " try:\n", " tad, popt,tpeak,perr=doub_expon_fit_2(v_t[sim_exp.fr[2][0:-1]],sp_V_max,std_error=True)\n", " mqe=mean_squared_error(sp_V_max[len(sp_V_max)-len(doub_expon_fun_2(tad,*popt)):], doub_expon_fun_2(tad,*popt))\n", " c=0\n", " while c < 4 and mqe>1.5:\n", " print('Trying improvement!')\n", " poptx=popt\n", " poptx[0]=popt[0]/10\n", " tad, popt,tpeak,perr=doub_expon_fit_2(v_t[sim_exp.fr[2][0:-1]],sp_V_max,p=poptx,std_error=True)\n", " mqe=mean_squared_error(sp_V_max[len(sp_V_max)-len(doub_expon_fun_2(tad,*popt)):], doub_expon_fun_2(tad,*popt))\n", " c+=1\n", "\n", " print('Fast tau= '+ str(popt[0]))\n", " print('Slow tau= '+ str(popt[1]))\n", " print('Ratio Fast slow= '+ str(popt[2]/popt[3]))\n", " arr_fit.append([list(popt)+list(perr)+[mqe]+[s_Cell]])\n", "\n", " except Exception as e:\n", " print(s_Cell +' Failed because: '+str(e))\n", " arr_fit.append([[nan for iii in range(11)]+[s_Cell]])\n", " pass\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "collapsed": false, "deletable": true, "editable": true }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/pandas/core/computation/expressions.py:180: UserWarning: evaluating in Python space because the '*' operator is not supported by numexpr for the bool dtype, use '&' instead\n", " .format(op=op_str, alt_op=unsupported[op_str]))\n" ] } ], "source": [ "df_dirty = pd.DataFrame(columns=['$\\\\tau_{fast}$','$\\\\tau_{slow}$','$D_{fast}$','$D_{slow}$','$D_{ss}$','$ste_{tau_{fast}}$','$ste_{tau_{slow}}$','$ste_{D_{fast}}$','$ste_{D_{slow}}$','$ste_{D_{ss}}$','Mean Squared error','Cell label'], data=np.concatenate(arr_fit))\n", "df=df_dirty[~df_dirty.isin([np.nan, np.inf, -np.inf, NaN]).any(1)]\n", "cols = df.columns.drop('Cell label')\n", "df[cols] = df[cols].apply(pd.to_numeric, errors='coerce')\n", "#### Selecting subsample of data that is free of artifacts***\n", "cond_fitable=(df['Mean Squared error']<2.0)*(df['Cell label']!='A171212A')*(df['Cell label']!='A171220J')*(df['Cell label']!='A171214G')\n", "\n", "df_st=df[cond_fitable]\n", "# df_st.to_pickle(\"./Data/Metadata/ParDistFit_DoubExpon_SpikeAmplitudeDecay_from_\"+dt_pool[0]+'_and_'+dt_pool[1]+\"_40Hz_DepolPulses_df_to_plot_PLOS.pkl\")\n", "###### Portraying statistics\n", "cols_fit=df.columns[0:5]\n", "cols_ste=df.columns[5:10]\n", "cols_msqe=df.columns[10]" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "collapsed": false, "deletable": true, "editable": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\\begin{tabular}{lrrrrr}\n", "\\toprule\n", "{} & \\$\\textbackslash tau\\_\\{fast\\}\\$ & \\$\\textbackslash tau\\_\\{slow\\}\\$ & \\$D\\_\\{fast\\}\\$ & \\$D\\_\\{slow\\}\\$ & \\$D\\_\\{ss\\}\\$ \\\\\n", "\\midrule\n", "count & 48.000000 & 48.000000 & 48.000000 & 48.000000 & 48.000000 \\\\\n", "mean & 480.293768 & 17727.182536 & 5.906122 & 20.378979 & 23.529793 \\\\\n", "std & 676.423913 & 7916.840369 & 2.470177 & 6.366371 & 11.478177 \\\\\n", "min & 61.686976 & 4312.710113 & 0.000002 & 7.860144 & 0.000001 \\\\\n", "25\\% & 170.353966 & 12050.396886 & 4.334064 & 17.144954 & 16.728523 \\\\\n", "50\\% & 232.372736 & 16797.597198 & 5.823583 & 20.102315 & 23.596663 \\\\\n", "75\\% & 368.297484 & 21156.877409 & 7.097274 & 22.357364 & 30.930222 \\\\\n", "max & 3082.960911 & 45774.557501 & 14.305466 & 48.164288 & 59.708845 \\\\\n", "\\bottomrule\n", "\\end{tabular}\n", "\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/scipy/stats/stats.py:1713: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n", " return np.add.reduce(sorted[indexer] * weights, axis=axis) / sumval\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import pandas as pd\n", "dt_pool=['40Hz_Group_1', '40Hz_Group_2']\n", "df_st = pd.read_pickle(\"./Data/Metadata/ParDistFit_DoubExpon_SpikeAmplitudeDecay_from_\"+dt_pool[0]+'_and_'+dt_pool[1]+\"_40Hz_DepolPulses_df_to_plot.pkl\")\n", "\n", "###### Portraying statistics\n", "cols_fit=df_st.columns[0:5]\n", "cols_ste=df_st.columns[5:10]\n", "cols_msqe=df_st.columns[10]\n", "\n", "fig, axes = plt.subplots(ncols=len(cols_fit),sharey=True,facecolor=\"1\",figsize=(fig_wide,fig_height))\n", "for ax, col in zip(axes, df_st[cols_fit].columns):\n", " sns.distplot(df_st[col], ax=ax, rug=True, kde=False, hist=True, norm_hist=False)\n", " locatory2 = MaxNLocator(nbins=3) # with 3 bins you will have 4 ticks\n", " ax.xaxis.set_major_locator(locatory2)\n", " del locatory2\n", "\n", "axes[0].set_ylabel('Count')\n", "fig.suptitle('Depolarizing pulses 40Hz: Distribution of parameters')\n", "fig.show()\n", "\n", "print(df_st[cols_fit].describe().to_latex())#### To generate latex table of Stat analysis" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "collapsed": false, "deletable": true, "editable": true }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/numpy/core/fromnumeric.py:3118: RuntimeWarning: Mean of empty slice.\n", " out=out, **kwargs)\n", "/usr/lib/python3/dist-packages/numpy/core/_methods.py:85: RuntimeWarning: invalid value encountered in double_scalars\n", " ret = ret.dtype.type(ret / rcount)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:663: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", "/usr/lib/python3/dist-packages/ipykernel_launcher.py:56: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n", "/usr/lib/python3/dist-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", " category=OptimizeWarning)\n" ] } ], "source": [ "########################################################################\n", "########################################################################\n", "################ Stats for all groups Hyperpol pulses ####################\n", "##########################################################################\n", "#########################################################################\n", "dir_exps='./Data/Recordings/SpikeAmplitude/'\n", "\n", "import matplotlib.cm as cm\n", "import pandas as pd\n", "import numpy as np\n", "import seaborn as sns\n", "from scipy import stats\n", "from sklearn.metrics import mean_squared_error\n", "######################## Loading cell Dictionary ###############################\n", "dt_pool=['DC_current_Group_1','DC_current_Group_2']\n", "arr_fit_fast=[]\n", "arr_fit_slow=[]\n", "arr_fit_data_prot=[]\n", "arr_raw_data=[]\n", "for i_s_cell in dt_pool:\n", " cell=str(i_s_cell)\n", " f=open(dir_exps+cell+'.pk1', 'rb')\n", " d_Cell=pickle.load(f, encoding='latin1')\n", " for i_which_cell in range(len(d_Cell.keys())):\n", " s_Cell=list(d_Cell.keys())[i_which_cell]\n", " if s_Cell!='s_name':\n", " for s_iExp in d_Cell[s_Cell].keys():\n", " i_Exp=d_Cell[s_Cell][s_iExp]\n", " c_s=0\n", " for s_var in i_Exp['s_vars']:\n", " if 'Time' in s_var or '(s))' in s_var:\n", " v_t=i_Exp['a_vars'][:,c_s]*1000#s To ms\n", " if 'Voltage' in s_var or 'Vm' in s_var:\n", " v_V=i_Exp['a_vars'][:,c_s]*1000#to mV\n", " if 'Current' in s_var or 'Im' in s_var:\n", " v_Iapp=i_Exp['a_vars'][:,c_s]*10e9-0.3\n", " c_s+=1\n", " ### Smoothing v_Iapp..\n", " neuron.noisy_current=v_Iapp\n", " sim_exp=organizing_experimentalData(neuron,v_t,v_V)\n", " sim=sim_exp\n", " sp_ampl,sp_V_max,sp_V_min=extract_spike_ampl(sim_exp.a_Results.V, sim_exp.fr[2])\n", " ## Start of spiking/ per interval in between hyperpol\n", " st_i=np.nonzero((v_Iapp[0:-1]<0) & (v_Iapp[1:]>0) & (diff(v_Iapp>=0,n=1)>0))[0]\n", " ## End of spiking/ per interval in between hyperpol\n", " end_i=np.nonzero((v_Iapp[0:-1]>0) & (v_Iapp[1:]<0) & (diff(v_Iapp<=0,n=1)>0))[0]\n", " ## Hyperpol duration\n", " v_hyperpol_dur=[v_t[st_i][c] - v_t[end_i[c-1]] for c in range(1,len(st_i))]\n", " ## Delta smallV\n", " V_st=[[sp_V_max[ii] for ii in range(len(sim_exp.fr[2])) if v_t[sim_exp.fr[2][ii]]>v_t[st_i][jj]][0] if len([sp_V_max[ii] for ii in range(len(sim_exp.fr[2])) if v_t[sim_exp.fr[2][ii]]>v_t[st_i][jj]])>2 else nan for jj in range(len(st_i)) ]## Selecting 1st spike\n", " V_nd=[[sp_V_max[ii] for ii in range(len(sim_exp.fr[2])) if v_t[sim_exp.fr[2][ii]]v_t[st_i][jj]][2] for jj in range(len(st_i))]\n", " c=0\n", " for i_st in st_i:\n", " try:\n", " if c=v_t[i_st] and v_t[sim_exp.fr[2]][i]=v_t[i_st] and v_t[sim_exp.fr[2]][i]=len(st_i)-1:\n", " y_data_fit_i=[data_fit[i] for i in range(len(sim_exp.fr[2])) if v_t[sim_exp.fr[2]][i]>=v_t[i_st] ]\n", " y_data_fit_i=y_data_fit_i[0:]## ignores first 2 spikes after dep pulse\n", " t_data_fit_i=[v_t[sim_exp.fr[2][i]] for i in range(len(sim_exp.fr[2])) if v_t[sim_exp.fr[2]][i]>=v_t[i_st]]\n", " t_data_fit_i=t_data_fit_i[0:]## ignores first 2 spikes after dep pulse\n", " y_data_fit_v.append(y_data_fit_i)\n", " t_data_fit_v.append(t_data_fit_i)\n", " tad_i, popt_i,tpeak_i,perr_i=doub_expon_fit_2(t_data_fit_i,y_data_fit_i,std_error=True)\n", " mqe=mean_squared_error(y_data_fit_i[len(y_data_fit_i)-len(doub_expon_fun_2(tad_i,*popt_i)):], doub_expon_fun_2(tad_i,*popt_i))\n", "\n", " arr_fit_fast.append([list(popt_i)+list(perr_i)+[mqe]+[s_Cell]])\n", " smqe.append(mqe)\n", " except:\n", " arr_fit_fast.append([[nan for iii in range(11)]+[s_Cell]])\n", " popt_i=[]\n", " perr_i=[]\n", " tad_i=[]\n", " tpeak_i=[]\n", " y_data_fit_i=[]\n", " t_data_fit_i=[]\n", " pass\n", " pop_fit.append(popt_i)\n", " perr_v.append(perr_i)\n", " tad_fit.append(tad_i)\n", " tpeak_fit.append(tpeak_i)\n", " c+=1\n", " mqe=[]\n", " try:\n", " tad_all, popt_all,tpeak_all,perr_all=doub_expon_fit_2(np.concatenate(t_data_fit_v),np.concatenate(y_data_fit_v),std_error=True)\n", " mqe=mean_squared_error(np.concatenate(y_data_fit_v)[len(np.concatenate(y_data_fit_v))-len(doub_expon_fun_2(tad_all,*popt_all)):], doub_expon_fun_2(tad_all,*popt_all))\n", " arr_fit_slow.append([list(popt_all)+list(perr_all)+[mqe]+[s_Cell]])\n", " arr_label_data=[s_Cell for iiij in range(len(np.concatenate(t_data_fit_v)))]\n", " arr_raw_data.append([np.concatenate(t_data_fit_v),np.concatenate(y_data_fit_v),arr_label_data])\n", " except:\n", " arr_fit_slow.append([[nan for iii in range(11)]+[s_Cell]])\n", " pass\n", " except:\n", " arr_fit_slow.append([[nan for iii in range(11)]+[s_Cell]])\n", " arr_fit_fast.append([[nan for iii in range(11)]+[s_Cell]])\n", " pass\n", " arr_label=[s_Cell for iiij in range(len(V_delta_Vfast))]\n", " arr_fit_data_prot.append([v_hyperpol_dur,V_fast_VsiniSpike,V_slow_VsiniSpike,V_delta_Vfast,V_delta_Vfast_percent,t_delta_VSlow,V_delta_VSlow,V_delta_Vslow_percent,Fr_nd,arr_label])\n", " \n", "\n", "\n", "df_slow = pd.DataFrame(columns=['$\\\\tau_{fast}$','$\\\\tau_{slow}$','$D_{fast}$','$D_{slow}$','$D_{ss}$','$ste_{tau_{fast}}$','$ste_{tau_{slow}}$','$ste_{D_{fast}}$','$ste_{D_{slow}}$','$ste_{D_{ss}}$','Mean Squared error','Cell label'], data=np.concatenate(arr_fit_slow))\n", "df_fast = pd.DataFrame(columns=['$\\\\tau_{fast}$','$\\\\tau_{slow}$','$D_{fast}$','$D_{slow}$','$D_{ss}$','$ste_{tau_{fast}}$','$ste_{tau_{slow}}$','$ste_{D_{fast}}$','$ste_{D_{slow}}$','$ste_{D_{ss}}$','Mean Squared error','Cell label'], data=np.concatenate(arr_fit_fast))\n", "\n", "########### Organizing just protocol..\n", "data =np.concatenate(arr_fit_data_prot,axis=1)\n", "df_prot = pd.DataFrame(columns=['Hyperpolarizing pulse duration','$\\% Recovery after Hyperpolarization$','$\\% of initial Spike amplitude $','$D_{fast}$','$D_{fastNormed}$','$t_{slow}$','$D_{slow}$','$D_{slowNormed}$','$FR_{perStimOn}$','Cell label'], data=data.T)\n", "cols = df_prot.columns.drop('Cell label')\n", "df_prot[cols] = df_prot[cols].apply(pd.to_numeric, errors='coerce')\n", "############## Organizing Raw data\n", "data_raw =np.concatenate(arr_raw_data,axis=1)\n", "df_raw_data=pd.DataFrame(columns=['t_data','y_data','Cell label'], data=data_raw.T)\n", "cols_raw = df_raw_data.columns.drop('Cell label')\n", "df_raw_data[cols_raw] = df_raw_data[cols_raw].apply(pd.to_numeric, errors='coerce')" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "########################################################################################\n", "########################################################################################\n", "######################3 Selecting useful traces.. : Controling with Fr\n", "grouped = df_prot.groupby('Cell label')\n", "\n", "### Creates filter to discard data that has lower firing rate than 1Hz in the end of the recording, and data with higher firing rate than initial part of recording\n", "def filter_func_lastFr(x):\n", " fr_end= x['$FR_{perStimOn}$'][x['$t_{slow}$']==max(list(x['$t_{slow}$']))]\n", " fr_st=x['$FR_{perStimOn}$'][x['$t_{slow}$']== min(list(x['$t_{slow}$']))]\n", " c= ((float(fr_end) >= 0.5) and (list(fr_end)<=list(1.2*fr_st)))\n", " return c\n", "\n", "### Creates filter to discard data that has lower firing rate than 1Hz in the end of the recording, and data with higher firing rate than initial part of recording\n", "def filter_func_SlowComponent(x):\n", " VdeltaSlow_end= x['$D_{slow}$'][x['$t_{slow}$']==max(list(x['$t_{slow}$']))]\n", " c= (float(VdeltaSlow_end) >= 0.0)\n", " return c\n", "\n", "### Creates filter to discard Data with artifacts\n", "def filter_weird_measurements(x):\n", " wd_list=['A171130L','A171130F','A171129D','A171218M','A171130i','A171127J','A171214i','A171211A','A171204J']\n", " c=~any(list(x['Cell label'].isin(wd_list)))\n", " return c\n", "\n", "### Applying filter, and creating new group g2_2 with useful data\n", "g2_2=grouped.filter(filter_func_lastFr)\n", "grouped_2 = g2_2.groupby('Cell label')\n", "g2_2_woWeirds=grouped_2.filter(filter_weird_measurements)\n", "\n", "grouped_3 = g2_2_woWeirds.groupby('Cell label')\n", "g2_2_showEffect=grouped_3.filter(filter_func_SlowComponent)\n", "#### Summary of data that passes basic criteria\n", "useful_records=sum(~g2_2_woWeirds['Cell label'].duplicated())\n", "#### Summary of data that show spike amplitude shrinking\n", "number_ofShowEffect=sum(~g2_2_showEffect['Cell label'].duplicated())\n", "## Compared to all the data\n", "all_records=sum(~df_prot['Cell label'].duplicated())" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "####################################################3\n", "####### filtering measurements with useful cells ######\n", "df_slow = pd.DataFrame(columns=['$\\\\tau_{fast}$','$\\\\tau_{slow}$','$D_{fast}$','$D_{slow}$','$D_{ss}$','$ste_{tau_{fast}}$','$ste_{tau_{slow}}$','$ste_{D_{fast}}$','$ste_{D_{slow}}$','$ste_{D_{ss}}$','Mean Squared error','Cell label'], data=np.concatenate(arr_fit_slow))\n", "cols = df_slow.columns.drop('Cell label')\n", "df_slow[cols] = df_slow[cols].apply(pd.to_numeric, errors='coerce')\n", "\n", "\n", "df_fast = pd.DataFrame(columns=['$\\\\tau_{fast}$','$\\\\tau_{slow}$','$D_{fast}$','$D_{slow}$','$D_{ss}$','$ste_{tau_{fast}}$','$ste_{tau_{slow}}$','$ste_{D_{fast}}$','$ste_{D_{slow}}$','$ste_{D_{ss}}$','Mean Squared error','Cell label'], data=np.concatenate(arr_fit_fast))\n", "cols = df_fast.columns.drop('Cell label')\n", "df_fast[cols] = df_fast[cols].apply(pd.to_numeric, errors='coerce')\n", "\n", "\n", "###################################################\n", "#######3 SUb group.. to get only useful measurements\n", "df_slow[df_slow['Cell label'].isin(list(g2_2_showEffect[~g2_2_showEffect['Cell label'].duplicated()]['Cell label']))]\n", "df_fast[df_fast['Cell label'].isin(list(g2_2_showEffect[~g2_2_showEffect['Cell label'].duplicated()]['Cell label']))]\n", "\n", "###### Portraying statistics\n", "cols_fit_slow=df_slow.columns[0:5]\n", "cols_fit_fast=df_fast.columns[0:5]\n", "\n", "cond_fitable=(df_slow['Mean Squared error']<10.0)\n", "sum(df_slow['Cell label'].isin(list(df_slow[cond_fitable]['Cell label'])))\n", "\n", "df_to_plot0=df_slow[df_slow['Cell label'].isin(list(g2_2_showEffect[~g2_2_showEffect['Cell label'].duplicated()]['Cell label']))]\n", "df_to_plot=df_to_plot0[df_to_plot0['Cell label'].isin(list(df_slow['Cell label'][cond_fitable]))]\n", "cols_to_plot=cols_fit_slow\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "collapsed": false, "deletable": true, "editable": true }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/scipy/stats/stats.py:1713: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n", " return np.add.reduce(sorted[indexer] * weights, axis=axis) / sumval\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\\begin{tabular}{lrrrrr}\n", "\\toprule\n", "{} & \\$\\textbackslash tau\\_\\{fast\\}\\$ & \\$\\textbackslash tau\\_\\{slow\\}\\$ & \\$D\\_\\{fast\\}\\$ & \\$D\\_\\{slow\\}\\$ & \\$D\\_\\{ss\\}\\$ \\\\\n", "\\midrule\n", "count & 73.000000 & 73.000000 & 73.000000 & 73.000000 & 73.000000 \\\\\n", "mean & 935.652651 & 15707.653647 & 5.064957 & 7.737310 & 40.589393 \\\\\n", "std & 599.644611 & 9936.369466 & 2.492782 & 4.081336 & 7.589756 \\\\\n", "min & 125.198826 & 1485.350564 & 0.965347 & 0.000004 & 0.000024 \\\\\n", "25\\% & 466.154928 & 10033.043848 & 3.045424 & 5.644995 & 36.885021 \\\\\n", "50\\% & 745.856489 & 13876.630769 & 4.882892 & 7.078889 & 42.152299 \\\\\n", "75\\% & 1319.313755 & 18294.743647 & 6.750978 & 8.840077 & 45.033475 \\\\\n", "max & 2436.623039 & 52548.189654 & 11.642939 & 32.905853 & 52.764149 \\\\\n", "\\bottomrule\n", "\\end{tabular}\n", "\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "###### Portraying statistics\n", "dt_pool=['DC_current_Group_1','DC_current_Group_2']\n", "df_to_plot = pd.read_pickle(\"Data/Metadata/ParDistFit_DoubExpon_SpikeAmplitudeDecay_from_\"+dt_pool[0]+'_and_'+dt_pool[1]+\"_hyperpolPulses_df_to_plot.pkl\")\n", "\n", "cols_to_plot=df_to_plot.columns[0:5]\n", "\n", "dir_figs='/home/contreras/Documents/Project_Adaptation/Gulledge_Experiments/figs/'\n", "fig, axes = plt.subplots(ncols=len(cols_to_plot),sharey=True,facecolor=\"1\",figsize=(fig_wide,fig_height))\n", "for ax, col in zip(axes, df_to_plot[cols_to_plot].columns):\n", " sns.distplot(df_to_plot[col], ax=ax, rug=True, kde=False, hist=True, norm_hist=False,color='g')\n", " locatory2 = MaxNLocator(nbins=3) # with 3 bins you will have 4 ticks\n", " ax.xaxis.set_major_locator(locatory2)\n", " del locatory2\n", "\n", "\n", "axes[0].set_ylabel('Count')\n", "fig.suptitle('Hyperpolarizing pulses: Distribution of parameters')\n", "fig.show()\n", "\n", "print(df_to_plot[cols_to_plot].describe().to_latex())#### To generate latex table of Stat analysis" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "collapsed": false, "deletable": true, "editable": true }, "outputs": [], "source": [ "dt_pool=['40Hz_Group_1', '40Hz_Group_2']\n", "df_Exp_depol = pd.read_pickle(\"./Data/Metadata/ParDistFit_DoubExpon_SpikeAmplitudeDecay_from_\"+dt_pool[0]+'_and_'+dt_pool[1]+\"_40Hz_DepolPulses_df_to_plot.pkl\")\n", "dt_pool=['DC_current_Group_1','DC_current_Group_2']\n", "df_Exp_hyperpol = pd.read_pickle(\"./Data/Metadata/ParDistFit_DoubExpon_SpikeAmplitudeDecay_from_\"+dt_pool[0]+'_and_'+dt_pool[1]+\"_hyperpolPulses_df_to_plot.pkl\")\n", "\n", "max_num=max(len(list(df_Exp_depol['$\\\\tau_{slow}$'])),len(list(df_Exp_hyperpol['$\\\\tau_{slow}$'])))\n", "arr=[]\n", "arr2=[]\n", "for ii in range(max_num):\n", " try:\n", " arr.append([list(df_Exp_depol['$\\\\tau_{slow}$'])[ii],list(df_Exp_hyperpol['$\\\\tau_{slow}$'])[ii]])\n", " arr2.append([list(df_Exp_depol['$\\\\tau_{slow}$'])[ii],list(df_Exp_hyperpol['$\\\\tau_{slow}$'])[ii]])\n", " except:\n", " try:\n", " arr.append([nan,list(df_Exp_hyperpol['$\\\\tau_{slow}$'])[ii]])\n", " arr2.append([nan,list(df_Exp_hyperpol['$\\\\tau_{slow}$'])[ii]])\n", " except:\n", " try:\n", " arr.append([list(df_Exp_depol['$\\\\tau_{slow}$'])[ii],nan])\n", " arr2.append([list(df_Exp_depol['$\\\\tau_{slow}$'])[ii],nan])\n", " except:\n", " pass\n", "\n", "\n", "### Temporary data filter_weird_measurements\n", "df_raw_data=pd.DataFrame(columns=['$\\\\tau_{slow}$ 1','$\\\\tau_{slow}$ 2'], data=arr)\n", "cols_raw = df_raw_data.columns\n", "df_raw_data[cols_raw] = df_raw_data[cols_raw].apply(pd.to_numeric, errors='coerce')\n", "\n", "df_raw_data=pd.DataFrame(columns=['$\\\\tau_{slow}$ '], data=np.concatenate(arr2))\n", "cols_raw = df_raw_data.columns\n", "df_raw_data[cols_raw] = df_raw_data[cols_raw].apply(pd.to_numeric, errors='coerce')\n", "\n", "df_raw_data['Protocol'] = pd.Series(['40Hz Depolarizations']*max_num+['Hyperpolarizations']*max_num)" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "collapsed": false, "deletable": true, "editable": true }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3/dist-packages/scipy/stats/stats.py:1713: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n", " return np.add.reduce(sorted[indexer] * weights, axis=axis) / sumval\n", "/usr/lib/python3/dist-packages/seaborn/categorical.py:2775: UserWarning: The `split` parameter has been renamed to `dodge`.\n", " warnings.warn(msg, UserWarning)\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "########################\n", "###### Plot distributions\n", "########################\n", "\n", "matplotlib.rcParams['lines.linewidth']=0.065\n", "fig_wide=matplotlib.rcParams[\"figure.figsize\"][0]\n", "fig_height=matplotlib.rcParams[\"figure.figsize\"][1]\n", "\n", "\n", "########################\n", "###### Properties of the figure palette\n", "########################\n", "\n", "face_pal = {}\n", "pal = {}\n", "hue_order = []\n", "c=0\n", "for s_icell in list(df_raw_data['Protocol'].unique()):\n", " if s_icell=='40Hz Depolarizations':\n", " face_pal[s_icell]=sns.color_palette(\"Paired\")[1]\n", " pal[s_icell]=sns.color_palette(\"Paired\")[1]\n", " else:\n", " face_pal[s_icell]=sns.color_palette(\"Paired\")[3]\n", " pal[s_icell]=sns.color_palette(\"Paired\")[3]\n", " hue_order.append(s_icell)\n", " c+=1\n", " \n", "boxprops = {'edgecolor': 'k', 'linewidth': 2}\n", "lineprops = {'color': 'k', 'linewidth': 2}\n", "boxplot_kwargs = {'boxprops': boxprops, 'medianprops': lineprops,\n", " 'whiskerprops': lineprops, 'capprops': lineprops,\n", " 'width': 0.75, 'palette': face_pal,\n", " 'hue_order': hue_order}\n", "stripplot_kwargs = {'linewidth': 0.6, 'size': 6, 'alpha': 0.7,\n", " 'palette': pal, 'hue_order': hue_order}\n", "\n", "\n", "########################\n", "###### Plot \n", "########################\n", "f1 = plt.figure(facecolor=\"1\",figsize=(fig_wide,fig_height*1.5))\n", "\n", "ax=[]\n", "ax.append(plt.subplot2grid((60, 40), (0, 0), colspan=18, rowspan=14))\n", "ax.append(plt.subplot2grid((60, 40), (0, 20), colspan=18, rowspan=14))\n", "ax.append(plt.subplot2grid((60, 40), (21, 0), colspan=18, rowspan=14))\n", "ax.append(plt.subplot2grid((60, 40), (21, 20), colspan=18, rowspan=14))\n", "ax.append(plt.subplot2grid((60, 40), (40, 0), colspan=40, rowspan=16))\n", "\n", "axes = [ax[0],ax[1]]\n", "###### First Graph: 40Hz Depolarizations\n", "for axi, col in zip(axes, df_st[cols_fit].columns[0:2]):\n", " sns.distplot(df_st[col], ax=axi, rug=True, kde=False, hist=True, norm_hist=False,color=sns.color_palette(\"Paired\")[1])\n", " locatory2 = MaxNLocator(nbins=3) # with 3 bins you will have 4 ticks\n", " axi.xaxis.set_major_locator(locatory2)\n", " axi.set_xlabel(col+' (ms)')\n", " del locatory2\n", "ax[0].set_title('40Hz Depolarizations')\n", "\n", "\n", "\n", "###### Second Graph: Hyperpolarizations\n", "axes = [ax[2],ax[3]]\n", "for axi, col in zip(axes, df_to_plot[cols_to_plot].columns[0:2]):\n", " sns.distplot(df_to_plot[col], ax=axi, rug=True, kde=False, hist=True, norm_hist=False,color=sns.color_palette(\"Paired\")[3])\n", " locatory2 = MaxNLocator(nbins=3) # with 3 bins you will have 4 ticks\n", " axi.xaxis.set_major_locator(locatory2)\n", " del locatory2\n", " axi.set_xlabel(col+' (ms)')\n", "ax[2].set_title('Hyperpolarizations')\n", " \n", "\n", "###### Third Graph: Comparison\n", "sns.boxplot(x='Protocol', y='$\\\\tau_{slow}$ ', data=df_raw_data, ax=ax[4],\n", " fliersize=0, **boxplot_kwargs)\n", "sns.stripplot(x='Protocol', y='$\\\\tau_{slow}$ ', data=df_raw_data, ax=ax[4],\n", " split=True, jitter=0.2, **stripplot_kwargs)\n", "\n", "str_y=ax[4].get_ylabel()\n", "ax[4].set_ylabel(str_y+' (ms)')\n", "\n", "f1.suptitle('Time scale of spike amplitude decay')\n", "\n", "f1.show()" ] } ], "metadata": { "kernel_info": { "name": "python3" }, "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.7.3" }, "nteract": { "version": "0.15.0" } }, "nbformat": 4, "nbformat_minor": 2 }