=h-SSKJr SSKJr SSKJr SSKrSSKrSSK r SSK J r SSK Jr SSKJr SSKJs Jr SSKJr SS KJrJrJr SS KJr SS KJrJrJ r SS K!J"r" SS K#J$r$J%r% SSK&J'r'J(r( SSK)J*r* Sr+Sr,Sr-Sr."SS5r/"SS\/5r0"SS\05r1"SS5r2"SS\25r3"SS\Rh5r5\Rl"\5\35 "S S!5r7"S"S#5r8"S$S%\3\75r9g)&) annotations)lzip)reduceN)stats) handle_data) Optimizer)handle_formula_data)ContrastResultsWaldTestResultst_test_pairwise)_is_using_pandas)cache_readonly cached_data cached_value) approx_fprime)HessianInversionWarning ValueWarning)nan_dotrecipr) bool_likeFaParameters ---------- endog : array_like A 1-d endogenous response variable. The dependent variable. exog : array_like A nobs x k array where `nobs` is the number of observations and `k` is the number of regressors. An intercept is not included by default and should be added by the user. See :func:`statsmodels.tools.add_constant`.zmissing : str Available options are 'none', 'drop', and 'raise'. If 'none', no nan checking is done. If 'drop', any observations with nans are dropped. If 'raise', an error is raised. Default is 'none'.a hasconst : None or bool Indicates whether the RHS includes a user-supplied constant. If True, a constant is not checked for and k_constant is set to 1 and all result statistics are calculated as if a constant is present. If False, a constant is not checked for and k_constant is set to 0. **kwargs Extra arguments that are used to set model properties when using the formula interface.c\rSrSrSR \\\-S9rSr /SQr SSjr Sr S\ 4S jrS r\SS j5r\S 5r\SS j5rSrSSjrSrg)Model?a A (predictive) statistical model. Intended to be subclassed not used. {params_doc} {extra_params_doc} Attributes ---------- exog_names endog_names Notes ----- `endog` and `exog` are references to any data provided. So if the data is already stored in numpy arrays and it is changed then `endog` and `exog` will change as well. ) params_docextra_params_docmissing missing_idxformula design_infohasconstNc (URSS5nURSS5nUR"XXE40UD6UlURRUlURRUlURR Ul/UlUR R/SQ5 SU;aUR RSS/5 [UR55Ul UbURRS5 gg)Nrnoner")exogendogz data.exogz data.endogr zdata.orig_endogzdata.orig_exog) pop _handle_datadata k_constantr%r& _data_attrextendlistkeys _init_keysappend)selfr&r%kwargsrr"s iC:\Users\julio\OneDrive\Documentos\Trabajo\Ideas Frescas\venv\Lib\site-packages\statsmodels/base/model.py__init__Model.__init__\s**Y/::j$/%%e70(.0 ))..IINN YY__  KL F " OO " "$57G#H Iv{{}-   OO " ": . c ^URVs0sHnU[XS5_M nnU$s snf)zAreturn dictionary with extra keys used in model.__init__ N)r/getattr)r1keykwdss r3_get_init_kwdsModel._get_init_kwdsns@!%1 /WT-- / 1 1s*c/SQnU(aURU5 UVs/sH oUU;dM UPM nnU(a:S[U5-nUSLa[R"U[5 g[ U5egs snf)Nrzunknown kwargs F)r,reprwarningswarnr ValueError)r1r2 keys_extraerrorkwargs_allowedikwargs_invalidmsgs r3 _check_kwargsModel._check_kwargsvsq   ! !* -%+GV/F!VG #d>&::C~ c<0 o% Hs A8A8c [XX440UD6nUH1nUS;aM [XURRU55 M3 U$![a MDf=f)N)r!r )rsetattr__dict__r'KeyError)r1r&r%rr"r2r)r9s r3r(Model._handle_datasb5DVDC00 4==#4#4S#9:    s%A AAcUbURUnURSS5nUcSnO/US:XaSSKJn U"05nO[ U[ 5(aUS- nUR SS 5n U S :XaS n [USXU S 9n U uuppURnUbGU RS:a7U RSU:a$[S RU R55eUb[U5S:aU RVs/sH nUU;dM UPM nn[U5[U R5:aFU Un [UR 5nUHnUR#U5 M UR%U5nUR'U U UUS.5 U"X/UQ70UD6nUUlUUR*lU$s snf![a Mxf=f)a Create a Model from a formula and dataframe. Parameters ---------- formula : str or generic Formula object The formula specifying the model. data : array_like The data for the model. See Notes. subset : array_like An array-like object of booleans, integers, or index values that indicate the subset of df to use in the model. Assumes df is a `pandas.DataFrame`. drop_cols : array_like Columns to drop from the design matrix. Cannot be used to drop terms involving categoricals. *args Additional positional argument that are passed to the model. **kwargs These are passed to the model with one exception. The ``eval_env`` keyword is passed to patsy. It can be either a :class:`patsy:patsy.EvalEnvironment` object or an integer indicating the depth of the namespace to use. For example, the default ``eval_env=0`` uses the calling namespace. If you wish to use a "clean" environment set ``eval_env=-1``. Returns ------- model The model instance. Notes ----- data must define __getitem__ with the keys in the formula terms args and kwargs are passed on to the model instantiation. E.g., a numpy structured or rec array, a dictionary, or a pandas DataFrame. Neval_envr)EvalEnvironmentrrdropr$raise)depthrzendog has evaluated to an array with multiple columns that has shape {}. This occurs when the variable converted to endog is non-numeric (e.g., bool or str).)rrr r!)locr'patsyrS isinstanceintgetr _formula_max_endogndimshaperAformatlencolumnsr- term_namesremovesubsetupdater r)frame)clsr r)rd drop_colsargsr2rPrSrtmpr&r%rr! max_endogxcolscolmods r3 from_formulaModel.from_formulasT  88F#D::j$/  H ^ -&r*H # & & MH**Y/ f G!$g*13471% **  ! Q5;;q>I#=56[TU]"X40UD6 UR5 gr)superr4 initialize)r1r&r%r2 __class__s r3r4LikelihoodModel.__init__ s // r6cg)z Initialize (possibly re-initialize) a Model instance. For example, if the the design matrix of a linear model changes then initialized can be used to recompute values using the modified design matrix. Nrrts r3rLikelihoodModel.initializes r6c[e)z Log-likelihood of model. Parameters ---------- params : ndarray The model parameters used to compute the log-likelihood. Notes ----- Must be overridden by subclasses. r}r1rs r3loglikeLikelihoodModel.loglikes "!r6c[e)z Score vector of model. The gradient of logL with respect to each parameter. Parameters ---------- params : ndarray The parameters to use when evaluating the Hessian. Returns ------- ndarray The score vector evaluated at the parameters. r}rs r3scoreLikelihoodModel.score-s "!r6c[e)z Fisher information matrix of model. Returns -1 * Hessian of the log-likelihood evaluated at params. Parameters ---------- params : ndarray The model parameters. r}rs r3 informationLikelihoodModel.information?s "!r6c[e)z The Hessian matrix of the model. Parameters ---------- params : ndarray The parameters to use when evaluating the Hessian. Returns ------- ndarray The hessian evaluated at the parameters. r}rs r3hessianLikelihoodModel.hessianLs "!r6rc  ^^Sn UcT[TS5(a TRnO6TRbS/TRRS-nO [ S5eTR RSmUU4Sjn US:XaUU4S jn UU4S jnOUU4S jn UU4S jnU R S S5nSU ;a(U RS05nU SUS.nU(aU S U S O0nSU ;a U SUS'U S [5nURXUXjUUUUUUUS9 unnnURU5 U RSS5nU(a U"TUU5n GOKUS:Xa/U(a([RRUS*5T- n GOU (GdSTRU5-nSn[R "[R""U55(a>[RR%U5unn[R&"U5S:aSnU(agWR)[R*"SW- 55R)UR,5n [R."XR,-S- 5n O[0R2"S[45 Sn [7TUU 4SS0UD6nUUl[;U[<5(a.U(a'US(dSSKJ n [0R2"SU5 UUl!U$)a Fit method for likelihood based models Parameters ---------- start_params : array_like, optional Initial guess of the solution for the loglikelihood maximization. The default is an array of zeros. method : str, optional The `method` determines which solver from `scipy.optimize` is used, and it can be chosen from among the following strings: - 'newton' for Newton-Raphson, 'nm' for Nelder-Mead - 'bfgs' for Broyden-Fletcher-Goldfarb-Shanno (BFGS) - 'lbfgs' for limited-memory BFGS with optional box constraints - 'powell' for modified Powell's method - 'cg' for conjugate gradient - 'ncg' for Newton-conjugate gradient - 'basinhopping' for global basin-hopping solver - 'minimize' for generic wrapper of scipy minimize (BFGS by default) The explicit arguments in `fit` are passed to the solver, with the exception of the basin-hopping solver. Each solver has several optional arguments that are not the same across solvers. See the notes section below (or scipy.optimize) for the available arguments and for the list of explicit arguments that the basin-hopping solver supports. maxiter : int, optional The maximum number of iterations to perform. full_output : bool, optional Set to True to have all available output in the Results object's mle_retvals attribute. The output is dependent on the solver. See LikelihoodModelResults notes section for more information. disp : bool, optional Set to True to print convergence messages. fargs : tuple, optional Extra arguments passed to the likelihood function, i.e., loglike(x,*args) callback : callable callback(xk), optional Called after each iteration, as callback(xk), where xk is the current parameter vector. retall : bool, optional Set to True to return list of solutions at each iteration. Available in Results object's mle_retvals attribute. skip_hessian : bool, optional If False (default), then the negative inverse hessian is calculated after the optimization. If True, then the hessian will not be calculated. However, it will be available in methods that use the hessian in the optimization (currently only with `"newton"`). kwargs : keywords All kwargs are passed to the chosen solver with one exception. The following keyword controls what happens after the fit:: warn_convergence : bool, optional If True, checks the model for the converged flag. If the converged flag is False, a ConvergenceWarning is issued. Notes ----- The 'basinhopping' solver ignores `maxiter`, `retall`, `full_output` explicit arguments. Optional arguments for solvers (see returned Results.mle_settings):: 'newton' tol : float Relative error in params acceptable for convergence. 'nm' -- Nelder Mead xtol : float Relative error in params acceptable for convergence ftol : float Relative error in loglike(params) acceptable for convergence maxfun : int Maximum number of function evaluations to make. 'bfgs' gtol : float Stop when norm of gradient is less than gtol. norm : float Order of norm (np.inf is max, -np.inf is min) epsilon If fprime is approximated, use this value for the step size. Only relevant if LikelihoodModel.score is None. 'lbfgs' m : int This many terms are used for the Hessian approximation. factr : float A stop condition that is a variant of relative error. pgtol : float A stop condition that uses the projected gradient. epsilon If fprime is approximated, use this value for the step size. Only relevant if LikelihoodModel.score is None. maxfun : int Maximum number of function evaluations to make. bounds : sequence (min, max) pairs for each element in x, defining the bounds on that parameter. Use None for one of min or max when there is no bound in that direction. 'cg' gtol : float Stop when norm of gradient is less than gtol. norm : float Order of norm (np.inf is max, -np.inf is min) epsilon : float If fprime is approximated, use this value for the step size. Can be scalar or vector. Only relevant if Likelihoodmodel.score is None. 'ncg' fhess_p : callable f'(x,*args) Function which computes the Hessian of f times an arbitrary vector, p. Should only be supplied if LikelihoodModel.hessian is None. avextol : float Stop when the average relative error in the minimizer falls below this amount. epsilon : float or ndarray If fhess is approximated, use this value for the step size. Only relevant if Likelihoodmodel.hessian is None. 'powell' xtol : float Line-search error tolerance ftol : float Relative error in loglike(params) for acceptable for convergence. maxfun : int Maximum number of function evaluations to make. start_direc : ndarray Initial direction set. 'basinhopping' niter : int The number of basin hopping iterations. niter_success : int Stop the run if the global minimum candidate remains the same for this number of iterations. T : float The "temperature" parameter for the accept or reject criterion. Higher "temperatures" mean that larger jumps in function value will be accepted. For best results `T` should be comparable to the separation (in function value) between local minima. stepsize : float Initial step size for use in the random displacement. interval : int The interval for how often to update the `stepsize`. minimizer : dict Extra keyword arguments to be passed to the minimizer `scipy.optimize.minimize()`, for example 'method' - the minimization method (e.g. 'L-BFGS-B'), or 'tol' - the tolerance for termination. Other arguments are mapped from explicit argument of `fit`: - `args` <- `fargs` - `jac` <- `score` - `hess` <- `hess` 'minimize' min_method : str, optional Name of minimization method to use. Any method specific arguments can be passed directly. For a list of methods and their arguments, see documentation of `scipy.optimize.minimize`. If no method is specified, then BFGS is used. N start_paramsgrz6If exog is None, then start_params should be specifiedrc2>TR"U/UQ76*T- $r)rrrinobsr1s r3fLikelihoodModel.fit..fsLL/$//$6 6r6newtonc0>TR"U/UQ76T- $rrrs r3r"LikelihoodModel.fit..scoreszz&040477r6c0>TR"U/UQ76T- $rrrs r3hess!LikelihoodModel.fit..hesss||F2T2T99r6c2>TR"U/UQ76*T- $rrrs r3rr s 61D11D88r6c2>TR"U/UQ76*T- $rrrs r3rr#s V3d33d::r6warn_convergenceTcov_typecov_kwds)rruse_t)rmethoddispmaxitercallbackretall full_outputcov_params_funcHessianrRF?g@z8Inverting hessian failed, no bse or cov_params availablescale converged)ConvergenceWarningzEMaximum Likelihood optimization failed to converge. Check mle_retvals)"hasattrrr%r^rAr&r'r[r_fitre setdefaultnplinalginvrallisfiniteeighmindotdiagTasfortranarrayr?r@rLikelihoodModelResults mle_retvalsrYdictstatsmodels.tools.sm_exceptionsr mle_settings)r1rrrrrfargsrr skip_hessianr2Hinvrrrrrr: optimizerxoptretvalsoptim_settingsrH invertibleeigvalseigvecsmlefitrrs` @r3rLikelihoodModel.fit\sL  t^,,#00 & #utyyq'99  "011zz" 7 X  8 : 9 ;"::&8$?  zz*b1H &z 2ID:&z"D f "7ODMwK (1q7D<@?F@H>DCN)7)P%g~ d# ++,=tD "4w7D x K99==')"4!45>!#4 66'?Q&!%J{{2773=#9:>>wyyI(($-3)>? *+BD(dDKKdK% gt $ $ (<N <02- r6c  [US5(ayURS:ai[R"USS9nURR Sn[R "XfUR-5n[R"X45nOUnUbX(US'[U5nUR5n UR"URURSS2U440U D6n U R"S0UD6n UnUc)URR SnU[USS5- n[R"U5n U RX'URSSSSS U S 9n [U R$S 5(a6U R$R&=U R$lU R(l[U S 5(aU R*U R(l[U S 5(aU R,U R(lXR(l[U R(S5(aU R(R.c'[R"XD45U R(lOSU R(R.S'[R"U5nU R.U R(R.USS2S4U4'U R0U R(R0- n[U S5(aR[R"XD45U R(lU R2U R(R2USS2S4U4'[U S5(a6U R4U R(lU R6U R(lXR(lU R0U R(lU R:U R(lXR(lXR(l[U R$S5(aU R(R@S U R(R@S U R(R@S U R(R@SnSUS'U RBXSS2S4U4'XR(lU $![ ["4a UR5n GNjf=f)a"experimental, fit the model subject to zero constraints Intended for internal use cases until we know what we need. API will need to change to handle models with two exog. This is not yet supported by all model subclasses. This is essentially a simplified version of `fit_constrained`, and does not need to use `offset`. The estimation creates a new model with transformed design matrix, exog, and converts the results back to the original parameterization. Some subclasses could use a more efficient calculation than using a new model. Parameters ---------- keep_index : array_like (int or bool) or slice variables that should be dropped. start_params : None or array_like starting values for the optimization. `start_params` needs to be given in the original parameter space and are internally transformed. k_params : int or None If None, then we try to infer from start_params or model. **fit_kwds : keyword arguments fit_kwds are used in the optimization of the transformed model. Returns ------- results : Results instance k_extrarT)copyrNrnmF)rrrrrrrrrnormalized_cov_params.cov_params_defaultrMresid fittedvaluessresid bcov_scaledr)"rrrarrayr%r^arange concatenater`r;rr&rr8zerosr TypeErrorrAmodelr_resultsrrrdf_residrrr keep_indexdf_modelk_constrresults_constrained_cacher)r1rrreturn_auxiliaryk_paramsfit_kwdsk extra_index keep_index_p init_kwds mod_constr res_constr params_fullresrcovs r3 _fit_zerosLikelihoodModel._fit_zerosfsH 4 # # q(8*48J "A))A4<<'78K>>:*CDL%L  #'3'AH^ $<(H'') ^^DJJ !Z-0H1&/1 ^^/h/ !  yyq)H i3 3Hhhx( ","3"3  ((11T,1 MC :##W - -4>3C3C3I3I ICIIOcll0 :} - -'1'='=CLL $ :~ . .(2(?(?CLL %)  &=>> 22:138:N1OCLL .67CLL . .s 3XXj)  , , **:ag+> +JK&&)>)>> :3 4 4.0hh7K.LCLL +-- LL + +Jq$w,?,K L :z * *$.$7$7CLL !$.$7$7CLL !",  * 3 3  * 3 3  ( +5 ( 399c " " ##G, ##N3 ##H-,,%%m4CCH3=3I3IC1d7#Z/ 0.1LL + :& ((*C sR!! SSc TURnXURS5--n[RR USS9n[R "UR 55[R"U5:n[R"U)5SnUR"SSU0UD6$)zexperimental, fit of the model without collinear variables This currently uses QR to drop variables based on the given sequence. Options will be added in future, when the supporting functions to identify collinear variables become available. rr)moderr) r%varrrqrabsdiagonalsqrtwherer) r1atolrtolr:rltolrmaskidx_keeps r3_fit_collinearLikelihoodModel._fit_collinears IIAEE!H_$ IILLL %vvajjl#bggcl288TE?1%;(;d;;r6r) NrdTTrNFF)NNFN)g+=gvIh%<=)rrrrrr4rrrrrrrr"r __classcell__rs@r3rrsR  ""$ "" ?BINHT8<48KZ<UbX0lUbX@lUbXPlURSS5n URR U5 [ T U]"X4XiS.UD6 Ub0[R"U5S:XaURSOSUl UbURU5 gg)Nr")rr"rQr) rrrr'rLrerr4rr]r^nparams_set_extra_params_names) r1r&r%rrrrextra_params_namesr:r"rs r3r4GenericLikelihoodModel.__init__6s  "L  J  "L88J- T"   !( ?C  -/WWT]a-?DJJqMQDL  )  ( (); < *r6c0UbyURbURRU5 OXRl[ U5Ul[US5(aU=RUR -sl[ UR5Ul g)Nr) r%rzr,r)ryr`rrrr*)r1r,s r3r+.GenericLikelihoodModel._set_extra_params_namesTsk  )yy$&&'9:#5  12DLtZ(( - 4??+ r6c>^TR(dU4SjTlTR(dOTR(dTRbg[RR TR5n[ US- 5Tl[ TRRSU- 5Tl O*[RTl[RTl [TT]15 g)z Initialize (possibly re-initialize) a Model instance. For instance, the design matrix of a linear model may change and some things must be recomputed. c0>[UTR5$r)rr)rlr1s r33GenericLikelihoodModel.initialize..js=DLL#Ar6Nrr) rrr%rr matrix_rankfloatrr^rnanrr)r1errs` r3r!GenericLikelihoodModel.initializecs zzADJ<<<< 99 &&tyy1B!"q&MDM!$))//!"4r"9:DMFFDMFFDM r6cVURR5nXUR'U$)a expand to full parameter array when some parameters are fixed Parameters ---------- params : ndarray reduced parameter array Returns ------- paramsfull : ndarray expanded parameter array where fixed parameters are included Notes ----- Calling this requires that self.fixed_params and self.fixed_paramsmask are defined. *developer notes:* This can be used in the log-likelihood to ... this could also be replaced by a more general parameter transformation. ) fixed_paramsrfixed_paramsmask)r1r paramsfulls r3 expandparams#GenericLikelihoodModel.expandparams}s,4&&++- ,24(()r6cXR$)zReduce parameters)r;rs r3 reduceparams#GenericLikelihoodModel.reduceparamss++,,r6cBURU5RS5$)z!Log-likelihood of model at paramsr loglikeobssumrs r3rGenericLikelihoodModel.loglikesv&**1--r6cDURU5RS5*$)z*Negative log-likelihood of model at paramsrrCrs r3nloglikeGenericLikelihoodModel.nloglikes'++A...r6c&URU5*$)z Log-likelihood of the model for all observations at params. Parameters ---------- params : array_like The parameters of the model. Returns ------- loglike : array_like The log likelihood of the model evaluated at `params`. ) nloglikeobsrs r3rD!GenericLikelihoodModel.loglikeobss  (((r6cr0nURSS5 [XR40UD6R5$)z0 Gradient of log-likelihood evaluated at params centeredT)rrrravelr1rr:s r3rGenericLikelihoodModel.scores4  D)V\\:T:@@BBr6c RURSS5 [XR40UD6$)zO Jacobian/Gradient of log-likelihood evaluated at params for each observation. rNT)rrrDrPs r3 score_obs GenericLikelihoodModel.score_obss&  D)V__===r6c2SSKJn U"XR5$)z/ Hessian of log-likelihood evaluated at params r) approx_hess)statsmodels.tools.numdiffrVr)r1rrVs r3rGenericLikelihoodModel.hessians :6<<00r6c[e)a}Weights for calculating Hessian Parameters ---------- params : ndarray parameter at which Hessian is evaluated scale : None or float If scale is None, then the default scale will be calculated. Default scale is defined by `self.scaletype` and set in fit. If scale is not None, then it is used as a fixed scale. observed : bool If True, then the observed Hessian is returned. If false then the expected information matrix is returned. Returns ------- hessian_factor : ndarray, 1d A 1d weight vector used in the calculation of the Hessian. The hessian is obtained by `(exog.T * hessian_factor).dot(exog)` r})r1rrobserveds r3hessian_factor%GenericLikelihoodModel.hessian_factors ,"!r6c 8>UcA[US5(a URnO#S[R"UR5-nSU;aSUS'[ TU]n U "S UX#UXVS.UD6n [US[5n U "X 5n URc/O URn [U 5[U R5- nUS:XdRUS:a1UR[U*5Vs/sHnSU-PM sn5 U $[R"S [ 5 U $s snf) Nrg?r nonrobust)rrrrrr results_classrzpar%dzmore exog_names than parametersr)rrronesr*rrr8GenericLikelihoodModelResultsrzr`rr+ranger?r@r)r1rrrrrrrr2 fit_methodrr_ genericmlefitrzk_missrErs r3rGenericLikelihoodModel.fits0  t^,,#00 "RWWT\\%:: V #!,F: W[ D#)(3!%D=CD  o =? %d3 !OO3R$// Z3v}}#55{z,,7BBF=< ,4<-./) C>1"0LM*+""r6r(c>\rSrSrSrSrSrS SjrS SjrSr S r g) Resultsiz Class to contain model results Parameters ---------- model : class instance the previously specified model instance params : ndarray parameter estimates from the fit model c URRU5 UR"X40UD6 /Ul/SQUlg)N)rrwresid)rLrerr+_data_in_cache)r1rrkwds r3r4Results.__init__s4 S! --Ar6c bX lXl[US5(aURUlgg)z Initialize (possibly re-initialize) a Results instance. Parameters ---------- model : Model The model instance. params : ndarray The model parameters. **kwargs Any additional keyword arguments required to initialize the model. r*N)rrrr*)r1rrr2s r3rResults.initialize s-  5, ' '#..DO (r6c[US5nSnU(aNURS:XdURRS:Xa URnOURR /nU(Ga[ URS5(GamUGbi[URSS5=(d URRRnSSK J n [U[R5(a[ US5(aT[UR [ 5(a5UR UR#5;a[R$"U5nO [R$"U5R&nURn[)U5n[U[*5nU"XQSS 9nU[)U5:a7U(d0Uc[2R4"S [65 OUR9U5nURnUb[:R<"U5nURS:XaTURR>RS:Xd'URR>R@SS:Xa USS2S4n[:RB"U5nX4$![,a9n S R/[![!U 555n U R1U 5eSn A ff=f) NrQrr r!r)dmatrixname dataframe) return_typezpredict requires that you use a DataFrame when predicting from a model that was created using the formula api. The original error message returned by patsy is: {}znan values have been dropped)"r r]rsizeindexrsrrr8r)r!rXrrrYpdSeriesstrdescribe DataFramerr`r Exceptionr_rr?r@rreindexrasarrayr%r^ atleast_2d) r1r% transform is_pandas exog_indexr!rr orig_exog_lenis_dictexcrGs r3_transform_predict_exogResults._transform_predict_exog2s$T40  yyA~!1!1Q!6!ZZ "jjoo. Y77T=M"4::}dC7::??66  %$ **D&))jC.H.H [%9%9%;;<<-D<<-//D!ZZ IM t,G ){kJs4y(%MM"@,O<< 3DJ  ::d#DyyA~4::??#7#71#<#'::??#8#8#;q#@AtG}==&D+ )#F3s3x=1  mmC((  )sJ K4K  KNcURUUS9upURR"URU/UQ70UD6nUbI[ US5(d8UR S:Xa[ R"XeS9$[ R"XeS9$U$)a Call self.model.predict with self.params as the first argument. Parameters ---------- exog : array_like, optional The values for which you want to predict. see Notes below. transform : bool, optional If the model was fit via a formula, do you want to pass exog through the formula. Default is True. E.g., if you fit a model y ~ log(x1) + log(x2), and transform is True, then you can pass a data structure that contains x1 and x2 in their original form. Otherwise, you'd need to log the data first. *args Additional arguments to pass to the model, see the predict method of the model for the details. **kwargs Additional keywords arguments to pass to the model, see the predict method of the model for the details. Returns ------- array_like See self.model.predict. Notes ----- The types of exog that are supported depends on whether a formula was used in the specification of the model. If a formula was used, then exog is processed in the same way as the original data. This transformation needs to have key access to the same variable names, and can be a pandas DataFrame or a dict like object that contains numpy arrays. If no formula was used, then the provided exog needs to have the same number of columns as the original exog in the model. No transformation of the data is performed except converting it to a numpy array. Row indices as in pandas data frames are supported, and added to the returned prediction. )rpredicted_valuesr)rw) rrrrrr]rxryr|)r1r%rrir2rpredict_resultss r3rResults.predictfsZ 77BK8M**,,T[[$77/57  !'/2D+F+F##q(yyCC||OFF" "r6c[e)z Summary Not implemented r}rts r3summaryResults.summaryrr6)r+rlr*rr)Trg) rrrrrr4rrrrrrr6r3riris# B/$2 h:#x"r6ric8^\rSrSrSrSU4SjjrSrSSjr\S5r \ RS5r \ S5r \ S 5r \ S 5r\ S 5rSS jrSS jrSSjrSSjrSSjrSSjrSSjrSSjrS Sjr\S5rSrSrU=r$)!ria Class to contain results from likelihood models Parameters ---------- model : LikelihoodModel instance or subclass instance LikelihoodModelResults holds a reference to the model that is fit. params : 1d array_like parameter estimates from estimated model normalized_cov_params : 2d array Normalized (before scaling) covariance of params. (dot(X.T,X))**-1 scale : float For (some subset of models) scale will typically be the mean square error from the estimated model (sigma^2) Attributes ---------- mle_retvals : dict Contains the values returned from the chosen optimization method if full_output is True during the fit. Available only if the model is fit by maximum likelihood. See notes below for the output from the different methods. mle_settings : dict Contains the arguments passed to the chosen optimization method. Available if the model is fit by maximum likelihood. See LikelihoodModel.fit for more information. model : model instance LikelihoodResults contains a reference to the model that is fit. params : ndarray The parameters estimated for the model. scale : float The scaling factor of the model given during instantiation. tvalues : ndarray The t-values of the standard errors. Notes ----- The covariance of params is given by scale times normalized_cov_params. Return values by solver if full_output is True during fit: 'newton' fopt : float The value of the (negative) loglikelihood at its minimum. iterations : int Number of iterations performed. score : ndarray The score vector at the optimum. Hessian : ndarray The Hessian at the optimum. warnflag : int 1 if maxiter is exceeded. 0 if successful convergence. converged : bool True: converged. False: did not converge. allvecs : list List of solutions at each iteration. 'nm' fopt : float The value of the (negative) loglikelihood at its minimum. iterations : int Number of iterations performed. warnflag : int 1: Maximum number of function evaluations made. 2: Maximum number of iterations reached. converged : bool True: converged. False: did not converge. allvecs : list List of solutions at each iteration. 'bfgs' fopt : float Value of the (negative) loglikelihood at its minimum. gopt : float Value of gradient at minimum, which should be near 0. Hinv : ndarray value of the inverse Hessian matrix at minimum. Note that this is just an approximation and will often be different from the value of the analytic Hessian. fcalls : int Number of calls to loglike. gcalls : int Number of calls to gradient/score. warnflag : int 1: Maximum number of iterations exceeded. 2: Gradient and/or function calls are not changing. converged : bool True: converged. False: did not converge. allvecs : list Results at each iteration. 'lbfgs' fopt : float Value of the (negative) loglikelihood at its minimum. gopt : float Value of gradient at minimum, which should be near 0. fcalls : int Number of calls to loglike. warnflag : int Warning flag: - 0 if converged - 1 if too many function evaluations or too many iterations - 2 if stopped for another reason converged : bool True: converged. False: did not converge. 'powell' fopt : float Value of the (negative) loglikelihood at its minimum. direc : ndarray Current direction set. iterations : int Number of iterations performed. fcalls : int Number of calls to loglike. warnflag : int 1: Maximum number of function evaluations. 2: Maximum number of iterations. converged : bool True : converged. False: did not converge. allvecs : list Results at each iteration. 'cg' fopt : float Value of the (negative) loglikelihood at its minimum. fcalls : int Number of calls to loglike. gcalls : int Number of calls to gradient/score. warnflag : int 1: Maximum number of iterations exceeded. 2: Gradient and/ or function calls not changing. converged : bool True: converged. False: did not converge. allvecs : list Results at each iteration. 'ncg' fopt : float Value of the (negative) loglikelihood at its minimum. fcalls : int Number of calls to loglike. gcalls : int Number of calls to gradient/score. hcalls : int Number of calls to hessian. warnflag : int 1: Maximum number of iterations exceeded. converged : bool True: converged. False: did not converge. allvecs : list Results at each iteration. c D>[T U]X5 X0lX@lSUlSU;aUSnUbUOSUlSU;a`UR SS5nUR S05nUS:XaSUlSS0UlgSS K J n Uc0nUR nU "U4US US .UD6 gg) NFrrr^r descriptionWStandard Errors assume that the covariance matrix of the errors is correctly specified.rget_robustcov_resultsTruse_selfr) rr4rr_use_trr[rrstatsmodels.base.covtyper) r1rrrrr2rrrrrs r3r4LikelihoodModelResults.__init__Js '%:"   f 7OE"'"3DJ  zz*k:Hzz*b1H;& + !.1.!/ K#!H %d?X,1?5=? r6c[e)z"See specific model class docstringr}rts r3r,LikelihoodModelResults.normalized_cov_paramshs!!r6c USLa [S5eSSKJn Uc0nUS:XaSUlSS0UlgU"U4USUS .UD6 g) NFz8use_self should have been removed long ago. See GH#4401rrr^rrTr)rArrrr)r1rrrrrs r3_get_robustcov_results-LikelihoodModelResults._get_robustcov_resultslsj u +, ,B  H { "'DM*-*+DM "$ ;D(- ;19 ;r6cUR$)z?Flag indicating to use the Student's distribution in inference.)rrts r3rLikelihoodModelResults.use_t~s{{r6c$[U5Ulgr)boolr)r1values r3rrs 5k r6cLURRUR5$)zLog-likelihood of model)rrrrts r3llfLikelihoodModelResults.llfszz!!$++..r6c[US5(dKURc>[R"[ UR 55n[R USS&U$[R"5 [R"S[5 [R"[R"UR555nSSS5 U$!,(df  W$=f)z/The standard errors of the parameter estimates.rNignore)rrremptyr`rr6r?catch_warnings simplefilterRuntimeWarningrr cov_params)r1bse_s r3bseLikelihoodModelResults.bses344++388C ,-DffDG  ((*%%h?wwrwwt'89:+ +* s 2AC Cc[R"5 [R"S[5 URUR - sSSS5 $!,(df  g=f)z8 Return the t-statistic for a given parameter estimate. rN)r?rrrrrrts r3tvaluesLikelihoodModelResults.tvaluess<  $ $ &  ! !(N ;;;)' & &s 4A A"c[R"5 [R"S[5 UR(aa[ USUR 5n[RR[R"UR5U5S-sSSS5 $[RR[R"UR55S-sSSS5 $!,(df  g=f)z6The two-tailed p values for the t-stats of the params.rdf_resid_inferencerQN)r?rrrrr8rrtsfrrrnorm)r1rs r3pvaluesLikelihoodModelResults.pvaluess $ $ &  ! !(N ;zz"4)=t}}Mwwzz"&&"6AAE ' & zz}}RVVDLL%9:Q> ' & &sBC-$?C-- C;c [US5(aURSS;a[nO[RnUc)UR c[US5(d [ S5eUbUcUb [ S5eUbUc [ S5eUc<[US5(a URnOUc URnUR U-nUb9[R"U5nURS :XaXBU4$XBSS2S4U4$Ubr[R"U5nURS :Xa [ S 5eUcUnO[R"U5nU"X"U[R"U555nU$U$) a Compute the variance/covariance matrix. The variance/covariance matrix can be of a linear contrast of the estimated parameters or all params multiplied by scale which will usually be an estimate of sigma^2. Scale is assumed to be a scalar. Parameters ---------- r_matrix : array_like Can be 1d, or 2d. Can be used alone or with other. column : array_like, optional Must be used on its own. Can be 0d or 1d see below. scale : float, optional Can be specified or not. Default is None, which means that the scale argument is taken from the model. cov_p : ndarray, optional The covariance of the parameters. If not provided, this value is read from `self.normalized_cov_params` or `self.cov_params_default`. other : array_like, optional Can be used when r_matrix is specified. Returns ------- ndarray The covariance matrix of the parameter estimates or of linear combination of parameter estimates. See Notes. Notes ----- (The below are assumed to be in matrix notation.) If no argument is specified returns the covariance matrix of a model ``(scale)*(X.T X)^(-1)`` If contrast is specified it pre and post-multiplies as follows ``(scale) * r_matrix (X.T X)^(-1) r_matrix.T`` If contrast and other are specified returns ``(scale) * r_matrix (X.T X)^(-1) other.T`` If column is specified returns ``(scale) * (X.T X)^(-1)[column,column]`` if column is 0d OR ``(scale) * (X.T X)^(-1)[column][:,column]`` if column is 1d rrl1 l1_cvxopt_cpNrzFneed covariance of parameters for computing (unnormalized) covariancesz3Column should be specified without other arguments.z)other can only be specified with r_matrixrzr_matrix should be 1d or 2d) rrrrrrrArrrr^ transpose)r1r_matrixcolumnrcov_potherdot_funrjs r3r!LikelihoodModelResults.cov_paramssf D. ) )!!+.2HHGffG Md88@D"677:; ;  8#75;L*+ +  !1HI I =t122//= JJE22U:  ZZ'F||r!V^,,AtG_f455  !zz(+H~~# !>??}  5)(GE2<<3F$GHCJLr6c SSKJn [USSSS9nURRS:Xa=UR R RVs/sHnSUSSUS 3PM nnO UR R RnU"U5RU5nURURpURSn URS n Uc)URc[US 5(d [S 5eURRS S 9n XRS:wa [S5eUc[ R""U 5nO&[ R$"U5nUR'5nUR(S :aURSU :wa [S5eUc[US5=(a UR*n[ R,"X5n U S :a8[ R."[ R0"UR3XS955n O#[ R."UR3XS95n X- [5U 5-n[7USUR85nU(a [;XU US9$[;XU USS9$s snf)a Compute a t-test for a each linear hypothesis of the form Rb = q. Parameters ---------- r_matrix : {array_like, str, tuple} One of: - array : If an array is given, a p x k 2d array or length k 1d array specifying the linear restrictions. It is assumed that the linear combination is equal to zero. - str : The full hypotheses to test can be given as a string. See the examples. - tuple : A tuple of arrays in the form (R, q). If q is given, can be either a scalar or a length p row vector. cov_p : array_like, optional An alternative estimate for the parameter covariance matrix. If None is given, self.normalized_cov_params is used. use_t : bool, optional If use_t is None, then the default of the model is used. If use_t is True, then the p-values are based on the t distribution. If use_t is False, then the p-values are based on the normal distribution. Returns ------- ContrastResults The results for the test are attributes of this results instance. The available results have the same elements as the parameter table in `summary()`. See Also -------- tvalues : Individual t statistics for the estimated parameters. f_test : Perform an F tests on model parameters. patsy.DesignInfo.linear_constraint : Specify a linear constraint. Examples -------- >>> import numpy as np >>> import statsmodels.api as sm >>> data = sm.datasets.longley.load() >>> data.exog = sm.add_constant(data.exog) >>> results = sm.OLS(data.endog, data.exog).fit() >>> r = np.zeros_like(results.params) >>> r[5:] = [1,-1] >>> print(r) [ 0. 0. 0. 0. 0. 1. -1.] r tests that the coefficients on the 5th and 6th independent variable are the same. >>> T_test = results.t_test(r) >>> print(T_test) Test for Constraints ============================================================================== coef std err t P>|t| [0.025 0.975] ------------------------------------------------------------------------------ c0 -1829.2026 455.391 -4.017 0.003 -2859.368 -799.037 ============================================================================== >>> T_test.effect -1829.2025687192481 >>> T_test.sd 455.39079425193762 >>> T_test.tvalue -4.0167754636411717 >>> T_test.pvalue 0.0015163772380899498 Alternatively, you can specify the hypothesis tests using a string >>> from statsmodels.formula.api import ols >>> dta = sm.datasets.longley.load_pandas().data >>> formula = 'TOTEMP ~ GNPDEFL + GNP + UNEMP + ARMED + POP + YEAR' >>> results = ols(formula, dta).fit() >>> hypotheses = 'GNPDEFL = GNP, UNEMP = 2, YEAR/1829 = 1' >>> t_test = results.t_test(hypotheses) >>> print(t_test) Test for Constraints ============================================================================== coef std err t P>|t| [0.025 0.975] ------------------------------------------------------------------------------ c0 15.0977 84.937 0.178 0.863 -177.042 207.238 c1 -2.0202 0.488 -8.231 0.000 -3.125 -0.915 c2 1.0001 0.249 0.000 1.000 0.437 1.563 ============================================================================== r DesignInforTstrictoptionalrQy_rrz8Need covariance of parameters for computing T statisticsForderz#r_matrix and params are not aligned7r_matrix and q_matrix must have the same number of rowsrrr)effectrsddf_denomr)r statisticrr distribution)rXrrrr]rr) cov_nameslinear_constraintcoefs constantsr^rrrArOrrrsqueezervrrrrrrr8rr )r1rrrrrEnamesLCq_matrix num_ttests num_paramsr_effect_sd_trs r3t_testLikelihoodModelResults.t_test sXr %%E ;;  q "jjoo77971a!v&7 9EJJOO--E   0 0 :XXr||(^^A& ^^A& Md88@D"677,- -"""- a (BC C  xx +Hzz(+H'')H ==1 ~~a J. "233 =T7+: E&&* >''"''$//!#2#012C''$//8/IJC F3K /4!5t}}E "'C,46 6#'C,4068 8]9sJc*URXUSSS9nU$)aT Compute the F-test for a joint linear hypothesis. This is a special case of `wald_test` that always uses the F distribution. Parameters ---------- r_matrix : {array_like, str, tuple} One of: - array : An r x k array where r is the number of restrictions to test and k is the number of regressors. It is assumed that the linear combination is equal to zero. - str : The full hypotheses to test can be given as a string. See the examples. - tuple : A tuple of arrays in the form (R, q), ``q`` can be either a scalar or a length k row vector. cov_p : array_like, optional An alternative estimate for the parameter covariance matrix. If None is given, self.normalized_cov_params is used. invcov : array_like, optional A q x q array to specify an inverse covariance matrix based on a restrictions matrix. Returns ------- ContrastResults The results for the test are attributes of this results instance. See Also -------- t_test : Perform a single hypothesis test. wald_test : Perform a Wald-test using a quadratic form. statsmodels.stats.contrast.ContrastResults : Test results. patsy.DesignInfo.linear_constraint : Specify a linear constraint. Notes ----- The matrix `r_matrix` is assumed to be non-singular. More precisely, r_matrix (pX pX.T) r_matrix.T is assumed invertible. Here, pX is the generalized inverse of the design matrix of the model. There can be problems in non-OLS models where the rank of the covariance of the noise is not full. Examples -------- >>> import numpy as np >>> import statsmodels.api as sm >>> data = sm.datasets.longley.load() >>> data.exog = sm.add_constant(data.exog) >>> results = sm.OLS(data.endog, data.exog).fit() >>> A = np.identity(len(results.params)) >>> A = A[1:,:] This tests that each coefficient is jointly statistically significantly different from zero. >>> print(results.f_test(A)) Compare this to >>> results.fvalue 330.2853392346658 >>> results.f_pvalue 4.98403096572e-10 >>> B = np.array(([0,0,1,-1,0,0,0],[0,0,0,0,0,1,-1])) This tests that the coefficient on the 2nd and 3rd regressors are equal and jointly that the coefficient on the 5th and 6th regressors are equal. >>> print(results.f_test(B)) Alternatively, you can specify the hypothesis tests using a string >>> from statsmodels.datasets import longley >>> from statsmodels.formula.api import ols >>> dta = longley.load_pandas().data >>> formula = 'TOTEMP ~ GNPDEFL + GNP + UNEMP + ARMED + POP + YEAR' >>> results = ols(formula, dta).fit() >>> hypotheses = '(GNPDEFL = GNP), (UNEMP = 2), (YEAR/1829 = 1)' >>> f_test = results.f_test(hypotheses) >>> print(f_test) T)rinvcovuse_fscalar) wald_test)r1rrrrs r3f_testLikelihoodModelResults.f_tests!znnX6VZn[ r6c"[USSSS9n[USSSS9nUc[US5=(a URnSSKJn UR R S :Xa=URRRVs/sHnS USS US 3PM n nO URRRn UR RS S9n U"U 5RU5n U RU RpURc"UcUc[US5(d [S5e[ R""XSS2S45n [%UR&S5nU c[ R("U5n O[ R*"U 5n U R S :Xa'U SS2S4n U R&SU:wa [S5eX- nUcUR-XS9n[ R."U5R15(a [S5e[ R2R5U5n[ R2R7U5nUU:a"[8R:"SUU4-[<5 UnUbUn[US5(a4UR>SS;a![A[AURBU5U5nO6[ R""[ R""URBU5U5n[EUSURF5nUc[8R:"S[H5 SnU(a/URJS :Xa[%[ RL"U55nU(aUU-n[OUUUS9$[OUUUSU4S9$s snf)a Compute a Wald-test for a joint linear hypothesis. Parameters ---------- r_matrix : {array_like, str, tuple} One of: - array : An r x k array where r is the number of restrictions to test and k is the number of regressors. It is assumed that the linear combination is equal to zero. - str : The full hypotheses to test can be given as a string. See the examples. - tuple : A tuple of arrays in the form (R, q), ``q`` can be either a scalar or a length p row vector. cov_p : array_like, optional An alternative estimate for the parameter covariance matrix. If None is given, self.normalized_cov_params is used. invcov : array_like, optional A q x q array to specify an inverse covariance matrix based on a restrictions matrix. use_f : bool If True, then the F-distribution is used. If False, then the asymptotic distribution, chisquare is used. If use_f is None, then the F distribution is used if the model specifies that use_t is True. The test statistic is proportionally adjusted for the distribution by the number of constraints in the hypothesis. df_constraints : int, optional The number of constraints. If not provided the number of constraints is determined from r_matrix. scalar : bool, optional Flag indicating whether the Wald test statistic should be returned as a sclar float. The current behavior is to return an array. This will switch to a scalar float after 0.14 is released. To get the future behavior now, set scalar to True. To silence the warning and retain the legacy behavior, set scalar to False. Returns ------- ContrastResults The results for the test are attributes of this results instance. See Also -------- f_test : Perform an F tests on model parameters. t_test : Perform a single hypothesis test. statsmodels.stats.contrast.ContrastResults : Test results. patsy.DesignInfo.linear_constraint : Specify a linear constraint. Notes ----- The matrix `r_matrix` is assumed to be non-singular. More precisely, r_matrix (pX pX.T) r_matrix.T is assumed invertible. Here, pX is the generalized inverse of the design matrix of the model. There can be problems in non-OLS models where the rank of the covariance of the noise is not full. rTrrNrrrrQrrrrrrz8need covariance of parameters for computing F statisticsrrzPr_matrix performs f_test for using dimensions that are asymptotically non-normalzbcovariance of constraints does not have full rank. The number of constraints is %d, but rank is %drrrrzThe behavior of wald_test will change after 0.14 to returning scalar test statistic values. To get the future behavior now, set scalar to True. To silence this message while retaining the legacy behavior, set scalar to False.F)rrdf_numchi2)rrrrdistargs)(rrrrXrrr]rr)rrOrrrrrArrr5r^rrrisnanmaxrpinvr4r?r@rrrrr8r FutureWarningrvrr )r1rrrrdf_constraintsrrrErrrrcparamsJRbqJ_rrs r3r LikelihoodModelResults.wald_tests?~%E68D4H =T7+: E$ ;;  q "jjoo77971a!v&7 9EJJOO--E"""-   0 0 :XXr||(  & & .5=wt5I'J'J,- -&&!T'?3 (..# $  xx{Hzz(+H ==A 4(H~~a A% "233  >OOXOCExx""$$ ".//YY^^E*F&&u-BAv +./W56BD  %A D. ) )!!+.2HHv.4ArvvceeV,c2A4!5t}}E > MM<  F affkbjjm$A  FA"Q*+- -#A06!G GI9s=N cSSKJn UnUc/nUc/n[URRSS5nUcUc [ S5e[ R"[UR55n/n U"[5n UbURH{n URU 5n U R5n XnUHnX;dM XRU5 M URSnU(aUS:XaMiU RX45 M} /nUH,nURU[ R "X545 M. O[#URR$5H]unn [ R&"UU5nUHnX;dM XRU5 M U(aMKU RX45 M_ /nUH,nURU[ R "X545 M. UR(nSS/Un/n/nU U-U-Hun nUR+UUS 9nUR,UR.URS/nU(aURUR05 URU5 URU 5 M /S QnU(aURS 5 SS KJn U"UUUS 9n[7SUSUS9nU U-U-UlU$)a Compute a sequence of Wald tests for terms over multiple columns. This computes joined Wald tests for the hypothesis that all coefficients corresponding to a `term` are zero. `Terms` are defined by the underlying formula or by string matching. Parameters ---------- skip_single : bool If true, then terms that consist only of a single column and, therefore, refers only to a single parameter is skipped. If false, then all terms are included. extra_constraints : ndarray Additional constraints to test. Note that this input has not been tested. combine_terms : {list[str], None} Each string in this list is matched to the name of the terms or the name of the exogenous variables. All columns whose name includes that string are combined in one joint test. scalar : bool, optional Flag indicating whether the Wald test statistic should be returned as a sclar float. The current behavior is to return an array. This will switch to a scalar float after 0.14 is released. To get the future behavior now, set scalar to True. To silence the warning and retain the legacy behavior, set scalar to False. Returns ------- WaldTestResults The result instance contains `table` which is a pandas DataFrame with the test results: test statistic, degrees of freedom and pvalues. Examples -------- >>> res_ols = ols("np.log(Days+1) ~ C(Duration, Sum)*C(Weight, Sum)", data).fit() >>> res_ols.wald_test_terms() F P>F df constraint df denom Intercept 279.754525 2.37985521351e-22 1 51 C(Duration, Sum) 5.367071 0.0245738436636 1 51 C(Weight, Sum) 12.432445 3.99943118767e-05 2 51 C(Duration, Sum):C(Weight, Sum) 0.176002 0.83912310946 2 51 >>> res_poi = Poisson.from_formula("Days ~ C(Weight) * C(Duration)", data).fit(cov_type='HC0') >>> wt = res_poi.wald_test_terms(skip_single=False, combine_terms=['Duration', 'Weight']) >>> print(wt) chi2 P>chi2 df constraint Intercept 15.695625 7.43960374424e-05 1 C(Weight) 16.132616 0.000313940174705 2 C(Duration) 1.009147 0.315107378931 1 C(Weight):C(Duration) 0.216694 0.897315972824 2 Duration 11.187849 0.010752286833 3 Weight 30.263368 4.32586407145e-06 4 r) defaultdictNr!zno constraints, nothing to dorrr)r)rpvalue df_constraintr)r|)rwra)table) collectionsrr8rr)rAreyer`rr-termsslicersr0r^vstack enumeraterzrrrrrrpandasr|r temp)r1 skip_singleextra_constraints combine_termsrrresultr!identity constraintscombinedtermrmrsconstraint_matrixcname k_constraintcombined_constraintsrnrrres_waldrw constraintwtrow col_namesr|rrs r3wald_test_terms&LikelihoodModelResults.wald_test_termss| ,  $ "   Mfll//E  #4#<<= =66#fmm,- t$  "#))"((.yy{$,N!+E} ../@A+ 166q9 #q( ""D#<=*"$& &$++UBIIho4N,OP''v||'>'>? T$&MM(3-$@!+E} ../@A+""D#<=@$& &$++UBIIho4N,OP' }U+  +.B BEV V D*!!*V!>> res = ols("np.log(Days+1) ~ C(Weight) + C(Duration)", data).fit() >>> pw = res.t_test_pairwise("C(Weight)") >>> pw.result_frame coef std err t P>|t| Conf. Int. Low 2-1 0.632315 0.230003 2.749157 8.028083e-03 0.171563 3-1 1.302555 0.230003 5.663201 5.331513e-07 0.841803 3-2 0.670240 0.230003 2.914044 5.119126e-03 0.209488 Conf. Int. Upp. pvalue-hs reject-hs 2-1 1.093067 0.010212 True 3-1 1.763307 0.000002 True 3-2 1.130992 0.010212 True )ralpha factor_labels)r )r1 term_namerrrrs r3r &LikelihoodModelResults.t_test_pairwisesrdf,9; r6cVSSKJn SnU"XRUR5X$S9nU$)aoExperimental method for nonlinear prediction and tests Parameters ---------- func : callable, f(params) nonlinear function of the estimation parameters. The return of the function can be vector valued, i.e. a 1-D array deriv : function or None first derivative or Jacobian of func. If deriv is None, then a numerical derivative will be used. If func returns a 1-D array, then the `deriv` should have rows corresponding to the elements of the return of func. Returns ------- nl : instance of `NonlinearDeltaCov` with attributes and methods to calculate the results for the prediction or tests r)NonlinearDeltaCovN)deriv func_args)statsmodels.stats._delta_methodr#rr)r1funcr$r#r%nls r3_get_wald_nonlinear*LikelihoodModelResults._get_wald_nonlinearUs1( F t[[$//2C%*A r6cURnUR(a@[Rn[ USUR 5nUR SUS- - U5nO'[RnUR SUS- - 5nURnXvU-- nXvU--n Ub9[R"S[5 [R"U5nXnXn [R"[X55$)a Construct confidence interval for the fitted parameters. Parameters ---------- alpha : float, optional The significance level for the confidence interval. The default `alpha` = .05 returns a 95% confidence interval. cols : array_like, optional Specifies which confidence intervals to return. .. deprecated: 0.13 cols is deprecated and will be removed after 0.14 is released. cols only works when inputs are NumPy arrays and will fail when using pandas Series or DataFrames as input. You can subset the confidence intervals using slices. Returns ------- array_like Each row contains [lower, upper] limits of the confidence interval for the corresponding parameter. The first column contains all lower, the second column contains all upper limits. Notes ----- The confidence interval is based on the standard normal distribution if self.use_t is False. If self.use_t is True, then uses a Student's t with self.df_resid_inference (or self.df_resid if df_resid_inference is not defined) degrees of freedom. Examples -------- >>> import statsmodels.api as sm >>> data = sm.datasets.longley.load() >>> data.exog = sm.add_constant(data.exog) >>> results = sm.OLS(data.endog, data.exog).fit() >>> results.conf_int() array([[-5496529.48322745, -1467987.78596704], [ -177.02903529, 207.15277984], [ -0.1115811 , 0.03994274], [ -3.12506664, -0.91539297], [ -1.5179487 , -0.54850503], [ -0.56251721, 0.460309 ], [ 798.7875153 , 2859.51541392]]) >>> results.conf_int(cols=(2,3)) array([[-0.1115811 , 0.03994274], [-3.12506664, -0.91539297]]) rrrQacols is deprecated and will be removed after 0.14 is released. cols only works when inputs are NumPy arrays and will fail when using pandas Series or DataFrames as input. Subsets of confidence intervals can be selected using slices of the full confidence interval array.)rrrrr8rppfrrr?r@rrrr) r1rrmrdistrqrloweruppers r3conf_intLikelihoodModelResults.conf_intpshhh ::77Dt%94==IHUQY1A::DUQY'AS S    MM9   ::d#DKEKEzz$u,--r6cNSSKJn U(aUR5 U"X5 g)a Save a pickle of this instance. Parameters ---------- fname : {str, handle} A string filename or a file handle. remove_data : bool If False (default), then the instance is pickled without changes. If True, then all arrays with length nobs are set to None before pickling. See the remove_data method. In some cases not all arrays will be set to None. Notes ----- If remove_data is true and the model result does not implement a remove_data method then this will raise an exception. r) save_pickleN)statsmodels.iolib.smpickler4 remove_data)r1fnamer6r4s r3saveLikelihoodModelResults.saves( ;     D r6cSSKJn U"U5$)a{ Load a pickled results instance .. warning:: Loading pickled models is not secure against erroneous or maliciously constructed data. Never unpickle data received from an untrusted or unauthenticated source. Parameters ---------- fname : {str, handle, pathlib.Path} A string filename or a file handle. Returns ------- Results The unpickled results instance. r) load_pickle)r5r;)rgr7r;s r3loadLikelihoodModelResults.loads, ;5!!r6cURn0n[U5Hn[RX5nXBU'M UVs/sHn[ X%[ 5(dMUPM nnUHnSURU'M Sn[US/5Vs/sHnSU-PM n nURRVs/sHnSU-PM n nURU -U -Hn X;aM U"X 5 M URHn SURU 'M g![a GM f=fs snfs snfs snf![[4a MLf=f)aV Remove data arrays, all nobs arrays from result and model. This reduces the size of the instance, so it can be pickled with less memory. Currently tested for use with predict from an unpickled results and model instance. .. warning:: Since data and some intermediate results have been removed calculating new statistics that require them will raise exceptions. The exception will occur the first time an attribute is accessed that has been set to None. Not fully tested for time series models, tsa, and might delete too much for prediction or not all that would be possible. The lists of arrays to delete are maintained as attributes of the result and model instance, except for cached values. These lists could be changed before calling remove_data. The attributes to remove are named in: model._data_attr : arrays attached to both the model instance and the results instance with the same attribute name. result._data_in_cache : arrays that may exist as values in result._cache result._data_attr_model : arrays attached to the model instance but not to the results instance NcURS5nURS5n[[U/U-5n[ XC5(a [ XCS5 gg![ a gf=f)N.rR)splitr'rr8rrKAttributeError)objattpatt_obj_s r3wipe0LikelihoodModelResults.remove_data..wipe$ s_ #A559D guqy14&&D-'!  s0A A#"A#_data_attr_modelzmodel.) rdirobject__getattribute__rBrYrrr8rr+rlrM) r1rg cls_attrsrsattrrl data_attrsrHrE model_only model_attrrDr9s r3r6"LikelihoodModelResults.remove_datas]Bnn HD '..s9#'$ "+@A#IL+> @D $DKK  -4D:Lb,QR,Qqhl,Q R,0JJ,A,AB,Aqhl,A B??Z/*LG\DH37L\=A&*;z6M.^!6""0IIr6rc6\rSrSrSSSSSSSS.r\rSSS.rSrg) LikelihoodResultsWrapperi? rarowsr)rrrrrrr)rr1rN)rrrr_attrs _wrap_attrs _wrap_methodsrrr6r3rXrX? s2!&FKMr6rXc\rSrSr\S5r\S5r\S5r\S5r\S5r \S5r \S5r \S 5r \S 5r SS jrS rS rg) ResultMixiniT c[URSS5n[US5(aP[US5(a URnO [US5(a URnOSnUR U-U-$UR R$)zModel WCrrrr*r"r)r8rrr*r"rrrv)r1rr"s r3 df_modelwcResultMixin.df_modelwcV sz $**i3 4 $ $t\**??z**====8+g5 5;;## #r6c@SUR-SUR--$)zAkaike information criterionrQ)rr`rts r3aicResultMixin.aich s DHH}qDOO444r6c|SUR-[R"UR5UR--$)zBayesian information criterionrc)rrlogrr`rts r3bicResultMixin.bicm s-DHH}rvvdii0DOODDDr6cLURRUR5$)z*cached Jacobian of log-likelihood )rrSrrts r3 score_obsvResultMixin.score_obsvr szz##DKK00r6cLURRUR5$)z)cached Hessian of log-likelihood )rrrrts r3hessvResultMixin.hessvx szz!!$++..r6cURn[RR[R"UR U55$)zO covariance of parameters based on outer product of jacobian of log-likelihood )rkrrrrr)r1jacvs r3covjacResultMixin.covjac~ s/yy}}RVVDFFD122r6c URnURn[RR U5n[R "U[R "[R "UR U5U55$)zcovariance of parameters based on HJJH dot product of Hessian, Jacobian, Jacobian, Hessian of likelihood name should be covhjh )rkrnrrrrr)r1rqrnhessinvs r3covjhjResultMixin.covjhj sS ))--&vvgrvvbffTVVT&:GDEEr6cj[R"[R"UR55$)zBstandard deviation of parameter estimates based on covHJH )rrrrvrts r3bsejhjResultMixin.bsejhj wwrwwt{{+,,r6cj[R"[R"UR55$)zBstandard deviation of parameter estimates based on covjac )rrrrrrts r3bsejacResultMixin.bsejac r{r6c  /n[URS5(aSOSn[U5GH n[RR UR UR S9nURbURUSS24n OSn URR5n URR"URU4SU 0U D6n U(a=URRH#n [X[URU 55 M% U RX#S9n URU R 5 GM [R""U5nU(aXPlUR'S5UR)S5U4$) a}simple bootstrap to get mean and variance of estimator see notes Parameters ---------- nrep : int number of bootstrap replications method : str optimization method to use disp : bool If true, then optimization prints results store : bool If true, then parameter estimates for all bootstrap iterations are attached in self.bootstrap_results Returns ------- mean : ndarray mean of parameter estimates over bootstrap replications std : ndarray standard deviation of parameter estimates over bootstrap replications Notes ----- This was mainly written to compare estimators of the standard errors of the parameter estimates. It uses independent random sampling from the original endog and exog, and therefore is only correct if observations are independently distributed. This will be moved to apply only to models with independently distributed observations. cloneattrTF)rvNr%)rrr)rrrbrrandomrandintrr%r;rr&rrKr8rr0rrbootstrap_resultsmeanstd)r1nreprrstoreresults hascloneattrrErvsind exog_resampr fitmodrOfitress r3 bootstrapResultMixin.bootstrap s;F&tzz;??tU tAYY&&tyytyy&AFyy$"ii 2 "  113IZZ))$**V*<I/:I>GIF JJ00DF'$**d*CD1ZZvZ9F NN6== )#$((7# %, "||A A77r6c[e)z$ get_nlfun This is not Implemented r})r1funs r3 get_nlfunResultMixin.get_nlfun s "!r6)rN)r$rrr)rrrrrr`rdrhrkrnrrrvryr}rrrrr6r3r^r^T s$$"55EE11 //  3 3 F F-- -- :8x"r6r^c\\rSrSrSrS Sjr\S5r\S5rS Sjr \S5r S r g) _LLRMixini z4Mixin class for Null model and likelihood ratio c\UR5nURS5(aSURUR- - nU$URS5(dUS;aBS[R "URUR- SUR - -5- nU$[S5e)z3 McFadden's pseudo-R-squared. `1 - (llf / llnull)` mcfrcox)cslrrQz)only McFadden and Cox-Snell are available)r/ startswithrllnullrexprrA)r1kindprsqs r3pseudo_rsquared_LLRMixin.pseudo_rsquared szz| ??5 ! !txx$++--D  __U # #t|';rvvt{{TXX5!dii-HIID HI Ir6c:SURUR- -$)z= Likelihood ratio chi-squared statistic; `-2*(llnull - llf)` rc)rrrts r3llr _LLRMixin.llr s 4;;)**r6cURnURnURnX2- nX@l[R R RX5$)z The chi-squared probability of getting a log-likelihood ratio statistic greater than llr. llr has a chi-squared distribution with degrees of freedom `df_model`. )rr df_resid_null df_lr_nullr distributionsrr)r1rdf_fulldf_restrlrdfs r3 llr_pvalue_LLRMixin.llr_pvalue sKhh--%%"""''**355r6Nc DURRSS5 URRSS5 URRSS5 URRSS5 [US5(aU?UbXRS'X lX0lg)a] Set the fit options for the Null (constant-only) model. This resets the cache for related attributes which is potentially fragile. This only sets the option, the null model is estimated when llnull is accessed, if llnull is not yet in cache. Parameters ---------- llnull : {None, float} If llnull is not None, then the value will be directly assigned to the cached attribute "llnull". attach_results : bool Sets an internal flag whether the results instance of the null model should be attached. By default without calling this method, thenull model results are not attached and only the loglikelihood value llnull is stored. **kwargs Additional keyword arguments used as fit keyword arguments for the null model. The override and model default values. Notes ----- Modifies attributes of this instance, and so has no return. rNrr prsquaredres_null)rr'rr_attach_nullmodel_optim_kwds_null)r1rattach_resultsr2s r3set_null_options_LLRMixin.set_null_options s|: $' t$  d+  T* 4 $ $  $*KK !!/ &r6cURnUR5R5n[US/5HnX# M UR"UR [ R"UR540UD6n[US05R5nSU;aURS5nO$[US5(aUR5nOSn[SSSS S 9nURU5 U(aUR"SSU0UD6nO0URUS SSS S 9nURURSSSS S 9n[US S5SLaXl[#UR5UlUR&UlUR*$)z* Value of the constant-only loglikelihood _null_drop_keysrr_get_start_params_nullNbfgsFi'r)rrrrr)rrrrrrr)rr;rr8rr&rr`rr'rrrrerrrr`k_nullrrr) r1rr:r9mod_null optim_kwdssp_nullopt_kwdsrs r3r_LLRMixin.llnull= su  ##%**,5"3R8C 9??5;; 0BKdK T#5r:??A Z ' nn^4G U4 5 5224GGvu  # ||EEHEH ||5:,1$;H ||5:,1$;H 4,e 4E A$M(//* %..||r6)rrrrrr)rrg) rrrrrrrrrrrrrr6r3rr sN ++  6 6''R--r6rc>\rSrSrSrSrSSjrS SjrSrg) rain a^ A results class for the discrete dependent variable models. ..Warning : The following description has not been updated to this version/class. Where are AIC, BIC, ....? docstring looks like copy from discretemod Parameters ---------- model : A DiscreteModel instance mlefit : instance of LikelihoodResults This contains the numerical optimization results as returned by LikelihoodModel.fit(), in a superclass of GnericLikelihoodModels Attributes ---------- aic : float Akaike information criterion. -2*(`llf` - p) where p is the number of regressors including the intercept. bic : float Bayesian information criterion. -2*`llf` + ln(`nobs`)*p where p is the number of regressors including the intercept. bse : ndarray The standard errors of the coefficients. df_resid : float See model definition. df_model : float See model definition. fitted_values : ndarray Linear predictor XB. llf : float Value of the loglikelihood llnull : float Value of the constant-only loglikelihood llr : float Likelihood ratio chi-squared statistic; -2*(`llnull` - `llf`) llr_pvalue : float The chi-squared probability of getting a log-likelihood ratio statistic greater than llr. llr has a chi-squared distribution with degrees of freedom `df_model`. prsquared : float McFadden's pseudo-R-squared. 1 - (`llf`/`llnull`) cnXlURUlURUlURRSUl[ URSS5n[ US5(a7[R"UR5(dURUl OE[UR5URR- U- nX@l X@Rl [ US5(a7[R"UR5(dURUl OIURRSUR- U- Ul URURl 0UlURR!UR5 [UR5nURURR-U-U:wa["R$"S[&5 URURU- :wa["R$"S5 gg)Nrrrrz5df_model + k_constant + k_extra differs from k_paramsz%df_resid differs from nobs - k_params)rr&r%r^rr8rrrrr`rr*rrrLrer?r@ UserWarning)r1rrrrrs r3r4&GenericLikelihoodModelResults.__init__ s [[ JJ KK%%a( $**i3 5* % %bhhu~~.F.F!NNDM6==)DJJ,A,AAGKH$M"*JJ  5* % %bhhu~~.F.F!NNDM JJ,,Q/$--?'IDM"&--DJJ   V__-v}}% ==4::00 07 :h F MM23> @ ==DII0 0 MMA B 1r6Nc 0SSKJn Un U"UUUUUUUU S9n U $)a Compute prediction results when endpoint transformation is valid. Parameters ---------- exog : array_like, optional The values for which you want to predict. transform : bool, optional If the model was fit via a formula, do you want to pass exog through the formula. Default is True. E.g., if you fit a model y ~ log(x1) + log(x2), and transform is True, then you can pass a data structure that contains x1 and x2 in their original form. Otherwise, you'd need to log the data first. which : str Which statistic is to be predicted. Default is "mean". The available statistics and options depend on the model. see the model.predict docstring row_labels : list of str or None If row_lables are provided, then they will replace the generated labels. average : bool If average is True, then the mean prediction is computed, that is, predictions are computed for individual exog and then the average over observation is used. If average is False, then the results are the predictions for all observations, i.e. same length as ``exog``. agg_weights : ndarray, optional Aggregation weights, only used if average is True. The weights are not normalized. **kwargs : Some models can take additional keyword arguments, such as offset, exposure or additional exog in multi-part models like zero inflated models. See the predict method of the model for the details. Returns ------- prediction_results : PredictionResults The prediction results instance contains prediction and prediction variance and can on demand calculate confidence intervals and summary dataframe for the prediction. Notes ----- Status: new in 0.14, experimental r)get_prediction)r%whichr row_labelsaverage agg_weights pred_kwds)&statsmodels.base._prediction_inferencer) r1r%rrrrrr2rrrs r3r,GenericLikelihoodModelResults.get_prediction s7r J  !#  r6c 0SSSS/4SSSSS /nS S S UR-/4S S UR-/4/nUc&URRRS-S-nSSKJn U"5nURXUXUS9 URXX$URS9 U$)aSummarize the Regression Results Parameters ---------- yname : str, optional Default is `y` xname : list[str], optional Names for the exogenous variables, default is "var_xx". Must match the number of parameters in the model title : str, optional Title for the top table. If not None, then this replaces the default title alpha : float significance level for the confidence intervals Returns ------- smry : Summary instance this holds the summary tables and text, which can be printed or converted to various output formats. See Also -------- statsmodels.iolib.summary.Summary : class to hold summary results )zDep. Variable:N)zModel:NzMethod:zMaximum Likelihood)zDate:N)zTime:N)zNo. Observations:N)z Df Residuals:N)z Df Model:N)zLog-Likelihood:NzAIC:z%#8.4gzBIC: rir)Summary)gleftgrightynamexnametitle)rrrr) rdrhrrrstatsmodels.iolib.summaryradd_table_2colsadd_table_paramsr) r1rrrrtop_left top_rightrsmrys r3r%GenericLikelihoodModelResults.summary s6-$!5 67##/+'/x$((234x$((234 =JJ((11C7)CE 6y T)#(U  D du$(JJ  0 r6)rrrr&r%rr)NrTNFN)NNNrU) rrrrrr4rrrrr6r3raran s/,\#CNGR5r6ra): __future__rstatsmodels.compat.pythonr functoolsrr?numpyrrrxscipyrstatsmodels.base.datarstatsmodels.base.optimizerrstatsmodels.base.wrapperbasewrapperwrapstatsmodels.formular statsmodels.stats.contrastr r r statsmodels.tools.datar statsmodels.tools.decoratorsrrrrWrrrrstatsmodels.tools.toolsrrstatsmodels.tools.validationrrrrrrrr(rirResultsWrapperrXpopulate_wrapperr^rrarr6r3rs "*-0''3 4 4423> F"F"R|