Statsmodels

https://www.statsmodels.org/stable/
Admin
Statsmodels is a Python library that provides classes and functions for estimating different...
Tokens:5,740,803
Snippets:36,307
Trust Score:9.2
Update:1 week ago
Show doc for...
Tokens:
Raw
### MarkovSwitchingParams parameter setup example

Source: https://www.statsmodels.org/stable/_modules/statsmodels/tsa/regime_switching/markov_switching.html

This example shows how to set up parameters for a Markov switching model using the MarkovSwitchingParams class. It sets regime_transition and exog parameters with switching indicators.

```python
parameters = MarkovSwitchingParams(k_regimes=2)
        parameters['regime_transition'] = [1,1]
        parameters['exog'] = [0, 1]
```

--------------------------------

### Default example for continuous distributions

Source: https://www.statsmodels.org/stable/_modules/scipy/stats/_distn_infrastructure.html

This code block is part of the default documentation example for continuous distributions. It imports numpy, scipy.stats, and matplotlib, creates a plot, and demonstrates how to get support, calculate moments, display the pdf, freeze the distribution, check cdf/ppf accuracy, generate random numbers, and plot a histogram. The example uses placeholder strings like %(name)s and %(shapes)s that are substituted at runtime.

```python
>>> import numpy as np
>>> from scipy.stats import %(name)s
>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots(1, 1)

Get the support:

%(set_vals_stmt)s
>>> lb, ub = %(name)s.support(%(shapes)s)

Calculate the first four moments:

>>> mean, var, skew, kurt = %(name)s.stats(%(shapes)s, moments='mvsk')

Display the probability density function (``pdf``):

>>> x = np.linspace(%(name)s.ppf(0.01, %(shapes)s),
...                 %(name)s.ppf(0.99, %(shapes)s), 100)
>>> ax.plot(x, %(name)s.pdf(x, %(shapes)s),
...        'r-', lw=5, alpha=0.6, label='%(name)s pdf')

Alternatively, the distribution object can be called (as a function)
to fix the shape, location and scale parameters. This returns a "frozen"
RV object holding the given parameters fixed.

Freeze the distribution and display the frozen ``pdf``:

>>> rv = %(name)s(%(shapes)s)
>>> ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf')

Check accuracy of ``cdf`` and ``ppf``:

>>> vals = %(name)s.ppf([0.001, 0.5, 0.999], %(shapes)s)
>>> np.allclose([0.001, 0.5, 0.999], %(name)s.cdf(vals, %(shapes)s))
True

Generate random numbers:

>>> r = %(name)s.rvs(%(shapes)s, size=1000)

And compare the histogram:

>>> ax.hist(r, density=True, bins='auto', histtype='stepfilled', alpha=0.2)
>>> ax.set_xlim([x[0], x[-1]])
>>> ax.legend(loc='best', frameon=False)
>>> plt.show()
```

--------------------------------

### Import libraries and load Cattaneo dataset

Source: https://www.statsmodels.org/stable/_sources/examples/notebooks/generated/treatment_effect.ipynb.txt

Sets up the environment by importing necessary modules, loading the cataneo2.csv dataset, and defining the list of treatment effect methods to be used. This is the initial setup required for all subsequent examples.

```python
import os

import numpy as np
import pandas as pd

from statsmodels.discrete.discrete_model import Probit
from statsmodels.regression.linear_model import OLS
from statsmodels.treatment.tests.results import results_teffects as res_st
from statsmodels.treatment.treatment_effects import TreatmentEffect

# Load data for example
cur_dir = os.path.abspath(os.path.dirname(res_st.__file__))
file_name = "cataneo2.csv"
file_path = os.path.join(cur_dir, file_name)
dta_cat = pd.read_csv(file_path)

methods = ["ra", "ipw", "aipw", "aipw_wls", "ipw_ra"]
methods_st = [
    ("ra", res_st.results_ra),
    ("ipw", res_st.results_ipw),
    ("aipw", res_st.results_aipw),
    ("aipw_wls", res_st.results_aipw_wls),
    ("ipw_ra", res_st.results_ipwra),
]

# allow wider display of data frames
pd.set_option("display.width", 500)
```

--------------------------------

### _optimize_parameters method for Holt-Winters optimization setup

Source: https://www.statsmodels.org/stable/_modules/statsmodels/tsa/holtwinters/model.html

Prepares data and starting values for parameter optimization. Extracts alpha, beta, phi, gamma, y, and start_params from the data object, then initializes a parameter vector of length 6 + seasonal_periods and computes initial level, trend, and seasonal values.

```python
    def _optimize_parameters(
        self, data: _OptConfig, use_brute, method, kwargs
    ) -> _OptConfig:
        # Prepare starting values
        alpha = data.alpha
        beta = data.beta
        phi = data.phi
        gamma = data.gamma
        y = data.y
        start_params = data.params

        has_seasonal = self.has_seasonal
        has_trend = self.has_trend
        trend = self.trend
        seasonal = self.seasonal
        damped_trend = self.damped_trend

        m = self.seasonal_periods
        params = np.zeros(6 + m)
        l0, b0, s0 = self.initial_values(
            initial_level=data.level, initial_trend=data.trend
        )
```

--------------------------------

### MLEModel.start_params

Source: https://www.statsmodels.org/stable/generated/statsmodels.tsa.statespace.mlemodel.MLEModel.html

Returns the starting parameters for optimization.

```APIDOC
## MLEModel.start_params

### Description
Returns the starting parameters for optimization.

### Property
start_params

### Returns
- **array_like** - The starting parameters.
```

--------------------------------

### Import statsmodels and matplotlib for KDE example

Source: https://www.statsmodels.org/stable/generated/statsmodels.nonparametric.kde.KDEUnivariate.html

Imports required libraries for the KDE example.

```python
>>> import statsmodels.api as sm
>>> import matplotlib.pyplot as plt
```

--------------------------------

### Import libraries for kernel density estimation

Source: https://www.statsmodels.org/stable/examples/notebooks/generated/kernel_density.html

Sets up the environment by importing matplotlib, numpy, scipy.stats, statsmodels, and the mixture_rvs function. This is the required setup for the examples that follow.

```python
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
from scipy import stats

import statsmodels.api as sm
from statsmodels.distributions.mixture_rvs import mixture_rvs

```

--------------------------------

### Denton 1971 Paper Implementation Examples

Source: https://www.statsmodels.org/stable/_modules/statsmodels/tsa/interp/denton.html

Examples demonstrating the mathematical approach described in the Denton 1971 paper.

```python
k = 4
m = 5
n = m*k

zQ = [50,100,150,100] * m
Y = [500,400,300,400,500]

A = np.eye(n)
B = block_diag(*(np.ones((k,1)),)*m)

r = Y - B.T.dot(zQ)
#Ainv = inv(A)
Ainv = A # shortcut for identity
C = Ainv.dot(B).dot(inv(B.T.dot(Ainv).dot(B)))
x = zQ + C.dot(r)

# minimize first difference d(x-z)
R = linalg.tri(n, dtype=float) # R is tril so actually R.T in paper
Ainv = R.dot(R.T)
C = Ainv.dot(B).dot(inv(B.T.dot(Ainv).dot(B)))
x1 = zQ + C.dot(r)
```

--------------------------------

### SimulationSmoother.simulator

Source: https://www.statsmodels.org/stable/generated/statsmodels.tsa.statespace.simulation_smoother.SimulationSmoother.smoother_all.html

Get the simulator.

```APIDOC
## SimulationSmoother.simulator

### Description
Returns the simulator object.

### Method
simulator

### Parameters
None

### Returns
- **Simulator** - The simulator.
```

--------------------------------

### summary([alpha, start])

Source: https://www.statsmodels.org/stable/generated/statsmodels.tsa.statespace.exponential_smoothing.ExponentialSmoothingResults.html

Summarize the Model.

```APIDOC
## summary([alpha, start])

### Description
Summarize the Model.

### Method
summary

### Parameters
- **alpha** (float, optional) - Significance level for confidence intervals.
- **start** (int, optional) - Start index for summary.

### Returns
- **summary** (Summary) - Summary of the model.
```

--------------------------------

### Import ARDL and load Danish data

Source: https://www.statsmodels.org/stable/generated/statsmodels.tsa.ardl.ARDL.html

Imports the ARDL class and loads the Danish data used in the examples. This setup is required for the subsequent ARDL model examples.

```python
>>> from statsmodels.tsa.api import ARDL
>>> from statsmodels.datasets import danish_data
>>> data = danish_data.load_pandas().data
>>> lrm = data.lrm
>>> exog = data[["lry", "ibo", "ide"]]
```

--------------------------------

### Setup: Import numpy and define contrast helper functions

Source: https://www.statsmodels.org/stable/_sources/contrasts.rst.txt

Sets up numpy printing options and imports ContrastMatrix. Defines a helper to name contrast levels and a Simple class with methods to create simple contrasts with or without an intercept.

```python
import numpy as np
np.set_printoptions(precision=4, suppress=True)

from patsy.contrasts import ContrastMatrix

def _name_levels(prefix, levels):
    return ["[%s%s]" % (prefix, level) for level in levels]
```

```python
class Simple(object):
    def _simple_contrast(self, levels):
        nlevels = len(levels)
        contr = -1./nlevels * np.ones((nlevels, nlevels-1))
        contr[1:][np.diag_indices(nlevels-1)] = (nlevels-1.)/nlevels
        return contr

    def code_with_intercept(self, levels):
        contrast = np.column_stack((np.ones(len(levels)),
                                   self._simple_contrast(levels)))
        return ContrastMatrix(contrast, _name_levels("Simp.", levels))

    def code_without_intercept(self, levels):
        contrast = self._simple_contrast(levels)
        return ContrastMatrix(contrast, _name_levels("Simp.", levels[:-1]))
```

--------------------------------

### UnobservedComponents.start_params

Source: https://www.statsmodels.org/stable/generated/statsmodels.tsa.statespace.structural.UnobservedComponents.start_params.html

Retrieves the starting parameters for maximum likelihood estimation of the UnobservedComponents model.

```APIDOC
## UnobservedComponents.start_params

### Description
Returns an array of starting parameter values for maximum likelihood estimation of the UnobservedComponents model.

### Property
`start_params`

### Returns
- **array** - Starting parameters for maximum likelihood estimation.

### Example
```python
model = UnobservedComponents(endog, level='local level')
start_params = model.start_params
```
```

--------------------------------

### Example: Using innovations_algo with macrodata

Source: https://www.statsmodels.org/stable/generated/statsmodels.tsa.stattools.innovations_algo.html

This example imports statsmodels, loads the macrodata dataset, computes the autocovariance function of the real GDP growth rate, and calls innovations_algo with the first four autocovariances and the number of observations. The result is the innovation coefficients theta and prediction error variance sigma2.

```python
>>> import statsmodels.api as sm
>>> data = sm.datasets.macrodata.load_pandas()
>>> rgdpg = data.data['realgdp'].pct_change().dropna()
>>> acov = sm.tsa.acovf(rgdpg)
>>> nobs = activity.shape[0]
>>> theta, sigma2  = innovations_algo(acov[:4], nobs=nobs)
```

--------------------------------

### Get residual degrees of freedom

Source: https://www.statsmodels.org/stable/_sources/examples/notebooks/generated/multivariate_ls.ipynb.txt

Accesses the residual degrees of freedom of the MultivariateLS model, which is 594 in this example.

```python
res.df_resid
```

--------------------------------

### Import libraries for KDE example

Source: https://www.statsmodels.org/stable/_sources/examples/notebooks/generated/kernel_density.ipynb.txt

Sets up the environment with matplotlib, numpy, scipy, and statsmodels, including the mixture_rvs function for generating sample data.

```python
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
from scipy import stats

import statsmodels.api as sm
from statsmodels.distributions.mixture_rvs import mixture_rvs
```

--------------------------------

### Import libraries and set up plotting style

Source: https://www.statsmodels.org/stable/_sources/vector_ar.rst.txt

Imports pandas, matplotlib, and sets the matplotlib style to 'ggplot'. This is a setup step for the subsequent examples.

```python
import pandas as pd
pd.options.display.max_rows = 10
import matplotlib
import matplotlib.pyplot as plt
matplotlib.style.use('ggplot')
```

--------------------------------

### Extend SARIMAX results with new observations

Source: https://www.statsmodels.org/stable/generated/statsmodels.tsa.statespace.sarimax.SARIMAXResults.extend.html

First example shows creating a SARIMAX model, fitting it, and printing parameters, fitted values, and a forecast. The second example extends the results with new observations and prints updated parameters, fitted values, and forecast.

```python
>>> index = pd.period_range(start='2000', periods=2, freq='Y')
>>> original_observations = pd.Series([1.2, 1.5], index=index)
>>> mod = sm.tsa.SARIMAX(original_observations)
>>> res = mod.fit()
>>> print(res.params)
ar.L1     0.9756
sigma2    0.0889
dtype: float64
>>> print(res.fittedvalues)
2000    0.0000
2001    1.1707
Freq: A-DEC, dtype: float64
>>> print(res.forecast(1))
2002    1.4634
Freq: A-DEC, dtype: float64
```

```python
>>> new_index = pd.period_range(start='2002', periods=1, freq='Y')
>>> new_observations = pd.Series([0.9], index=new_index)
>>> updated_res = res.extend(new_observations)
>>> print(updated_res.params)
ar.L1     0.9756
sigma2    0.0889
dtype: float64
>>> print(updated_res.fittedvalues)
2002    1.4634
Freq: A-DEC, dtype: float64
>>> print(updated_res.forecast(1))
2003    0.878
Freq: A-DEC, dtype: float64
```

--------------------------------

### Slice confidence interval results

Source: https://www.statsmodels.org/stable/dev/generated/statsmodels.base.model.GenericLikelihoodModelResults.conf_int.html

Example showing how to slice the confidence interval array to get limits for a subset of parameters (rows 2 to 4).

```python
>>> results.conf_int()[2:4]
array([[-0.1115811 ,  0.03994274],
       [-3.12506664, -0.91539297]])
```

--------------------------------

### _get_starting_values method for Holt-Winters starting parameters

Source: https://www.statsmodels.org/stable/_modules/statsmodels/tsa/holtwinters/model.html

Determines starting parameter values for optimization. Uses brute-force grid search over alpha, beta, gamma when start_params is None and use_brute is True; otherwise uses user-provided start_params, raising ValueError if the length does not match the number of selected parameters.

```python
    def _get_starting_values(
        self,
        params,
        start_params,
        use_brute,
        sel,
        hw_args,
        bounds,
        alpha,
        func,
    ):
        if start_params is None and use_brute and np.any(sel[:3]):
            # Have a quick look in the region for a good starting place for
            # alpha, beta & gamma using fixed values for initial
            m = self.seasonal_periods
            sv_sel = np.array([False] * (6 + m))
            sv_sel[:3] = True
            sv_sel &= sel
            hw_args.xi = sv_sel.astype(np.int64)
            hw_args.transform = False
            # Setup the grid points, respecting constraints
            points = self._setup_brute(sv_sel, bounds, alpha)
            opt = opt_wrapper(func)
            best_val = np.inf
            best_params = points[0]
            for point in points:
                val = opt(point, hw_args)
                if val < best_val:
                    best_params = point
                    best_val = val
            params[sv_sel] = best_params
        elif start_params is not None:
            if len(start_params) != sel.sum():
                msg = "start_params must have {0} values but has {1}."
                nxi, nsp = len(sel), len(start_params)
                raise ValueError(msg.format(nxi, nsp))
            params[sel] = start_params
        return params
```

--------------------------------

### VARMAX.start_params

Source: https://www.statsmodels.org/stable/generated/statsmodels.tsa.statespace.varmax.VARMAX.start_params.html

Property that returns the starting parameters for maximum likelihood estimation of the VARMAX model.

```APIDOC
## VARMAX.start_params

### Description
Returns an array of starting parameters for maximum likelihood estimation of the VARMAX model.

### Property
`start_params`

### Returns
- **array** - Starting parameters for maximum likelihood estimation.

```

--------------------------------

### Counter.elements() examples (repetition and prime factors)

Source: https://www.statsmodels.org/stable/_modules/collections.html

Docstring examples for Counter.elements(). The first shows that elements() repeats each element as many times as its count. The second uses Knuth's example for prime factors of 1836 (2**2 * 3**3 * 17**1) and multiplies the elements to get 1836. Note that elements() ignores elements with zero or negative counts.

```python
>>> c = Counter('ABCABC')
>>> sorted(c.elements())
['A', 'A', 'B', 'B', 'C', 'C']
```

```python
>>> import math
>>> prime_factors = Counter({2: 2, 3: 3, 17: 1})
>>> math.prod(prime_factors.elements())
1836
```

--------------------------------

### ArmaProcess.from_roots example

Source: https://www.statsmodels.org/stable/_modules/statsmodels/tsa/arima_process.html

Creates an ArmaProcess from AR and MA roots. The example shows how to use from_roots with arroots and maroots, and checks isstationary and isinvertible.

```python
>>> arroots = [2, -2]
>>> maroots = [3, 1.5]
>>> arma_process = sm.tsa.ArmaProcess.from_roots(
...     arroots=arroots, maroots=maroots
... )
>>> arma_process.isstationary
True
>>> arma_process.isinvertible
True
```

--------------------------------

### First Example Timings with MKL_NUM_THREADS=1

Source: https://www.statsmodels.org/stable/examples/notebooks/generated/statespace_chandrasekhar.html

Timing output for the first example after disabling multithreading, showing slower performance compared to the multithreaded case.

```text
307 ms ± 3.08 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
97.5 ms ± 1.64 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

```

--------------------------------

### Discrete distribution documentation example template

Source: https://www.statsmodels.org/stable/_modules/scipy/stats/_distn_infrastructure.html

Template for the 'Examples' section of discrete distribution docstrings. It shows how to plot the pmf, freeze the distribution, check cdf/ppf accuracy, and generate random numbers. Placeholders like %(name)s and %(shapes)s are substituted at runtime.

```python
_doc_default_discrete_example = """\
Examples
--------
>>> import numpy as np
>>> from scipy.stats import %(name)s
>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots(1, 1)

Get the support:

%(set_vals_stmt)s
>>> lb, ub = %(name)s.support(%(shapes)s)

Calculate the first four moments:

>>> mean, var, skew, kurt = %(name)s.stats(%(shapes)s, moments='mvsk')

Display the probability mass function (``pmf``):

>>> x = np.arange(%(name)s.ppf(0.01, %(shapes)s),
...               %(name)s.ppf(0.99, %(shapes)s))
>>> ax.plot(x, %(name)s.pmf(x, %(shapes)s), 'bo', ms=8, label='%(name)s pmf')
>>> ax.vlines(x, 0, %(name)s.pmf(x, %(shapes)s), colors='b', lw=5, alpha=0.5)

Alternatively, the distribution object can be called (as a function)
to fix the shape and location. This returns a "frozen" RV object holding
the given parameters fixed.

Freeze the distribution and display the frozen ``pmf``:

>>> rv = %(name)s(%(shapes)s)
>>> ax.vlines(x, 0, rv.pmf(x), colors='k', linestyles='-', lw=1,
...         label='frozen pmf')
>>> ax.legend(loc='best', frameon=False)
>>> plt.show()

Check accuracy of ``cdf`` and ``ppf``:

>>> prob = %(name)s.cdf(x, %(shapes)s)
>>> np.allclose(x, %(name)s.ppf(prob, %(shapes)s))
True

Generate random numbers:

>>> r = %(name)s.rvs(%(shapes)s, size=1000)
"""
```

--------------------------------

### Get variable names with data.endog_name and data.exog_name

Source: https://www.statsmodels.org/stable/datasets/index.html

Shows how to obtain the names of the endogenous and exogenous variables for a dataset. The example outputs the endog_name as a string and exog_name as a list of strings.

```python
In [10]: data.endog_name
Out[10]: 'TOTEMP'

In [11]: data.exog_name
Out[11]: ['GNPDEFL', 'GNP', 'UNEMP', 'ARMED', 'POP', 'YEAR']

```

--------------------------------

### Build documentation with make clean and make html

Source: https://www.statsmodels.org/stable/_sources/dev/index.rst.txt

Run from the top-level docs/ directory to rebuild the documentation and verify that your changes parse without warnings.

```bash
make clean
make html
```

--------------------------------

### SimulationSmoother.initialize_components

Source: https://www.statsmodels.org/stable/generated/statsmodels.tsa.statespace.simulation_smoother.SimulationSmoother.smoother_all.html

Initialize components.

```APIDOC
## SimulationSmoother.initialize_components

### Description
Initializes the state space components.

### Method
initialize_components

### Parameters
- **a** (array_like) - State intercept.
- **P** (array_like) - State covariance.

### Returns
None
```

--------------------------------

### Construct confidence interval for fitted parameters

Source: https://www.statsmodels.org/stable/dev/generated/statsmodels.base.model.GenericLikelihoodModelResults.conf_int.html

Example using statsmodels OLS on the Longley dataset to fit a model and call conf_int() to get a 95% confidence interval for all parameters.

```python
>>> 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]])
```

--------------------------------

### Run full mediation example

Source: https://www.statsmodels.org/stable/examples/notebooks/generated/mediation_survival.html

Runs the simulation with full mediation and displays the resulting mediation analysis summary table.

```python
run("full")

```

```text
                          Estimate  Lower CI bound  Upper CI bound  P-value
ACME (control)            0.783217        0.669836        0.901194      0.0
ACME (treated)            0.783217        0.669836        0.901194      0.0
ADE (control)             0.025815       -0.070741        0.111009      0.5
ADE (treated)             0.025815       -0.070741        0.111009      0.5
Total effect              0.809033        0.701157        0.924868      0.0
Prop. mediated (control)  0.963520        0.870958        1.087129      0.0
Prop. mediated (treated)  0.963520        0.870958        1.087129      0.0
ACME (average)            0.783217        0.669836        0.901194      0.0
ADE (average)             0.025815       -0.070741        0.111009      0.5
Prop. mediated (average)  0.963520        0.870958        1.087129      0.0

```

--------------------------------

### Load macrodata dataset and set period index

Source: https://www.statsmodels.org/stable/_sources/examples/notebooks/generated/statespace_concentrated_scale.ipynb.txt

Loads the macrodata dataset and sets a quarterly period index from 1959Q1 to 2009Q3. This is the initial setup for the state space model examples.

```python
import pandas as pd

import statsmodels.api as sm

dta = sm.datasets.macrodata.load_pandas().data
dta.index = pd.period_range(start="1959Q1", end="2009Q3", freq="Q")
```

--------------------------------

### TLinearModel class definition with initialization, start parameters, and log-likelihood

Source: https://www.statsmodels.org/stable/_modules/statsmodels/miscmodels/tmodel.html

Defines the TLinearModel class, a generic MLE example for a linear model with t-distributed errors. The initialize method sets up parameter names and start values, optionally fixing the degrees of freedom. _set_start_params constructs starting values from an OLS fit, optionally using kurtosis for the df parameter. loglike returns the summed log-likelihood. Gradients and Hessian are based on numerical differentiation.

```python
import numpy as np
from scipy import special, stats

from statsmodels.base.model import GenericLikelihoodModel

# redefine some shortcuts
np_log = np.log
np_pi = np.pi
sps_gamln = special.gammaln




[docs]
class TLinearModel(GenericLikelihoodModel):
    """
    Maximum Likelihood Estimation of Linear Model with t-distributed errors

    This is an example for generic MLE.

    Except for defining the negative log-likelihood method, all
    methods and results are generic. Gradients and Hessian
    and all resulting statistics are based on numerical
    differentiation.
    """



[docs]
    def initialize(self):
        """Initialize the model, setting up parameter names and start values"""
        print("running Tmodel initialize")
        # TODO: here or in __init__
        self.k_vars = self.exog.shape[1]
        if not hasattr(self, "fix_df"):
            self.fix_df = False

        if self.fix_df is False:
            # df will be estimated, no parameter restrictions
            self.fixed_params = None
            self.fixed_paramsmask = None
            self.k_params = self.exog.shape[1] + 2
            extra_params_names = ["df", "scale"]
        else:
            # df fixed
            self.k_params = self.exog.shape[1] + 1
            fixdf = np.nan * np.zeros(self.exog.shape[1] + 2)
            fixdf[-2] = self.fix_df
            self.fixed_params = fixdf
            self.fixed_paramsmask = np.isnan(fixdf)
            extra_params_names = ["scale"]

        super().initialize()

        # Note: this needs to be after super initialize
        # super initialize sets default df_resid,
        # _set_extra_params_names adjusts it
        self._set_extra_params_names(extra_params_names)
        self._set_start_params()



    def _set_start_params(self, start_params=None, use_kurtosis=False):
        """
        Set starting values for the parameters

        Parameters
        ----------
        start_params : array_like, optional
            Starting values to use directly. If None, starting values are
            constructed from an OLS fit of `endog` on `exog`.
        use_kurtosis : bool, optional
            If True and `start_params` is None and `df` is not fixed, use
            the kurtosis of the OLS residuals to construct a starting
            value for the degrees of freedom parameter. Otherwise a
            starting value of 5 is used.
        """
        if start_params is not None:
            self.start_params = start_params
        else:
            from statsmodels.regression.linear_model import OLS
            res_ols = OLS(self.endog, self.exog).fit()
            start_params = 0.1*np.ones(self.k_params)
            start_params[:self.k_vars] = res_ols.params

            if self.fix_df is False:

                if use_kurtosis:
                    kurt = stats.kurtosis(res_ols.resid)
                    df = 6./kurt + 4
                else:
                    df = 5

                start_params[-2] = df
                # TODO adjust scale for df
                start_params[-1] = np.sqrt(res_ols.scale)

            self.start_params = start_params



[docs]
    def loglike(self, params):
        """
        Loglikelihood of the model evaluated at params

        Parameters
        ----------
        params : ndarray
            The parameters of the model. The last 2 parameters are degrees
            of freedom and scale.

        Returns
        -------
        float
            The log likelihood of the model evaluated at `params`, summed
            over all observations.
        """
        return -self.nloglikeobs(params).sum(0)

```

--------------------------------

### Create and display a SimpleTable

Source: https://www.statsmodels.org/stable/_modules/statsmodels/iolib/table.html

Demonstrates initializing a SimpleTable with data, headers, and stubs, then printing it in text and HTML formats.

```python
>>> mydata = [[11,12],[21,22]]  # data MUST be 2-dimensional
>>> myheaders = [ "Column 1", "Column 2" ]
>>> mystubs = [ "Row 1", "Row 2" ]
>>> tbl = text.SimpleTable(mydata, myheaders, mystubs, title="Title")
>>> print( tbl )
>>> print( tbl.as_html() )
```

--------------------------------

### Calling X-12-ARIMA/X-13-ARIMA from statsmodels

Source: https://www.statsmodels.org/stable/_sources/release/version0.6.rst.txt

Example of using the new X-12-ARIMA/X-13-ARIMA interface. Requires separate installation of X-12-ARIMA or X-13ARIMA-SEATS. Demonstrates loading the CO2 dataset, interpolating and resampling, selecting order, and performing analysis with plotting.

```python
import statsmodels.api as sm

dta = sm.datasets.co2.load_pandas().data
co2 = dta.co2.interpolate()
co2 = co2.resample('M').last()

res = sm.tsa.x13_arima_select_order(dta.co2)
print(res.order, res.sorder)

results = sm.tsa.x13_arima_analysis(co2)

fig = results.plot()
fig.set_size_inches(12, 5)
fig.tight_layout()
```

--------------------------------

### Compute news impact with res_pre.news()

Source: https://www.statsmodels.org/stable/_sources/examples/notebooks/generated/statespace_news.ipynb.txt

Computes the impact of news on forecasts for specified periods using the `news` method. Requires passing two of `start`, `end`, and `periods`; dates can be used if the time series has a date/period index. The example uses `start='2008Q3'` and `end='2009Q2'`.

```python
# Compute the impact of the news on the four periods that we previously
# forecasted: 2008Q3 through 2009Q2
news = res_pre.news(res_post, start="2008Q3", end="2009Q2")
# Note: one alternative way to specify these impact dates is
# `start='2008Q3', periods=4`
```

--------------------------------

### set_partition example

Source: https://www.statsmodels.org/stable/generated/statsmodels.sandbox.stats.multicomp.set_partition.html

Shows how to call set_partition with a list of tuples. The function returns a tuple containing the selected largest sets and the remaining elements as singletons.

```python
>>> li
[(5, 6, 7, 8), (1, 2, 3), (4, 5), (0, 1)]
>>> set_partition(li)
([(5, 6, 7, 8), (1, 2, 3)], [0, 4])
```

--------------------------------

### padone and trimone example

Source: https://www.statsmodels.org/stable/_modules/statsmodels/tsa/varma_process.html

Shows how to use padone to pad an array and trimone to trim it back. The example pads a 2x3 array with ones along axis 1, then trims it to return the original shape.

```python
>>> xp = padone(np.ones((2,3)),1,3,axis=1)
>>> xp
array([[ 0.,  1.,  1.,  1.,  0.,  0.,  0.],
       [ 0.,  1.,  1.,  1.,  0.,  0.,  0.]])
>>> trimone(xp,1,3,1)
array([[ 1.,  1.,  1.],
       [ 1.,  1.,  1.]])
```

--------------------------------

### Define MultipleYsModel class with custom state space setup

Source: https://www.statsmodels.org/stable/_sources/examples/notebooks/generated/statespace_custom_models.ipynb.txt

Defines a custom MLEModel subclass for a multiple-equation state space model. Sets up the design, selection, and transition matrices, defines parameter names and starting values, and implements transform/untransform methods to keep variances positive. The update method assigns parameters to observation covariance, state covariance, and transition matrix entries.

```python
starting_values = {
    "var_e1": 0.2,
    "var_e2": 0.1,
    "var_w1": 0.15,
    "var_w2": 0.18,
    "delta1": 0.7,
    "delta2": 0.1,
    "delta3": 0.85,
}


class MultipleYsModel(sm.tsa.statespace.MLEModel):
    def __init__(self, i_t: np.array, s_t: np.array, m_t: np.array):

        exog = np.c_[s_t, np.repeat(1, len(s_t))]  # exog.shape => (nobs, 2)

        super().__init__(
            endog=np.c_[i_t, m_t], exog=exog, k_states=2, initialization="diffuse"
        )

        self.ssm["design"] = np.zeros((self.k_endog, self.k_states, self.nobs))
        self.ssm["design", 0, 0, :] = s_t
        self.ssm["design", 1, 1, :] = 1

        # These have ok shape. Placeholders since I'm changing them
        # in the update() function
        self.ssm["selection"] = np.eye(self.k_states)
        self.ssm["transition"] = np.eye(self.k_states)

        # Dictionary of positions to names
        self.position_dict = OrderedDict(
            var_e1=1, var_e2=2, var_w1=3, var_w2=4, delta1=5, delta2=6, delta3=7
        )
        self.initial_values = starting_values
        self.positive_parameters = slice(0, 4)

    @property
    def param_names(self):
        return list(self.position_dict.keys())

    @property
    def start_params(self):
        """
        Initial values
        """
        # (optional) Use scale for var_e1 and var_e2 starting values
        params = np.r_[
            self.initial_values["var_e1"],
            self.initial_values["var_e2"],
            self.initial_values["var_w1"],
            self.initial_values["var_w2"],
            self.initial_values["delta1"],
            self.initial_values["delta2"],
            self.initial_values["delta3"],
        ]
        return params

    def transform_params(self, unconstrained):
        """
        If you need to restrict parameters
        For example, variances should be > 0
        Parameters maybe have to be within -1 and 1
        """
        constrained = unconstrained.copy()
        constrained[self.positive_parameters] = (
            constrained[self.positive_parameters] ** 2
        )
        return constrained

    def untransform_params(self, constrained):
        """
        Need to reverse what you did in transform_params()
        """
        unconstrained = constrained.copy()
        unconstrained[self.positive_parameters] = (
            unconstrained[self.positive_parameters] ** 0.5
        )
        return unconstrained

    def update(self, params, **kwargs):
        params = super().update(params, **kwargs)

        # The following line is not needed (by default, this matrix is initialized by zeroes),
        # But I leave it here so the dimensions are clearer
        self["obs_intercept"] = np.repeat([np.array([0, 0])], self.nobs, axis=0).T

        self["obs_cov", 0, 0] = params[0]
        self["obs_cov", 1, 1] = params[1]

        self["state_cov"] = np.diag(params[2:4])

        # delta1, delta2, delta3
        self["transition", 0, 0] = params[4]
        self["transition", 0, 1] = params[5]
        self["transition", 1, 1] = params[6]
```

--------------------------------

### Import libraries and set display options

Source: https://www.statsmodels.org/stable/_sources/examples/notebooks/generated/statespace_dfm_coincident.ipynb.txt

Sets up the environment by importing matplotlib, numpy, pandas, and statsmodels, and configures numpy print options for concise output.

```python
%matplotlib inline

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd

import statsmodels.api as sm

np.set_printoptions(precision=4, suppress=True, linewidth=120)
```

--------------------------------

### Multidimensional correlation examples

Source: https://www.statsmodels.org/stable/_modules/statsmodels/sandbox/tsa/movstat.html

Examples of using ndimage.filters.correlate for multidimensional arrays.

```python
ndimage.filters.correlate(np.vstack([x,x]),np.array([[1,1,1],[0,0,0]]), origin = 1)
ndimage.filters.correlate(x,[1,1,1],origin = 1))
ndimage.filters.correlate(np.vstack([x,x]),np.array([[0.5,0.5,0.5],[0.5,0.5,0.5]]), \
origin = 1)
```

```python
>>> np.all(ndimage.filters.correlate(np.vstack([x,x]),np.array([[1,1,1],[0,0,0]]), origin = 1)[0]==\
ndimage.filters.correlate(x,[1,1,1],origin = 1))
True
>>> np.all(ndimage.filters.correlate(np.vstack([x,x]),np.array([[0.5,0.5,0.5],[0.5,0.5,0.5]]), \
origin = 1)[0]==ndimage.filters.correlate(x,[1,1,1],origin = 1))
```

--------------------------------

### Load housing starts data with FredReader

Source: https://www.statsmodels.org/stable/examples/notebooks/generated/theta-model.html

Loads US housing starts data from FRED using pandas_datareader. Sets the index frequency to monthly start (MS) and plots the series.

```python
reader = pdr.fred.FredReader(["HOUST"], start="1980-01-01", end="2020-04-01")
data = reader.read()
housing = data.HOUST
housing.index.freq = "MS"
ax = housing.plot()
```

--------------------------------

### LinearIVGMM.fitstart()

Source: https://www.statsmodels.org/stable/generated/statsmodels.sandbox.regression.gmm.LinearIVGMM.fitstart.html

The fitstart method provides initial parameter estimates for the GMM optimization by returning an array of zeros.

```APIDOC
## LinearIVGMM.fitstart()

### Description
Returns an array of zeros as the starting values for the GMM optimization.

### Method
fitstart()

### Parameters
None

### Returns
- **start_params** (ndarray) - Array of zeros with length equal to the number of parameters in the model.
```
Tokens:
Raw